Home | History | Annotate | Download | only in linker_test_apk 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 // This file implements the native methods of
      6 // org.content.chromium.app.LinkerTests
      7 // Unlike the content of linker_jni.cc, it is part of the content library and
      8 // can
      9 // thus use base/ and the C++ STL.
     10 
     11 #include "content/shell/android/linker_test_apk/chromium_linker_test_linker_tests.h"
     12 
     13 #include <errno.h>
     14 #include <sys/mman.h>
     15 #include <stdio.h>
     16 #include <string>
     17 
     18 #include "base/basictypes.h"
     19 #include "base/debug/proc_maps_linux.h"
     20 #include "base/logging.h"
     21 #include "base/strings/stringprintf.h"
     22 
     23 #include "jni/LinkerTests_jni.h"
     24 
     25 namespace content {
     26 
     27 namespace {
     28 
     29 using base::debug::MappedMemoryRegion;
     30 
     31 jboolean RunChecks(bool in_browser_process, bool need_relros) {
     32 
     33   // IMPORTANT NOTE: The Python test control script reads the logcat for
     34   // lines like:
     35   //   BROWSER_LINKER_TEST: <status>
     36   //   RENDERER_LINKER_TEST: <status>
     37   //
     38   // Where <status> can be either SUCCESS or FAIL. Other lines starting
     39   // with the same prefixes, but not using SUCCESS or FAIL are ignored.
     40   const char* prefix =
     41       in_browser_process ? "BROWSER_LINKER_TEST: " : "RENDERER_LINKER_TEST: ";
     42 
     43   // The RELRO section(s), after being copied into an ashmem region, will
     44   // appear in /proc/self/maps as a mapped memory region for a file name
     45   // that begins with the following prefix.
     46   //
     47   // Note that the full name will be something like:
     48   //   "/dev/ashmem/RELRO:<libname> (deleted)"
     49   //
     50   // Where <libname> is the library name and '(deleted)' is actually
     51   // added by the kernel to indicate there is no corresponding file
     52   // on the filesystem.
     53   //
     54   // For regular builds, there is only one library, and thus one RELRO
     55   // section, but for the component build, there are several libraries,
     56   // each one with its own RELRO.
     57   static const char kRelroSectionPrefix[] = "/dev/ashmem/RELRO:";
     58 
     59   // Parse /proc/self/maps and builds a list of region mappings in this
     60   // process.
     61   std::string maps;
     62   base::debug::ReadProcMaps(&maps);
     63   if (maps.empty()) {
     64     LOG(ERROR) << prefix << "FAIL Cannot parse /proc/self/maps";
     65     return false;
     66   }
     67 
     68   std::vector<MappedMemoryRegion> regions;
     69   base::debug::ParseProcMaps(maps, &regions);
     70   if (regions.empty()) {
     71     LOG(ERROR) << prefix << "FAIL Cannot read memory mappings in this process";
     72     return false;
     73   }
     74 
     75   size_t num_shared_relros = 0;
     76   size_t num_bad_shared_relros = 0;
     77 
     78   for (size_t n = 0; n < regions.size(); ++n) {
     79     MappedMemoryRegion& region = regions[n];
     80 
     81     if (region.path.find(kRelroSectionPrefix) != 0) {
     82       // Ignore any mapping that isn't a shared RELRO.
     83       continue;
     84     }
     85 
     86     num_shared_relros++;
     87 
     88     void* region_start = reinterpret_cast<void*>(region.start);
     89     void* region_end = reinterpret_cast<void*>(region.end);
     90 
     91     // Check that it is mapped read-only.
     92     const uint8 expected_flags = MappedMemoryRegion::READ;
     93     const uint8 expected_mask = MappedMemoryRegion::READ |
     94                                 MappedMemoryRegion::WRITE |
     95                                 MappedMemoryRegion::EXECUTE;
     96 
     97     uint8 region_flags = region.permissions & expected_mask;
     98     if (region_flags != expected_flags) {
     99       LOG(ERROR)
    100           << prefix
    101           << base::StringPrintf(
    102                  "Shared RELRO section at %p-%p is not mapped read-only. "
    103                  "Protection flags are %d (%d expected)!",
    104                  region_start,
    105                  region_end,
    106                  region_flags,
    107                  expected_flags);
    108       num_bad_shared_relros++;
    109       continue;
    110     }
    111 
    112     // Check that trying to remap it read-write fails with EACCES
    113     size_t region_size = region.end - region.start;
    114     int ret = ::mprotect(region_start, region_size, PROT_READ | PROT_WRITE);
    115     if (ret != -1) {
    116       LOG(ERROR)
    117           << prefix
    118           << base::StringPrintf(
    119                  "Shared RELRO section at %p-%p could be remapped read-write!?",
    120                  region_start,
    121                  region_end);
    122       num_bad_shared_relros++;
    123       // Just in case.
    124       ::mprotect(region_start, region_size, PROT_READ);
    125     } else if (errno != EACCES) {
    126       LOG(ERROR) << prefix << base::StringPrintf(
    127                                   "Shared RELRO section at %p-%p failed "
    128                                   "read-write mprotect with "
    129                                   "unexpected error %d (EACCES:%d wanted): %s",
    130                                   region_start,
    131                                   region_end,
    132                                   errno,
    133                                   EACCES,
    134                                   strerror(errno));
    135       num_bad_shared_relros++;
    136     }
    137   }
    138 
    139   VLOG(0)
    140       << prefix
    141       << base::StringPrintf(
    142              "There are %d shared RELRO sections in this process, %d are bad",
    143              num_shared_relros,
    144              num_bad_shared_relros);
    145 
    146   if (num_bad_shared_relros > 0) {
    147     LOG(ERROR) << prefix << "FAIL Bad Relros sections in this process";
    148     return false;
    149   }
    150 
    151   if (need_relros) {
    152     if (num_shared_relros == 0) {
    153       LOG(ERROR) << prefix
    154                  << "FAIL Missing shared RELRO sections in this process!";
    155       return false;
    156     }
    157   } else {
    158     if (num_shared_relros > 0) {
    159       LOG(ERROR) << prefix << "FAIL Unexpected " << num_shared_relros
    160                  << " shared RELRO sections in this process!";
    161       return false;
    162     }
    163   }
    164 
    165   VLOG(0) << prefix << "SUCCESS";
    166   return true;
    167 }
    168 
    169 }  // namespace
    170 
    171 jboolean CheckForSharedRelros(JNIEnv* env,
    172                               jclass clazz,
    173                               jboolean in_browser_process) {
    174   return RunChecks(in_browser_process, true);
    175 }
    176 
    177 jboolean CheckForNoSharedRelros(JNIEnv* env,
    178                                 jclass clazz,
    179                                 jboolean in_browser_process) {
    180   return RunChecks(in_browser_process, false);
    181 }
    182 
    183 bool RegisterLinkerTestsJni(JNIEnv* env) { return RegisterNativesImpl(env); }
    184 
    185 }  // namespace content
    186