1 //===-- asan_interceptors.cpp ---------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file is a part of AddressSanitizer, an address sanity checker. 10 // 11 // Intercept various libc functions. 12 //===----------------------------------------------------------------------===// 13 14 #include "asan_interceptors.h" 15 16 #include "asan_allocator.h" 17 #include "asan_internal.h" 18 #include "asan_mapping.h" 19 #include "asan_poisoning.h" 20 #include "asan_report.h" 21 #include "asan_stack.h" 22 #include "asan_stats.h" 23 #include "asan_suppressions.h" 24 #include "asan_thread.h" 25 #include "lsan/lsan_common.h" 26 #include "sanitizer_common/sanitizer_errno.h" 27 #include "sanitizer_common/sanitizer_internal_defs.h" 28 #include "sanitizer_common/sanitizer_libc.h" 29 30 // There is no general interception at all on Fuchsia. 31 // Only the functions in asan_interceptors_memintrinsics.cpp are 32 // really defined to replace libc functions. 33 #if !SANITIZER_FUCHSIA 34 35 # if SANITIZER_POSIX 36 # include "sanitizer_common/sanitizer_posix.h" 37 # endif 38 39 # if ASAN_INTERCEPT__UNWIND_RAISEEXCEPTION || \ 40 ASAN_INTERCEPT__SJLJ_UNWIND_RAISEEXCEPTION 41 # include <unwind.h> 42 # endif 43 44 # if defined(__i386) && SANITIZER_LINUX 45 # define ASAN_PTHREAD_CREATE_VERSION "GLIBC_2.1" 46 # elif defined(__mips__) && SANITIZER_LINUX 47 # define ASAN_PTHREAD_CREATE_VERSION "GLIBC_2.2" 48 # endif 49 50 namespace __asan { 51 52 #define ASAN_READ_STRING_OF_LEN(ctx, s, len, n) \ 53 ASAN_READ_RANGE((ctx), (s), \ 54 common_flags()->strict_string_checks ? (len) + 1 : (n)) 55 56 # define ASAN_READ_STRING(ctx, s, n) \ 57 ASAN_READ_STRING_OF_LEN((ctx), (s), internal_strlen(s), (n)) 58 59 static inline uptr MaybeRealStrnlen(const char *s, uptr maxlen) { 60 #if SANITIZER_INTERCEPT_STRNLEN 61 if (REAL(strnlen)) { 62 return REAL(strnlen)(s, maxlen); 63 } 64 #endif 65 return internal_strnlen(s, maxlen); 66 } 67 68 void SetThreadName(const char *name) { 69 AsanThread *t = GetCurrentThread(); 70 if (t) 71 asanThreadRegistry().SetThreadName(t->tid(), name); 72 } 73 74 int OnExit() { 75 if (CAN_SANITIZE_LEAKS && common_flags()->detect_leaks && 76 __lsan::HasReportedLeaks()) { 77 return common_flags()->exitcode; 78 } 79 // FIXME: ask frontend whether we need to return failure. 80 return 0; 81 } 82 83 } // namespace __asan 84 85 // ---------------------- Wrappers ---------------- {{{1 86 using namespace __asan; 87 88 DECLARE_REAL_AND_INTERCEPTOR(void *, malloc, uptr) 89 DECLARE_REAL_AND_INTERCEPTOR(void, free, void *) 90 91 #define COMMON_INTERCEPT_FUNCTION_VER(name, ver) \ 92 ASAN_INTERCEPT_FUNC_VER(name, ver) 93 #define COMMON_INTERCEPT_FUNCTION_VER_UNVERSIONED_FALLBACK(name, ver) \ 94 ASAN_INTERCEPT_FUNC_VER_UNVERSIONED_FALLBACK(name, ver) 95 #define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \ 96 ASAN_WRITE_RANGE(ctx, ptr, size) 97 #define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \ 98 ASAN_READ_RANGE(ctx, ptr, size) 99 # define COMMON_INTERCEPTOR_ENTER(ctx, func, ...) \ 100 ASAN_INTERCEPTOR_ENTER(ctx, func); \ 101 do { \ 102 if constexpr (SANITIZER_APPLE) { \ 103 if (UNLIKELY(!AsanInited())) \ 104 return REAL(func)(__VA_ARGS__); \ 105 } else { \ 106 if (!TryAsanInitFromRtl()) \ 107 return REAL(func)(__VA_ARGS__); \ 108 } \ 109 } while (false) 110 #define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \ 111 do { \ 112 } while (false) 113 #define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \ 114 do { \ 115 } while (false) 116 #define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \ 117 do { \ 118 } while (false) 119 #define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \ 120 do { \ 121 } while (false) 122 #define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) SetThreadName(name) 123 // Should be asanThreadRegistry().SetThreadNameByUserId(thread, name) 124 // But asan does not remember UserId's for threads (pthread_t); 125 // and remembers all ever existed threads, so the linear search by UserId 126 // can be slow. 127 #define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \ 128 do { \ 129 } while (false) 130 #define COMMON_INTERCEPTOR_BLOCK_REAL(name) REAL(name) 131 // Strict init-order checking is dlopen-hostile: 132 // https://github.com/google/sanitizers/issues/178 133 # define COMMON_INTERCEPTOR_DLOPEN(filename, flag) \ 134 ({ \ 135 if (flags()->strict_init_order) \ 136 StopInitOrderChecking(); \ 137 CheckNoDeepBind(filename, flag); \ 138 REAL(dlopen)(filename, flag); \ 139 }) 140 # define COMMON_INTERCEPTOR_ON_EXIT(ctx) OnExit() 141 # define COMMON_INTERCEPTOR_LIBRARY_LOADED(filename, handle) 142 # define COMMON_INTERCEPTOR_LIBRARY_UNLOADED() 143 # define COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED (!AsanInited()) 144 # define COMMON_INTERCEPTOR_GET_TLS_RANGE(begin, end) \ 145 if (AsanThread *t = GetCurrentThread()) { \ 146 *begin = t->tls_begin(); \ 147 *end = t->tls_end(); \ 148 } else { \ 149 *begin = *end = 0; \ 150 } 151 152 template <class Mmap> 153 static void* mmap_interceptor(Mmap real_mmap, void *addr, SIZE_T length, 154 int prot, int flags, int fd, OFF64_T offset) { 155 void *res = real_mmap(addr, length, prot, flags, fd, offset); 156 if (length && res != (void *)-1) { 157 const uptr beg = reinterpret_cast<uptr>(res); 158 DCHECK(IsAligned(beg, GetPageSize())); 159 SIZE_T rounded_length = RoundUpTo(length, GetPageSize()); 160 // Only unpoison shadow if it's an ASAN managed address. 161 if (AddrIsInMem(beg) && AddrIsInMem(beg + rounded_length - 1)) 162 PoisonShadow(beg, RoundUpTo(length, GetPageSize()), 0); 163 } 164 return res; 165 } 166 167 template <class Munmap> 168 static int munmap_interceptor(Munmap real_munmap, void *addr, SIZE_T length) { 169 // We should not tag if munmap fail, but it's to late to tag after 170 // real_munmap, as the pages could be mmaped by another thread. 171 const uptr beg = reinterpret_cast<uptr>(addr); 172 if (length && IsAligned(beg, GetPageSize())) { 173 SIZE_T rounded_length = RoundUpTo(length, GetPageSize()); 174 // Protect from unmapping the shadow. 175 if (AddrIsInMem(beg) && AddrIsInMem(beg + rounded_length - 1)) 176 PoisonShadow(beg, rounded_length, 0); 177 } 178 return real_munmap(addr, length); 179 } 180 181 # define COMMON_INTERCEPTOR_MMAP_IMPL(ctx, mmap, addr, length, prot, flags, \ 182 fd, offset) \ 183 do { \ 184 (void)(ctx); \ 185 return mmap_interceptor(REAL(mmap), addr, sz, prot, flags, fd, off); \ 186 } while (false) 187 188 # define COMMON_INTERCEPTOR_MUNMAP_IMPL(ctx, addr, length) \ 189 do { \ 190 (void)(ctx); \ 191 return munmap_interceptor(REAL(munmap), addr, sz); \ 192 } while (false) 193 194 #if CAN_SANITIZE_LEAKS 195 #define COMMON_INTERCEPTOR_STRERROR() \ 196 __lsan::ScopedInterceptorDisabler disabler 197 #endif 198 199 # define SIGNAL_INTERCEPTOR_ENTER() \ 200 do { \ 201 AsanInitFromRtl(); \ 202 } while (false) 203 204 # include "sanitizer_common/sanitizer_common_interceptors.inc" 205 # include "sanitizer_common/sanitizer_signal_interceptors.inc" 206 207 // Syscall interceptors don't have contexts, we don't support suppressions 208 // for them. 209 #define COMMON_SYSCALL_PRE_READ_RANGE(p, s) ASAN_READ_RANGE(nullptr, p, s) 210 #define COMMON_SYSCALL_PRE_WRITE_RANGE(p, s) ASAN_WRITE_RANGE(nullptr, p, s) 211 #define COMMON_SYSCALL_POST_READ_RANGE(p, s) \ 212 do { \ 213 (void)(p); \ 214 (void)(s); \ 215 } while (false) 216 #define COMMON_SYSCALL_POST_WRITE_RANGE(p, s) \ 217 do { \ 218 (void)(p); \ 219 (void)(s); \ 220 } while (false) 221 #include "sanitizer_common/sanitizer_common_syscalls.inc" 222 #include "sanitizer_common/sanitizer_syscalls_netbsd.inc" 223 224 #if ASAN_INTERCEPT_PTHREAD_CREATE 225 static thread_return_t THREAD_CALLING_CONV asan_thread_start(void *arg) { 226 AsanThread *t = (AsanThread *)arg; 227 SetCurrentThread(t); 228 auto self = GetThreadSelf(); 229 auto args = asanThreadArgRetval().GetArgs(self); 230 t->ThreadStart(GetTid()); 231 232 # if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \ 233 SANITIZER_SOLARIS 234 __sanitizer_sigset_t sigset; 235 t->GetStartData(sigset); 236 SetSigProcMask(&sigset, nullptr); 237 # endif 238 239 thread_return_t retval = (*args.routine)(args.arg_retval); 240 asanThreadArgRetval().Finish(self, retval); 241 return retval; 242 } 243 244 INTERCEPTOR(int, pthread_create, void *thread, void *attr, 245 void *(*start_routine)(void *), void *arg) { 246 EnsureMainThreadIDIsCorrect(); 247 // Strict init-order checking is thread-hostile. 248 if (flags()->strict_init_order) 249 StopInitOrderChecking(); 250 GET_STACK_TRACE_THREAD; 251 bool detached = [attr]() { 252 int d = 0; 253 return attr && !REAL(pthread_attr_getdetachstate)(attr, &d) && 254 IsStateDetached(d); 255 }(); 256 257 u32 current_tid = GetCurrentTidOrInvalid(); 258 259 __sanitizer_sigset_t sigset = {}; 260 # if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \ 261 SANITIZER_SOLARIS 262 ScopedBlockSignals block(&sigset); 263 # endif 264 265 AsanThread *t = AsanThread::Create(sigset, current_tid, &stack, detached); 266 267 int result; 268 { 269 // Ignore all allocations made by pthread_create: thread stack/TLS may be 270 // stored by pthread for future reuse even after thread destruction, and 271 // the linked list it's stored in doesn't even hold valid pointers to the 272 // objects, the latter are calculated by obscure pointer arithmetic. 273 # if CAN_SANITIZE_LEAKS 274 __lsan::ScopedInterceptorDisabler disabler; 275 # endif 276 asanThreadArgRetval().Create(detached, {start_routine, arg}, [&]() -> uptr { 277 result = REAL(pthread_create)(thread, attr, asan_thread_start, t); 278 return result ? 0 : *(uptr *)(thread); 279 }); 280 } 281 if (result != 0) { 282 // If the thread didn't start delete the AsanThread to avoid leaking it. 283 // Note AsanThreadContexts never get destroyed so the AsanThreadContext 284 // that was just created for the AsanThread is wasted. 285 t->Destroy(); 286 } 287 return result; 288 } 289 290 INTERCEPTOR(int, pthread_join, void *thread, void **retval) { 291 int result; 292 asanThreadArgRetval().Join((uptr)thread, [&]() { 293 result = REAL(pthread_join)(thread, retval); 294 return !result; 295 }); 296 return result; 297 } 298 299 INTERCEPTOR(int, pthread_detach, void *thread) { 300 int result; 301 asanThreadArgRetval().Detach((uptr)thread, [&]() { 302 result = REAL(pthread_detach)(thread); 303 return !result; 304 }); 305 return result; 306 } 307 308 INTERCEPTOR(void, pthread_exit, void *retval) { 309 asanThreadArgRetval().Finish(GetThreadSelf(), retval); 310 REAL(pthread_exit)(retval); 311 } 312 313 # if ASAN_INTERCEPT_TRYJOIN 314 INTERCEPTOR(int, pthread_tryjoin_np, void *thread, void **ret) { 315 int result; 316 asanThreadArgRetval().Join((uptr)thread, [&]() { 317 result = REAL(pthread_tryjoin_np)(thread, ret); 318 return !result; 319 }); 320 return result; 321 } 322 # endif 323 324 # if ASAN_INTERCEPT_TIMEDJOIN 325 INTERCEPTOR(int, pthread_timedjoin_np, void *thread, void **ret, 326 const struct timespec *abstime) { 327 int result; 328 asanThreadArgRetval().Join((uptr)thread, [&]() { 329 result = REAL(pthread_timedjoin_np)(thread, ret, abstime); 330 return !result; 331 }); 332 return result; 333 } 334 # endif 335 336 DEFINE_REAL_PTHREAD_FUNCTIONS 337 #endif // ASAN_INTERCEPT_PTHREAD_CREATE 338 339 #if ASAN_INTERCEPT_SWAPCONTEXT 340 static void ClearShadowMemoryForContextStack(uptr stack, uptr ssize) { 341 // Only clear if we know the stack. This should be true only for contexts 342 // created with makecontext(). 343 if (!ssize) 344 return; 345 // Align to page size. 346 uptr PageSize = GetPageSizeCached(); 347 uptr bottom = RoundDownTo(stack, PageSize); 348 if (!AddrIsInMem(bottom)) 349 return; 350 ssize += stack - bottom; 351 ssize = RoundUpTo(ssize, PageSize); 352 PoisonShadow(bottom, ssize, 0); 353 } 354 355 INTERCEPTOR(void, makecontext, struct ucontext_t *ucp, void (*func)(), int argc, 356 ...) { 357 va_list ap; 358 uptr args[64]; 359 // We don't know a better way to forward ... into REAL function. We can 360 // increase args size if neccecary. 361 CHECK_LE(argc, ARRAY_SIZE(args)); 362 internal_memset(args, 0, sizeof(args)); 363 va_start(ap, argc); 364 for (int i = 0; i < argc; ++i) args[i] = va_arg(ap, uptr); 365 va_end(ap); 366 367 # define ENUMERATE_ARRAY_4(start) \ 368 args[start], args[start + 1], args[start + 2], args[start + 3] 369 # define ENUMERATE_ARRAY_16(start) \ 370 ENUMERATE_ARRAY_4(start), ENUMERATE_ARRAY_4(start + 4), \ 371 ENUMERATE_ARRAY_4(start + 8), ENUMERATE_ARRAY_4(start + 12) 372 # define ENUMERATE_ARRAY_64() \ 373 ENUMERATE_ARRAY_16(0), ENUMERATE_ARRAY_16(16), ENUMERATE_ARRAY_16(32), \ 374 ENUMERATE_ARRAY_16(48) 375 376 REAL(makecontext) 377 ((struct ucontext_t *)ucp, func, argc, ENUMERATE_ARRAY_64()); 378 379 # undef ENUMERATE_ARRAY_4 380 # undef ENUMERATE_ARRAY_16 381 # undef ENUMERATE_ARRAY_64 382 383 // Sign the stack so we can identify it for unpoisoning. 384 SignContextStack(ucp); 385 } 386 387 INTERCEPTOR(int, swapcontext, struct ucontext_t *oucp, 388 struct ucontext_t *ucp) { 389 static bool reported_warning = false; 390 if (!reported_warning) { 391 Report("WARNING: ASan doesn't fully support makecontext/swapcontext " 392 "functions and may produce false positives in some cases!\n"); 393 reported_warning = true; 394 } 395 // Clear shadow memory for new context (it may share stack 396 // with current context). 397 uptr stack, ssize; 398 ReadContextStack(ucp, &stack, &ssize); 399 ClearShadowMemoryForContextStack(stack, ssize); 400 401 # if __has_attribute(__indirect_return__) && \ 402 (defined(__x86_64__) || defined(__i386__)) 403 int (*real_swapcontext)(struct ucontext_t *, struct ucontext_t *) 404 __attribute__((__indirect_return__)) = REAL(swapcontext); 405 int res = real_swapcontext(oucp, ucp); 406 # else 407 int res = REAL(swapcontext)(oucp, ucp); 408 # endif 409 // swapcontext technically does not return, but program may swap context to 410 // "oucp" later, that would look as if swapcontext() returned 0. 411 // We need to clear shadow for ucp once again, as it may be in arbitrary 412 // state. 413 ClearShadowMemoryForContextStack(stack, ssize); 414 return res; 415 } 416 #endif // ASAN_INTERCEPT_SWAPCONTEXT 417 418 #if SANITIZER_NETBSD 419 #define longjmp __longjmp14 420 #define siglongjmp __siglongjmp14 421 #endif 422 423 INTERCEPTOR(void, longjmp, void *env, int val) { 424 __asan_handle_no_return(); 425 REAL(longjmp)(env, val); 426 } 427 428 #if ASAN_INTERCEPT__LONGJMP 429 INTERCEPTOR(void, _longjmp, void *env, int val) { 430 __asan_handle_no_return(); 431 REAL(_longjmp)(env, val); 432 } 433 #endif 434 435 #if ASAN_INTERCEPT___LONGJMP_CHK 436 INTERCEPTOR(void, __longjmp_chk, void *env, int val) { 437 __asan_handle_no_return(); 438 REAL(__longjmp_chk)(env, val); 439 } 440 #endif 441 442 #if ASAN_INTERCEPT_SIGLONGJMP 443 INTERCEPTOR(void, siglongjmp, void *env, int val) { 444 __asan_handle_no_return(); 445 REAL(siglongjmp)(env, val); 446 } 447 #endif 448 449 #if ASAN_INTERCEPT___CXA_THROW 450 INTERCEPTOR(void, __cxa_throw, void *a, void *b, void *c) { 451 CHECK(REAL(__cxa_throw)); 452 __asan_handle_no_return(); 453 REAL(__cxa_throw)(a, b, c); 454 } 455 #endif 456 457 #if ASAN_INTERCEPT___CXA_RETHROW_PRIMARY_EXCEPTION 458 INTERCEPTOR(void, __cxa_rethrow_primary_exception, void *a) { 459 CHECK(REAL(__cxa_rethrow_primary_exception)); 460 __asan_handle_no_return(); 461 REAL(__cxa_rethrow_primary_exception)(a); 462 } 463 #endif 464 465 #if ASAN_INTERCEPT__UNWIND_RAISEEXCEPTION 466 INTERCEPTOR(_Unwind_Reason_Code, _Unwind_RaiseException, 467 _Unwind_Exception *object) { 468 CHECK(REAL(_Unwind_RaiseException)); 469 __asan_handle_no_return(); 470 return REAL(_Unwind_RaiseException)(object); 471 } 472 #endif 473 474 #if ASAN_INTERCEPT__SJLJ_UNWIND_RAISEEXCEPTION 475 INTERCEPTOR(_Unwind_Reason_Code, _Unwind_SjLj_RaiseException, 476 _Unwind_Exception *object) { 477 CHECK(REAL(_Unwind_SjLj_RaiseException)); 478 __asan_handle_no_return(); 479 return REAL(_Unwind_SjLj_RaiseException)(object); 480 } 481 #endif 482 483 #if ASAN_INTERCEPT_INDEX 484 # if ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX 485 INTERCEPTOR(char*, index, const char *string, int c) 486 ALIAS(WRAP(strchr)); 487 # else 488 # if SANITIZER_APPLE 489 DECLARE_REAL(char*, index, const char *string, int c) 490 OVERRIDE_FUNCTION(index, strchr); 491 # else 492 DEFINE_REAL(char*, index, const char *string, int c) 493 # endif 494 # endif 495 #endif // ASAN_INTERCEPT_INDEX 496 497 // For both strcat() and strncat() we need to check the validity of |to| 498 // argument irrespective of the |from| length. 499 INTERCEPTOR(char *, strcat, char *to, const char *from) { 500 void *ctx; 501 ASAN_INTERCEPTOR_ENTER(ctx, strcat); 502 AsanInitFromRtl(); 503 if (flags()->replace_str) { 504 uptr from_length = internal_strlen(from); 505 ASAN_READ_RANGE(ctx, from, from_length + 1); 506 uptr to_length = internal_strlen(to); 507 ASAN_READ_STRING_OF_LEN(ctx, to, to_length, to_length); 508 ASAN_WRITE_RANGE(ctx, to + to_length, from_length + 1); 509 // If the copying actually happens, the |from| string should not overlap 510 // with the resulting string starting at |to|, which has a length of 511 // to_length + from_length + 1. 512 if (from_length > 0) { 513 CHECK_RANGES_OVERLAP("strcat", to, from_length + to_length + 1, from, 514 from_length + 1); 515 } 516 } 517 return REAL(strcat)(to, from); 518 } 519 520 INTERCEPTOR(char*, strncat, char *to, const char *from, uptr size) { 521 void *ctx; 522 ASAN_INTERCEPTOR_ENTER(ctx, strncat); 523 AsanInitFromRtl(); 524 if (flags()->replace_str) { 525 uptr from_length = MaybeRealStrnlen(from, size); 526 uptr copy_length = Min(size, from_length + 1); 527 ASAN_READ_RANGE(ctx, from, copy_length); 528 uptr to_length = internal_strlen(to); 529 ASAN_READ_STRING_OF_LEN(ctx, to, to_length, to_length); 530 ASAN_WRITE_RANGE(ctx, to + to_length, from_length + 1); 531 if (from_length > 0) { 532 CHECK_RANGES_OVERLAP("strncat", to, to_length + copy_length + 1, 533 from, copy_length); 534 } 535 } 536 return REAL(strncat)(to, from, size); 537 } 538 539 INTERCEPTOR(char *, strcpy, char *to, const char *from) { 540 void *ctx; 541 ASAN_INTERCEPTOR_ENTER(ctx, strcpy); 542 if constexpr (SANITIZER_APPLE) { 543 // strcpy is called from malloc_default_purgeable_zone() 544 // in __asan::ReplaceSystemAlloc() on Mac. 545 if (UNLIKELY(!AsanInited())) 546 return REAL(strcpy)(to, from); 547 } else { 548 if (!TryAsanInitFromRtl()) 549 return REAL(strcpy)(to, from); 550 } 551 552 if (flags()->replace_str) { 553 uptr from_size = internal_strlen(from) + 1; 554 CHECK_RANGES_OVERLAP("strcpy", to, from_size, from, from_size); 555 ASAN_READ_RANGE(ctx, from, from_size); 556 ASAN_WRITE_RANGE(ctx, to, from_size); 557 } 558 return REAL(strcpy)(to, from); 559 } 560 561 INTERCEPTOR(char*, strdup, const char *s) { 562 void *ctx; 563 ASAN_INTERCEPTOR_ENTER(ctx, strdup); 564 if (UNLIKELY(!TryAsanInitFromRtl())) 565 return internal_strdup(s); 566 uptr length = internal_strlen(s); 567 if (flags()->replace_str) { 568 ASAN_READ_RANGE(ctx, s, length + 1); 569 } 570 GET_STACK_TRACE_MALLOC; 571 void *new_mem = asan_malloc(length + 1, &stack); 572 if (new_mem) { 573 REAL(memcpy)(new_mem, s, length + 1); 574 } 575 return reinterpret_cast<char*>(new_mem); 576 } 577 578 #if ASAN_INTERCEPT___STRDUP 579 INTERCEPTOR(char*, __strdup, const char *s) { 580 void *ctx; 581 ASAN_INTERCEPTOR_ENTER(ctx, strdup); 582 if (UNLIKELY(!TryAsanInitFromRtl())) 583 return internal_strdup(s); 584 uptr length = internal_strlen(s); 585 if (flags()->replace_str) { 586 ASAN_READ_RANGE(ctx, s, length + 1); 587 } 588 GET_STACK_TRACE_MALLOC; 589 void *new_mem = asan_malloc(length + 1, &stack); 590 if (new_mem) { 591 REAL(memcpy)(new_mem, s, length + 1); 592 } 593 return reinterpret_cast<char*>(new_mem); 594 } 595 #endif // ASAN_INTERCEPT___STRDUP 596 597 INTERCEPTOR(char*, strncpy, char *to, const char *from, uptr size) { 598 void *ctx; 599 ASAN_INTERCEPTOR_ENTER(ctx, strncpy); 600 AsanInitFromRtl(); 601 if (flags()->replace_str) { 602 uptr from_size = Min(size, MaybeRealStrnlen(from, size) + 1); 603 CHECK_RANGES_OVERLAP("strncpy", to, from_size, from, from_size); 604 ASAN_READ_RANGE(ctx, from, from_size); 605 ASAN_WRITE_RANGE(ctx, to, size); 606 } 607 return REAL(strncpy)(to, from, size); 608 } 609 610 template <typename Fn> 611 static ALWAYS_INLINE auto StrtolImpl(void *ctx, Fn real, const char *nptr, 612 char **endptr, int base) 613 -> decltype(real(nullptr, nullptr, 0)) { 614 if (!flags()->replace_str) 615 return real(nptr, endptr, base); 616 char *real_endptr; 617 auto res = real(nptr, &real_endptr, base); 618 StrtolFixAndCheck(ctx, nptr, endptr, real_endptr, base); 619 return res; 620 } 621 622 # define INTERCEPTOR_STRTO_BASE(ret_type, func) \ 623 INTERCEPTOR(ret_type, func, const char *nptr, char **endptr, int base) { \ 624 void *ctx; \ 625 ASAN_INTERCEPTOR_ENTER(ctx, func); \ 626 AsanInitFromRtl(); \ 627 return StrtolImpl(ctx, REAL(func), nptr, endptr, base); \ 628 } 629 630 INTERCEPTOR_STRTO_BASE(long, strtol) 631 INTERCEPTOR_STRTO_BASE(long long, strtoll) 632 633 # if SANITIZER_GLIBC 634 INTERCEPTOR_STRTO_BASE(long, __isoc23_strtol) 635 INTERCEPTOR_STRTO_BASE(long long, __isoc23_strtoll) 636 # endif 637 638 INTERCEPTOR(int, atoi, const char *nptr) { 639 void *ctx; 640 ASAN_INTERCEPTOR_ENTER(ctx, atoi); 641 if (SANITIZER_APPLE && UNLIKELY(!AsanInited())) 642 return REAL(atoi)(nptr); 643 AsanInitFromRtl(); 644 if (!flags()->replace_str) { 645 return REAL(atoi)(nptr); 646 } 647 char *real_endptr; 648 // "man atoi" tells that behavior of atoi(nptr) is the same as 649 // strtol(nptr, 0, 10), i.e. it sets errno to ERANGE if the 650 // parsed integer can't be stored in *long* type (even if it's 651 // different from int). So, we just imitate this behavior. 652 int result = REAL(strtol)(nptr, &real_endptr, 10); 653 FixRealStrtolEndptr(nptr, &real_endptr); 654 ASAN_READ_STRING(ctx, nptr, (real_endptr - nptr) + 1); 655 return result; 656 } 657 658 INTERCEPTOR(long, atol, const char *nptr) { 659 void *ctx; 660 ASAN_INTERCEPTOR_ENTER(ctx, atol); 661 if (SANITIZER_APPLE && UNLIKELY(!AsanInited())) 662 return REAL(atol)(nptr); 663 AsanInitFromRtl(); 664 if (!flags()->replace_str) { 665 return REAL(atol)(nptr); 666 } 667 char *real_endptr; 668 long result = REAL(strtol)(nptr, &real_endptr, 10); 669 FixRealStrtolEndptr(nptr, &real_endptr); 670 ASAN_READ_STRING(ctx, nptr, (real_endptr - nptr) + 1); 671 return result; 672 } 673 674 INTERCEPTOR(long long, atoll, const char *nptr) { 675 void *ctx; 676 ASAN_INTERCEPTOR_ENTER(ctx, atoll); 677 AsanInitFromRtl(); 678 if (!flags()->replace_str) { 679 return REAL(atoll)(nptr); 680 } 681 char *real_endptr; 682 long long result = REAL(strtoll)(nptr, &real_endptr, 10); 683 FixRealStrtolEndptr(nptr, &real_endptr); 684 ASAN_READ_STRING(ctx, nptr, (real_endptr - nptr) + 1); 685 return result; 686 } 687 688 #if ASAN_INTERCEPT___CXA_ATEXIT || ASAN_INTERCEPT_ATEXIT 689 static void AtCxaAtexit(void *unused) { 690 (void)unused; 691 StopInitOrderChecking(); 692 } 693 #endif 694 695 #if ASAN_INTERCEPT___CXA_ATEXIT 696 INTERCEPTOR(int, __cxa_atexit, void (*func)(void *), void *arg, 697 void *dso_handle) { 698 if (SANITIZER_APPLE && UNLIKELY(!AsanInited())) 699 return REAL(__cxa_atexit)(func, arg, dso_handle); 700 AsanInitFromRtl(); 701 # if CAN_SANITIZE_LEAKS 702 __lsan::ScopedInterceptorDisabler disabler; 703 #endif 704 int res = REAL(__cxa_atexit)(func, arg, dso_handle); 705 REAL(__cxa_atexit)(AtCxaAtexit, nullptr, nullptr); 706 return res; 707 } 708 #endif // ASAN_INTERCEPT___CXA_ATEXIT 709 710 #if ASAN_INTERCEPT_ATEXIT 711 INTERCEPTOR(int, atexit, void (*func)()) { 712 AsanInitFromRtl(); 713 # if CAN_SANITIZE_LEAKS 714 __lsan::ScopedInterceptorDisabler disabler; 715 #endif 716 // Avoid calling real atexit as it is unreachable on at least on Linux. 717 int res = REAL(__cxa_atexit)((void (*)(void *a))func, nullptr, nullptr); 718 REAL(__cxa_atexit)(AtCxaAtexit, nullptr, nullptr); 719 return res; 720 } 721 #endif 722 723 #if ASAN_INTERCEPT_PTHREAD_ATFORK 724 extern "C" { 725 extern int _pthread_atfork(void (*prepare)(), void (*parent)(), 726 void (*child)()); 727 }; 728 729 INTERCEPTOR(int, pthread_atfork, void (*prepare)(), void (*parent)(), 730 void (*child)()) { 731 #if CAN_SANITIZE_LEAKS 732 __lsan::ScopedInterceptorDisabler disabler; 733 #endif 734 // REAL(pthread_atfork) cannot be called due to symbol indirections at least 735 // on NetBSD 736 return _pthread_atfork(prepare, parent, child); 737 } 738 #endif 739 740 #if ASAN_INTERCEPT_VFORK 741 DEFINE_REAL(int, vfork) 742 DECLARE_EXTERN_INTERCEPTOR_AND_WRAPPER(int, vfork) 743 #endif 744 745 // ---------------------- InitializeAsanInterceptors ---------------- {{{1 746 namespace __asan { 747 void InitializeAsanInterceptors() { 748 static bool was_called_once; 749 CHECK(!was_called_once); 750 was_called_once = true; 751 InitializePlatformInterceptors(); 752 InitializeCommonInterceptors(); 753 InitializeSignalInterceptors(); 754 755 // Intercept str* functions. 756 ASAN_INTERCEPT_FUNC(strcat); 757 ASAN_INTERCEPT_FUNC(strcpy); 758 ASAN_INTERCEPT_FUNC(strncat); 759 ASAN_INTERCEPT_FUNC(strncpy); 760 ASAN_INTERCEPT_FUNC(strdup); 761 #if ASAN_INTERCEPT___STRDUP 762 ASAN_INTERCEPT_FUNC(__strdup); 763 #endif 764 #if ASAN_INTERCEPT_INDEX && ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX 765 ASAN_INTERCEPT_FUNC(index); 766 #endif 767 768 ASAN_INTERCEPT_FUNC(atoi); 769 ASAN_INTERCEPT_FUNC(atol); 770 ASAN_INTERCEPT_FUNC(atoll); 771 ASAN_INTERCEPT_FUNC(strtol); 772 ASAN_INTERCEPT_FUNC(strtoll); 773 # if SANITIZER_GLIBC 774 ASAN_INTERCEPT_FUNC(__isoc23_strtol); 775 ASAN_INTERCEPT_FUNC(__isoc23_strtoll); 776 # endif 777 778 // Intecept jump-related functions. 779 ASAN_INTERCEPT_FUNC(longjmp); 780 781 # if ASAN_INTERCEPT_SWAPCONTEXT 782 ASAN_INTERCEPT_FUNC(swapcontext); 783 ASAN_INTERCEPT_FUNC(makecontext); 784 # endif 785 # if ASAN_INTERCEPT__LONGJMP 786 ASAN_INTERCEPT_FUNC(_longjmp); 787 #endif 788 #if ASAN_INTERCEPT___LONGJMP_CHK 789 ASAN_INTERCEPT_FUNC(__longjmp_chk); 790 #endif 791 #if ASAN_INTERCEPT_SIGLONGJMP 792 ASAN_INTERCEPT_FUNC(siglongjmp); 793 #endif 794 795 // Intercept exception handling functions. 796 #if ASAN_INTERCEPT___CXA_THROW 797 ASAN_INTERCEPT_FUNC(__cxa_throw); 798 #endif 799 #if ASAN_INTERCEPT___CXA_RETHROW_PRIMARY_EXCEPTION 800 ASAN_INTERCEPT_FUNC(__cxa_rethrow_primary_exception); 801 #endif 802 // Indirectly intercept std::rethrow_exception. 803 #if ASAN_INTERCEPT__UNWIND_RAISEEXCEPTION 804 ASAN_INTERCEPT_FUNC(_Unwind_RaiseException); 805 #endif 806 // Indirectly intercept std::rethrow_exception. 807 #if ASAN_INTERCEPT__UNWIND_SJLJ_RAISEEXCEPTION 808 ASAN_INTERCEPT_FUNC(_Unwind_SjLj_RaiseException); 809 #endif 810 811 // Intercept threading-related functions 812 #if ASAN_INTERCEPT_PTHREAD_CREATE 813 // TODO: this should probably have an unversioned fallback for newer arches? 814 #if defined(ASAN_PTHREAD_CREATE_VERSION) 815 ASAN_INTERCEPT_FUNC_VER(pthread_create, ASAN_PTHREAD_CREATE_VERSION); 816 #else 817 ASAN_INTERCEPT_FUNC(pthread_create); 818 #endif 819 ASAN_INTERCEPT_FUNC(pthread_join); 820 ASAN_INTERCEPT_FUNC(pthread_detach); 821 ASAN_INTERCEPT_FUNC(pthread_exit); 822 # endif 823 824 # if ASAN_INTERCEPT_TIMEDJOIN 825 ASAN_INTERCEPT_FUNC(pthread_timedjoin_np); 826 #endif 827 828 #if ASAN_INTERCEPT_TRYJOIN 829 ASAN_INTERCEPT_FUNC(pthread_tryjoin_np); 830 #endif 831 832 // Intercept atexit function. 833 #if ASAN_INTERCEPT___CXA_ATEXIT 834 ASAN_INTERCEPT_FUNC(__cxa_atexit); 835 #endif 836 837 #if ASAN_INTERCEPT_ATEXIT 838 ASAN_INTERCEPT_FUNC(atexit); 839 #endif 840 841 #if ASAN_INTERCEPT_PTHREAD_ATFORK 842 ASAN_INTERCEPT_FUNC(pthread_atfork); 843 #endif 844 845 #if ASAN_INTERCEPT_VFORK 846 ASAN_INTERCEPT_FUNC(vfork); 847 #endif 848 849 VReport(1, "AddressSanitizer: libc interceptors initialized\n"); 850 } 851 852 } // namespace __asan 853 854 #endif // !SANITIZER_FUCHSIA 855