asan_interceptors.cc revision eb2809311c94b73c269ccef8d68ae368642e5754
1//===-- asan_interceptors.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 AddressSanitizer, an address sanity checker. 11// 12// Intercept various libc functions. 13//===----------------------------------------------------------------------===// 14#include "asan_interceptors.h" 15 16#include "asan_allocator.h" 17#include "asan_intercepted_functions.h" 18#include "asan_internal.h" 19#include "asan_mapping.h" 20#include "asan_report.h" 21#include "asan_stack.h" 22#include "asan_stats.h" 23#include "asan_thread_registry.h" 24#include "interception/interception.h" 25#include "sanitizer/asan_interface.h" 26#include "sanitizer_common/sanitizer_libc.h" 27 28namespace __asan { 29 30// We implement ACCESS_MEMORY_RANGE, ASAN_READ_RANGE, 31// and ASAN_WRITE_RANGE as macro instead of function so 32// that no extra frames are created, and stack trace contains 33// relevant information only. 34// We check all shadow bytes. 35#define ACCESS_MEMORY_RANGE(offset, size, isWrite) do { \ 36 if (uptr __ptr = __asan_region_is_poisoned((uptr)(offset), size)) { \ 37 GET_CURRENT_PC_BP_SP; \ 38 __asan_report_error(pc, bp, sp, __ptr, isWrite, /* access_size */1); \ 39 } \ 40} while (0) 41 42#define ASAN_READ_RANGE(offset, size) ACCESS_MEMORY_RANGE(offset, size, false) 43#define ASAN_WRITE_RANGE(offset, size) ACCESS_MEMORY_RANGE(offset, size, true); 44 45// Behavior of functions like "memcpy" or "strcpy" is undefined 46// if memory intervals overlap. We report error in this case. 47// Macro is used to avoid creation of new frames. 48static inline bool RangesOverlap(const char *offset1, uptr length1, 49 const char *offset2, uptr length2) { 50 return !((offset1 + length1 <= offset2) || (offset2 + length2 <= offset1)); 51} 52#define CHECK_RANGES_OVERLAP(name, _offset1, length1, _offset2, length2) do { \ 53 const char *offset1 = (const char*)_offset1; \ 54 const char *offset2 = (const char*)_offset2; \ 55 if (RangesOverlap(offset1, length1, offset2, length2)) { \ 56 GET_STACK_TRACE_FATAL_HERE; \ 57 ReportStringFunctionMemoryRangesOverlap(name, offset1, length1, \ 58 offset2, length2, &stack); \ 59 } \ 60} while (0) 61 62#define ENSURE_ASAN_INITED() do { \ 63 CHECK(!asan_init_is_running); \ 64 if (!asan_inited) { \ 65 __asan_init(); \ 66 } \ 67} while (0) 68 69static inline uptr MaybeRealStrnlen(const char *s, uptr maxlen) { 70#if ASAN_INTERCEPT_STRNLEN 71 if (REAL(strnlen) != 0) { 72 return REAL(strnlen)(s, maxlen); 73 } 74#endif 75 return internal_strnlen(s, maxlen); 76} 77 78} // namespace __asan 79 80// ---------------------- Wrappers ---------------- {{{1 81using namespace __asan; // NOLINT 82 83#define COMMON_INTERCEPTOR_WRITE_RANGE(ptr, size) ASAN_WRITE_RANGE(ptr, size) 84#define COMMON_INTERCEPTOR_READ_RANGE(ptr, size) ASAN_READ_RANGE(ptr, size) 85#define COMMON_INTERCEPTOR_ENTER(func, ...) ENSURE_ASAN_INITED() 86#include "sanitizer_common/sanitizer_common_interceptors.h" 87 88static thread_return_t THREAD_CALLING_CONV asan_thread_start(void *arg) { 89 AsanThread *t = (AsanThread*)arg; 90 asanThreadRegistry().SetCurrent(t); 91 return t->ThreadStart(); 92} 93 94#if ASAN_INTERCEPT_PTHREAD_CREATE 95INTERCEPTOR(int, pthread_create, void *thread, 96 void *attr, void *(*start_routine)(void*), void *arg) { 97 GET_STACK_TRACE_THREAD; 98 u32 current_tid = asanThreadRegistry().GetCurrentTidOrInvalid(); 99 AsanThread *t = AsanThread::Create(current_tid, start_routine, arg, &stack); 100 asanThreadRegistry().RegisterThread(t); 101 return REAL(pthread_create)(thread, attr, asan_thread_start, t); 102} 103#endif // ASAN_INTERCEPT_PTHREAD_CREATE 104 105#if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION 106INTERCEPTOR(void*, signal, int signum, void *handler) { 107 if (!AsanInterceptsSignal(signum)) { 108 return REAL(signal)(signum, handler); 109 } 110 return 0; 111} 112 113INTERCEPTOR(int, sigaction, int signum, const struct sigaction *act, 114 struct sigaction *oldact) { 115 if (!AsanInterceptsSignal(signum)) { 116 return REAL(sigaction)(signum, act, oldact); 117 } 118 return 0; 119} 120#elif ASAN_POSIX 121// We need to have defined REAL(sigaction) on posix systems. 122DEFINE_REAL(int, sigaction, int signum, const struct sigaction *act, 123 struct sigaction *oldact); 124#endif // ASAN_INTERCEPT_SIGNAL_AND_SIGACTION 125 126#if ASAN_INTERCEPT_SWAPCONTEXT 127INTERCEPTOR(int, swapcontext, struct ucontext_t *oucp, 128 struct ucontext_t *ucp) { 129 static bool reported_warning = false; 130 if (!reported_warning) { 131 Report("WARNING: ASan doesn't fully support makecontext/swapcontext " 132 "functions and may produce false positives in some cases!\n"); 133 reported_warning = true; 134 } 135 // Clear shadow memory for new context (it may share stack 136 // with current context). 137 ClearShadowMemoryForContext(ucp); 138 int res = REAL(swapcontext)(oucp, ucp); 139 // swapcontext technically does not return, but program may swap context to 140 // "oucp" later, that would look as if swapcontext() returned 0. 141 // We need to clear shadow for ucp once again, as it may be in arbitrary 142 // state. 143 ClearShadowMemoryForContext(ucp); 144 return res; 145} 146#endif 147 148INTERCEPTOR(void, longjmp, void *env, int val) { 149 __asan_handle_no_return(); 150 REAL(longjmp)(env, val); 151} 152 153#if ASAN_INTERCEPT__LONGJMP 154INTERCEPTOR(void, _longjmp, void *env, int val) { 155 __asan_handle_no_return(); 156 REAL(_longjmp)(env, val); 157} 158#endif 159 160#if ASAN_INTERCEPT_SIGLONGJMP 161INTERCEPTOR(void, siglongjmp, void *env, int val) { 162 __asan_handle_no_return(); 163 REAL(siglongjmp)(env, val); 164} 165#endif 166 167#if ASAN_INTERCEPT_PRCTL 168#define PR_SET_NAME 15 169INTERCEPTOR(int, prctl, int option, 170 unsigned long arg2, unsigned long arg3, // NOLINT 171 unsigned long arg4, unsigned long arg5) { // NOLINT 172 int res = REAL(prctl(option, arg2, arg3, arg4, arg5)); 173 if (option == PR_SET_NAME) { 174 AsanThread *t = asanThreadRegistry().GetCurrent(); 175 if (t) { 176 char buff[17]; 177 internal_strncpy(buff, (char*)arg2, 16); 178 buff[16] = 0; 179 t->summary()->set_name(buff); 180 } 181 } 182 return res; 183} 184#endif 185 186#if ASAN_INTERCEPT___CXA_THROW 187INTERCEPTOR(void, __cxa_throw, void *a, void *b, void *c) { 188 CHECK(REAL(__cxa_throw)); 189 __asan_handle_no_return(); 190 REAL(__cxa_throw)(a, b, c); 191} 192#endif 193 194// intercept mlock and friends. 195// Since asan maps 16T of RAM, mlock is completely unfriendly to asan. 196// All functions return 0 (success). 197static void MlockIsUnsupported() { 198 static bool printed = 0; 199 if (printed) return; 200 printed = true; 201 Printf("INFO: AddressSanitizer ignores mlock/mlockall/munlock/munlockall\n"); 202} 203 204extern "C" { 205INTERCEPTOR(int, mlock, const void *addr, uptr len) { 206 MlockIsUnsupported(); 207 return 0; 208} 209 210INTERCEPTOR(int, munlock, const void *addr, uptr len) { 211 MlockIsUnsupported(); 212 return 0; 213} 214 215INTERCEPTOR(int, mlockall, int flags) { 216 MlockIsUnsupported(); 217 return 0; 218} 219 220INTERCEPTOR(int, munlockall, void) { 221 MlockIsUnsupported(); 222 return 0; 223} 224} // extern "C" 225 226static inline int CharCmp(unsigned char c1, unsigned char c2) { 227 return (c1 == c2) ? 0 : (c1 < c2) ? -1 : 1; 228} 229 230static inline int CharCaseCmp(unsigned char c1, unsigned char c2) { 231 int c1_low = ToLower(c1); 232 int c2_low = ToLower(c2); 233 return c1_low - c2_low; 234} 235 236INTERCEPTOR(int, memcmp, const void *a1, const void *a2, uptr size) { 237 if (!asan_inited) return internal_memcmp(a1, a2, size); 238 ENSURE_ASAN_INITED(); 239 unsigned char c1 = 0, c2 = 0; 240 const unsigned char *s1 = (const unsigned char*)a1; 241 const unsigned char *s2 = (const unsigned char*)a2; 242 uptr i; 243 for (i = 0; i < size; i++) { 244 c1 = s1[i]; 245 c2 = s2[i]; 246 if (c1 != c2) break; 247 } 248 ASAN_READ_RANGE(s1, Min(i + 1, size)); 249 ASAN_READ_RANGE(s2, Min(i + 1, size)); 250 return CharCmp(c1, c2); 251} 252 253INTERCEPTOR(void*, memcpy, void *to, const void *from, uptr size) { 254 if (!asan_inited) return internal_memcpy(to, from, size); 255 // memcpy is called during __asan_init() from the internals 256 // of printf(...). 257 if (asan_init_is_running) { 258 return REAL(memcpy)(to, from, size); 259 } 260 ENSURE_ASAN_INITED(); 261 if (flags()->replace_intrin) { 262 if (to != from) { 263 // We do not treat memcpy with to==from as a bug. 264 // See http://llvm.org/bugs/show_bug.cgi?id=11763. 265 CHECK_RANGES_OVERLAP("memcpy", to, size, from, size); 266 } 267 ASAN_READ_RANGE(from, size); 268 ASAN_WRITE_RANGE(to, size); 269 } 270#if MAC_INTERPOSE_FUNCTIONS 271 // Interposing of resolver functions is broken on Mac OS 10.7 and 10.8. 272 // See also http://code.google.com/p/address-sanitizer/issues/detail?id=116. 273 return internal_memcpy(to, from, size); 274#else 275 return REAL(memcpy)(to, from, size); 276#endif 277} 278 279INTERCEPTOR(void*, memmove, void *to, const void *from, uptr size) { 280 if (!asan_inited) return internal_memmove(to, from, size); 281 if (asan_init_is_running) { 282 return REAL(memmove)(to, from, size); 283 } 284 ENSURE_ASAN_INITED(); 285 if (flags()->replace_intrin) { 286 ASAN_READ_RANGE(from, size); 287 ASAN_WRITE_RANGE(to, size); 288 } 289#if MAC_INTERPOSE_FUNCTIONS 290 // Interposing of resolver functions is broken on Mac OS 10.7 and 10.8. 291 // See also http://code.google.com/p/address-sanitizer/issues/detail?id=116. 292 return internal_memmove(to, from, size); 293#else 294 return REAL(memmove)(to, from, size); 295#endif 296} 297 298INTERCEPTOR(void*, memset, void *block, int c, uptr size) { 299 if (!asan_inited) return internal_memset(block, c, size); 300 // memset is called inside Printf. 301 if (asan_init_is_running) { 302 return REAL(memset)(block, c, size); 303 } 304 ENSURE_ASAN_INITED(); 305 if (flags()->replace_intrin) { 306 ASAN_WRITE_RANGE(block, size); 307 } 308 return REAL(memset)(block, c, size); 309} 310 311INTERCEPTOR(char*, strchr, const char *str, int c) { 312 if (!asan_inited) return internal_strchr(str, c); 313 // strchr is called inside create_purgeable_zone() when MallocGuardEdges=1 is 314 // used. 315 if (asan_init_is_running) { 316 return REAL(strchr)(str, c); 317 } 318 ENSURE_ASAN_INITED(); 319 char *result = REAL(strchr)(str, c); 320 if (flags()->replace_str) { 321 uptr bytes_read = (result ? result - str : REAL(strlen)(str)) + 1; 322 ASAN_READ_RANGE(str, bytes_read); 323 } 324 return result; 325} 326 327#if ASAN_INTERCEPT_INDEX 328# if ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX 329INTERCEPTOR(char*, index, const char *string, int c) 330 ALIAS(WRAPPER_NAME(strchr)); 331# else 332DEFINE_REAL(char*, index, const char *string, int c) 333# endif 334#endif // ASAN_INTERCEPT_INDEX 335 336// For both strcat() and strncat() we need to check the validity of |to| 337// argument irrespective of the |from| length. 338INTERCEPTOR(char*, strcat, char *to, const char *from) { // NOLINT 339 ENSURE_ASAN_INITED(); 340 if (flags()->replace_str) { 341 uptr from_length = REAL(strlen)(from); 342 ASAN_READ_RANGE(from, from_length + 1); 343 uptr to_length = REAL(strlen)(to); 344 ASAN_READ_RANGE(to, to_length); 345 ASAN_WRITE_RANGE(to + to_length, from_length + 1); 346 // If the copying actually happens, the |from| string should not overlap 347 // with the resulting string starting at |to|, which has a length of 348 // to_length + from_length + 1. 349 if (from_length > 0) { 350 CHECK_RANGES_OVERLAP("strcat", to, from_length + to_length + 1, 351 from, from_length + 1); 352 } 353 } 354 return REAL(strcat)(to, from); // NOLINT 355} 356 357INTERCEPTOR(char*, strncat, char *to, const char *from, uptr size) { 358 ENSURE_ASAN_INITED(); 359 if (flags()->replace_str) { 360 uptr from_length = MaybeRealStrnlen(from, size); 361 uptr copy_length = Min(size, from_length + 1); 362 ASAN_READ_RANGE(from, copy_length); 363 uptr to_length = REAL(strlen)(to); 364 ASAN_READ_RANGE(to, to_length); 365 ASAN_WRITE_RANGE(to + to_length, from_length + 1); 366 if (from_length > 0) { 367 CHECK_RANGES_OVERLAP("strncat", to, to_length + copy_length + 1, 368 from, copy_length); 369 } 370 } 371 return REAL(strncat)(to, from, size); 372} 373 374INTERCEPTOR(int, strcmp, const char *s1, const char *s2) { 375 if (!asan_inited) return internal_strcmp(s1, s2); 376 if (asan_init_is_running) { 377 return REAL(strcmp)(s1, s2); 378 } 379 ENSURE_ASAN_INITED(); 380 unsigned char c1, c2; 381 uptr i; 382 for (i = 0; ; i++) { 383 c1 = (unsigned char)s1[i]; 384 c2 = (unsigned char)s2[i]; 385 if (c1 != c2 || c1 == '\0') break; 386 } 387 ASAN_READ_RANGE(s1, i + 1); 388 ASAN_READ_RANGE(s2, i + 1); 389 return CharCmp(c1, c2); 390} 391 392INTERCEPTOR(char*, strcpy, char *to, const char *from) { // NOLINT 393#if MAC_INTERPOSE_FUNCTIONS 394 if (!asan_inited) return REAL(strcpy)(to, from); // NOLINT 395#endif 396 // strcpy is called from malloc_default_purgeable_zone() 397 // in __asan::ReplaceSystemAlloc() on Mac. 398 if (asan_init_is_running) { 399 return REAL(strcpy)(to, from); // NOLINT 400 } 401 ENSURE_ASAN_INITED(); 402 if (flags()->replace_str) { 403 uptr from_size = REAL(strlen)(from) + 1; 404 CHECK_RANGES_OVERLAP("strcpy", to, from_size, from, from_size); 405 ASAN_READ_RANGE(from, from_size); 406 ASAN_WRITE_RANGE(to, from_size); 407 } 408 return REAL(strcpy)(to, from); // NOLINT 409} 410 411#if ASAN_INTERCEPT_STRDUP 412INTERCEPTOR(char*, strdup, const char *s) { 413#if MAC_INTERPOSE_FUNCTIONS 414 // FIXME: because internal_strdup() uses InternalAlloc(), which currently 415 // just calls malloc() on Mac, we can't use internal_strdup() with the 416 // dynamic runtime. We can remove the call to REAL(strdup) once InternalAlloc 417 // starts using mmap() instead. 418 // See also http://code.google.com/p/address-sanitizer/issues/detail?id=123. 419 if (!asan_inited) return REAL(strdup)(s); 420#endif 421 if (!asan_inited) return internal_strdup(s); 422 ENSURE_ASAN_INITED(); 423 if (flags()->replace_str) { 424 uptr length = REAL(strlen)(s); 425 ASAN_READ_RANGE(s, length + 1); 426 } 427 return REAL(strdup)(s); 428} 429#endif 430 431INTERCEPTOR(uptr, strlen, const char *s) { 432 if (!asan_inited) return internal_strlen(s); 433 // strlen is called from malloc_default_purgeable_zone() 434 // in __asan::ReplaceSystemAlloc() on Mac. 435 if (asan_init_is_running) { 436 return REAL(strlen)(s); 437 } 438 ENSURE_ASAN_INITED(); 439 uptr length = REAL(strlen)(s); 440 if (flags()->replace_str) { 441 ASAN_READ_RANGE(s, length + 1); 442 } 443 return length; 444} 445 446#if ASAN_INTERCEPT_STRCASECMP_AND_STRNCASECMP 447INTERCEPTOR(int, strcasecmp, const char *s1, const char *s2) { 448 ENSURE_ASAN_INITED(); 449 unsigned char c1, c2; 450 uptr i; 451 for (i = 0; ; i++) { 452 c1 = (unsigned char)s1[i]; 453 c2 = (unsigned char)s2[i]; 454 if (CharCaseCmp(c1, c2) != 0 || c1 == '\0') break; 455 } 456 ASAN_READ_RANGE(s1, i + 1); 457 ASAN_READ_RANGE(s2, i + 1); 458 return CharCaseCmp(c1, c2); 459} 460 461INTERCEPTOR(int, strncasecmp, const char *s1, const char *s2, uptr n) { 462 ENSURE_ASAN_INITED(); 463 unsigned char c1 = 0, c2 = 0; 464 uptr i; 465 for (i = 0; i < n; i++) { 466 c1 = (unsigned char)s1[i]; 467 c2 = (unsigned char)s2[i]; 468 if (CharCaseCmp(c1, c2) != 0 || c1 == '\0') break; 469 } 470 ASAN_READ_RANGE(s1, Min(i + 1, n)); 471 ASAN_READ_RANGE(s2, Min(i + 1, n)); 472 return CharCaseCmp(c1, c2); 473} 474#endif // ASAN_INTERCEPT_STRCASECMP_AND_STRNCASECMP 475 476INTERCEPTOR(int, strncmp, const char *s1, const char *s2, uptr size) { 477 if (!asan_inited) return internal_strncmp(s1, s2, size); 478 // strncmp is called from malloc_default_purgeable_zone() 479 // in __asan::ReplaceSystemAlloc() on Mac. 480 if (asan_init_is_running) { 481 return REAL(strncmp)(s1, s2, size); 482 } 483 ENSURE_ASAN_INITED(); 484 unsigned char c1 = 0, c2 = 0; 485 uptr i; 486 for (i = 0; i < size; i++) { 487 c1 = (unsigned char)s1[i]; 488 c2 = (unsigned char)s2[i]; 489 if (c1 != c2 || c1 == '\0') break; 490 } 491 ASAN_READ_RANGE(s1, Min(i + 1, size)); 492 ASAN_READ_RANGE(s2, Min(i + 1, size)); 493 return CharCmp(c1, c2); 494} 495 496INTERCEPTOR(char*, strncpy, char *to, const char *from, uptr size) { 497 ENSURE_ASAN_INITED(); 498 if (flags()->replace_str) { 499 uptr from_size = Min(size, MaybeRealStrnlen(from, size) + 1); 500 CHECK_RANGES_OVERLAP("strncpy", to, from_size, from, from_size); 501 ASAN_READ_RANGE(from, from_size); 502 ASAN_WRITE_RANGE(to, size); 503 } 504 return REAL(strncpy)(to, from, size); 505} 506 507#if ASAN_INTERCEPT_STRNLEN 508INTERCEPTOR(uptr, strnlen, const char *s, uptr maxlen) { 509 ENSURE_ASAN_INITED(); 510 uptr length = REAL(strnlen)(s, maxlen); 511 if (flags()->replace_str) { 512 ASAN_READ_RANGE(s, Min(length + 1, maxlen)); 513 } 514 return length; 515} 516#endif // ASAN_INTERCEPT_STRNLEN 517 518static inline bool IsValidStrtolBase(int base) { 519 return (base == 0) || (2 <= base && base <= 36); 520} 521 522static inline void FixRealStrtolEndptr(const char *nptr, char **endptr) { 523 CHECK(endptr != 0); 524 if (nptr == *endptr) { 525 // No digits were found at strtol call, we need to find out the last 526 // symbol accessed by strtoll on our own. 527 // We get this symbol by skipping leading blanks and optional +/- sign. 528 while (IsSpace(*nptr)) nptr++; 529 if (*nptr == '+' || *nptr == '-') nptr++; 530 *endptr = (char*)nptr; 531 } 532 CHECK(*endptr >= nptr); 533} 534 535INTERCEPTOR(long, strtol, const char *nptr, // NOLINT 536 char **endptr, int base) { 537 ENSURE_ASAN_INITED(); 538 if (!flags()->replace_str) { 539 return REAL(strtol)(nptr, endptr, base); 540 } 541 char *real_endptr; 542 long result = REAL(strtol)(nptr, &real_endptr, base); // NOLINT 543 if (endptr != 0) { 544 *endptr = real_endptr; 545 } 546 if (IsValidStrtolBase(base)) { 547 FixRealStrtolEndptr(nptr, &real_endptr); 548 ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1); 549 } 550 return result; 551} 552 553INTERCEPTOR(int, atoi, const char *nptr) { 554#if MAC_INTERPOSE_FUNCTIONS 555 if (!asan_inited) return REAL(atoi)(nptr); 556#endif 557 ENSURE_ASAN_INITED(); 558 if (!flags()->replace_str) { 559 return REAL(atoi)(nptr); 560 } 561 char *real_endptr; 562 // "man atoi" tells that behavior of atoi(nptr) is the same as 563 // strtol(nptr, 0, 10), i.e. it sets errno to ERANGE if the 564 // parsed integer can't be stored in *long* type (even if it's 565 // different from int). So, we just imitate this behavior. 566 int result = REAL(strtol)(nptr, &real_endptr, 10); 567 FixRealStrtolEndptr(nptr, &real_endptr); 568 ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1); 569 return result; 570} 571 572INTERCEPTOR(long, atol, const char *nptr) { // NOLINT 573#if MAC_INTERPOSE_FUNCTIONS 574 if (!asan_inited) return REAL(atol)(nptr); 575#endif 576 ENSURE_ASAN_INITED(); 577 if (!flags()->replace_str) { 578 return REAL(atol)(nptr); 579 } 580 char *real_endptr; 581 long result = REAL(strtol)(nptr, &real_endptr, 10); // NOLINT 582 FixRealStrtolEndptr(nptr, &real_endptr); 583 ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1); 584 return result; 585} 586 587#if ASAN_INTERCEPT_ATOLL_AND_STRTOLL 588INTERCEPTOR(long long, strtoll, const char *nptr, // NOLINT 589 char **endptr, int base) { 590 ENSURE_ASAN_INITED(); 591 if (!flags()->replace_str) { 592 return REAL(strtoll)(nptr, endptr, base); 593 } 594 char *real_endptr; 595 long long result = REAL(strtoll)(nptr, &real_endptr, base); // NOLINT 596 if (endptr != 0) { 597 *endptr = real_endptr; 598 } 599 // If base has unsupported value, strtoll can exit with EINVAL 600 // without reading any characters. So do additional checks only 601 // if base is valid. 602 if (IsValidStrtolBase(base)) { 603 FixRealStrtolEndptr(nptr, &real_endptr); 604 ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1); 605 } 606 return result; 607} 608 609INTERCEPTOR(long long, atoll, const char *nptr) { // NOLINT 610 ENSURE_ASAN_INITED(); 611 if (!flags()->replace_str) { 612 return REAL(atoll)(nptr); 613 } 614 char *real_endptr; 615 long long result = REAL(strtoll)(nptr, &real_endptr, 10); // NOLINT 616 FixRealStrtolEndptr(nptr, &real_endptr); 617 ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1); 618 return result; 619} 620#endif // ASAN_INTERCEPT_ATOLL_AND_STRTOLL 621 622#define ASAN_INTERCEPT_FUNC(name) do { \ 623 if (!INTERCEPT_FUNCTION(name) && flags()->verbosity > 0) \ 624 Report("AddressSanitizer: failed to intercept '" #name "'\n"); \ 625 } while (0) 626 627#if defined(_WIN32) 628INTERCEPTOR_WINAPI(DWORD, CreateThread, 629 void* security, uptr stack_size, 630 DWORD (__stdcall *start_routine)(void*), void* arg, 631 DWORD flags, void* tid) { 632 GET_STACK_TRACE_THREAD; 633 u32 current_tid = asanThreadRegistry().GetCurrentTidOrInvalid(); 634 AsanThread *t = AsanThread::Create(current_tid, start_routine, arg, &stack); 635 asanThreadRegistry().RegisterThread(t); 636 return REAL(CreateThread)(security, stack_size, 637 asan_thread_start, t, flags, tid); 638} 639 640namespace __asan { 641void InitializeWindowsInterceptors() { 642 ASAN_INTERCEPT_FUNC(CreateThread); 643} 644 645} // namespace __asan 646#endif 647 648// ---------------------- InitializeAsanInterceptors ---------------- {{{1 649namespace __asan { 650void InitializeAsanInterceptors() { 651 static bool was_called_once; 652 CHECK(was_called_once == false); 653 was_called_once = true; 654#if MAC_INTERPOSE_FUNCTIONS 655 return; 656#endif 657 658 SANITIZER_COMMON_INTERCEPTORS_INIT; 659 660 // Intercept mem* functions. 661 ASAN_INTERCEPT_FUNC(memcmp); 662 ASAN_INTERCEPT_FUNC(memmove); 663 ASAN_INTERCEPT_FUNC(memset); 664 if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) { 665 ASAN_INTERCEPT_FUNC(memcpy); 666 } else { 667#if !MAC_INTERPOSE_FUNCTIONS 668 // If we're using dynamic interceptors on Mac, these two are just plain 669 // functions. 670 internal_memcpy(&REAL(memcpy), &REAL(memmove), sizeof(REAL(memmove))); 671#endif 672 } 673 674 // Intercept str* functions. 675 ASAN_INTERCEPT_FUNC(strcat); // NOLINT 676 ASAN_INTERCEPT_FUNC(strchr); 677 ASAN_INTERCEPT_FUNC(strcmp); 678 ASAN_INTERCEPT_FUNC(strcpy); // NOLINT 679 ASAN_INTERCEPT_FUNC(strlen); 680 ASAN_INTERCEPT_FUNC(strncat); 681 ASAN_INTERCEPT_FUNC(strncmp); 682 ASAN_INTERCEPT_FUNC(strncpy); 683#if ASAN_INTERCEPT_STRCASECMP_AND_STRNCASECMP 684 ASAN_INTERCEPT_FUNC(strcasecmp); 685 ASAN_INTERCEPT_FUNC(strncasecmp); 686#endif 687#if ASAN_INTERCEPT_STRDUP 688 ASAN_INTERCEPT_FUNC(strdup); 689#endif 690#if ASAN_INTERCEPT_STRNLEN 691 ASAN_INTERCEPT_FUNC(strnlen); 692#endif 693#if ASAN_INTERCEPT_INDEX 694# if ASAN_USE_ALIAS_ATTRIBUTE_FOR_INDEX 695 ASAN_INTERCEPT_FUNC(index); 696# else 697 CHECK(OVERRIDE_FUNCTION(index, WRAP(strchr))); 698# endif 699#endif 700 701 ASAN_INTERCEPT_FUNC(atoi); 702 ASAN_INTERCEPT_FUNC(atol); 703 ASAN_INTERCEPT_FUNC(strtol); 704#if ASAN_INTERCEPT_ATOLL_AND_STRTOLL 705 ASAN_INTERCEPT_FUNC(atoll); 706 ASAN_INTERCEPT_FUNC(strtoll); 707#endif 708 709#if ASAN_INTERCEPT_MLOCKX 710 // Intercept mlock/munlock. 711 ASAN_INTERCEPT_FUNC(mlock); 712 ASAN_INTERCEPT_FUNC(munlock); 713 ASAN_INTERCEPT_FUNC(mlockall); 714 ASAN_INTERCEPT_FUNC(munlockall); 715#endif 716 717 // Intecept signal- and jump-related functions. 718 ASAN_INTERCEPT_FUNC(longjmp); 719#if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION 720 ASAN_INTERCEPT_FUNC(sigaction); 721 ASAN_INTERCEPT_FUNC(signal); 722#endif 723#if ASAN_INTERCEPT_SWAPCONTEXT 724 ASAN_INTERCEPT_FUNC(swapcontext); 725#endif 726#if ASAN_INTERCEPT__LONGJMP 727 ASAN_INTERCEPT_FUNC(_longjmp); 728#endif 729#if ASAN_INTERCEPT_SIGLONGJMP 730 ASAN_INTERCEPT_FUNC(siglongjmp); 731#endif 732#if ASAN_INTERCEPT_PRCTL 733 ASAN_INTERCEPT_FUNC(prctl); 734#endif 735 736 // Intercept exception handling functions. 737#if ASAN_INTERCEPT___CXA_THROW 738 INTERCEPT_FUNCTION(__cxa_throw); 739#endif 740 741 // Intercept threading-related functions 742#if ASAN_INTERCEPT_PTHREAD_CREATE 743 ASAN_INTERCEPT_FUNC(pthread_create); 744#endif 745 746 // Some Windows-specific interceptors. 747#if defined(_WIN32) 748 InitializeWindowsInterceptors(); 749#endif 750 751 // Some Mac-specific interceptors. 752#if defined(__APPLE__) 753 InitializeMacInterceptors(); 754#endif 755 756 if (flags()->verbosity > 0) { 757 Report("AddressSanitizer: libc interceptors initialized\n"); 758 } 759} 760 761} // namespace __asan 762