tests/stack_protector_test.cpp

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * Contributed by: Intel Corporation
  19  */
  20
  21 #include <gtest/gtest.h>
  22 #include "BionicDeathTest.h"
  23
  24 #include <pthread.h>
  25 #include <stdint.h>
  26 #include <stdio.h>
  27 #include <unistd.h>
  28 #include <set>
  29
  30 extern "C" pid_t gettid();
  31
  32 // For x86, bionic and glibc have per-thread stack guard values (all identical).
  33 #if defined(__i386__)
  34 static uint32_t GetGuardFromTls() {
  35   uint32_t guard;
  36   asm ("mov %%gs:0x14, %0": "=d" (guard));
  37   return guard;
  38 }
  39
  40 struct stack_protector_checker {
  41   std::set<pid_t> tids;
  42   std::set<uint32_t> guards;
  43
  44   void Check() {
  45     pid_t tid = gettid();
  46     uint32_t guard = GetGuardFromTls();
  47
  48     printf("[thread %d] %%gs:0x14 = 0x%08x\n", tid, guard);
  49
  50     // Duplicate tid. gettid(2) bug? Seeing this would be very upsetting.
  51     ASSERT_TRUE(tids.find(tid) == tids.end());
  52
  53     // Uninitialized guard. Our bug. Note this is potentially flaky; we _could_ get
  54     // four random zero bytes, but it should be vanishingly unlikely.
  55     ASSERT_NE(guard, 0U);
  56
  57     tids.insert(tid);
  58     guards.insert(guard);
  59   }
  60 };
  61
  62 static void* ThreadGuardHelper(void* arg) {
  63   stack_protector_checker* checker = reinterpret_cast<stack_protector_checker*>(arg);
  64   checker->Check();
  65   return NULL;
  66 }
  67 #endif // __i386__
  68
  69 TEST(stack_protector, same_guard_per_thread) {
  70 #if defined(__i386__)
  71   stack_protector_checker checker;
  72   size_t thread_count = 10;
  73   for (size_t i = 0; i < thread_count; ++i) {
  74     pthread_t t;
  75     ASSERT_EQ(0, pthread_create(&t, NULL, ThreadGuardHelper, &checker));
  76     void* result;
  77     ASSERT_EQ(0, pthread_join(t, &result));
  78     ASSERT_EQ(NULL, result);
  79   }
  80   ASSERT_EQ(thread_count, checker.tids.size());
  81
  82   // bionic and glibc use the same guard for every thread.
  83   ASSERT_EQ(1U, checker.guards.size());
  84 #else // __i386__
  85   GTEST_LOG_(INFO) << "This test does nothing.\n";
  86 #endif // __i386__
  87 }
  88
  89 // For ARM and MIPS, glibc has a global stack check guard value.
  90 #if defined(__BIONIC__) || defined(__arm__) || defined(__mips__)
  91 #define TEST_STACK_CHK_GUARD
  92
  93 // Bionic has the global for x86 too, to support binaries that can run on
  94 // Android releases that didn't implement the TLS guard value.
  95 extern "C" uintptr_t __stack_chk_guard;
  96
  97 /*
  98  * When this function returns, the stack canary will be inconsistent
  99  * with the previous value, which will generate a call to __stack_chk_fail(),
 100  * eventually resulting in a SIGABRT.
 101  *
 102  * This must be marked with "__attribute__ ((noinline))", to ensure the
 103  * compiler generates the proper stack guards around this function.
 104  */
 105 static char* dummy_buf;
 106
 107 __attribute__ ((noinline))
 108 static void do_modify_stack_chk_guard() {
 109   char buf[128];
 110   // Store local array's address to global variable to force compiler to generate stack guards.
 111   dummy_buf = buf;
 112   __stack_chk_guard = 0x12345678;
 113 }
 114
 115 #endif
 116
 117 TEST(stack_protector, global_guard) {
 118 #if defined(TEST_STACK_CHK_GUARD)
 119   ASSERT_NE(0, gettid());
 120   ASSERT_NE(0U, __stack_chk_guard);
 121 #else // TEST_STACK_CHK_GUARD
 122   GTEST_LOG_(INFO) << "This test does nothing.\n";
 123 #endif // TEST_STACK_CHK_GUARD
 124 }
 125
 126 class stack_protector_DeathTest : public BionicDeathTest {};
 127
 128 TEST_F(stack_protector_DeathTest, modify_stack_protector) {
 129 #if defined(TEST_STACK_CHK_GUARD)
 130   ASSERT_EXIT(do_modify_stack_chk_guard(), testing::KilledBySignal(SIGABRT), "");
 131 #else // TEST_STACK_CHK_GUARD
 132   GTEST_LOG_(INFO) << "This test does nothing.\n";
 133 #endif // TEST_STACK_CHK_GUARD
 134 }