1 //===-- interception_win_test.cc ------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file is a part of ThreadSanitizer/AddressSanitizer runtime. 11 // Tests for interception_win.h. 12 // 13 //===----------------------------------------------------------------------===// 14 #include "interception/interception.h" 15 16 #include "gtest/gtest.h" 17 18 // Too slow for debug build 19 #if !SANITIZER_DEBUG 20 #if SANITIZER_WINDOWS 21 22 #define WIN32_LEAN_AND_MEAN 23 #include <windows.h> 24 25 namespace __interception { 26 namespace { 27 28 enum FunctionPrefixKind { 29 FunctionPrefixNone, 30 FunctionPrefixPadding, 31 FunctionPrefixHotPatch, 32 FunctionPrefixDetour, 33 }; 34 35 typedef bool (*TestOverrideFunction)(uptr, uptr, uptr*); 36 typedef int (*IdentityFunction)(int); 37 38 #if SANITIZER_WINDOWS64 39 40 const u8 kIdentityCodeWithPrologue[] = { 41 0x55, // push rbp 42 0x48, 0x89, 0xE5, // mov rbp,rsp 43 0x8B, 0xC1, // mov eax,ecx 44 0x5D, // pop rbp 45 0xC3, // ret 46 }; 47 48 const u8 kIdentityCodeWithPushPop[] = { 49 0x55, // push rbp 50 0x48, 0x89, 0xE5, // mov rbp,rsp 51 0x53, // push rbx 52 0x50, // push rax 53 0x58, // pop rax 54 0x8B, 0xC1, // mov rax,rcx 55 0x5B, // pop rbx 56 0x5D, // pop rbp 57 0xC3, // ret 58 }; 59 60 const u8 kIdentityTwiceOffset = 16; 61 const u8 kIdentityTwice[] = { 62 0x55, // push rbp 63 0x48, 0x89, 0xE5, // mov rbp,rsp 64 0x8B, 0xC1, // mov eax,ecx 65 0x5D, // pop rbp 66 0xC3, // ret 67 0x90, 0x90, 0x90, 0x90, 68 0x90, 0x90, 0x90, 0x90, 69 0x55, // push rbp 70 0x48, 0x89, 0xE5, // mov rbp,rsp 71 0x8B, 0xC1, // mov eax,ecx 72 0x5D, // pop rbp 73 0xC3, // ret 74 }; 75 76 const u8 kIdentityCodeWithMov[] = { 77 0x89, 0xC8, // mov eax, ecx 78 0xC3, // ret 79 }; 80 81 const u8 kIdentityCodeWithJump[] = { 82 0xE9, 0x04, 0x00, 0x00, 83 0x00, // jmp + 4 84 0xCC, 0xCC, 0xCC, 0xCC, 85 0x89, 0xC8, // mov eax, ecx 86 0xC3, // ret 87 }; 88 89 #else 90 91 const u8 kIdentityCodeWithPrologue[] = { 92 0x55, // push ebp 93 0x8B, 0xEC, // mov ebp,esp 94 0x8B, 0x45, 0x08, // mov eax,dword ptr [ebp + 8] 95 0x5D, // pop ebp 96 0xC3, // ret 97 }; 98 99 const u8 kIdentityCodeWithPushPop[] = { 100 0x55, // push ebp 101 0x8B, 0xEC, // mov ebp,esp 102 0x53, // push ebx 103 0x50, // push eax 104 0x58, // pop eax 105 0x8B, 0x45, 0x08, // mov eax,dword ptr [ebp + 8] 106 0x5B, // pop ebx 107 0x5D, // pop ebp 108 0xC3, // ret 109 }; 110 111 const u8 kIdentityTwiceOffset = 8; 112 const u8 kIdentityTwice[] = { 113 0x55, // push ebp 114 0x8B, 0xEC, // mov ebp,esp 115 0x8B, 0x45, 0x08, // mov eax,dword ptr [ebp + 8] 116 0x5D, // pop ebp 117 0xC3, // ret 118 0x55, // push ebp 119 0x8B, 0xEC, // mov ebp,esp 120 0x8B, 0x45, 0x08, // mov eax,dword ptr [ebp + 8] 121 0x5D, // pop ebp 122 0xC3, // ret 123 }; 124 125 const u8 kIdentityCodeWithMov[] = { 126 0x8B, 0x44, 0x24, 0x04, // mov eax,dword ptr [esp + 4] 127 0xC3, // ret 128 }; 129 130 const u8 kIdentityCodeWithJump[] = { 131 0xE9, 0x04, 0x00, 0x00, 132 0x00, // jmp + 4 133 0xCC, 0xCC, 0xCC, 0xCC, 134 0x8B, 0x44, 0x24, 0x04, // mov eax,dword ptr [esp + 4] 135 0xC3, // ret 136 }; 137 138 #endif 139 140 const u8 kPatchableCode1[] = { 141 0xB8, 0x4B, 0x00, 0x00, 0x00, // mov eax,4B 142 0x33, 0xC9, // xor ecx,ecx 143 0xC3, // ret 144 }; 145 146 const u8 kPatchableCode2[] = { 147 0x55, // push ebp 148 0x8B, 0xEC, // mov ebp,esp 149 0x33, 0xC0, // xor eax,eax 150 0x5D, // pop ebp 151 0xC3, // ret 152 }; 153 154 const u8 kPatchableCode3[] = { 155 0x55, // push ebp 156 0x8B, 0xEC, // mov ebp,esp 157 0x6A, 0x00, // push 0 158 0xE8, 0x3D, 0xFF, 0xFF, 0xFF, // call <func> 159 }; 160 161 const u8 kPatchableCode4[] = { 162 0xE9, 0xCC, 0xCC, 0xCC, 0xCC, // jmp <label> 163 0x90, 0x90, 0x90, 0x90, 164 }; 165 166 const u8 kUnpatchableCode1[] = { 167 0xC3, // ret 168 }; 169 170 const u8 kUnpatchableCode2[] = { 171 0x33, 0xC9, // xor ecx,ecx 172 0xC3, // ret 173 }; 174 175 const u8 kUnpatchableCode3[] = { 176 0x75, 0xCC, // jne <label> 177 0x33, 0xC9, // xor ecx,ecx 178 0xC3, // ret 179 }; 180 181 const u8 kUnpatchableCode4[] = { 182 0x74, 0xCC, // jne <label> 183 0x33, 0xC9, // xor ecx,ecx 184 0xC3, // ret 185 }; 186 187 const u8 kUnpatchableCode5[] = { 188 0xEB, 0x02, // jmp <label> 189 0x33, 0xC9, // xor ecx,ecx 190 0xC3, // ret 191 }; 192 193 const u8 kUnpatchableCode6[] = { 194 0xE8, 0xCC, 0xCC, 0xCC, 0xCC, // call <func> 195 0x90, 0x90, 0x90, 0x90, 196 }; 197 198 // A buffer holding the dynamically generated code under test. 199 u8* ActiveCode; 200 size_t ActiveCodeLength = 4096; 201 202 template<class T> 203 static void LoadActiveCode( 204 const T &code, 205 uptr *entry_point, 206 FunctionPrefixKind prefix_kind = FunctionPrefixNone) { 207 if (ActiveCode == nullptr) { 208 ActiveCode = 209 (u8*)::VirtualAlloc(nullptr, ActiveCodeLength, 210 MEM_COMMIT | MEM_RESERVE, 211 PAGE_EXECUTE_READWRITE); 212 ASSERT_NE(ActiveCode, nullptr); 213 } 214 215 size_t position = 0; 216 217 // Add padding to avoid memory violation when scanning the prefix. 218 for (int i = 0; i < 16; ++i) 219 ActiveCode[position++] = 0xC3; // Instruction 'ret'. 220 221 // Add function padding. 222 size_t padding = 0; 223 if (prefix_kind == FunctionPrefixPadding) 224 padding = 16; 225 else if (prefix_kind == FunctionPrefixDetour || 226 prefix_kind == FunctionPrefixHotPatch) 227 padding = FIRST_32_SECOND_64(5, 6); 228 // Insert |padding| instructions 'nop'. 229 for (size_t i = 0; i < padding; ++i) 230 ActiveCode[position++] = 0x90; 231 232 // Keep track of the entry point. 233 *entry_point = (uptr)&ActiveCode[position]; 234 235 // Add the detour instruction (i.e. mov edi, edi) 236 if (prefix_kind == FunctionPrefixDetour) { 237 #if SANITIZER_WINDOWS64 238 // Note that "mov edi,edi" is NOP in 32-bit only, in 64-bit it clears 239 // higher bits of RDI. 240 // Use 66,90H as NOP for Windows64. 241 ActiveCode[position++] = 0x66; 242 ActiveCode[position++] = 0x90; 243 #else 244 // mov edi,edi. 245 ActiveCode[position++] = 0x8B; 246 ActiveCode[position++] = 0xFF; 247 #endif 248 249 } 250 251 // Copy the function body. 252 for (size_t i = 0; i < sizeof(T); ++i) 253 ActiveCode[position++] = code[i]; 254 } 255 256 int InterceptorFunctionCalled; 257 IdentityFunction InterceptedRealFunction; 258 259 int InterceptorFunction(int x) { 260 ++InterceptorFunctionCalled; 261 return InterceptedRealFunction(x); 262 } 263 264 } // namespace 265 266 // Tests for interception_win.h 267 TEST(Interception, InternalGetProcAddress) { 268 HMODULE ntdll_handle = ::GetModuleHandle("ntdll"); 269 ASSERT_NE(nullptr, ntdll_handle); 270 uptr DbgPrint_expected = (uptr)::GetProcAddress(ntdll_handle, "DbgPrint"); 271 uptr isdigit_expected = (uptr)::GetProcAddress(ntdll_handle, "isdigit"); 272 uptr DbgPrint_adddress = InternalGetProcAddress(ntdll_handle, "DbgPrint"); 273 uptr isdigit_address = InternalGetProcAddress(ntdll_handle, "isdigit"); 274 275 EXPECT_EQ(DbgPrint_expected, DbgPrint_adddress); 276 EXPECT_EQ(isdigit_expected, isdigit_address); 277 EXPECT_NE(DbgPrint_adddress, isdigit_address); 278 } 279 280 template<class T> 281 static void TestIdentityFunctionPatching( 282 const T &code, 283 TestOverrideFunction override, 284 FunctionPrefixKind prefix_kind = FunctionPrefixNone) { 285 uptr identity_address; 286 LoadActiveCode(code, &identity_address, prefix_kind); 287 IdentityFunction identity = (IdentityFunction)identity_address; 288 289 // Validate behavior before dynamic patching. 290 InterceptorFunctionCalled = 0; 291 EXPECT_EQ(0, identity(0)); 292 EXPECT_EQ(42, identity(42)); 293 EXPECT_EQ(0, InterceptorFunctionCalled); 294 295 // Patch the function. 296 uptr real_identity_address = 0; 297 bool success = override(identity_address, 298 (uptr)&InterceptorFunction, 299 &real_identity_address); 300 EXPECT_TRUE(success); 301 EXPECT_NE(0U, real_identity_address); 302 IdentityFunction real_identity = (IdentityFunction)real_identity_address; 303 InterceptedRealFunction = real_identity; 304 305 // Don't run tests if hooking failed or the real function is not valid. 306 if (!success || !real_identity_address) 307 return; 308 309 // Calling the redirected function. 310 InterceptorFunctionCalled = 0; 311 EXPECT_EQ(0, identity(0)); 312 EXPECT_EQ(42, identity(42)); 313 EXPECT_EQ(2, InterceptorFunctionCalled); 314 315 // Calling the real function. 316 InterceptorFunctionCalled = 0; 317 EXPECT_EQ(0, real_identity(0)); 318 EXPECT_EQ(42, real_identity(42)); 319 EXPECT_EQ(0, InterceptorFunctionCalled); 320 321 TestOnlyReleaseTrampolineRegions(); 322 } 323 324 #if !SANITIZER_WINDOWS64 325 TEST(Interception, OverrideFunctionWithDetour) { 326 TestOverrideFunction override = OverrideFunctionWithDetour; 327 FunctionPrefixKind prefix = FunctionPrefixDetour; 328 TestIdentityFunctionPatching(kIdentityCodeWithPrologue, override, prefix); 329 TestIdentityFunctionPatching(kIdentityCodeWithPushPop, override, prefix); 330 TestIdentityFunctionPatching(kIdentityCodeWithMov, override, prefix); 331 TestIdentityFunctionPatching(kIdentityCodeWithJump, override, prefix); 332 } 333 #endif // !SANITIZER_WINDOWS64 334 335 TEST(Interception, OverrideFunctionWithRedirectJump) { 336 TestOverrideFunction override = OverrideFunctionWithRedirectJump; 337 TestIdentityFunctionPatching(kIdentityCodeWithJump, override); 338 } 339 340 TEST(Interception, OverrideFunctionWithHotPatch) { 341 TestOverrideFunction override = OverrideFunctionWithHotPatch; 342 FunctionPrefixKind prefix = FunctionPrefixHotPatch; 343 TestIdentityFunctionPatching(kIdentityCodeWithMov, override, prefix); 344 } 345 346 TEST(Interception, OverrideFunctionWithTrampoline) { 347 TestOverrideFunction override = OverrideFunctionWithTrampoline; 348 FunctionPrefixKind prefix = FunctionPrefixNone; 349 TestIdentityFunctionPatching(kIdentityCodeWithPrologue, override, prefix); 350 TestIdentityFunctionPatching(kIdentityCodeWithPushPop, override, prefix); 351 352 prefix = FunctionPrefixPadding; 353 TestIdentityFunctionPatching(kIdentityCodeWithPrologue, override, prefix); 354 TestIdentityFunctionPatching(kIdentityCodeWithPushPop, override, prefix); 355 } 356 357 TEST(Interception, OverrideFunction) { 358 TestOverrideFunction override = OverrideFunction; 359 FunctionPrefixKind prefix = FunctionPrefixNone; 360 TestIdentityFunctionPatching(kIdentityCodeWithPrologue, override, prefix); 361 TestIdentityFunctionPatching(kIdentityCodeWithPushPop, override, prefix); 362 TestIdentityFunctionPatching(kIdentityCodeWithJump, override, prefix); 363 364 prefix = FunctionPrefixPadding; 365 TestIdentityFunctionPatching(kIdentityCodeWithPrologue, override, prefix); 366 TestIdentityFunctionPatching(kIdentityCodeWithPushPop, override, prefix); 367 TestIdentityFunctionPatching(kIdentityCodeWithMov, override, prefix); 368 TestIdentityFunctionPatching(kIdentityCodeWithJump, override, prefix); 369 370 prefix = FunctionPrefixHotPatch; 371 TestIdentityFunctionPatching(kIdentityCodeWithPrologue, override, prefix); 372 TestIdentityFunctionPatching(kIdentityCodeWithPushPop, override, prefix); 373 TestIdentityFunctionPatching(kIdentityCodeWithMov, override, prefix); 374 TestIdentityFunctionPatching(kIdentityCodeWithJump, override, prefix); 375 376 prefix = FunctionPrefixDetour; 377 TestIdentityFunctionPatching(kIdentityCodeWithPrologue, override, prefix); 378 TestIdentityFunctionPatching(kIdentityCodeWithPushPop, override, prefix); 379 TestIdentityFunctionPatching(kIdentityCodeWithMov, override, prefix); 380 TestIdentityFunctionPatching(kIdentityCodeWithJump, override, prefix); 381 } 382 383 template<class T> 384 static void TestIdentityFunctionMultiplePatching( 385 const T &code, 386 TestOverrideFunction override, 387 FunctionPrefixKind prefix_kind = FunctionPrefixNone) { 388 uptr identity_address; 389 LoadActiveCode(code, &identity_address, prefix_kind); 390 391 // Patch the function. 392 uptr real_identity_address = 0; 393 bool success = override(identity_address, 394 (uptr)&InterceptorFunction, 395 &real_identity_address); 396 EXPECT_TRUE(success); 397 EXPECT_NE(0U, real_identity_address); 398 399 // Re-patching the function should not work. 400 success = override(identity_address, 401 (uptr)&InterceptorFunction, 402 &real_identity_address); 403 EXPECT_FALSE(success); 404 405 TestOnlyReleaseTrampolineRegions(); 406 } 407 408 TEST(Interception, OverrideFunctionMultiplePatchingIsFailing) { 409 #if !SANITIZER_WINDOWS64 410 TestIdentityFunctionMultiplePatching(kIdentityCodeWithPrologue, 411 OverrideFunctionWithDetour, 412 FunctionPrefixDetour); 413 #endif 414 415 TestIdentityFunctionMultiplePatching(kIdentityCodeWithMov, 416 OverrideFunctionWithHotPatch, 417 FunctionPrefixHotPatch); 418 419 TestIdentityFunctionMultiplePatching(kIdentityCodeWithPushPop, 420 OverrideFunctionWithTrampoline, 421 FunctionPrefixPadding); 422 } 423 424 TEST(Interception, OverrideFunctionTwice) { 425 uptr identity_address1; 426 LoadActiveCode(kIdentityTwice, &identity_address1); 427 uptr identity_address2 = identity_address1 + kIdentityTwiceOffset; 428 IdentityFunction identity1 = (IdentityFunction)identity_address1; 429 IdentityFunction identity2 = (IdentityFunction)identity_address2; 430 431 // Patch the two functions. 432 uptr real_identity_address = 0; 433 EXPECT_TRUE(OverrideFunction(identity_address1, 434 (uptr)&InterceptorFunction, 435 &real_identity_address)); 436 EXPECT_TRUE(OverrideFunction(identity_address2, 437 (uptr)&InterceptorFunction, 438 &real_identity_address)); 439 IdentityFunction real_identity = (IdentityFunction)real_identity_address; 440 InterceptedRealFunction = real_identity; 441 442 // Calling the redirected function. 443 InterceptorFunctionCalled = 0; 444 EXPECT_EQ(42, identity1(42)); 445 EXPECT_EQ(42, identity2(42)); 446 EXPECT_EQ(2, InterceptorFunctionCalled); 447 448 TestOnlyReleaseTrampolineRegions(); 449 } 450 451 template<class T> 452 static bool TestFunctionPatching( 453 const T &code, 454 TestOverrideFunction override, 455 FunctionPrefixKind prefix_kind = FunctionPrefixNone) { 456 uptr address; 457 LoadActiveCode(code, &address, prefix_kind); 458 uptr unused_real_address = 0; 459 bool result = override( 460 address, (uptr)&InterceptorFunction, &unused_real_address); 461 462 TestOnlyReleaseTrampolineRegions(); 463 return result; 464 } 465 466 TEST(Interception, PatchableFunction) { 467 TestOverrideFunction override = OverrideFunction; 468 // Test without function padding. 469 EXPECT_TRUE(TestFunctionPatching(kPatchableCode1, override)); 470 EXPECT_TRUE(TestFunctionPatching(kPatchableCode2, override)); 471 #if SANITIZER_WINDOWS64 472 EXPECT_FALSE(TestFunctionPatching(kPatchableCode3, override)); 473 #else 474 EXPECT_TRUE(TestFunctionPatching(kPatchableCode3, override)); 475 #endif 476 EXPECT_TRUE(TestFunctionPatching(kPatchableCode4, override)); 477 478 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode1, override)); 479 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode2, override)); 480 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode3, override)); 481 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode4, override)); 482 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode5, override)); 483 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode6, override)); 484 } 485 486 #if !SANITIZER_WINDOWS64 487 TEST(Interception, PatchableFunctionWithDetour) { 488 TestOverrideFunction override = OverrideFunctionWithDetour; 489 // Without the prefix, no function can be detoured. 490 EXPECT_FALSE(TestFunctionPatching(kPatchableCode1, override)); 491 EXPECT_FALSE(TestFunctionPatching(kPatchableCode2, override)); 492 EXPECT_FALSE(TestFunctionPatching(kPatchableCode3, override)); 493 EXPECT_FALSE(TestFunctionPatching(kPatchableCode4, override)); 494 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode1, override)); 495 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode2, override)); 496 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode3, override)); 497 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode4, override)); 498 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode5, override)); 499 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode6, override)); 500 501 // With the prefix, all functions can be detoured. 502 FunctionPrefixKind prefix = FunctionPrefixDetour; 503 EXPECT_TRUE(TestFunctionPatching(kPatchableCode1, override, prefix)); 504 EXPECT_TRUE(TestFunctionPatching(kPatchableCode2, override, prefix)); 505 EXPECT_TRUE(TestFunctionPatching(kPatchableCode3, override, prefix)); 506 EXPECT_TRUE(TestFunctionPatching(kPatchableCode4, override, prefix)); 507 EXPECT_TRUE(TestFunctionPatching(kUnpatchableCode1, override, prefix)); 508 EXPECT_TRUE(TestFunctionPatching(kUnpatchableCode2, override, prefix)); 509 EXPECT_TRUE(TestFunctionPatching(kUnpatchableCode3, override, prefix)); 510 EXPECT_TRUE(TestFunctionPatching(kUnpatchableCode4, override, prefix)); 511 EXPECT_TRUE(TestFunctionPatching(kUnpatchableCode5, override, prefix)); 512 EXPECT_TRUE(TestFunctionPatching(kUnpatchableCode6, override, prefix)); 513 } 514 #endif // !SANITIZER_WINDOWS64 515 516 TEST(Interception, PatchableFunctionWithRedirectJump) { 517 TestOverrideFunction override = OverrideFunctionWithRedirectJump; 518 EXPECT_FALSE(TestFunctionPatching(kPatchableCode1, override)); 519 EXPECT_FALSE(TestFunctionPatching(kPatchableCode2, override)); 520 EXPECT_FALSE(TestFunctionPatching(kPatchableCode3, override)); 521 EXPECT_TRUE(TestFunctionPatching(kPatchableCode4, override)); 522 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode1, override)); 523 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode2, override)); 524 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode3, override)); 525 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode4, override)); 526 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode5, override)); 527 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode6, override)); 528 } 529 530 TEST(Interception, PatchableFunctionWithHotPatch) { 531 TestOverrideFunction override = OverrideFunctionWithHotPatch; 532 FunctionPrefixKind prefix = FunctionPrefixHotPatch; 533 534 EXPECT_TRUE(TestFunctionPatching(kPatchableCode1, override, prefix)); 535 EXPECT_FALSE(TestFunctionPatching(kPatchableCode2, override, prefix)); 536 EXPECT_FALSE(TestFunctionPatching(kPatchableCode3, override, prefix)); 537 EXPECT_FALSE(TestFunctionPatching(kPatchableCode4, override, prefix)); 538 539 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode1, override, prefix)); 540 EXPECT_TRUE(TestFunctionPatching(kUnpatchableCode2, override, prefix)); 541 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode3, override, prefix)); 542 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode4, override, prefix)); 543 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode5, override, prefix)); 544 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode6, override, prefix)); 545 } 546 547 TEST(Interception, PatchableFunctionWithTrampoline) { 548 TestOverrideFunction override = OverrideFunctionWithTrampoline; 549 FunctionPrefixKind prefix = FunctionPrefixPadding; 550 551 EXPECT_TRUE(TestFunctionPatching(kPatchableCode1, override, prefix)); 552 EXPECT_TRUE(TestFunctionPatching(kPatchableCode2, override, prefix)); 553 #if SANITIZER_WINDOWS64 554 EXPECT_FALSE(TestFunctionPatching(kPatchableCode3, override, prefix)); 555 #else 556 EXPECT_TRUE(TestFunctionPatching(kPatchableCode3, override, prefix)); 557 #endif 558 EXPECT_FALSE(TestFunctionPatching(kPatchableCode4, override, prefix)); 559 560 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode1, override, prefix)); 561 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode2, override, prefix)); 562 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode3, override, prefix)); 563 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode4, override, prefix)); 564 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode5, override, prefix)); 565 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode6, override, prefix)); 566 } 567 568 TEST(Interception, PatchableFunctionPadding) { 569 TestOverrideFunction override = OverrideFunction; 570 FunctionPrefixKind prefix = FunctionPrefixPadding; 571 572 EXPECT_TRUE(TestFunctionPatching(kPatchableCode1, override, prefix)); 573 EXPECT_TRUE(TestFunctionPatching(kPatchableCode2, override, prefix)); 574 #if SANITIZER_WINDOWS64 575 EXPECT_FALSE(TestFunctionPatching(kPatchableCode3, override, prefix)); 576 #else 577 EXPECT_TRUE(TestFunctionPatching(kPatchableCode3, override, prefix)); 578 #endif 579 EXPECT_TRUE(TestFunctionPatching(kPatchableCode4, override, prefix)); 580 581 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode1, override, prefix)); 582 EXPECT_TRUE(TestFunctionPatching(kUnpatchableCode2, override, prefix)); 583 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode3, override, prefix)); 584 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode4, override, prefix)); 585 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode5, override, prefix)); 586 EXPECT_FALSE(TestFunctionPatching(kUnpatchableCode6, override, prefix)); 587 } 588 589 } // namespace __interception 590 591 #endif // SANITIZER_WINDOWS 592 #endif // #if !SANITIZER_DEBUG 593
