1//===-- dfsan.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 DataFlowSanitizer. 10// 11// This file defines the custom functions listed in done_abilist.txt. 12//===----------------------------------------------------------------------===// 13 14#include "sanitizer_common/sanitizer_common.h" 15#include "sanitizer_common/sanitizer_internal_defs.h" 16#include "sanitizer_common/sanitizer_linux.h" 17 18#include "dfsan/dfsan.h" 19 20#include <arpa/inet.h> 21#include <assert.h> 22#include <ctype.h> 23#include <dlfcn.h> 24#include <link.h> 25#include <poll.h> 26#include <pthread.h> 27#include <pwd.h> 28#include <sched.h> 29#include <signal.h> 30#include <stdarg.h> 31#include <stdint.h> 32#include <stdio.h> 33#include <stdlib.h> 34#include <string.h> 35#include <sys/resource.h> 36#include <sys/select.h> 37#include <sys/stat.h> 38#include <sys/time.h> 39#include <sys/types.h> 40#include <time.h> 41#include <unistd.h> 42 43using namespace __dfsan; 44 45#define CALL_WEAK_INTERCEPTOR_HOOK(f, ...) \ 46 do { \ 47 if (f) \ 48 f(__VA_ARGS__); \ 49 } while (false) 50#define DECLARE_WEAK_INTERCEPTOR_HOOK(f, ...) \ 51SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void f(__VA_ARGS__); 52 53extern "C" { 54SANITIZER_INTERFACE_ATTRIBUTE int 55__dfsw_stat(const char *path, struct stat *buf, dfsan_label path_label, 56 dfsan_label buf_label, dfsan_label *ret_label) { 57 int ret = stat(path, buf); 58 if (ret == 0) 59 dfsan_set_label(0, buf, sizeof(struct stat)); 60 *ret_label = 0; 61 return ret; 62} 63 64SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_fstat(int fd, struct stat *buf, 65 dfsan_label fd_label, 66 dfsan_label buf_label, 67 dfsan_label *ret_label) { 68 int ret = fstat(fd, buf); 69 if (ret == 0) 70 dfsan_set_label(0, buf, sizeof(struct stat)); 71 *ret_label = 0; 72 return ret; 73} 74 75SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strchr(const char *s, int c, 76 dfsan_label s_label, 77 dfsan_label c_label, 78 dfsan_label *ret_label) { 79 for (size_t i = 0;; ++i) { 80 if (s[i] == c || s[i] == 0) { 81 if (flags().strict_data_dependencies) { 82 *ret_label = s_label; 83 } else { 84 *ret_label = dfsan_union(dfsan_read_label(s, i + 1), 85 dfsan_union(s_label, c_label)); 86 } 87 88 // If s[i] is the \0 at the end of the string, and \0 is not the 89 // character we are searching for, then return null. 90 if (s[i] == 0 && c != 0) { 91 return nullptr; 92 } 93 return const_cast<char *>(s + i); 94 } 95 } 96} 97 98DECLARE_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_memcmp, uptr caller_pc, 99 const void *s1, const void *s2, size_t n, 100 dfsan_label s1_label, dfsan_label s2_label, 101 dfsan_label n_label) 102 103SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_memcmp(const void *s1, const void *s2, 104 size_t n, dfsan_label s1_label, 105 dfsan_label s2_label, 106 dfsan_label n_label, 107 dfsan_label *ret_label) { 108 CALL_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_memcmp, GET_CALLER_PC(), s1, s2, n, 109 s1_label, s2_label, n_label); 110 const char *cs1 = (const char *) s1, *cs2 = (const char *) s2; 111 for (size_t i = 0; i != n; ++i) { 112 if (cs1[i] != cs2[i]) { 113 if (flags().strict_data_dependencies) { 114 *ret_label = 0; 115 } else { 116 *ret_label = dfsan_union(dfsan_read_label(cs1, i + 1), 117 dfsan_read_label(cs2, i + 1)); 118 } 119 return cs1[i] - cs2[i]; 120 } 121 } 122 123 if (flags().strict_data_dependencies) { 124 *ret_label = 0; 125 } else { 126 *ret_label = dfsan_union(dfsan_read_label(cs1, n), 127 dfsan_read_label(cs2, n)); 128 } 129 return 0; 130} 131 132DECLARE_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strcmp, uptr caller_pc, 133 const char *s1, const char *s2, 134 dfsan_label s1_label, dfsan_label s2_label) 135 136SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_strcmp(const char *s1, const char *s2, 137 dfsan_label s1_label, 138 dfsan_label s2_label, 139 dfsan_label *ret_label) { 140 CALL_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strcmp, GET_CALLER_PC(), s1, s2, 141 s1_label, s2_label); 142 for (size_t i = 0;; ++i) { 143 if (s1[i] != s2[i] || s1[i] == 0 || s2[i] == 0) { 144 if (flags().strict_data_dependencies) { 145 *ret_label = 0; 146 } else { 147 *ret_label = dfsan_union(dfsan_read_label(s1, i + 1), 148 dfsan_read_label(s2, i + 1)); 149 } 150 return s1[i] - s2[i]; 151 } 152 } 153 return 0; 154} 155 156SANITIZER_INTERFACE_ATTRIBUTE int 157__dfsw_strcasecmp(const char *s1, const char *s2, dfsan_label s1_label, 158 dfsan_label s2_label, dfsan_label *ret_label) { 159 for (size_t i = 0;; ++i) { 160 char s1_lower = tolower(s1[i]); 161 char s2_lower = tolower(s2[i]); 162 163 if (s1_lower != s2_lower || s1[i] == 0 || s2[i] == 0) { 164 if (flags().strict_data_dependencies) { 165 *ret_label = 0; 166 } else { 167 *ret_label = dfsan_union(dfsan_read_label(s1, i + 1), 168 dfsan_read_label(s2, i + 1)); 169 } 170 return s1_lower - s2_lower; 171 } 172 } 173 return 0; 174} 175 176DECLARE_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strncmp, uptr caller_pc, 177 const char *s1, const char *s2, size_t n, 178 dfsan_label s1_label, dfsan_label s2_label, 179 dfsan_label n_label) 180 181SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_strncmp(const char *s1, const char *s2, 182 size_t n, dfsan_label s1_label, 183 dfsan_label s2_label, 184 dfsan_label n_label, 185 dfsan_label *ret_label) { 186 if (n == 0) { 187 *ret_label = 0; 188 return 0; 189 } 190 191 CALL_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strncmp, GET_CALLER_PC(), s1, s2, 192 n, s1_label, s2_label, n_label); 193 194 for (size_t i = 0;; ++i) { 195 if (s1[i] != s2[i] || s1[i] == 0 || s2[i] == 0 || i == n - 1) { 196 if (flags().strict_data_dependencies) { 197 *ret_label = 0; 198 } else { 199 *ret_label = dfsan_union(dfsan_read_label(s1, i + 1), 200 dfsan_read_label(s2, i + 1)); 201 } 202 return s1[i] - s2[i]; 203 } 204 } 205 return 0; 206} 207 208SANITIZER_INTERFACE_ATTRIBUTE int 209__dfsw_strncasecmp(const char *s1, const char *s2, size_t n, 210 dfsan_label s1_label, dfsan_label s2_label, 211 dfsan_label n_label, dfsan_label *ret_label) { 212 if (n == 0) { 213 *ret_label = 0; 214 return 0; 215 } 216 217 for (size_t i = 0;; ++i) { 218 char s1_lower = tolower(s1[i]); 219 char s2_lower = tolower(s2[i]); 220 221 if (s1_lower != s2_lower || s1[i] == 0 || s2[i] == 0 || i == n - 1) { 222 if (flags().strict_data_dependencies) { 223 *ret_label = 0; 224 } else { 225 *ret_label = dfsan_union(dfsan_read_label(s1, i + 1), 226 dfsan_read_label(s2, i + 1)); 227 } 228 return s1_lower - s2_lower; 229 } 230 } 231 return 0; 232} 233 234SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_calloc(size_t nmemb, size_t size, 235 dfsan_label nmemb_label, 236 dfsan_label size_label, 237 dfsan_label *ret_label) { 238 void *p = calloc(nmemb, size); 239 dfsan_set_label(0, p, nmemb * size); 240 *ret_label = 0; 241 return p; 242} 243 244SANITIZER_INTERFACE_ATTRIBUTE size_t 245__dfsw_strlen(const char *s, dfsan_label s_label, dfsan_label *ret_label) { 246 size_t ret = strlen(s); 247 if (flags().strict_data_dependencies) { 248 *ret_label = 0; 249 } else { 250 *ret_label = dfsan_read_label(s, ret + 1); 251 } 252 return ret; 253} 254 255 256static void *dfsan_memcpy(void *dest, const void *src, size_t n) { 257 dfsan_label *sdest = shadow_for(dest); 258 const dfsan_label *ssrc = shadow_for(src); 259 internal_memcpy((void *)sdest, (const void *)ssrc, n * sizeof(dfsan_label)); 260 return internal_memcpy(dest, src, n); 261} 262 263static void dfsan_memset(void *s, int c, dfsan_label c_label, size_t n) { 264 internal_memset(s, c, n); 265 dfsan_set_label(c_label, s, n); 266} 267 268SANITIZER_INTERFACE_ATTRIBUTE 269void *__dfsw_memcpy(void *dest, const void *src, size_t n, 270 dfsan_label dest_label, dfsan_label src_label, 271 dfsan_label n_label, dfsan_label *ret_label) { 272 *ret_label = dest_label; 273 return dfsan_memcpy(dest, src, n); 274} 275 276SANITIZER_INTERFACE_ATTRIBUTE 277void *__dfsw_memset(void *s, int c, size_t n, 278 dfsan_label s_label, dfsan_label c_label, 279 dfsan_label n_label, dfsan_label *ret_label) { 280 dfsan_memset(s, c, c_label, n); 281 *ret_label = s_label; 282 return s; 283} 284 285SANITIZER_INTERFACE_ATTRIBUTE char * 286__dfsw_strdup(const char *s, dfsan_label s_label, dfsan_label *ret_label) { 287 size_t len = strlen(s); 288 void *p = malloc(len+1); 289 dfsan_memcpy(p, s, len+1); 290 *ret_label = 0; 291 return static_cast<char *>(p); 292} 293 294SANITIZER_INTERFACE_ATTRIBUTE char * 295__dfsw_strncpy(char *s1, const char *s2, size_t n, dfsan_label s1_label, 296 dfsan_label s2_label, dfsan_label n_label, 297 dfsan_label *ret_label) { 298 size_t len = strlen(s2); 299 if (len < n) { 300 dfsan_memcpy(s1, s2, len+1); 301 dfsan_memset(s1+len+1, 0, 0, n-len-1); 302 } else { 303 dfsan_memcpy(s1, s2, n); 304 } 305 306 *ret_label = s1_label; 307 return s1; 308} 309 310SANITIZER_INTERFACE_ATTRIBUTE ssize_t 311__dfsw_pread(int fd, void *buf, size_t count, off_t offset, 312 dfsan_label fd_label, dfsan_label buf_label, 313 dfsan_label count_label, dfsan_label offset_label, 314 dfsan_label *ret_label) { 315 ssize_t ret = pread(fd, buf, count, offset); 316 if (ret > 0) 317 dfsan_set_label(0, buf, ret); 318 *ret_label = 0; 319 return ret; 320} 321 322SANITIZER_INTERFACE_ATTRIBUTE ssize_t 323__dfsw_read(int fd, void *buf, size_t count, 324 dfsan_label fd_label, dfsan_label buf_label, 325 dfsan_label count_label, 326 dfsan_label *ret_label) { 327 ssize_t ret = read(fd, buf, count); 328 if (ret > 0) 329 dfsan_set_label(0, buf, ret); 330 *ret_label = 0; 331 return ret; 332} 333 334SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_clock_gettime(clockid_t clk_id, 335 struct timespec *tp, 336 dfsan_label clk_id_label, 337 dfsan_label tp_label, 338 dfsan_label *ret_label) { 339 int ret = clock_gettime(clk_id, tp); 340 if (ret == 0) 341 dfsan_set_label(0, tp, sizeof(struct timespec)); 342 *ret_label = 0; 343 return ret; 344} 345 346static void unpoison(const void *ptr, uptr size) { 347 dfsan_set_label(0, const_cast<void *>(ptr), size); 348} 349 350// dlopen() ultimately calls mmap() down inside the loader, which generally 351// doesn't participate in dynamic symbol resolution. Therefore we won't 352// intercept its calls to mmap, and we have to hook it here. 353SANITIZER_INTERFACE_ATTRIBUTE void * 354__dfsw_dlopen(const char *filename, int flag, dfsan_label filename_label, 355 dfsan_label flag_label, dfsan_label *ret_label) { 356 void *handle = dlopen(filename, flag); 357 link_map *map = GET_LINK_MAP_BY_DLOPEN_HANDLE(handle); 358 if (map) 359 ForEachMappedRegion(map, unpoison); 360 *ret_label = 0; 361 return handle; 362} 363 364struct pthread_create_info { 365 void *(*start_routine_trampoline)(void *, void *, dfsan_label, dfsan_label *); 366 void *start_routine; 367 void *arg; 368}; 369 370static void *pthread_create_cb(void *p) { 371 pthread_create_info pci(*(pthread_create_info *)p); 372 free(p); 373 dfsan_label ret_label; 374 return pci.start_routine_trampoline(pci.start_routine, pci.arg, 0, 375 &ret_label); 376} 377 378SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_pthread_create( 379 pthread_t *thread, const pthread_attr_t *attr, 380 void *(*start_routine_trampoline)(void *, void *, dfsan_label, 381 dfsan_label *), 382 void *start_routine, void *arg, dfsan_label thread_label, 383 dfsan_label attr_label, dfsan_label start_routine_label, 384 dfsan_label arg_label, dfsan_label *ret_label) { 385 pthread_create_info *pci = 386 (pthread_create_info *)malloc(sizeof(pthread_create_info)); 387 pci->start_routine_trampoline = start_routine_trampoline; 388 pci->start_routine = start_routine; 389 pci->arg = arg; 390 int rv = pthread_create(thread, attr, pthread_create_cb, (void *)pci); 391 if (rv != 0) 392 free(pci); 393 *ret_label = 0; 394 return rv; 395} 396 397struct dl_iterate_phdr_info { 398 int (*callback_trampoline)(void *callback, struct dl_phdr_info *info, 399 size_t size, void *data, dfsan_label info_label, 400 dfsan_label size_label, dfsan_label data_label, 401 dfsan_label *ret_label); 402 void *callback; 403 void *data; 404}; 405 406int dl_iterate_phdr_cb(struct dl_phdr_info *info, size_t size, void *data) { 407 dl_iterate_phdr_info *dipi = (dl_iterate_phdr_info *)data; 408 dfsan_set_label(0, *info); 409 dfsan_set_label(0, const_cast<char *>(info->dlpi_name), 410 strlen(info->dlpi_name) + 1); 411 dfsan_set_label( 412 0, const_cast<char *>(reinterpret_cast<const char *>(info->dlpi_phdr)), 413 sizeof(*info->dlpi_phdr) * info->dlpi_phnum); 414 dfsan_label ret_label; 415 return dipi->callback_trampoline(dipi->callback, info, size, dipi->data, 0, 0, 416 0, &ret_label); 417} 418 419SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_dl_iterate_phdr( 420 int (*callback_trampoline)(void *callback, struct dl_phdr_info *info, 421 size_t size, void *data, dfsan_label info_label, 422 dfsan_label size_label, dfsan_label data_label, 423 dfsan_label *ret_label), 424 void *callback, void *data, dfsan_label callback_label, 425 dfsan_label data_label, dfsan_label *ret_label) { 426 dl_iterate_phdr_info dipi = { callback_trampoline, callback, data }; 427 *ret_label = 0; 428 return dl_iterate_phdr(dl_iterate_phdr_cb, &dipi); 429} 430 431SANITIZER_INTERFACE_ATTRIBUTE 432char *__dfsw_ctime_r(const time_t *timep, char *buf, dfsan_label timep_label, 433 dfsan_label buf_label, dfsan_label *ret_label) { 434 char *ret = ctime_r(timep, buf); 435 if (ret) { 436 dfsan_set_label(dfsan_read_label(timep, sizeof(time_t)), buf, 437 strlen(buf) + 1); 438 *ret_label = buf_label; 439 } else { 440 *ret_label = 0; 441 } 442 return ret; 443} 444 445SANITIZER_INTERFACE_ATTRIBUTE 446char *__dfsw_fgets(char *s, int size, FILE *stream, dfsan_label s_label, 447 dfsan_label size_label, dfsan_label stream_label, 448 dfsan_label *ret_label) { 449 char *ret = fgets(s, size, stream); 450 if (ret) { 451 dfsan_set_label(0, ret, strlen(ret) + 1); 452 *ret_label = s_label; 453 } else { 454 *ret_label = 0; 455 } 456 return ret; 457} 458 459SANITIZER_INTERFACE_ATTRIBUTE 460char *__dfsw_getcwd(char *buf, size_t size, dfsan_label buf_label, 461 dfsan_label size_label, dfsan_label *ret_label) { 462 char *ret = getcwd(buf, size); 463 if (ret) { 464 dfsan_set_label(0, ret, strlen(ret) + 1); 465 *ret_label = buf_label; 466 } else { 467 *ret_label = 0; 468 } 469 return ret; 470} 471 472SANITIZER_INTERFACE_ATTRIBUTE 473char *__dfsw_get_current_dir_name(dfsan_label *ret_label) { 474 char *ret = get_current_dir_name(); 475 if (ret) { 476 dfsan_set_label(0, ret, strlen(ret) + 1); 477 } 478 *ret_label = 0; 479 return ret; 480} 481 482SANITIZER_INTERFACE_ATTRIBUTE 483int __dfsw_gethostname(char *name, size_t len, dfsan_label name_label, 484 dfsan_label len_label, dfsan_label *ret_label) { 485 int ret = gethostname(name, len); 486 if (ret == 0) { 487 dfsan_set_label(0, name, strlen(name) + 1); 488 } 489 *ret_label = 0; 490 return ret; 491} 492 493SANITIZER_INTERFACE_ATTRIBUTE 494int __dfsw_getrlimit(int resource, struct rlimit *rlim, 495 dfsan_label resource_label, dfsan_label rlim_label, 496 dfsan_label *ret_label) { 497 int ret = getrlimit(resource, rlim); 498 if (ret == 0) { 499 dfsan_set_label(0, rlim, sizeof(struct rlimit)); 500 } 501 *ret_label = 0; 502 return ret; 503} 504 505SANITIZER_INTERFACE_ATTRIBUTE 506int __dfsw_getrusage(int who, struct rusage *usage, dfsan_label who_label, 507 dfsan_label usage_label, dfsan_label *ret_label) { 508 int ret = getrusage(who, usage); 509 if (ret == 0) { 510 dfsan_set_label(0, usage, sizeof(struct rusage)); 511 } 512 *ret_label = 0; 513 return ret; 514} 515 516SANITIZER_INTERFACE_ATTRIBUTE 517char *__dfsw_strcpy(char *dest, const char *src, dfsan_label dst_label, 518 dfsan_label src_label, dfsan_label *ret_label) { 519 char *ret = strcpy(dest, src); // NOLINT 520 if (ret) { 521 internal_memcpy(shadow_for(dest), shadow_for(src), 522 sizeof(dfsan_label) * (strlen(src) + 1)); 523 } 524 *ret_label = dst_label; 525 return ret; 526} 527 528SANITIZER_INTERFACE_ATTRIBUTE 529long int __dfsw_strtol(const char *nptr, char **endptr, int base, 530 dfsan_label nptr_label, dfsan_label endptr_label, 531 dfsan_label base_label, dfsan_label *ret_label) { 532 char *tmp_endptr; 533 long int ret = strtol(nptr, &tmp_endptr, base); 534 if (endptr) { 535 *endptr = tmp_endptr; 536 } 537 if (tmp_endptr > nptr) { 538 // If *tmp_endptr is '\0' include its label as well. 539 *ret_label = dfsan_union( 540 base_label, 541 dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1))); 542 } else { 543 *ret_label = 0; 544 } 545 return ret; 546} 547 548SANITIZER_INTERFACE_ATTRIBUTE 549double __dfsw_strtod(const char *nptr, char **endptr, 550 dfsan_label nptr_label, dfsan_label endptr_label, 551 dfsan_label *ret_label) { 552 char *tmp_endptr; 553 double ret = strtod(nptr, &tmp_endptr); 554 if (endptr) { 555 *endptr = tmp_endptr; 556 } 557 if (tmp_endptr > nptr) { 558 // If *tmp_endptr is '\0' include its label as well. 559 *ret_label = dfsan_read_label( 560 nptr, 561 tmp_endptr - nptr + (*tmp_endptr ? 0 : 1)); 562 } else { 563 *ret_label = 0; 564 } 565 return ret; 566} 567 568SANITIZER_INTERFACE_ATTRIBUTE 569long long int __dfsw_strtoll(const char *nptr, char **endptr, int base, 570 dfsan_label nptr_label, dfsan_label endptr_label, 571 dfsan_label base_label, dfsan_label *ret_label) { 572 char *tmp_endptr; 573 long long int ret = strtoll(nptr, &tmp_endptr, base); 574 if (endptr) { 575 *endptr = tmp_endptr; 576 } 577 if (tmp_endptr > nptr) { 578 // If *tmp_endptr is '\0' include its label as well. 579 *ret_label = dfsan_union( 580 base_label, 581 dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1))); 582 } else { 583 *ret_label = 0; 584 } 585 return ret; 586} 587 588SANITIZER_INTERFACE_ATTRIBUTE 589unsigned long int __dfsw_strtoul(const char *nptr, char **endptr, int base, 590 dfsan_label nptr_label, dfsan_label endptr_label, 591 dfsan_label base_label, dfsan_label *ret_label) { 592 char *tmp_endptr; 593 unsigned long int ret = strtoul(nptr, &tmp_endptr, base); 594 if (endptr) { 595 *endptr = tmp_endptr; 596 } 597 if (tmp_endptr > nptr) { 598 // If *tmp_endptr is '\0' include its label as well. 599 *ret_label = dfsan_union( 600 base_label, 601 dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1))); 602 } else { 603 *ret_label = 0; 604 } 605 return ret; 606} 607 608SANITIZER_INTERFACE_ATTRIBUTE 609long long unsigned int __dfsw_strtoull(const char *nptr, char **endptr, 610 dfsan_label nptr_label, 611 int base, dfsan_label endptr_label, 612 dfsan_label base_label, 613 dfsan_label *ret_label) { 614 char *tmp_endptr; 615 long long unsigned int ret = strtoull(nptr, &tmp_endptr, base); 616 if (endptr) { 617 *endptr = tmp_endptr; 618 } 619 if (tmp_endptr > nptr) { 620 // If *tmp_endptr is '\0' include its label as well. 621 *ret_label = dfsan_union( 622 base_label, 623 dfsan_read_label(nptr, tmp_endptr - nptr + (*tmp_endptr ? 0 : 1))); 624 } else { 625 *ret_label = 0; 626 } 627 return ret; 628} 629 630SANITIZER_INTERFACE_ATTRIBUTE 631time_t __dfsw_time(time_t *t, dfsan_label t_label, dfsan_label *ret_label) { 632 time_t ret = time(t); 633 if (ret != (time_t) -1 && t) { 634 dfsan_set_label(0, t, sizeof(time_t)); 635 } 636 *ret_label = 0; 637 return ret; 638} 639 640SANITIZER_INTERFACE_ATTRIBUTE 641int __dfsw_inet_pton(int af, const char *src, void *dst, dfsan_label af_label, 642 dfsan_label src_label, dfsan_label dst_label, 643 dfsan_label *ret_label) { 644 int ret = inet_pton(af, src, dst); 645 if (ret == 1) { 646 dfsan_set_label(dfsan_read_label(src, strlen(src) + 1), dst, 647 af == AF_INET ? sizeof(struct in_addr) : sizeof(in6_addr)); 648 } 649 *ret_label = 0; 650 return ret; 651} 652 653SANITIZER_INTERFACE_ATTRIBUTE 654struct tm *__dfsw_localtime_r(const time_t *timep, struct tm *result, 655 dfsan_label timep_label, dfsan_label result_label, 656 dfsan_label *ret_label) { 657 struct tm *ret = localtime_r(timep, result); 658 if (ret) { 659 dfsan_set_label(dfsan_read_label(timep, sizeof(time_t)), result, 660 sizeof(struct tm)); 661 *ret_label = result_label; 662 } else { 663 *ret_label = 0; 664 } 665 return ret; 666} 667 668SANITIZER_INTERFACE_ATTRIBUTE 669int __dfsw_getpwuid_r(id_t uid, struct passwd *pwd, 670 char *buf, size_t buflen, struct passwd **result, 671 dfsan_label uid_label, dfsan_label pwd_label, 672 dfsan_label buf_label, dfsan_label buflen_label, 673 dfsan_label result_label, dfsan_label *ret_label) { 674 // Store the data in pwd, the strings referenced from pwd in buf, and the 675 // address of pwd in *result. On failure, NULL is stored in *result. 676 int ret = getpwuid_r(uid, pwd, buf, buflen, result); 677 if (ret == 0) { 678 dfsan_set_label(0, pwd, sizeof(struct passwd)); 679 dfsan_set_label(0, buf, strlen(buf) + 1); 680 } 681 *ret_label = 0; 682 dfsan_set_label(0, result, sizeof(struct passwd*)); 683 return ret; 684} 685 686SANITIZER_INTERFACE_ATTRIBUTE 687int __dfsw_poll(struct pollfd *fds, nfds_t nfds, int timeout, 688 dfsan_label dfs_label, dfsan_label nfds_label, 689 dfsan_label timeout_label, dfsan_label *ret_label) { 690 int ret = poll(fds, nfds, timeout); 691 if (ret >= 0) { 692 for (; nfds > 0; --nfds) { 693 dfsan_set_label(0, &fds[nfds - 1].revents, sizeof(fds[nfds - 1].revents)); 694 } 695 } 696 *ret_label = 0; 697 return ret; 698} 699 700SANITIZER_INTERFACE_ATTRIBUTE 701int __dfsw_select(int nfds, fd_set *readfds, fd_set *writefds, 702 fd_set *exceptfds, struct timeval *timeout, 703 dfsan_label nfds_label, dfsan_label readfds_label, 704 dfsan_label writefds_label, dfsan_label exceptfds_label, 705 dfsan_label timeout_label, dfsan_label *ret_label) { 706 int ret = select(nfds, readfds, writefds, exceptfds, timeout); 707 // Clear everything (also on error) since their content is either set or 708 // undefined. 709 if (readfds) { 710 dfsan_set_label(0, readfds, sizeof(fd_set)); 711 } 712 if (writefds) { 713 dfsan_set_label(0, writefds, sizeof(fd_set)); 714 } 715 if (exceptfds) { 716 dfsan_set_label(0, exceptfds, sizeof(fd_set)); 717 } 718 dfsan_set_label(0, timeout, sizeof(struct timeval)); 719 *ret_label = 0; 720 return ret; 721} 722 723SANITIZER_INTERFACE_ATTRIBUTE 724int __dfsw_sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask, 725 dfsan_label pid_label, 726 dfsan_label cpusetsize_label, 727 dfsan_label mask_label, dfsan_label *ret_label) { 728 int ret = sched_getaffinity(pid, cpusetsize, mask); 729 if (ret == 0) { 730 dfsan_set_label(0, mask, cpusetsize); 731 } 732 *ret_label = 0; 733 return ret; 734} 735 736SANITIZER_INTERFACE_ATTRIBUTE 737int __dfsw_sigemptyset(sigset_t *set, dfsan_label set_label, 738 dfsan_label *ret_label) { 739 int ret = sigemptyset(set); 740 dfsan_set_label(0, set, sizeof(sigset_t)); 741 return ret; 742} 743 744SANITIZER_INTERFACE_ATTRIBUTE 745int __dfsw_sigaction(int signum, const struct sigaction *act, 746 struct sigaction *oldact, dfsan_label signum_label, 747 dfsan_label act_label, dfsan_label oldact_label, 748 dfsan_label *ret_label) { 749 int ret = sigaction(signum, act, oldact); 750 if (oldact) { 751 dfsan_set_label(0, oldact, sizeof(struct sigaction)); 752 } 753 *ret_label = 0; 754 return ret; 755} 756 757SANITIZER_INTERFACE_ATTRIBUTE 758int __dfsw_gettimeofday(struct timeval *tv, struct timezone *tz, 759 dfsan_label tv_label, dfsan_label tz_label, 760 dfsan_label *ret_label) { 761 int ret = gettimeofday(tv, tz); 762 if (tv) { 763 dfsan_set_label(0, tv, sizeof(struct timeval)); 764 } 765 if (tz) { 766 dfsan_set_label(0, tz, sizeof(struct timezone)); 767 } 768 *ret_label = 0; 769 return ret; 770} 771 772SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_memchr(void *s, int c, size_t n, 773 dfsan_label s_label, 774 dfsan_label c_label, 775 dfsan_label n_label, 776 dfsan_label *ret_label) { 777 void *ret = memchr(s, c, n); 778 if (flags().strict_data_dependencies) { 779 *ret_label = ret ? s_label : 0; 780 } else { 781 size_t len = 782 ret ? reinterpret_cast<char *>(ret) - reinterpret_cast<char *>(s) + 1 783 : n; 784 *ret_label = 785 dfsan_union(dfsan_read_label(s, len), dfsan_union(s_label, c_label)); 786 } 787 return ret; 788} 789 790SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strrchr(char *s, int c, 791 dfsan_label s_label, 792 dfsan_label c_label, 793 dfsan_label *ret_label) { 794 char *ret = strrchr(s, c); 795 if (flags().strict_data_dependencies) { 796 *ret_label = ret ? s_label : 0; 797 } else { 798 *ret_label = 799 dfsan_union(dfsan_read_label(s, strlen(s) + 1), 800 dfsan_union(s_label, c_label)); 801 } 802 803 return ret; 804} 805 806SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strstr(char *haystack, char *needle, 807 dfsan_label haystack_label, 808 dfsan_label needle_label, 809 dfsan_label *ret_label) { 810 char *ret = strstr(haystack, needle); 811 if (flags().strict_data_dependencies) { 812 *ret_label = ret ? haystack_label : 0; 813 } else { 814 size_t len = ret ? ret + strlen(needle) - haystack : strlen(haystack) + 1; 815 *ret_label = 816 dfsan_union(dfsan_read_label(haystack, len), 817 dfsan_union(dfsan_read_label(needle, strlen(needle) + 1), 818 dfsan_union(haystack_label, needle_label))); 819 } 820 821 return ret; 822} 823 824SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_nanosleep(const struct timespec *req, 825 struct timespec *rem, 826 dfsan_label req_label, 827 dfsan_label rem_label, 828 dfsan_label *ret_label) { 829 int ret = nanosleep(req, rem); 830 *ret_label = 0; 831 if (ret == -1) { 832 // Interrupted by a signal, rem is filled with the remaining time. 833 dfsan_set_label(0, rem, sizeof(struct timespec)); 834 } 835 return ret; 836} 837 838SANITIZER_INTERFACE_ATTRIBUTE int 839__dfsw_socketpair(int domain, int type, int protocol, int sv[2], 840 dfsan_label domain_label, dfsan_label type_label, 841 dfsan_label protocol_label, dfsan_label sv_label, 842 dfsan_label *ret_label) { 843 int ret = socketpair(domain, type, protocol, sv); 844 *ret_label = 0; 845 if (ret == 0) { 846 dfsan_set_label(0, sv, sizeof(*sv) * 2); 847 } 848 return ret; 849} 850 851// Type of the trampoline function passed to the custom version of 852// dfsan_set_write_callback. 853typedef void (*write_trampoline_t)( 854 void *callback, 855 int fd, const void *buf, ssize_t count, 856 dfsan_label fd_label, dfsan_label buf_label, dfsan_label count_label); 857 858// Calls to dfsan_set_write_callback() set the values in this struct. 859// Calls to the custom version of write() read (and invoke) them. 860static struct { 861 write_trampoline_t write_callback_trampoline = nullptr; 862 void *write_callback = nullptr; 863} write_callback_info; 864 865SANITIZER_INTERFACE_ATTRIBUTE void 866__dfsw_dfsan_set_write_callback( 867 write_trampoline_t write_callback_trampoline, 868 void *write_callback, 869 dfsan_label write_callback_label, 870 dfsan_label *ret_label) { 871 write_callback_info.write_callback_trampoline = write_callback_trampoline; 872 write_callback_info.write_callback = write_callback; 873} 874 875SANITIZER_INTERFACE_ATTRIBUTE int 876__dfsw_write(int fd, const void *buf, size_t count, 877 dfsan_label fd_label, dfsan_label buf_label, 878 dfsan_label count_label, dfsan_label *ret_label) { 879 if (write_callback_info.write_callback) { 880 write_callback_info.write_callback_trampoline( 881 write_callback_info.write_callback, 882 fd, buf, count, 883 fd_label, buf_label, count_label); 884 } 885 886 *ret_label = 0; 887 return write(fd, buf, count); 888} 889} // namespace __dfsan 890 891// Type used to extract a dfsan_label with va_arg() 892typedef int dfsan_label_va; 893 894// Formats a chunk either a constant string or a single format directive (e.g., 895// '%.3f'). 896struct Formatter { 897 Formatter(char *str_, const char *fmt_, size_t size_) 898 : str(str_), str_off(0), size(size_), fmt_start(fmt_), fmt_cur(fmt_), 899 width(-1) {} 900 901 int format() { 902 char *tmp_fmt = build_format_string(); 903 int retval = 904 snprintf(str + str_off, str_off < size ? size - str_off : 0, tmp_fmt, 905 0 /* used only to avoid warnings */); 906 free(tmp_fmt); 907 return retval; 908 } 909 910 template <typename T> int format(T arg) { 911 char *tmp_fmt = build_format_string(); 912 int retval; 913 if (width >= 0) { 914 retval = snprintf(str + str_off, str_off < size ? size - str_off : 0, 915 tmp_fmt, width, arg); 916 } else { 917 retval = snprintf(str + str_off, str_off < size ? size - str_off : 0, 918 tmp_fmt, arg); 919 } 920 free(tmp_fmt); 921 return retval; 922 } 923 924 char *build_format_string() { 925 size_t fmt_size = fmt_cur - fmt_start + 1; 926 char *new_fmt = (char *)malloc(fmt_size + 1); 927 assert(new_fmt); 928 internal_memcpy(new_fmt, fmt_start, fmt_size); 929 new_fmt[fmt_size] = '\0'; 930 return new_fmt; 931 } 932 933 char *str_cur() { return str + str_off; } 934 935 size_t num_written_bytes(int retval) { 936 if (retval < 0) { 937 return 0; 938 } 939 940 size_t num_avail = str_off < size ? size - str_off : 0; 941 if (num_avail == 0) { 942 return 0; 943 } 944 945 size_t num_written = retval; 946 // A return value of {v,}snprintf of size or more means that the output was 947 // truncated. 948 if (num_written >= num_avail) { 949 num_written -= num_avail; 950 } 951 952 return num_written; 953 } 954 955 char *str; 956 size_t str_off; 957 size_t size; 958 const char *fmt_start; 959 const char *fmt_cur; 960 int width; 961}; 962 963// Formats the input and propagates the input labels to the output. The output 964// is stored in 'str'. 'size' bounds the number of output bytes. 'format' and 965// 'ap' are the format string and the list of arguments for formatting. Returns 966// the return value vsnprintf would return. 967// 968// The function tokenizes the format string in chunks representing either a 969// constant string or a single format directive (e.g., '%.3f') and formats each 970// chunk independently into the output string. This approach allows to figure 971// out which bytes of the output string depends on which argument and thus to 972// propagate labels more precisely. 973// 974// WARNING: This implementation does not support conversion specifiers with 975// positional arguments. 976static int format_buffer(char *str, size_t size, const char *fmt, 977 dfsan_label *va_labels, dfsan_label *ret_label, 978 va_list ap) { 979 Formatter formatter(str, fmt, size); 980 981 while (*formatter.fmt_cur) { 982 formatter.fmt_start = formatter.fmt_cur; 983 formatter.width = -1; 984 int retval = 0; 985 986 if (*formatter.fmt_cur != '%') { 987 // Ordinary character. Consume all the characters until a '%' or the end 988 // of the string. 989 for (; *(formatter.fmt_cur + 1) && *(formatter.fmt_cur + 1) != '%'; 990 ++formatter.fmt_cur) {} 991 retval = formatter.format(); 992 dfsan_set_label(0, formatter.str_cur(), 993 formatter.num_written_bytes(retval)); 994 } else { 995 // Conversion directive. Consume all the characters until a conversion 996 // specifier or the end of the string. 997 bool end_fmt = false; 998 for (; *formatter.fmt_cur && !end_fmt; ) { 999 switch (*++formatter.fmt_cur) { 1000 case 'd': 1001 case 'i': 1002 case 'o': 1003 case 'u': 1004 case 'x': 1005 case 'X': 1006 switch (*(formatter.fmt_cur - 1)) { 1007 case 'h': 1008 // Also covers the 'hh' case (since the size of the arg is still 1009 // an int). 1010 retval = formatter.format(va_arg(ap, int)); 1011 break; 1012 case 'l': 1013 if (formatter.fmt_cur - formatter.fmt_start >= 2 && 1014 *(formatter.fmt_cur - 2) == 'l') { 1015 retval = formatter.format(va_arg(ap, long long int)); 1016 } else { 1017 retval = formatter.format(va_arg(ap, long int)); 1018 } 1019 break; 1020 case 'q': 1021 retval = formatter.format(va_arg(ap, long long int)); 1022 break; 1023 case 'j': 1024 retval = formatter.format(va_arg(ap, intmax_t)); 1025 break; 1026 case 'z': 1027 case 't': 1028 retval = formatter.format(va_arg(ap, size_t)); 1029 break; 1030 default: 1031 retval = formatter.format(va_arg(ap, int)); 1032 } 1033 dfsan_set_label(*va_labels++, formatter.str_cur(), 1034 formatter.num_written_bytes(retval)); 1035 end_fmt = true; 1036 break; 1037 1038 case 'a': 1039 case 'A': 1040 case 'e': 1041 case 'E': 1042 case 'f': 1043 case 'F': 1044 case 'g': 1045 case 'G': 1046 if (*(formatter.fmt_cur - 1) == 'L') { 1047 retval = formatter.format(va_arg(ap, long double)); 1048 } else { 1049 retval = formatter.format(va_arg(ap, double)); 1050 } 1051 dfsan_set_label(*va_labels++, formatter.str_cur(), 1052 formatter.num_written_bytes(retval)); 1053 end_fmt = true; 1054 break; 1055 1056 case 'c': 1057 retval = formatter.format(va_arg(ap, int)); 1058 dfsan_set_label(*va_labels++, formatter.str_cur(), 1059 formatter.num_written_bytes(retval)); 1060 end_fmt = true; 1061 break; 1062 1063 case 's': { 1064 char *arg = va_arg(ap, char *); 1065 retval = formatter.format(arg); 1066 va_labels++; 1067 internal_memcpy(shadow_for(formatter.str_cur()), shadow_for(arg), 1068 sizeof(dfsan_label) * 1069 formatter.num_written_bytes(retval)); 1070 end_fmt = true; 1071 break; 1072 } 1073 1074 case 'p': 1075 retval = formatter.format(va_arg(ap, void *)); 1076 dfsan_set_label(*va_labels++, formatter.str_cur(), 1077 formatter.num_written_bytes(retval)); 1078 end_fmt = true; 1079 break; 1080 1081 case 'n': { 1082 int *ptr = va_arg(ap, int *); 1083 *ptr = (int)formatter.str_off; 1084 va_labels++; 1085 dfsan_set_label(0, ptr, sizeof(ptr)); 1086 end_fmt = true; 1087 break; 1088 } 1089 1090 case '%': 1091 retval = formatter.format(); 1092 dfsan_set_label(0, formatter.str_cur(), 1093 formatter.num_written_bytes(retval)); 1094 end_fmt = true; 1095 break; 1096 1097 case '*': 1098 formatter.width = va_arg(ap, int); 1099 va_labels++; 1100 break; 1101 1102 default: 1103 break; 1104 } 1105 } 1106 } 1107 1108 if (retval < 0) { 1109 return retval; 1110 } 1111 1112 formatter.fmt_cur++; 1113 formatter.str_off += retval; 1114 } 1115 1116 *ret_label = 0; 1117 1118 // Number of bytes written in total. 1119 return formatter.str_off; 1120} 1121 1122extern "C" { 1123SANITIZER_INTERFACE_ATTRIBUTE 1124int __dfsw_sprintf(char *str, const char *format, dfsan_label str_label, 1125 dfsan_label format_label, dfsan_label *va_labels, 1126 dfsan_label *ret_label, ...) { 1127 va_list ap; 1128 va_start(ap, ret_label); 1129 int ret = format_buffer(str, ~0ul, format, va_labels, ret_label, ap); 1130 va_end(ap); 1131 return ret; 1132} 1133 1134SANITIZER_INTERFACE_ATTRIBUTE 1135int __dfsw_snprintf(char *str, size_t size, const char *format, 1136 dfsan_label str_label, dfsan_label size_label, 1137 dfsan_label format_label, dfsan_label *va_labels, 1138 dfsan_label *ret_label, ...) { 1139 va_list ap; 1140 va_start(ap, ret_label); 1141 int ret = format_buffer(str, size, format, va_labels, ret_label, ap); 1142 va_end(ap); 1143 return ret; 1144} 1145 1146// Default empty implementations (weak). Users should redefine them. 1147SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard, u32 *) {} 1148SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard_init, u32 *, 1149 u32 *) {} 1150SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_pcs_init, void) {} 1151SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_indir, void) {} 1152 1153SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp, void) {} 1154SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp1, void) {} 1155SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp2, void) {} 1156SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp4, void) {} 1157SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp8, void) {} 1158SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_const_cmp1, 1159 void) {} 1160SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_const_cmp2, 1161 void) {} 1162SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_const_cmp4, 1163 void) {} 1164SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_const_cmp8, 1165 void) {} 1166SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_switch, void) {} 1167} // extern "C" 1168