asan_interceptors.cc revision 88207ab15125e2f1e9b3d541b735b2b8aba9b6d9
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_interface.h" 18#include "asan_internal.h" 19#include "asan_mapping.h" 20#include "asan_stack.h" 21#include "asan_stats.h" 22#include "asan_thread_registry.h" 23#include "interception/interception.h" 24#include "sanitizer_common/sanitizer_libc.h" 25 26// Use macro to describe if specific function should be 27// intercepted on a given platform. 28#if !defined(_WIN32) 29# define ASAN_INTERCEPT_ATOLL_AND_STRTOLL 1 30#else 31# define ASAN_INTERCEPT_ATOLL_AND_STRTOLL 0 32#endif 33 34#if !defined(__APPLE__) 35# define ASAN_INTERCEPT_STRNLEN 1 36#else 37# define ASAN_INTERCEPT_STRNLEN 0 38#endif 39 40#if defined(ANDROID) || defined(_WIN32) 41# define ASAN_INTERCEPT_SIGNAL_AND_SIGACTION 0 42#else 43# define ASAN_INTERCEPT_SIGNAL_AND_SIGACTION 1 44#endif 45 46// Use extern declarations of intercepted functions on Mac and Windows 47// to avoid including system headers. 48#if defined(__APPLE__) || (defined(_WIN32) && !defined(_DLL)) 49extern "C" { 50// signal.h 51# if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION 52struct sigaction; 53int sigaction(int sig, const struct sigaction *act, 54 struct sigaction *oldact); 55void *signal(int signum, void *handler); 56# endif 57 58// setjmp.h 59void longjmp(void* env, int value); 60# if !defined(_WIN32) 61void _longjmp(void *env, int value); 62# endif 63 64// string.h / strings.h 65int memcmp(const void *a1, const void *a2, uptr size); 66void* memmove(void *to, const void *from, uptr size); 67void* memcpy(void *to, const void *from, uptr size); 68void* memset(void *block, int c, uptr size); 69char* strchr(const char *str, int c); 70# if defined(__APPLE__) 71char* index(const char *string, int c); 72# endif 73char* strcat(char *to, const char* from); // NOLINT 74char *strncat(char *to, const char* from, uptr size); 75char* strcpy(char *to, const char* from); // NOLINT 76char* strncpy(char *to, const char* from, uptr size); 77int strcmp(const char *s1, const char* s2); 78int strncmp(const char *s1, const char* s2, uptr size); 79# if !defined(_WIN32) 80int strcasecmp(const char *s1, const char *s2); 81int strncasecmp(const char *s1, const char *s2, uptr n); 82char* strdup(const char *s); 83# endif 84uptr strlen(const char *s); 85# if ASAN_INTERCEPT_STRNLEN 86uptr strnlen(const char *s, uptr maxlen); 87# endif 88 89// stdlib.h 90int atoi(const char *nptr); 91long atol(const char *nptr); // NOLINT 92long strtol(const char *nptr, char **endptr, int base); // NOLINT 93# if ASAN_INTERCEPT_ATOLL_AND_STRTOLL 94long long atoll(const char *nptr); // NOLINT 95long long strtoll(const char *nptr, char **endptr, int base); // NOLINT 96# endif 97 98// Windows threads. 99# if defined(_WIN32) 100__declspec(dllimport) 101void* __stdcall CreateThread(void *sec, uptr st, void* start, 102 void *arg, DWORD fl, DWORD *id); 103# endif 104 105// Posix threads. 106# if !defined(_WIN32) 107int pthread_create(void *thread, void *attr, void *(*start_routine)(void*), 108 void *arg); 109# endif 110} // extern "C" 111#endif 112 113namespace __asan { 114 115// Instruments read/write access to a single byte in memory. 116// On error calls __asan_report_error, which aborts the program. 117#define ACCESS_ADDRESS(address, isWrite) do { \ 118 if (AddressIsPoisoned(address)) { \ 119 GET_CURRENT_PC_BP_SP; \ 120 __asan_report_error(pc, bp, sp, address, isWrite, /* access_size */ 1); \ 121 } \ 122} while (0) 123 124// We implement ACCESS_MEMORY_RANGE, ASAN_READ_RANGE, 125// and ASAN_WRITE_RANGE as macro instead of function so 126// that no extra frames are created, and stack trace contains 127// relevant information only. 128 129// Instruments read/write access to a memory range. 130// More complex implementation is possible, for now just 131// checking the first and the last byte of a range. 132#define ACCESS_MEMORY_RANGE(offset, size, isWrite) do { \ 133 if (size > 0) { \ 134 uptr ptr = (uptr)(offset); \ 135 ACCESS_ADDRESS(ptr, isWrite); \ 136 ACCESS_ADDRESS(ptr + (size) - 1, isWrite); \ 137 } \ 138} while (0) 139 140#define ASAN_READ_RANGE(offset, size) do { \ 141 ACCESS_MEMORY_RANGE(offset, size, false); \ 142} while (0) 143 144#define ASAN_WRITE_RANGE(offset, size) do { \ 145 ACCESS_MEMORY_RANGE(offset, size, true); \ 146} while (0) 147 148// Behavior of functions like "memcpy" or "strcpy" is undefined 149// if memory intervals overlap. We report error in this case. 150// Macro is used to avoid creation of new frames. 151static inline bool RangesOverlap(const char *offset1, uptr length1, 152 const char *offset2, uptr length2) { 153 return !((offset1 + length1 <= offset2) || (offset2 + length2 <= offset1)); 154} 155#define CHECK_RANGES_OVERLAP(name, _offset1, length1, _offset2, length2) do { \ 156 const char *offset1 = (const char*)_offset1; \ 157 const char *offset2 = (const char*)_offset2; \ 158 if (RangesOverlap(offset1, length1, offset2, length2)) { \ 159 AsanReport("ERROR: AddressSanitizer %s-param-overlap: " \ 160 "memory ranges [%p,%p) and [%p, %p) overlap\n", \ 161 name, offset1, offset1 + length1, offset2, offset2 + length2); \ 162 PRINT_CURRENT_STACK(); \ 163 ShowStatsAndAbort(); \ 164 } \ 165} while (0) 166 167#define ENSURE_ASAN_INITED() do { \ 168 CHECK(!asan_init_is_running); \ 169 if (!asan_inited) { \ 170 __asan_init(); \ 171 } \ 172} while (0) 173 174static inline bool IsSpace(int c) { 175 return (c == ' ') || (c == '\n') || (c == '\t') || 176 (c == '\f') || (c == '\r') || (c == '\v'); 177} 178 179static inline bool IsDigit(int c) { 180 return (c >= '0') && (c <= '9'); 181} 182 183static inline int ToLower(int c) { 184 return (c >= 'A' && c <= 'Z') ? (c + 'a' - 'A') : c; 185} 186 187// ---------------------- Internal string functions ---------------- {{{1 188 189s64 internal_simple_strtoll(const char *nptr, char **endptr, int base) { 190 CHECK(base == 10); 191 while (IsSpace(*nptr)) nptr++; 192 int sgn = 1; 193 u64 res = 0; 194 bool have_digits = false; 195 char *old_nptr = (char*)nptr; 196 if (*nptr == '+') { 197 sgn = 1; 198 nptr++; 199 } else if (*nptr == '-') { 200 sgn = -1; 201 nptr++; 202 } 203 while (IsDigit(*nptr)) { 204 res = (res <= UINT64_MAX / 10) ? res * 10 : UINT64_MAX; 205 int digit = ((*nptr) - '0'); 206 res = (res <= UINT64_MAX - digit) ? res + digit : UINT64_MAX; 207 have_digits = true; 208 nptr++; 209 } 210 if (endptr != 0) { 211 *endptr = (have_digits) ? (char*)nptr : old_nptr; 212 } 213 if (sgn > 0) { 214 return (s64)(Min((u64)INT64_MAX, res)); 215 } else { 216 return (res > INT64_MAX) ? INT64_MIN : ((s64)res * -1); 217 } 218} 219 220s64 internal_atoll(const char *nptr) { 221 return internal_simple_strtoll(nptr, (char**)0, 10); 222} 223 224uptr internal_strnlen(const char *s, uptr maxlen) { 225#if ASAN_INTERCEPT_STRNLEN 226 if (REAL(strnlen) != 0) { 227 return REAL(strnlen)(s, maxlen); 228 } 229#endif 230 uptr i = 0; 231 while (i < maxlen && s[i]) i++; 232 return i; 233} 234 235char *internal_strstr(const char *haystack, const char *needle) { 236 // This is O(N^2), but we are not using it in hot places. 237 uptr len1 = internal_strlen(haystack); 238 uptr len2 = internal_strlen(needle); 239 if (len1 < len2) return 0; 240 for (uptr pos = 0; pos <= len1 - len2; pos++) { 241 if (internal_memcmp(haystack + pos, needle, len2) == 0) 242 return (char*)haystack + pos; 243 } 244 return 0; 245} 246 247char *internal_strncat(char *dst, const char *src, uptr n) { 248 uptr len = internal_strlen(dst); 249 uptr i; 250 for (i = 0; i < n && src[i]; i++) 251 dst[len + i] = src[i]; 252 dst[len + i] = 0; 253 return dst; 254} 255 256} // namespace __asan 257 258// ---------------------- Wrappers ---------------- {{{1 259using namespace __asan; // NOLINT 260 261static thread_return_t THREAD_CALLING_CONV asan_thread_start(void *arg) { 262 AsanThread *t = (AsanThread*)arg; 263 asanThreadRegistry().SetCurrent(t); 264 return t->ThreadStart(); 265} 266 267#ifndef _WIN32 268INTERCEPTOR(int, pthread_create, void *thread, 269 void *attr, void *(*start_routine)(void*), void *arg) { 270 GET_STACK_TRACE_HERE(kStackTraceMax); 271 u32 current_tid = asanThreadRegistry().GetCurrentTidOrInvalid(); 272 AsanThread *t = AsanThread::Create(current_tid, start_routine, arg, &stack); 273 asanThreadRegistry().RegisterThread(t); 274 return REAL(pthread_create)(thread, attr, asan_thread_start, t); 275} 276#endif // !_WIN32 277 278#if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION 279INTERCEPTOR(void*, signal, int signum, void *handler) { 280 if (!AsanInterceptsSignal(signum)) { 281 return REAL(signal)(signum, handler); 282 } 283 return 0; 284} 285 286INTERCEPTOR(int, sigaction, int signum, const struct sigaction *act, 287 struct sigaction *oldact) { 288 if (!AsanInterceptsSignal(signum)) { 289 return REAL(sigaction)(signum, act, oldact); 290 } 291 return 0; 292} 293#elif ASAN_POSIX 294// We need to have defined REAL(sigaction) on posix systems. 295DEFINE_REAL(int, sigaction, int signum, const struct sigaction *act, 296 struct sigaction *oldact); 297#endif // ASAN_INTERCEPT_SIGNAL_AND_SIGACTION 298 299INTERCEPTOR(void, longjmp, void *env, int val) { 300 __asan_handle_no_return(); 301 REAL(longjmp)(env, val); 302} 303 304#if !defined(_WIN32) 305INTERCEPTOR(void, _longjmp, void *env, int val) { 306 __asan_handle_no_return(); 307 REAL(_longjmp)(env, val); 308} 309 310INTERCEPTOR(void, siglongjmp, void *env, int val) { 311 __asan_handle_no_return(); 312 REAL(siglongjmp)(env, val); 313} 314#endif 315 316#if ASAN_HAS_EXCEPTIONS == 1 317#ifdef __APPLE__ 318extern "C" void __cxa_throw(void *a, void *b, void *c); 319#endif // __APPLE__ 320 321INTERCEPTOR(void, __cxa_throw, void *a, void *b, void *c) { 322 CHECK(REAL(__cxa_throw)); 323 __asan_handle_no_return(); 324 REAL(__cxa_throw)(a, b, c); 325} 326#endif 327 328// intercept mlock and friends. 329// Since asan maps 16T of RAM, mlock is completely unfriendly to asan. 330// All functions return 0 (success). 331static void MlockIsUnsupported() { 332 static bool printed = 0; 333 if (printed) return; 334 printed = true; 335 Printf("INFO: AddressSanitizer ignores mlock/mlockall/munlock/munlockall\n"); 336} 337 338extern "C" { 339INTERCEPTOR_ATTRIBUTE 340int mlock(const void *addr, uptr len) { 341 MlockIsUnsupported(); 342 return 0; 343} 344 345INTERCEPTOR_ATTRIBUTE 346int munlock(const void *addr, uptr len) { 347 MlockIsUnsupported(); 348 return 0; 349} 350 351INTERCEPTOR_ATTRIBUTE 352int mlockall(int flags) { 353 MlockIsUnsupported(); 354 return 0; 355} 356 357INTERCEPTOR_ATTRIBUTE 358int munlockall(void) { 359 MlockIsUnsupported(); 360 return 0; 361} 362} // extern "C" 363 364static inline int CharCmp(unsigned char c1, unsigned char c2) { 365 return (c1 == c2) ? 0 : (c1 < c2) ? -1 : 1; 366} 367 368static inline int CharCaseCmp(unsigned char c1, unsigned char c2) { 369 int c1_low = ToLower(c1); 370 int c2_low = ToLower(c2); 371 return c1_low - c2_low; 372} 373 374INTERCEPTOR(int, memcmp, const void *a1, const void *a2, uptr size) { 375 ENSURE_ASAN_INITED(); 376 unsigned char c1 = 0, c2 = 0; 377 const unsigned char *s1 = (const unsigned char*)a1; 378 const unsigned char *s2 = (const unsigned char*)a2; 379 uptr i; 380 for (i = 0; i < size; i++) { 381 c1 = s1[i]; 382 c2 = s2[i]; 383 if (c1 != c2) break; 384 } 385 ASAN_READ_RANGE(s1, Min(i + 1, size)); 386 ASAN_READ_RANGE(s2, Min(i + 1, size)); 387 return CharCmp(c1, c2); 388} 389 390INTERCEPTOR(void*, memcpy, void *to, const void *from, uptr size) { 391 // memcpy is called during __asan_init() from the internals 392 // of printf(...). 393 if (asan_init_is_running) { 394 return REAL(memcpy)(to, from, size); 395 } 396 ENSURE_ASAN_INITED(); 397 if (FLAG_replace_intrin) { 398 if (to != from) { 399 // We do not treat memcpy with to==from as a bug. 400 // See http://llvm.org/bugs/show_bug.cgi?id=11763. 401 CHECK_RANGES_OVERLAP("memcpy", to, size, from, size); 402 } 403 ASAN_WRITE_RANGE(from, size); 404 ASAN_READ_RANGE(to, size); 405 } 406 return REAL(memcpy)(to, from, size); 407} 408 409INTERCEPTOR(void*, memmove, void *to, const void *from, uptr size) { 410 if (asan_init_is_running) { 411 return REAL(memmove)(to, from, size); 412 } 413 ENSURE_ASAN_INITED(); 414 if (FLAG_replace_intrin) { 415 ASAN_WRITE_RANGE(from, size); 416 ASAN_READ_RANGE(to, size); 417 } 418 return REAL(memmove)(to, from, size); 419} 420 421INTERCEPTOR(void*, memset, void *block, int c, uptr size) { 422 // memset is called inside Printf. 423 if (asan_init_is_running) { 424 return REAL(memset)(block, c, size); 425 } 426 ENSURE_ASAN_INITED(); 427 if (FLAG_replace_intrin) { 428 ASAN_WRITE_RANGE(block, size); 429 } 430 return REAL(memset)(block, c, size); 431} 432 433INTERCEPTOR(char*, strchr, const char *str, int c) { 434 ENSURE_ASAN_INITED(); 435 char *result = REAL(strchr)(str, c); 436 if (FLAG_replace_str) { 437 uptr bytes_read = (result ? result - str : REAL(strlen)(str)) + 1; 438 ASAN_READ_RANGE(str, bytes_read); 439 } 440 return result; 441} 442 443#ifdef __linux__ 444INTERCEPTOR(char*, index, const char *string, int c) 445 ALIAS(WRAPPER_NAME(strchr)); 446#else 447DEFINE_REAL(char*, index, const char *string, int c); 448#endif 449 450INTERCEPTOR(int, strcasecmp, const char *s1, const char *s2) { 451 ENSURE_ASAN_INITED(); 452 unsigned char c1, c2; 453 uptr i; 454 for (i = 0; ; i++) { 455 c1 = (unsigned char)s1[i]; 456 c2 = (unsigned char)s2[i]; 457 if (CharCaseCmp(c1, c2) != 0 || c1 == '\0') break; 458 } 459 ASAN_READ_RANGE(s1, i + 1); 460 ASAN_READ_RANGE(s2, i + 1); 461 return CharCaseCmp(c1, c2); 462} 463 464INTERCEPTOR(char*, strcat, char *to, const char *from) { // NOLINT 465 ENSURE_ASAN_INITED(); 466 if (FLAG_replace_str) { 467 uptr from_length = REAL(strlen)(from); 468 ASAN_READ_RANGE(from, from_length + 1); 469 if (from_length > 0) { 470 uptr to_length = REAL(strlen)(to); 471 ASAN_READ_RANGE(to, to_length); 472 ASAN_WRITE_RANGE(to + to_length, from_length + 1); 473 CHECK_RANGES_OVERLAP("strcat", to, to_length + 1, from, from_length + 1); 474 } 475 } 476 return REAL(strcat)(to, from); // NOLINT 477} 478 479INTERCEPTOR(char*, strncat, char *to, const char *from, uptr size) { 480 ENSURE_ASAN_INITED(); 481 if (FLAG_replace_str && size > 0) { 482 uptr from_length = internal_strnlen(from, size); 483 ASAN_READ_RANGE(from, Min(size, from_length + 1)); 484 uptr to_length = REAL(strlen)(to); 485 ASAN_READ_RANGE(to, to_length); 486 ASAN_WRITE_RANGE(to + to_length, from_length + 1); 487 if (from_length > 0) { 488 CHECK_RANGES_OVERLAP("strncat", to, to_length + 1, 489 from, Min(size, from_length + 1)); 490 } 491 } 492 return REAL(strncat)(to, from, size); 493} 494 495INTERCEPTOR(int, strcmp, const char *s1, const char *s2) { 496 if (!asan_inited) { 497 return internal_strcmp(s1, s2); 498 } 499 unsigned char c1, c2; 500 uptr i; 501 for (i = 0; ; i++) { 502 c1 = (unsigned char)s1[i]; 503 c2 = (unsigned char)s2[i]; 504 if (c1 != c2 || c1 == '\0') break; 505 } 506 ASAN_READ_RANGE(s1, i + 1); 507 ASAN_READ_RANGE(s2, i + 1); 508 return CharCmp(c1, c2); 509} 510 511INTERCEPTOR(char*, strcpy, char *to, const char *from) { // NOLINT 512 // strcpy is called from malloc_default_purgeable_zone() 513 // in __asan::ReplaceSystemAlloc() on Mac. 514 if (asan_init_is_running) { 515 return REAL(strcpy)(to, from); // NOLINT 516 } 517 ENSURE_ASAN_INITED(); 518 if (FLAG_replace_str) { 519 uptr from_size = REAL(strlen)(from) + 1; 520 CHECK_RANGES_OVERLAP("strcpy", to, from_size, from, from_size); 521 ASAN_READ_RANGE(from, from_size); 522 ASAN_WRITE_RANGE(to, from_size); 523 } 524 return REAL(strcpy)(to, from); // NOLINT 525} 526 527INTERCEPTOR(char*, strdup, const char *s) { 528 ENSURE_ASAN_INITED(); 529 if (FLAG_replace_str) { 530 uptr length = REAL(strlen)(s); 531 ASAN_READ_RANGE(s, length + 1); 532 } 533 return REAL(strdup)(s); 534} 535 536INTERCEPTOR(uptr, strlen, const char *s) { 537 // strlen is called from malloc_default_purgeable_zone() 538 // in __asan::ReplaceSystemAlloc() on Mac. 539 if (asan_init_is_running) { 540 return REAL(strlen)(s); 541 } 542 ENSURE_ASAN_INITED(); 543 uptr length = REAL(strlen)(s); 544 if (FLAG_replace_str) { 545 ASAN_READ_RANGE(s, length + 1); 546 } 547 return length; 548} 549 550INTERCEPTOR(int, strncasecmp, const char *s1, const char *s2, uptr n) { 551 ENSURE_ASAN_INITED(); 552 unsigned char c1 = 0, c2 = 0; 553 uptr i; 554 for (i = 0; i < n; i++) { 555 c1 = (unsigned char)s1[i]; 556 c2 = (unsigned char)s2[i]; 557 if (CharCaseCmp(c1, c2) != 0 || c1 == '\0') break; 558 } 559 ASAN_READ_RANGE(s1, Min(i + 1, n)); 560 ASAN_READ_RANGE(s2, Min(i + 1, n)); 561 return CharCaseCmp(c1, c2); 562} 563 564INTERCEPTOR(int, strncmp, const char *s1, const char *s2, uptr size) { 565 // strncmp is called from malloc_default_purgeable_zone() 566 // in __asan::ReplaceSystemAlloc() on Mac. 567 if (asan_init_is_running) { 568 return REAL(strncmp)(s1, s2, size); 569 } 570 unsigned char c1 = 0, c2 = 0; 571 uptr i; 572 for (i = 0; i < size; i++) { 573 c1 = (unsigned char)s1[i]; 574 c2 = (unsigned char)s2[i]; 575 if (c1 != c2 || c1 == '\0') break; 576 } 577 ASAN_READ_RANGE(s1, Min(i + 1, size)); 578 ASAN_READ_RANGE(s2, Min(i + 1, size)); 579 return CharCmp(c1, c2); 580} 581 582INTERCEPTOR(char*, strncpy, char *to, const char *from, uptr size) { 583 ENSURE_ASAN_INITED(); 584 if (FLAG_replace_str) { 585 uptr from_size = Min(size, internal_strnlen(from, size) + 1); 586 CHECK_RANGES_OVERLAP("strncpy", to, from_size, from, from_size); 587 ASAN_READ_RANGE(from, from_size); 588 ASAN_WRITE_RANGE(to, size); 589 } 590 return REAL(strncpy)(to, from, size); 591} 592 593#if ASAN_INTERCEPT_STRNLEN 594INTERCEPTOR(uptr, strnlen, const char *s, uptr maxlen) { 595 ENSURE_ASAN_INITED(); 596 uptr length = REAL(strnlen)(s, maxlen); 597 if (FLAG_replace_str) { 598 ASAN_READ_RANGE(s, Min(length + 1, maxlen)); 599 } 600 return length; 601} 602#endif // ASAN_INTERCEPT_STRNLEN 603 604static inline bool IsValidStrtolBase(int base) { 605 return (base == 0) || (2 <= base && base <= 36); 606} 607 608static inline void FixRealStrtolEndptr(const char *nptr, char **endptr) { 609 CHECK(endptr != 0); 610 if (nptr == *endptr) { 611 // No digits were found at strtol call, we need to find out the last 612 // symbol accessed by strtoll on our own. 613 // We get this symbol by skipping leading blanks and optional +/- sign. 614 while (IsSpace(*nptr)) nptr++; 615 if (*nptr == '+' || *nptr == '-') nptr++; 616 *endptr = (char*)nptr; 617 } 618 CHECK(*endptr >= nptr); 619} 620 621INTERCEPTOR(long, strtol, const char *nptr, // NOLINT 622 char **endptr, int base) { 623 ENSURE_ASAN_INITED(); 624 if (!FLAG_replace_str) { 625 return REAL(strtol)(nptr, endptr, base); 626 } 627 char *real_endptr; 628 long result = REAL(strtol)(nptr, &real_endptr, base); // NOLINT 629 if (endptr != 0) { 630 *endptr = real_endptr; 631 } 632 if (IsValidStrtolBase(base)) { 633 FixRealStrtolEndptr(nptr, &real_endptr); 634 ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1); 635 } 636 return result; 637} 638 639INTERCEPTOR(int, atoi, const char *nptr) { 640 ENSURE_ASAN_INITED(); 641 if (!FLAG_replace_str) { 642 return REAL(atoi)(nptr); 643 } 644 char *real_endptr; 645 // "man atoi" tells that behavior of atoi(nptr) is the same as 646 // strtol(nptr, 0, 10), i.e. it sets errno to ERANGE if the 647 // parsed integer can't be stored in *long* type (even if it's 648 // different from int). So, we just imitate this behavior. 649 int result = REAL(strtol)(nptr, &real_endptr, 10); 650 FixRealStrtolEndptr(nptr, &real_endptr); 651 ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1); 652 return result; 653} 654 655INTERCEPTOR(long, atol, const char *nptr) { // NOLINT 656 ENSURE_ASAN_INITED(); 657 if (!FLAG_replace_str) { 658 return REAL(atol)(nptr); 659 } 660 char *real_endptr; 661 long result = REAL(strtol)(nptr, &real_endptr, 10); // NOLINT 662 FixRealStrtolEndptr(nptr, &real_endptr); 663 ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1); 664 return result; 665} 666 667#if ASAN_INTERCEPT_ATOLL_AND_STRTOLL 668INTERCEPTOR(long long, strtoll, const char *nptr, // NOLINT 669 char **endptr, int base) { 670 ENSURE_ASAN_INITED(); 671 if (!FLAG_replace_str) { 672 return REAL(strtoll)(nptr, endptr, base); 673 } 674 char *real_endptr; 675 long long result = REAL(strtoll)(nptr, &real_endptr, base); // NOLINT 676 if (endptr != 0) { 677 *endptr = real_endptr; 678 } 679 // If base has unsupported value, strtoll can exit with EINVAL 680 // without reading any characters. So do additional checks only 681 // if base is valid. 682 if (IsValidStrtolBase(base)) { 683 FixRealStrtolEndptr(nptr, &real_endptr); 684 ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1); 685 } 686 return result; 687} 688 689INTERCEPTOR(long long, atoll, const char *nptr) { // NOLINT 690 ENSURE_ASAN_INITED(); 691 if (!FLAG_replace_str) { 692 return REAL(atoll)(nptr); 693 } 694 char *real_endptr; 695 long long result = REAL(strtoll)(nptr, &real_endptr, 10); // NOLINT 696 FixRealStrtolEndptr(nptr, &real_endptr); 697 ASAN_READ_RANGE(nptr, (real_endptr - nptr) + 1); 698 return result; 699} 700#endif // ASAN_INTERCEPT_ATOLL_AND_STRTOLL 701 702#define ASAN_INTERCEPT_FUNC(name) do { \ 703 if (!INTERCEPT_FUNCTION(name) && FLAG_v > 0) \ 704 Report("AddressSanitizer: failed to intercept '" #name "'\n"); \ 705 } while (0) 706 707#if defined(_WIN32) 708INTERCEPTOR_WINAPI(DWORD, CreateThread, 709 void* security, uptr stack_size, 710 DWORD (__stdcall *start_routine)(void*), void* arg, 711 DWORD flags, void* tid) { 712 GET_STACK_TRACE_HERE(kStackTraceMax); 713 u32 current_tid = asanThreadRegistry().GetCurrentTidOrInvalid(); 714 AsanThread *t = AsanThread::Create(current_tid, start_routine, arg, &stack); 715 asanThreadRegistry().RegisterThread(t); 716 return REAL(CreateThread)(security, stack_size, 717 asan_thread_start, t, flags, tid); 718} 719 720namespace __asan { 721void InitializeWindowsInterceptors() { 722 ASAN_INTERCEPT_FUNC(CreateThread); 723} 724 725} // namespace __asan 726#endif 727 728// ---------------------- InitializeAsanInterceptors ---------------- {{{1 729namespace __asan { 730void InitializeAsanInterceptors() { 731 static bool was_called_once; 732 CHECK(was_called_once == false); 733 was_called_once = true; 734 // Intercept mem* functions. 735 ASAN_INTERCEPT_FUNC(memcmp); 736 ASAN_INTERCEPT_FUNC(memmove); 737 ASAN_INTERCEPT_FUNC(memset); 738 if (PLATFORM_HAS_DIFFERENT_MEMCPY_AND_MEMMOVE) { 739 ASAN_INTERCEPT_FUNC(memcpy); 740 } else { 741 REAL(memcpy) = REAL(memmove); 742 } 743 744 // Intercept str* functions. 745 ASAN_INTERCEPT_FUNC(strcat); // NOLINT 746 ASAN_INTERCEPT_FUNC(strchr); 747 ASAN_INTERCEPT_FUNC(strcmp); 748 ASAN_INTERCEPT_FUNC(strcpy); // NOLINT 749 ASAN_INTERCEPT_FUNC(strlen); 750 ASAN_INTERCEPT_FUNC(strncat); 751 ASAN_INTERCEPT_FUNC(strncmp); 752 ASAN_INTERCEPT_FUNC(strncpy); 753#if !defined(_WIN32) 754 ASAN_INTERCEPT_FUNC(strcasecmp); 755 ASAN_INTERCEPT_FUNC(strdup); 756 ASAN_INTERCEPT_FUNC(strncasecmp); 757# ifndef __APPLE__ 758 ASAN_INTERCEPT_FUNC(index); 759# else 760 CHECK(OVERRIDE_FUNCTION(index, WRAP(strchr))); 761# endif 762#endif 763#if ASAN_INTERCEPT_STRNLEN 764 ASAN_INTERCEPT_FUNC(strnlen); 765#endif 766 767 ASAN_INTERCEPT_FUNC(atoi); 768 ASAN_INTERCEPT_FUNC(atol); 769 ASAN_INTERCEPT_FUNC(strtol); 770#if ASAN_INTERCEPT_ATOLL_AND_STRTOLL 771 ASAN_INTERCEPT_FUNC(atoll); 772 ASAN_INTERCEPT_FUNC(strtoll); 773#endif 774 775 // Intecept signal- and jump-related functions. 776 ASAN_INTERCEPT_FUNC(longjmp); 777#if ASAN_INTERCEPT_SIGNAL_AND_SIGACTION 778 ASAN_INTERCEPT_FUNC(sigaction); 779 ASAN_INTERCEPT_FUNC(signal); 780#endif 781 782#if !defined(_WIN32) 783 ASAN_INTERCEPT_FUNC(_longjmp); 784 INTERCEPT_FUNCTION(__cxa_throw); 785# if !defined(__APPLE__) 786 // On Darwin siglongjmp tailcalls longjmp, so we don't want to intercept it 787 // there. 788 ASAN_INTERCEPT_FUNC(siglongjmp); 789# endif 790#endif 791 792 // Intercept threading-related functions 793#if !defined(_WIN32) 794 ASAN_INTERCEPT_FUNC(pthread_create); 795#endif 796 797 // Some Windows-specific interceptors. 798#if defined(_WIN32) 799 InitializeWindowsInterceptors(); 800#endif 801 802 // Some Mac-specific interceptors. 803#if defined(__APPLE__) 804 InitializeMacInterceptors(); 805#endif 806 807 if (FLAG_v > 0) { 808 Report("AddressSanitizer: libc interceptors initialized\n"); 809 } 810} 811 812} // namespace __asan 813