The Tor Browser / file comparison
comparison: security/sandbox/win/src/service_resolver_unittest.cc
security/sandbox/win/src/service_resolver_unittest.cc
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:ced5a38c3f89 |
|---|---|
| 1 // Copyright (c) 2012 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 contains unit tests for ServiceResolverThunk. | |
| 6 | |
| 7 #include "base/basictypes.h" | |
| 8 #include "base/memory/scoped_ptr.h" | |
| 9 #include "base/win/windows_version.h" | |
| 10 #include "sandbox/win/src/resolver.h" | |
| 11 #include "sandbox/win/src/sandbox_utils.h" | |
| 12 #include "sandbox/win/src/service_resolver.h" | |
| 13 #include "testing/gtest/include/gtest/gtest.h" | |
| 14 | |
| 15 namespace { | |
| 16 | |
| 17 // This is the concrete resolver used to perform service-call type functions | |
| 18 // inside ntdll.dll. | |
| 19 template<typename T> | |
| 20 class ResolverThunkTest : public T { | |
| 21 public: | |
| 22 // The service resolver needs a child process to write to. | |
| 23 explicit ResolverThunkTest(bool relaxed) | |
| 24 : T(::GetCurrentProcess(), relaxed) {} | |
| 25 | |
| 26 // Sets the interception target to the desired address. | |
| 27 void set_target(void* target) { | |
| 28 fake_target_ = target; | |
| 29 } | |
| 30 | |
| 31 protected: | |
| 32 // Overrides Resolver::Init | |
| 33 virtual NTSTATUS Init(const void* target_module, | |
| 34 const void* interceptor_module, | |
| 35 const char* target_name, | |
| 36 const char* interceptor_name, | |
| 37 const void* interceptor_entry_point, | |
| 38 void* thunk_storage, | |
| 39 size_t storage_bytes) { | |
| 40 NTSTATUS ret = STATUS_SUCCESS; | |
| 41 ret = ResolverThunk::Init(target_module, interceptor_module, target_name, | |
| 42 interceptor_name, interceptor_entry_point, | |
| 43 thunk_storage, storage_bytes); | |
| 44 EXPECT_EQ(STATUS_SUCCESS, ret); | |
| 45 | |
| 46 target_ = fake_target_; | |
| 47 ntdll_base_ = ::GetModuleHandle(L"ntdll.dll"); | |
| 48 return ret; | |
| 49 }; | |
| 50 | |
| 51 private: | |
| 52 // Holds the address of the fake target. | |
| 53 void* fake_target_; | |
| 54 | |
| 55 DISALLOW_COPY_AND_ASSIGN(ResolverThunkTest); | |
| 56 }; | |
| 57 | |
| 58 typedef ResolverThunkTest<sandbox::ServiceResolverThunk> WinXpResolverTest; | |
| 59 | |
| 60 #if !defined(_WIN64) | |
| 61 typedef ResolverThunkTest<sandbox::Win2kResolverThunk> Win2kResolverTest; | |
| 62 typedef ResolverThunkTest<sandbox::Win8ResolverThunk> Win8ResolverTest; | |
| 63 typedef ResolverThunkTest<sandbox::Wow64ResolverThunk> Wow64ResolverTest; | |
| 64 typedef ResolverThunkTest<sandbox::Wow64W8ResolverThunk> Wow64W8ResolverTest; | |
| 65 #endif | |
| 66 | |
| 67 const BYTE kJump32 = 0xE9; | |
| 68 | |
| 69 void CheckJump(void* source, void* target) { | |
| 70 #pragma pack(push) | |
| 71 #pragma pack(1) | |
| 72 struct Code { | |
| 73 BYTE jump; | |
| 74 ULONG delta; | |
| 75 }; | |
| 76 #pragma pack(pop) | |
| 77 | |
| 78 #if defined(_WIN64) | |
| 79 FAIL() << "Running 32-bit codepath"; | |
| 80 #else | |
| 81 Code* patched = reinterpret_cast<Code*>(source); | |
| 82 EXPECT_EQ(kJump32, patched->jump); | |
| 83 | |
| 84 ULONG source_addr = bit_cast<ULONG>(source); | |
| 85 ULONG target_addr = bit_cast<ULONG>(target); | |
| 86 EXPECT_EQ(target_addr + 19 - source_addr, patched->delta); | |
| 87 #endif | |
| 88 } | |
| 89 | |
| 90 NTSTATUS PatchNtdllWithResolver(const char* function, bool relaxed, | |
| 91 sandbox::ServiceResolverThunk* resolver) { | |
| 92 HMODULE ntdll_base = ::GetModuleHandle(L"ntdll.dll"); | |
| 93 EXPECT_TRUE(NULL != ntdll_base); | |
| 94 | |
| 95 void* target = ::GetProcAddress(ntdll_base, function); | |
| 96 EXPECT_TRUE(NULL != target); | |
| 97 if (NULL == target) | |
| 98 return STATUS_UNSUCCESSFUL; | |
| 99 | |
| 100 BYTE service[50]; | |
| 101 memcpy(service, target, sizeof(service)); | |
| 102 | |
| 103 static_cast<WinXpResolverTest*>(resolver)->set_target(service); | |
| 104 | |
| 105 // Any pointer will do as an interception_entry_point | |
| 106 void* function_entry = resolver; | |
| 107 size_t thunk_size = resolver->GetThunkSize(); | |
| 108 scoped_ptr<char[]> thunk(new char[thunk_size]); | |
| 109 size_t used; | |
| 110 | |
| 111 NTSTATUS ret = resolver->Setup(ntdll_base, NULL, function, NULL, | |
| 112 function_entry, thunk.get(), thunk_size, | |
| 113 &used); | |
| 114 if (NT_SUCCESS(ret)) { | |
| 115 EXPECT_EQ(thunk_size, used); | |
| 116 EXPECT_NE(0, memcmp(service, target, sizeof(service))); | |
| 117 EXPECT_NE(kJump32, service[0]); | |
| 118 | |
| 119 if (relaxed) { | |
| 120 // It's already patched, let's patch again, and simulate a direct patch. | |
| 121 service[0] = kJump32; | |
| 122 ret = resolver->Setup(ntdll_base, NULL, function, NULL, function_entry, | |
| 123 thunk.get(), thunk_size, &used); | |
| 124 CheckJump(service, thunk.get()); | |
| 125 } | |
| 126 } | |
| 127 | |
| 128 return ret; | |
| 129 } | |
| 130 | |
| 131 sandbox::ServiceResolverThunk* GetTestResolver(bool relaxed) { | |
| 132 #if defined(_WIN64) | |
| 133 return new WinXpResolverTest(relaxed); | |
| 134 #else | |
| 135 base::win::OSInfo* os_info = base::win::OSInfo::GetInstance(); | |
| 136 if (os_info->wow64_status() == base::win::OSInfo::WOW64_ENABLED) { | |
| 137 if (os_info->version() >= base::win::VERSION_WIN8) | |
| 138 return new Wow64W8ResolverTest(relaxed); | |
| 139 return new Wow64ResolverTest(relaxed); | |
| 140 } | |
| 141 | |
| 142 if (!sandbox::IsXPSP2OrLater()) | |
| 143 return new Win2kResolverTest(relaxed); | |
| 144 | |
| 145 if (os_info->version() >= base::win::VERSION_WIN8) | |
| 146 return new Win8ResolverTest(relaxed); | |
| 147 | |
| 148 return new WinXpResolverTest(relaxed); | |
| 149 #endif | |
| 150 } | |
| 151 | |
| 152 NTSTATUS PatchNtdll(const char* function, bool relaxed) { | |
| 153 sandbox::ServiceResolverThunk* resolver = GetTestResolver(relaxed); | |
| 154 | |
| 155 NTSTATUS ret = PatchNtdllWithResolver(function, relaxed, resolver); | |
| 156 delete resolver; | |
| 157 return ret; | |
| 158 } | |
| 159 | |
| 160 TEST(ServiceResolverTest, PatchesServices) { | |
| 161 NTSTATUS ret = PatchNtdll("NtClose", false); | |
| 162 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtClose, last error: " << ::GetLastError(); | |
| 163 | |
| 164 ret = PatchNtdll("NtCreateFile", false); | |
| 165 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtCreateFile, last error: " << | |
| 166 ::GetLastError(); | |
| 167 | |
| 168 ret = PatchNtdll("NtCreateMutant", false); | |
| 169 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtCreateMutant, last error: " << | |
| 170 ::GetLastError(); | |
| 171 | |
| 172 ret = PatchNtdll("NtMapViewOfSection", false); | |
| 173 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtMapViewOfSection, last error: " << | |
| 174 ::GetLastError(); | |
| 175 } | |
| 176 | |
| 177 TEST(ServiceResolverTest, FailsIfNotService) { | |
| 178 #if !defined(_WIN64) | |
| 179 EXPECT_NE(STATUS_SUCCESS, PatchNtdll("RtlUlongByteSwap", false)); | |
| 180 #endif | |
| 181 | |
| 182 EXPECT_NE(STATUS_SUCCESS, PatchNtdll("LdrLoadDll", false)); | |
| 183 } | |
| 184 | |
| 185 TEST(ServiceResolverTest, PatchesPatchedServices) { | |
| 186 // We don't support "relaxed mode" for Win64 apps. | |
| 187 #if !defined(_WIN64) | |
| 188 NTSTATUS ret = PatchNtdll("NtClose", true); | |
| 189 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtClose, last error: " << ::GetLastError(); | |
| 190 | |
| 191 ret = PatchNtdll("NtCreateFile", true); | |
| 192 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtCreateFile, last error: " << | |
| 193 ::GetLastError(); | |
| 194 | |
| 195 ret = PatchNtdll("NtCreateMutant", true); | |
| 196 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtCreateMutant, last error: " << | |
| 197 ::GetLastError(); | |
| 198 | |
| 199 ret = PatchNtdll("NtMapViewOfSection", true); | |
| 200 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtMapViewOfSection, last error: " << | |
| 201 ::GetLastError(); | |
| 202 #endif | |
| 203 } | |
| 204 | |
| 205 TEST(ServiceResolverTest, MultiplePatchedServices) { | |
| 206 // We don't support "relaxed mode" for Win64 apps. | |
| 207 #if !defined(_WIN64) | |
| 208 sandbox::ServiceResolverThunk* resolver = GetTestResolver(true); | |
| 209 NTSTATUS ret = PatchNtdllWithResolver("NtClose", true, resolver); | |
| 210 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtClose, last error: " << ::GetLastError(); | |
| 211 | |
| 212 ret = PatchNtdllWithResolver("NtCreateFile", true, resolver); | |
| 213 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtCreateFile, last error: " << | |
| 214 ::GetLastError(); | |
| 215 | |
| 216 ret = PatchNtdllWithResolver("NtCreateMutant", true, resolver); | |
| 217 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtCreateMutant, last error: " << | |
| 218 ::GetLastError(); | |
| 219 | |
| 220 ret = PatchNtdllWithResolver("NtMapViewOfSection", true, resolver); | |
| 221 EXPECT_EQ(STATUS_SUCCESS, ret) << "NtMapViewOfSection, last error: " << | |
| 222 ::GetLastError(); | |
| 223 delete resolver; | |
| 224 #endif | |
| 225 } | |
| 226 | |
| 227 } // namespace |
