1 // RUN: %clang_dfsan %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t 2 // RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES %s -o %t && %run %t 3 // RUN: %clang_dfsan -DORIGIN_TRACKING -mllvm -dfsan-track-origins=1 -mllvm -dfsan-combine-pointer-labels-on-load=false -DSTRICT_DATA_DEPENDENCIES %s -o %t && %run %t 4 // RUN: %clang_dfsan -DORIGIN_TRACKING -mllvm -dfsan-track-origins=1 -mllvm -dfsan-combine-pointer-labels-on-load=false %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t 5 // 6 // Tests custom implementations of various glibc functions. 7 // 8 // REQUIRES: x86_64-target-arch 9 10 #pragma clang diagnostic ignored "-Wformat-extra-args" 11 12 #include <sanitizer/dfsan_interface.h> 13 14 #include <arpa/inet.h> 15 #include <assert.h> 16 #include <fcntl.h> 17 #include <link.h> 18 #include <poll.h> 19 #include <pthread.h> 20 #include <pwd.h> 21 #include <sched.h> 22 #include <signal.h> 23 #include <stdint.h> 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <string.h> 27 #include <strings.h> 28 #include <sys/epoll.h> 29 #include <sys/resource.h> 30 #include <sys/select.h> 31 #include <sys/socket.h> 32 #include <sys/stat.h> 33 #include <sys/time.h> 34 #include <sys/types.h> 35 #include <time.h> 36 #include <unistd.h> 37 38 dfsan_label i_label = 0; 39 dfsan_label j_label = 0; 40 dfsan_label k_label = 0; 41 dfsan_label m_label = 0; 42 dfsan_label n_label = 0; 43 dfsan_label i_j_label = 0; 44 45 #define ASSERT_ZERO_LABEL(data) \ 46 assert(0 == dfsan_get_label((long) (data))) 47 48 #define ASSERT_READ_ZERO_LABEL(ptr, size) \ 49 assert(0 == dfsan_read_label(ptr, size)) 50 51 #define ASSERT_LABEL(data, label) \ 52 assert(label == dfsan_get_label((long) (data))) 53 54 #define ASSERT_READ_LABEL(ptr, size, label) \ 55 assert(label == dfsan_read_label(ptr, size)) 56 57 #ifdef ORIGIN_TRACKING 58 #define ASSERT_ZERO_ORIGIN(data) \ 59 assert(0 == dfsan_get_origin((long)(data))) 60 #else 61 #define ASSERT_ZERO_ORIGIN(data) 62 #endif 63 64 #ifdef ORIGIN_TRACKING 65 #define ASSERT_ZERO_ORIGINS(ptr, size) \ 66 for (int i = 0; i < size; ++i) { \ 67 assert(0 == dfsan_get_origin((long)(((char *)ptr)[i]))); \ 68 } 69 #else 70 #define ASSERT_ZERO_ORIGINS(ptr, size) 71 #endif 72 73 #ifdef ORIGIN_TRACKING 74 #define ASSERT_ORIGIN(data, origin) \ 75 assert(origin == dfsan_get_origin((long)(data))) 76 #else 77 #define ASSERT_ORIGIN(data, origin) 78 #endif 79 80 #ifdef ORIGIN_TRACKING 81 #define ASSERT_ORIGINS(ptr, size, origin) \ 82 for (int i = 0; i < size; ++i) { \ 83 assert(origin == dfsan_get_origin((long)(((char *)ptr)[i]))); \ 84 } 85 #else 86 #define ASSERT_ORIGINS(ptr, size, origin) 87 #endif 88 89 #ifdef ORIGIN_TRACKING 90 #define ASSERT_INIT_ORIGIN(ptr, origin) \ 91 assert(origin == dfsan_get_init_origin(ptr)) 92 #else 93 #define ASSERT_INIT_ORIGIN(ptr, origin) 94 #endif 95 96 #ifdef ORIGIN_TRACKING 97 #define ASSERT_INIT_ORIGIN_EQ_ORIGIN(ptr, data) \ 98 assert(dfsan_get_origin((long)(data)) == dfsan_get_init_origin(ptr)) 99 #else 100 #define ASSERT_INIT_ORIGIN_EQ_ORIGIN(ptr, data) 101 #endif 102 103 #ifdef ORIGIN_TRACKING 104 #define ASSERT_INIT_ORIGINS(ptr, size, origin) \ 105 for (int i = 0; i < size; ++i) { \ 106 assert(origin == dfsan_get_init_origin(&((char *)ptr)[i])); \ 107 } 108 #else 109 #define ASSERT_INIT_ORIGINS(ptr, size, origin) 110 #endif 111 112 #ifdef ORIGIN_TRACKING 113 #define ASSERT_EQ_ORIGIN(data1, data2) \ 114 assert(dfsan_get_origin((long)(data1)) == dfsan_get_origin((long)(data2))) 115 #else 116 #define ASSERT_EQ_ORIGIN(data1, data2) 117 #endif 118 119 #ifdef ORIGIN_TRACKING 120 #define DEFINE_AND_SAVE_ORIGINS(val) \ 121 dfsan_origin val##_o[sizeof(val)]; \ 122 for (int i = 0; i < sizeof(val); ++i) \ 123 val##_o[i] = dfsan_get_origin((long)(((char *)(&val))[i])); 124 #else 125 #define DEFINE_AND_SAVE_ORIGINS(val) 126 #endif 127 128 #ifdef ORIGIN_TRACKING 129 #define SAVE_ORIGINS(val) \ 130 for (int i = 0; i < sizeof(val); ++i) \ 131 val##_o[i] = dfsan_get_origin((long)(((char *)(&val))[i])); 132 #else 133 #define SAVE_ORIGINS(val) 134 #endif 135 136 #ifdef ORIGIN_TRACKING 137 #define ASSERT_SAVED_ORIGINS(val) \ 138 for (int i = 0; i < sizeof(val); ++i) \ 139 ASSERT_ORIGIN(((char *)(&val))[i], val##_o[i]); 140 #else 141 #define ASSERT_SAVED_ORIGINS(val) 142 #endif 143 144 #ifdef ORIGIN_TRACKING 145 #define DEFINE_AND_SAVE_N_ORIGINS(val, n) \ 146 dfsan_origin val##_o[n]; \ 147 for (int i = 0; i < n; ++i) \ 148 val##_o[i] = dfsan_get_origin((long)(val[i])); 149 #else 150 #define DEFINE_AND_SAVE_N_ORIGINS(val, n) 151 #endif 152 153 #ifdef ORIGIN_TRACKING 154 #define ASSERT_SAVED_N_ORIGINS(val, n) \ 155 for (int i = 0; i < n; ++i) \ 156 ASSERT_ORIGIN(val[i], val##_o[i]); 157 #else 158 #define ASSERT_SAVED_N_ORIGINS(val, n) 159 #endif 160 161 #if !defined(__GLIBC_PREREQ) 162 # define __GLIBC_PREREQ(a, b) 0 163 #endif 164 165 void test_stat() { 166 int i = 1; 167 dfsan_set_label(i_label, &i, sizeof(i)); 168 169 struct stat s; 170 s.st_dev = i; 171 DEFINE_AND_SAVE_ORIGINS(s) 172 int ret = stat("/", &s); 173 assert(0 == ret); 174 ASSERT_ZERO_LABEL(ret); 175 ASSERT_ZERO_LABEL(s.st_dev); 176 ASSERT_SAVED_ORIGINS(s) 177 178 s.st_dev = i; 179 SAVE_ORIGINS(s) 180 ret = stat("/nonexistent", &s); 181 assert(-1 == ret); 182 ASSERT_ZERO_LABEL(ret); 183 ASSERT_LABEL(s.st_dev, i_label); 184 ASSERT_SAVED_ORIGINS(s) 185 } 186 187 void test_fstat() { 188 int i = 1; 189 dfsan_set_label(i_label, &i, sizeof(i)); 190 191 struct stat s; 192 int fd = open("/dev/zero", O_RDONLY); 193 s.st_dev = i; 194 DEFINE_AND_SAVE_ORIGINS(s) 195 int rv = fstat(fd, &s); 196 assert(0 == rv); 197 ASSERT_ZERO_LABEL(rv); 198 ASSERT_ZERO_LABEL(s.st_dev); 199 ASSERT_SAVED_ORIGINS(s) 200 } 201 202 void test_memcmp() { 203 char str1[] = "str1", str2[] = "str2"; 204 dfsan_set_label(i_label, &str1[3], 1); 205 dfsan_set_label(j_label, &str2[3], 1); 206 207 int rv = memcmp(str1, str2, sizeof(str1)); 208 assert(rv < 0); 209 #ifdef STRICT_DATA_DEPENDENCIES 210 ASSERT_ZERO_LABEL(rv); 211 #else 212 ASSERT_LABEL(rv, i_j_label); 213 ASSERT_EQ_ORIGIN(rv, str1[3]); 214 #endif 215 216 rv = memcmp(str1, str2, sizeof(str1) - 2); 217 assert(rv == 0); 218 ASSERT_ZERO_LABEL(rv); 219 } 220 221 void test_bcmp() { 222 char str1[] = "str1", str2[] = "str2"; 223 dfsan_set_label(i_label, &str1[3], 1); 224 dfsan_set_label(j_label, &str2[3], 1); 225 226 int rv = bcmp(str1, str2, sizeof(str1)); 227 assert(rv != 0); 228 #ifdef STRICT_DATA_DEPENDENCIES 229 ASSERT_ZERO_LABEL(rv); 230 #else 231 ASSERT_LABEL(rv, i_j_label); 232 ASSERT_EQ_ORIGIN(rv, str1[3]); 233 #endif 234 235 rv = bcmp(str1, str2, sizeof(str1) - 2); 236 assert(rv == 0); 237 ASSERT_ZERO_LABEL(rv); 238 } 239 240 void test_memcpy() { 241 char str1[] = "str1"; 242 char str2[sizeof(str1)]; 243 dfsan_set_label(i_label, &str1[3], 1); 244 245 DEFINE_AND_SAVE_ORIGINS(str1) 246 247 char *ptr2 = str2; 248 dfsan_set_label(j_label, &ptr2, sizeof(ptr2)); 249 250 void *r = memcpy(ptr2, str1, sizeof(str1)); 251 ASSERT_LABEL(r, j_label); 252 ASSERT_EQ_ORIGIN(r, ptr2); 253 assert(0 == memcmp(str2, str1, sizeof(str1))); 254 ASSERT_ZERO_LABEL(str2[0]); 255 ASSERT_LABEL(str2[3], i_label); 256 257 for (int i = 0; i < sizeof(str2); ++i) { 258 if (!dfsan_get_label(str2[i])) 259 continue; 260 ASSERT_INIT_ORIGIN(&(str2[i]), str1_o[i]); 261 } 262 } 263 264 void test_memmove() { 265 char str[] = "str1xx"; 266 dfsan_set_label(i_label, &str[3], 1); 267 268 DEFINE_AND_SAVE_ORIGINS(str) 269 270 char *ptr = str + 2; 271 dfsan_set_label(j_label, &ptr, sizeof(ptr)); 272 273 void *r = memmove(ptr, str, 4); 274 ASSERT_LABEL(r, j_label); 275 ASSERT_EQ_ORIGIN(r, ptr); 276 assert(0 == memcmp(str + 2, "str1", 4)); 277 ASSERT_ZERO_LABEL(str[4]); 278 ASSERT_LABEL(str[5], i_label); 279 280 for (int i = 0; i < 4; ++i) { 281 if (!dfsan_get_label(ptr[i])) 282 continue; 283 ASSERT_INIT_ORIGIN(&(ptr[i]), str_o[i]); 284 } 285 } 286 287 void test_memset() { 288 char buf[8]; 289 int j = 'a'; 290 char *ptr = buf; 291 dfsan_set_label(j_label, &j, sizeof(j)); 292 dfsan_set_label(k_label, &ptr, sizeof(ptr)); 293 void *ret = memset(ptr, j, sizeof(buf)); 294 ASSERT_LABEL(ret, k_label); 295 ASSERT_EQ_ORIGIN(ret, ptr); 296 for (int i = 0; i < 8; ++i) { 297 ASSERT_LABEL(buf[i], j_label); 298 ASSERT_EQ_ORIGIN(buf[i], j); 299 assert(buf[i] == 'a'); 300 } 301 } 302 303 void test_strcmp() { 304 char str1[] = "str1", str2[] = "str2"; 305 dfsan_set_label(i_label, &str1[3], 1); 306 dfsan_set_label(j_label, &str2[3], 1); 307 308 int rv = strcmp(str1, str2); 309 assert(rv < 0); 310 #ifdef STRICT_DATA_DEPENDENCIES 311 ASSERT_ZERO_LABEL(rv); 312 #else 313 ASSERT_LABEL(rv, i_j_label); 314 ASSERT_EQ_ORIGIN(rv, str1[3]); 315 #endif 316 317 rv = strcmp(str1, str1); 318 assert(rv == 0); 319 #ifdef STRICT_DATA_DEPENDENCIES 320 ASSERT_ZERO_LABEL(rv); 321 ASSERT_ZERO_ORIGIN(rv); 322 #else 323 ASSERT_LABEL(rv, i_label); 324 ASSERT_EQ_ORIGIN(rv, str1[3]); 325 #endif 326 } 327 328 void test_strcat() { 329 char src[] = "world"; 330 int volatile x = 0; // buffer to ensure src and dst do not share origins 331 (void)x; 332 char dst[] = "hello \0 "; 333 int volatile y = 0; // buffer to ensure dst and p do not share origins 334 (void)y; 335 char *p = dst; 336 dfsan_set_label(k_label, &p, sizeof(p)); 337 dfsan_set_label(i_label, src, sizeof(src)); 338 dfsan_set_label(j_label, dst, sizeof(dst)); 339 dfsan_origin dst_o = dfsan_get_origin((long)dst[0]); 340 (void)dst_o; 341 char *ret = strcat(p, src); 342 ASSERT_LABEL(ret, k_label); 343 ASSERT_EQ_ORIGIN(ret, p); 344 assert(ret == dst); 345 assert(strcmp(src, dst + 6) == 0); 346 // Origins are assigned for every 4 contiguous 4-aligned bytes. After 347 // appending src to dst, origins of src can overwrite origins of dst if their 348 // application adddresses are within [start_aligned_down, end_aligned_up). 349 // Other origins are not changed. 350 char *start_aligned_down = (char *)(((size_t)(dst + 6)) & ~3UL); 351 char *end_aligned_up = (char *)(((size_t)(dst + 11 + 4)) & ~3UL); 352 for (int i = 0; i < 12; ++i) { 353 if (dst + i < start_aligned_down || dst + i >= end_aligned_up) { 354 ASSERT_INIT_ORIGIN(&dst[i], dst_o); 355 } else { 356 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&dst[i], src[0]); 357 } 358 } 359 for (int i = 0; i < 6; ++i) { 360 ASSERT_LABEL(dst[i], j_label); 361 } 362 for (int i = 6; i < strlen(dst); ++i) { 363 ASSERT_LABEL(dst[i], i_label); 364 assert(dfsan_get_label(dst[i]) == dfsan_get_label(src[i - 6])); 365 } 366 ASSERT_LABEL(dst[11], j_label); 367 } 368 369 void test_strlen() { 370 char str1[] = "str1"; 371 dfsan_set_label(i_label, &str1[3], 1); 372 373 int rv = strlen(str1); 374 assert(rv == 4); 375 #ifdef STRICT_DATA_DEPENDENCIES 376 ASSERT_ZERO_LABEL(rv); 377 #else 378 ASSERT_LABEL(rv, i_label); 379 ASSERT_EQ_ORIGIN(rv, str1[3]); 380 #endif 381 } 382 383 void test_strdup() { 384 char str1[] = "str1"; 385 dfsan_set_label(i_label, &str1[3], 1); 386 DEFINE_AND_SAVE_ORIGINS(str1) 387 388 char *strd = strdup(str1); 389 ASSERT_ZERO_LABEL(strd); 390 ASSERT_ZERO_LABEL(strd[0]); 391 ASSERT_LABEL(strd[3], i_label); 392 393 for (int i = 0; i < strlen(strd); ++i) { 394 if (!dfsan_get_label(strd[i])) 395 continue; 396 ASSERT_INIT_ORIGIN(&(strd[i]), str1_o[i]); 397 } 398 399 free(strd); 400 } 401 402 void test_strncpy() { 403 char str1[] = "str1"; 404 char str2[sizeof(str1)]; 405 dfsan_set_label(i_label, &str1[3], 1); 406 407 char *strd = strncpy(str2, str1, 5); 408 assert(strd == str2); 409 assert(strcmp(str1, str2) == 0); 410 ASSERT_ZERO_LABEL(strd); 411 ASSERT_ZERO_LABEL(strd[0]); 412 ASSERT_ZERO_LABEL(strd[1]); 413 ASSERT_ZERO_LABEL(strd[2]); 414 ASSERT_LABEL(strd[3], i_label); 415 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&(strd[3]), str1[3]); 416 417 char *p2 = str2; 418 dfsan_set_label(j_label, &p2, sizeof(p2)); 419 strd = strncpy(p2, str1, 3); 420 assert(strd == str2); 421 assert(strncmp(str1, str2, 3) == 0); 422 ASSERT_LABEL(strd, j_label); 423 ASSERT_EQ_ORIGIN(strd, p2); 424 // When -dfsan-combine-pointer-labels-on-load is on, strd's label propagates 425 // to strd[i]'s label. When ORIGIN_TRACKING is defined, 426 // -dfsan-combine-pointer-labels-on-load is always off, otherwise the flag 427 // is on by default. 428 #if defined(ORIGIN_TRACKING) 429 ASSERT_ZERO_LABEL(strd[0]); 430 ASSERT_ZERO_LABEL(strd[1]); 431 ASSERT_ZERO_LABEL(strd[2]); 432 #else 433 ASSERT_LABEL(strd[0], j_label); 434 ASSERT_LABEL(strd[1], j_label); 435 ASSERT_LABEL(strd[2], j_label); 436 #endif 437 } 438 439 void test_strncmp() { 440 char str1[] = "str1", str2[] = "str2"; 441 dfsan_set_label(i_label, &str1[3], 1); 442 dfsan_set_label(j_label, &str2[3], 1); 443 444 int rv = strncmp(str1, str2, sizeof(str1)); 445 assert(rv < 0); 446 #ifdef STRICT_DATA_DEPENDENCIES 447 ASSERT_ZERO_LABEL(rv); 448 #else 449 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 450 ASSERT_EQ_ORIGIN(rv, str1[3]); 451 #endif 452 453 rv = strncmp(str1, str2, 0); 454 assert(rv == 0); 455 ASSERT_ZERO_LABEL(rv); 456 457 rv = strncmp(str1, str2, 3); 458 assert(rv == 0); 459 ASSERT_ZERO_LABEL(rv); 460 461 rv = strncmp(str1, str1, 4); 462 assert(rv == 0); 463 #ifdef STRICT_DATA_DEPENDENCIES 464 ASSERT_ZERO_LABEL(rv); 465 #else 466 ASSERT_LABEL(rv, i_label); 467 ASSERT_EQ_ORIGIN(rv, str1[3]); 468 #endif 469 } 470 471 void test_strcasecmp() { 472 char str1[] = "str1", str2[] = "str2", str3[] = "Str1"; 473 dfsan_set_label(i_label, &str1[3], 1); 474 dfsan_set_label(j_label, &str2[3], 1); 475 dfsan_set_label(j_label, &str3[2], 1); 476 477 int rv = strcasecmp(str1, str2); 478 assert(rv < 0); 479 #ifdef STRICT_DATA_DEPENDENCIES 480 ASSERT_ZERO_LABEL(rv); 481 #else 482 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 483 ASSERT_EQ_ORIGIN(rv, str1[3]); 484 #endif 485 486 rv = strcasecmp(str1, str3); 487 assert(rv == 0); 488 #ifdef STRICT_DATA_DEPENDENCIES 489 ASSERT_ZERO_LABEL(rv); 490 #else 491 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 492 ASSERT_EQ_ORIGIN(rv, str1[3]); 493 #endif 494 495 char s1[] = "AbZ"; 496 char s2[] = "aBy"; 497 dfsan_set_label(i_label, &s1[2], 1); 498 dfsan_set_label(j_label, &s2[2], 1); 499 500 rv = strcasecmp(s1, s2); 501 assert(rv > 0); // 'Z' > 'y' 502 #ifdef STRICT_DATA_DEPENDENCIES 503 ASSERT_ZERO_LABEL(rv); 504 #else 505 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 506 ASSERT_EQ_ORIGIN(rv, s1[2]); 507 #endif 508 } 509 510 void test_strncasecmp() { 511 char str1[] = "Str1", str2[] = "str2"; 512 dfsan_set_label(i_label, &str1[3], 1); 513 dfsan_set_label(j_label, &str2[3], 1); 514 515 int rv = strncasecmp(str1, str2, sizeof(str1)); 516 assert(rv < 0); 517 #ifdef STRICT_DATA_DEPENDENCIES 518 ASSERT_ZERO_LABEL(rv); 519 #else 520 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 521 ASSERT_EQ_ORIGIN(rv, str1[3]); 522 #endif 523 524 rv = strncasecmp(str1, str2, 3); 525 assert(rv == 0); 526 ASSERT_ZERO_LABEL(rv); 527 528 char s1[] = "AbZ"; 529 char s2[] = "aBy"; 530 dfsan_set_label(i_label, &s1[2], 1); 531 dfsan_set_label(j_label, &s2[2], 1); 532 533 rv = strncasecmp(s1, s2, 0); 534 assert(rv == 0); // Compare zero chars. 535 ASSERT_ZERO_LABEL(rv); 536 537 rv = strncasecmp(s1, s2, 1); 538 assert(rv == 0); // 'A' == 'a' 539 ASSERT_ZERO_LABEL(rv); 540 541 rv = strncasecmp(s1, s2, 2); 542 assert(rv == 0); // 'b' == 'B' 543 ASSERT_ZERO_LABEL(rv); 544 545 rv = strncasecmp(s1, s2, 3); 546 assert(rv > 0); // 'Z' > 'y' 547 #ifdef STRICT_DATA_DEPENDENCIES 548 ASSERT_ZERO_LABEL(rv); 549 #else 550 ASSERT_LABEL(rv, dfsan_union(i_label, j_label)); 551 ASSERT_EQ_ORIGIN(rv, s1[2]); 552 #endif 553 } 554 555 void test_strchr() { 556 char str1[] = "str1"; 557 dfsan_set_label(i_label, &str1[3], 1); 558 559 char *p1 = str1; 560 char c = 'r'; 561 dfsan_set_label(k_label, &c, sizeof(c)); 562 563 char *crv = strchr(p1, c); 564 assert(crv == &str1[2]); 565 #ifdef STRICT_DATA_DEPENDENCIES 566 ASSERT_ZERO_LABEL(crv); 567 #else 568 ASSERT_LABEL(crv, k_label); 569 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, c); 570 #endif 571 572 dfsan_set_label(j_label, &p1, sizeof(p1)); 573 crv = strchr(p1, 'r'); 574 assert(crv == &str1[2]); 575 ASSERT_LABEL(crv, j_label); 576 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, p1); 577 578 crv = strchr(p1, '1'); 579 assert(crv == &str1[3]); 580 #ifdef STRICT_DATA_DEPENDENCIES 581 ASSERT_LABEL(crv, j_label); 582 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, p1); 583 #else 584 ASSERT_LABEL(crv, i_j_label); 585 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, str1[3]); 586 #endif 587 588 crv = strchr(p1, 'x'); 589 assert(!crv); 590 #ifdef STRICT_DATA_DEPENDENCIES 591 ASSERT_LABEL(crv, j_label); 592 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, p1); 593 #else 594 ASSERT_LABEL(crv, i_j_label); 595 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, str1[3]); 596 #endif 597 598 // `man strchr` says: 599 // The terminating null byte is considered part of the string, so that if c 600 // is specified as '\0', these functions return a pointer to the terminator. 601 crv = strchr(p1, '\0'); 602 assert(crv == &str1[4]); 603 #ifdef STRICT_DATA_DEPENDENCIES 604 ASSERT_LABEL(crv, j_label); 605 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, p1); 606 #else 607 ASSERT_LABEL(crv, i_j_label); 608 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&crv, str1[3]); 609 #endif 610 } 611 612 void test_recvmmsg() { 613 int sockfds[2]; 614 int ret = socketpair(AF_UNIX, SOCK_DGRAM, 0, sockfds); 615 assert(ret != -1); 616 617 // Setup messages to send. 618 struct mmsghdr smmsg[2] = {}; 619 char sbuf0[] = "abcdefghijkl"; 620 struct iovec siov0[2] = {{&sbuf0[0], 4}, {&sbuf0[4], 4}}; 621 smmsg[0].msg_hdr.msg_iov = siov0; 622 smmsg[0].msg_hdr.msg_iovlen = 2; 623 char sbuf1[] = "1234567890"; 624 struct iovec siov1[1] = {{&sbuf1[0], 7}}; 625 smmsg[1].msg_hdr.msg_iov = siov1; 626 smmsg[1].msg_hdr.msg_iovlen = 1; 627 628 // Send messages. 629 int sent_msgs = sendmmsg(sockfds[0], smmsg, 2, 0); 630 assert(sent_msgs == 2); 631 632 // Setup receive buffers. 633 struct mmsghdr rmmsg[2] = {}; 634 char rbuf0[128]; 635 struct iovec riov0[2] = {{&rbuf0[0], 4}, {&rbuf0[4], 4}}; 636 rmmsg[0].msg_hdr.msg_iov = riov0; 637 rmmsg[0].msg_hdr.msg_iovlen = 2; 638 char rbuf1[128]; 639 struct iovec riov1[1] = {{&rbuf1[0], 16}}; 640 rmmsg[1].msg_hdr.msg_iov = riov1; 641 rmmsg[1].msg_hdr.msg_iovlen = 1; 642 struct timespec timeout = {1, 1}; 643 dfsan_set_label(i_label, rbuf0, sizeof(rbuf0)); 644 dfsan_set_label(i_label, rbuf1, sizeof(rbuf1)); 645 dfsan_set_label(i_label, &rmmsg[0].msg_len, sizeof(rmmsg[0].msg_len)); 646 dfsan_set_label(i_label, &rmmsg[1].msg_len, sizeof(rmmsg[1].msg_len)); 647 dfsan_set_label(i_label, &timeout, sizeof(timeout)); 648 649 dfsan_origin msg_len0_o = dfsan_get_origin((long)(rmmsg[0].msg_len)); 650 dfsan_origin msg_len1_o = dfsan_get_origin((long)(rmmsg[1].msg_len)); 651 #ifndef ORIGIN_TRACKING 652 (void)msg_len0_o; 653 (void)msg_len1_o; 654 #endif 655 656 // Receive messages and check labels. 657 int received_msgs = recvmmsg(sockfds[1], rmmsg, 2, 0, &timeout); 658 assert(received_msgs == sent_msgs); 659 assert(rmmsg[0].msg_len == smmsg[0].msg_len); 660 assert(rmmsg[1].msg_len == smmsg[1].msg_len); 661 assert(memcmp(sbuf0, rbuf0, 8) == 0); 662 assert(memcmp(sbuf1, rbuf1, 7) == 0); 663 ASSERT_ZERO_LABEL(received_msgs); 664 ASSERT_ZERO_LABEL(rmmsg[0].msg_len); 665 ASSERT_ZERO_LABEL(rmmsg[1].msg_len); 666 ASSERT_READ_ZERO_LABEL(&rbuf0[0], 8); 667 ASSERT_READ_LABEL(&rbuf0[8], 1, i_label); 668 ASSERT_READ_ZERO_LABEL(&rbuf1[0], 7); 669 ASSERT_READ_LABEL(&rbuf1[7], 1, i_label); 670 ASSERT_LABEL(timeout.tv_sec, i_label); 671 ASSERT_LABEL(timeout.tv_nsec, i_label); 672 673 ASSERT_ORIGIN((long)(rmmsg[0].msg_len), msg_len0_o); 674 ASSERT_ORIGIN((long)(rmmsg[1].msg_len), msg_len1_o); 675 676 close(sockfds[0]); 677 close(sockfds[1]); 678 } 679 680 void test_recvmsg() { 681 int sockfds[2]; 682 int ret = socketpair(AF_UNIX, SOCK_DGRAM, 0, sockfds); 683 assert(ret != -1); 684 685 char sbuf[] = "abcdefghijkl"; 686 struct iovec siovs[2] = {{&sbuf[0], 4}, {&sbuf[4], 4}}; 687 struct msghdr smsg = {}; 688 smsg.msg_iov = siovs; 689 smsg.msg_iovlen = 2; 690 691 ssize_t sent = sendmsg(sockfds[0], &smsg, 0); 692 assert(sent > 0); 693 694 char rbuf[128]; 695 struct iovec riovs[2] = {{&rbuf[0], 4}, {&rbuf[4], 4}}; 696 struct msghdr rmsg = {}; 697 rmsg.msg_iov = riovs; 698 rmsg.msg_iovlen = 2; 699 700 dfsan_set_label(i_label, rbuf, sizeof(rbuf)); 701 dfsan_set_label(i_label, &rmsg, sizeof(rmsg)); 702 703 DEFINE_AND_SAVE_ORIGINS(rmsg) 704 705 ssize_t received = recvmsg(sockfds[1], &rmsg, 0); 706 assert(received == sent); 707 assert(memcmp(sbuf, rbuf, 8) == 0); 708 ASSERT_ZERO_LABEL(received); 709 ASSERT_READ_ZERO_LABEL(&rmsg, sizeof(rmsg)); 710 ASSERT_READ_ZERO_LABEL(&rbuf[0], 8); 711 ASSERT_READ_LABEL(&rbuf[8], 1, i_label); 712 713 ASSERT_SAVED_ORIGINS(rmsg) 714 715 close(sockfds[0]); 716 close(sockfds[1]); 717 } 718 719 void test_read() { 720 char buf[16]; 721 dfsan_set_label(i_label, buf, 1); 722 dfsan_set_label(j_label, buf + 15, 1); 723 724 DEFINE_AND_SAVE_ORIGINS(buf) 725 ASSERT_LABEL(buf[0], i_label); 726 ASSERT_LABEL(buf[15], j_label); 727 728 int fd = open("/dev/zero", O_RDONLY); 729 int rv = read(fd, buf, sizeof(buf)); 730 assert(rv == sizeof(buf)); 731 ASSERT_ZERO_LABEL(rv); 732 ASSERT_ZERO_LABEL(buf[0]); 733 ASSERT_ZERO_LABEL(buf[15]); 734 ASSERT_SAVED_ORIGINS(buf) 735 close(fd); 736 } 737 738 void test_pread() { 739 char buf[16]; 740 dfsan_set_label(i_label, buf, 1); 741 dfsan_set_label(j_label, buf + 15, 1); 742 743 DEFINE_AND_SAVE_ORIGINS(buf) 744 ASSERT_LABEL(buf[0], i_label); 745 ASSERT_LABEL(buf[15], j_label); 746 747 int fd = open("/bin/sh", O_RDONLY); 748 int rv = pread(fd, buf, sizeof(buf), 0); 749 assert(rv == sizeof(buf)); 750 ASSERT_ZERO_LABEL(rv); 751 ASSERT_ZERO_LABEL(buf[0]); 752 ASSERT_ZERO_LABEL(buf[15]); 753 ASSERT_SAVED_ORIGINS(buf) 754 close(fd); 755 } 756 757 void test_dlopen() { 758 void *map = dlopen(NULL, RTLD_NOW); 759 assert(map); 760 ASSERT_ZERO_LABEL(map); 761 dlclose(map); 762 map = dlopen("/nonexistent", RTLD_NOW); 763 assert(!map); 764 ASSERT_ZERO_LABEL(map); 765 } 766 767 void test_clock_gettime() { 768 struct timespec tp; 769 dfsan_set_label(j_label, ((char *)&tp) + 3, 1); 770 dfsan_origin origin = dfsan_get_origin((long)(((char *)&tp)[3])); 771 #ifndef ORIGIN_TRACKING 772 (void)origin; 773 #endif 774 int t = clock_gettime(CLOCK_REALTIME, &tp); 775 assert(t == 0); 776 ASSERT_ZERO_LABEL(t); 777 ASSERT_ZERO_LABEL(((char *)&tp)[3]); 778 ASSERT_ORIGIN(((char *)&tp)[3], origin); 779 } 780 781 void test_ctime_r() { 782 char *buf = (char*) malloc(64); 783 time_t t = 0; 784 785 DEFINE_AND_SAVE_ORIGINS(buf) 786 dfsan_origin t_o = dfsan_get_origin((long)t); 787 788 char *ret = ctime_r(&t, buf); 789 ASSERT_ZERO_LABEL(ret); 790 assert(buf == ret); 791 ASSERT_READ_ZERO_LABEL(buf, strlen(buf) + 1); 792 ASSERT_SAVED_ORIGINS(buf) 793 794 dfsan_set_label(i_label, &t, sizeof(t)); 795 t_o = dfsan_get_origin((long)t); 796 ret = ctime_r(&t, buf); 797 ASSERT_ZERO_LABEL(ret); 798 ASSERT_READ_LABEL(buf, strlen(buf) + 1, i_label); 799 for (int i = 0; i < strlen(buf) + 1; ++i) 800 ASSERT_ORIGIN(buf[i], t_o); 801 802 t = 0; 803 dfsan_set_label(j_label, &buf, sizeof(&buf)); 804 dfsan_origin buf_ptr_o = dfsan_get_origin((long)buf); 805 #ifndef ORIGIN_TRACKING 806 (void)buf_ptr_o; 807 #endif 808 ret = ctime_r(&t, buf); 809 ASSERT_LABEL(ret, j_label); 810 ASSERT_ORIGIN(ret, buf_ptr_o); 811 ASSERT_READ_ZERO_LABEL(buf, strlen(buf) + 1); 812 for (int i = 0; i < strlen(buf) + 1; ++i) 813 ASSERT_ORIGIN(buf[i], t_o); 814 } 815 816 static int write_callback_count = 0; 817 static int last_fd; 818 static const unsigned char *last_buf; 819 static size_t last_count; 820 821 void write_callback(int fd, const void *buf, size_t count) { 822 write_callback_count++; 823 824 last_fd = fd; 825 last_buf = (const unsigned char*) buf; 826 last_count = count; 827 } 828 829 void test_dfsan_set_write_callback() { 830 char a_buf[] = "Sample chars"; 831 int a_buf_len = strlen(a_buf); 832 833 int fd = open("/dev/null", O_WRONLY); 834 835 dfsan_set_write_callback(write_callback); 836 837 write_callback_count = 0; 838 839 DEFINE_AND_SAVE_ORIGINS(a_buf) 840 841 // Callback should be invoked on every call to write(). 842 int res = write(fd, a_buf, a_buf_len); 843 assert(write_callback_count == 1); 844 ASSERT_READ_ZERO_LABEL(&res, sizeof(res)); 845 ASSERT_READ_ZERO_LABEL(&last_fd, sizeof(last_fd)); 846 ASSERT_READ_ZERO_LABEL(last_buf, sizeof(last_buf)); 847 848 for (int i = 0; i < a_buf_len; ++i) 849 ASSERT_ORIGIN(last_buf[i], a_buf_o[i]); 850 851 ASSERT_ZERO_ORIGINS(&last_count, sizeof(last_count)); 852 last_fd = 0; 853 last_buf = 0; 854 last_count = 0; 855 856 char b_buf[] = "Other chars"; 857 int b_buf_len = strlen(b_buf); 858 // Create a separate variable so we can taint the pointer. 859 // We would always get a shadow of 0 for b_buf because it is a constant. 860 const unsigned char *buf = (const unsigned char *)b_buf; 861 862 // Add a label to write() arguments. Check that the labels are readable from 863 // the values passed to the callback. 864 dfsan_set_label(i_label, &fd, sizeof(fd)); 865 dfsan_set_label(j_label, &buf, sizeof(buf)); // ptr 866 dfsan_set_label(k_label, &(b_buf[3]), 1); // content 867 dfsan_set_label(m_label, &b_buf_len, sizeof(b_buf_len)); 868 869 dfsan_origin fd_o = dfsan_get_origin((long)fd); 870 dfsan_origin b_buf3_o = dfsan_get_origin((long)(b_buf[3])); 871 dfsan_origin b_buf_len_o = dfsan_get_origin((long)b_buf_len); 872 #ifndef ORIGIN_TRACKING 873 (void)fd_o; 874 (void)b_buf3_o; 875 (void)b_buf_len_o; 876 #endif 877 DEFINE_AND_SAVE_ORIGINS(b_buf) 878 879 res = write(fd, buf, b_buf_len); 880 assert(write_callback_count == 2); 881 assert(last_fd == fd); 882 assert(last_buf == (const unsigned char *)b_buf); 883 assert(last_count == b_buf_len); 884 885 ASSERT_READ_ZERO_LABEL(&res, sizeof(res)); 886 ASSERT_READ_LABEL(&last_fd, sizeof(last_fd), i_label); 887 ASSERT_READ_LABEL(&last_buf, sizeof(&last_buf), j_label); // ptr 888 ASSERT_READ_LABEL(last_buf, last_count, k_label); // content 889 ASSERT_READ_LABEL(&last_buf[3], sizeof(last_buf[3]), k_label); // content 890 ASSERT_READ_LABEL(&last_count, sizeof(last_count), m_label); 891 ASSERT_ZERO_ORIGINS(&res, sizeof(res)); 892 ASSERT_INIT_ORIGINS(&last_fd, sizeof(last_fd), fd_o); 893 ASSERT_INIT_ORIGINS(&last_buf[3], sizeof(last_buf[3]), b_buf3_o); 894 895 // Origins are assigned for every 4 contiguous 4-aligned bytes. After 896 // appending src to dst, origins of src can overwrite origins of dst if their 897 // application adddresses are within an aligned range. Other origins are not 898 // changed. 899 for (int i = 0; i < b_buf_len; ++i) { 900 size_t i_addr = size_t(&last_buf[i]); 901 if (((size_t(&last_buf[3]) & ~3UL) > i_addr) || 902 (((size_t(&last_buf[3]) + 4) & ~3UL) <= i_addr)) 903 ASSERT_ORIGIN(last_buf[i], b_buf_o[i]); 904 } 905 906 ASSERT_INIT_ORIGINS(&last_count, sizeof(last_count), b_buf_len_o); 907 908 dfsan_set_write_callback(NULL); 909 } 910 911 void test_fgets() { 912 char *buf = (char*) malloc(128); 913 FILE *f = fopen("/etc/passwd", "r"); 914 dfsan_set_label(j_label, buf, 1); 915 DEFINE_AND_SAVE_N_ORIGINS(buf, 128) 916 917 char *ret = fgets(buf, sizeof(buf), f); 918 assert(ret == buf); 919 ASSERT_ZERO_LABEL(ret); 920 ASSERT_EQ_ORIGIN(ret, buf); 921 ASSERT_READ_ZERO_LABEL(buf, 128); 922 ASSERT_SAVED_N_ORIGINS(buf, 128) 923 924 dfsan_set_label(j_label, &buf, sizeof(&buf)); 925 ret = fgets(buf, sizeof(buf), f); 926 ASSERT_LABEL(ret, j_label); 927 ASSERT_EQ_ORIGIN(ret, buf); 928 ASSERT_SAVED_N_ORIGINS(buf, 128) 929 930 fclose(f); 931 free(buf); 932 } 933 934 void test_getcwd() { 935 char buf[1024]; 936 char *ptr = buf; 937 dfsan_set_label(i_label, buf + 2, 2); 938 DEFINE_AND_SAVE_ORIGINS(buf) 939 940 char* ret = getcwd(buf, sizeof(buf)); 941 assert(ret == buf); 942 assert(ret[0] == '/'); 943 ASSERT_ZERO_LABEL(ret); 944 ASSERT_EQ_ORIGIN(ret, buf); 945 ASSERT_READ_ZERO_LABEL(buf + 2, 2); 946 ASSERT_SAVED_ORIGINS(buf) 947 948 dfsan_set_label(i_label, &ptr, sizeof(ptr)); 949 ret = getcwd(ptr, sizeof(buf)); 950 ASSERT_LABEL(ret, i_label); 951 ASSERT_EQ_ORIGIN(ret, ptr); 952 ASSERT_SAVED_ORIGINS(buf) 953 } 954 955 void test_get_current_dir_name() { 956 char* ret = get_current_dir_name(); 957 assert(ret); 958 assert(ret[0] == '/'); 959 ASSERT_READ_ZERO_LABEL(ret, strlen(ret) + 1); 960 ASSERT_ZERO_LABEL(ret); 961 } 962 963 void test_getentropy() { 964 char buf[64]; 965 dfsan_set_label(i_label, buf + 2, 2); 966 DEFINE_AND_SAVE_ORIGINS(buf) 967 #if __GLIBC_PREREQ(2, 25) 968 // glibc >= 2.25 has getentropy() 969 int ret = getentropy(buf, sizeof(buf)); 970 ASSERT_ZERO_LABEL(ret); 971 if (ret == 0) { 972 ASSERT_READ_ZERO_LABEL(buf + 2, 2); 973 ASSERT_SAVED_ORIGINS(buf) 974 } 975 #endif 976 } 977 978 void test_gethostname() { 979 char buf[1024]; 980 dfsan_set_label(i_label, buf + 2, 2); 981 DEFINE_AND_SAVE_ORIGINS(buf) 982 int ret = gethostname(buf, sizeof(buf)); 983 assert(ret == 0); 984 ASSERT_ZERO_LABEL(ret); 985 ASSERT_READ_ZERO_LABEL(buf + 2, 2); 986 ASSERT_SAVED_ORIGINS(buf) 987 } 988 989 void test_getrlimit() { 990 struct rlimit rlim; 991 dfsan_set_label(i_label, &rlim, sizeof(rlim)); 992 DEFINE_AND_SAVE_ORIGINS(rlim); 993 int ret = getrlimit(RLIMIT_CPU, &rlim); 994 assert(ret == 0); 995 ASSERT_ZERO_LABEL(ret); 996 ASSERT_READ_ZERO_LABEL(&rlim, sizeof(rlim)); 997 ASSERT_SAVED_ORIGINS(rlim) 998 } 999 1000 void test_getrusage() { 1001 struct rusage usage; 1002 dfsan_set_label(i_label, &usage, sizeof(usage)); 1003 DEFINE_AND_SAVE_ORIGINS(usage); 1004 int ret = getrusage(RUSAGE_SELF, &usage); 1005 assert(ret == 0); 1006 ASSERT_ZERO_LABEL(ret); 1007 ASSERT_READ_ZERO_LABEL(&usage, sizeof(usage)); 1008 ASSERT_SAVED_ORIGINS(usage) 1009 } 1010 1011 void test_strcpy() { 1012 char src[] = "hello world"; 1013 char dst[sizeof(src) + 2]; 1014 char *p_dst = dst; 1015 dfsan_set_label(0, src, sizeof(src)); 1016 dfsan_set_label(0, dst, sizeof(dst)); 1017 dfsan_set_label(k_label, &p_dst, sizeof(p_dst)); 1018 dfsan_set_label(i_label, src + 2, 1); 1019 dfsan_set_label(j_label, src + 3, 1); 1020 dfsan_set_label(j_label, dst + 4, 1); 1021 dfsan_set_label(i_label, dst + 12, 1); 1022 char *ret = strcpy(p_dst, src); 1023 assert(ret == dst); 1024 assert(strcmp(src, dst) == 0); 1025 ASSERT_LABEL(ret, k_label); 1026 ASSERT_EQ_ORIGIN(ret, p_dst); 1027 for (int i = 0; i < strlen(src) + 1; ++i) { 1028 assert(dfsan_get_label(dst[i]) == dfsan_get_label(src[i])); 1029 if (dfsan_get_label(dst[i])) 1030 assert(dfsan_get_init_origin(&dst[i]) == dfsan_get_origin(src[i])); 1031 } 1032 // Note: if strlen(src) + 1 were used instead to compute the first untouched 1033 // byte of dest, the label would be I|J. This is because strlen() might 1034 // return a non-zero label, and because by default pointer labels are not 1035 // ignored on loads. 1036 ASSERT_LABEL(dst[12], i_label); 1037 } 1038 1039 void test_strtol() { 1040 char non_number_buf[] = "ab "; 1041 char *endptr = NULL; 1042 long int ret = strtol(non_number_buf, &endptr, 10); 1043 assert(ret == 0); 1044 assert(endptr == non_number_buf); 1045 ASSERT_ZERO_LABEL(ret); 1046 1047 char buf[] = "1234578910"; 1048 int base = 10; 1049 dfsan_set_label(k_label, &base, sizeof(base)); 1050 ret = strtol(buf, &endptr, base); 1051 assert(ret == 1234578910); 1052 assert(endptr == buf + 10); 1053 ASSERT_LABEL(ret, k_label); 1054 ASSERT_EQ_ORIGIN(ret, base); 1055 1056 dfsan_set_label(i_label, buf + 1, 1); 1057 dfsan_set_label(j_label, buf + 10, 1); 1058 ret = strtol(buf, &endptr, 10); 1059 assert(ret == 1234578910); 1060 assert(endptr == buf + 10); 1061 ASSERT_LABEL(ret, i_j_label); 1062 ASSERT_EQ_ORIGIN(ret, buf[1]); 1063 } 1064 1065 void test_strtoll() { 1066 char non_number_buf[] = "ab "; 1067 char *endptr = NULL; 1068 long long int ret = strtoll(non_number_buf, &endptr, 10); 1069 assert(ret == 0); 1070 assert(endptr == non_number_buf); 1071 ASSERT_ZERO_LABEL(ret); 1072 1073 char buf[] = "1234578910 "; 1074 int base = 10; 1075 dfsan_set_label(k_label, &base, sizeof(base)); 1076 ret = strtoll(buf, &endptr, base); 1077 assert(ret == 1234578910); 1078 assert(endptr == buf + 10); 1079 ASSERT_LABEL(ret, k_label); 1080 ASSERT_EQ_ORIGIN(ret, base); 1081 1082 dfsan_set_label(i_label, buf + 1, 1); 1083 dfsan_set_label(j_label, buf + 2, 1); 1084 ret = strtoll(buf, &endptr, 10); 1085 assert(ret == 1234578910); 1086 assert(endptr == buf + 10); 1087 ASSERT_LABEL(ret, i_j_label); 1088 ASSERT_EQ_ORIGIN(ret, buf[1]); 1089 } 1090 1091 void test_strtoul() { 1092 char non_number_buf[] = "xy "; 1093 char *endptr = NULL; 1094 long unsigned int ret = strtoul(non_number_buf, &endptr, 16); 1095 assert(ret == 0); 1096 assert(endptr == non_number_buf); 1097 ASSERT_ZERO_LABEL(ret); 1098 1099 char buf[] = "ffffffffffffaa"; 1100 int base = 16; 1101 dfsan_set_label(k_label, &base, sizeof(base)); 1102 ret = strtoul(buf, &endptr, base); 1103 assert(ret == 72057594037927850); 1104 assert(endptr == buf + 14); 1105 ASSERT_LABEL(ret, k_label); 1106 ASSERT_EQ_ORIGIN(ret, base); 1107 1108 dfsan_set_label(i_label, buf + 1, 1); 1109 dfsan_set_label(j_label, buf + 2, 1); 1110 ret = strtoul(buf, &endptr, 16); 1111 assert(ret == 72057594037927850); 1112 assert(endptr == buf + 14); 1113 ASSERT_LABEL(ret, i_j_label); 1114 ASSERT_EQ_ORIGIN(ret, buf[1]); 1115 } 1116 1117 void test_strtoull() { 1118 char non_number_buf[] = "xy "; 1119 char *endptr = NULL; 1120 long long unsigned int ret = strtoull(non_number_buf, &endptr, 16); 1121 assert(ret == 0); 1122 assert(endptr == non_number_buf); 1123 ASSERT_ZERO_LABEL(ret); 1124 1125 char buf[] = "ffffffffffffffaa"; 1126 int base = 16; 1127 dfsan_set_label(k_label, &base, sizeof(base)); 1128 ret = strtoull(buf, &endptr, base); 1129 assert(ret == 0xffffffffffffffaa); 1130 assert(endptr == buf + 16); 1131 ASSERT_LABEL(ret, k_label); 1132 ASSERT_EQ_ORIGIN(ret, base); 1133 1134 dfsan_set_label(i_label, buf + 1, 1); 1135 dfsan_set_label(j_label, buf + 2, 1); 1136 ret = strtoull(buf, &endptr, 16); 1137 assert(ret == 0xffffffffffffffaa); 1138 assert(endptr == buf + 16); 1139 ASSERT_LABEL(ret, i_j_label); 1140 ASSERT_EQ_ORIGIN(ret, buf[1]); 1141 } 1142 1143 void test_strtod() { 1144 char non_number_buf[] = "ab "; 1145 char *endptr = NULL; 1146 double ret = strtod(non_number_buf, &endptr); 1147 assert(ret == 0); 1148 assert(endptr == non_number_buf); 1149 ASSERT_ZERO_LABEL(ret); 1150 1151 char buf[] = "12345.76 foo"; 1152 dfsan_set_label(i_label, buf + 1, 1); 1153 dfsan_set_label(j_label, buf + 6, 1); 1154 ret = strtod(buf, &endptr); 1155 assert(ret == 12345.76); 1156 assert(endptr == buf + 8); 1157 ASSERT_LABEL(ret, i_j_label); 1158 ASSERT_EQ_ORIGIN(ret, buf[1]); 1159 } 1160 1161 void test_time() { 1162 time_t t = 0; 1163 dfsan_set_label(i_label, &t, 1); 1164 DEFINE_AND_SAVE_ORIGINS(t) 1165 time_t ret = time(&t); 1166 assert(ret == t); 1167 assert(ret > 0); 1168 ASSERT_ZERO_LABEL(ret); 1169 ASSERT_ZERO_LABEL(t); 1170 ASSERT_SAVED_ORIGINS(t) 1171 } 1172 1173 void test_inet_pton() { 1174 char addr4[] = "127.0.0.1"; 1175 dfsan_set_label(i_label, addr4 + 3, 1); 1176 struct in_addr in4; 1177 int ret4 = inet_pton(AF_INET, addr4, &in4); 1178 assert(ret4 == 1); 1179 ASSERT_ZERO_LABEL(ret4); 1180 ASSERT_READ_LABEL(&in4, sizeof(in4), i_label); 1181 ASSERT_ORIGINS(&in4, sizeof(in4), dfsan_get_origin((long)(addr4[3]))) 1182 assert(in4.s_addr == htonl(0x7f000001)); 1183 1184 char addr6[] = "::1"; 1185 dfsan_set_label(j_label, addr6 + 3, 1); 1186 struct in6_addr in6; 1187 int ret6 = inet_pton(AF_INET6, addr6, &in6); 1188 assert(ret6 == 1); 1189 ASSERT_ZERO_LABEL(ret6); 1190 ASSERT_READ_LABEL(((char *) &in6) + sizeof(in6) - 1, 1, j_label); 1191 ASSERT_ORIGINS(&in6, sizeof(in6), dfsan_get_origin((long)(addr6[3]))) 1192 } 1193 1194 void test_localtime_r() { 1195 time_t t0 = 1384800998; 1196 struct tm t1; 1197 dfsan_set_label(i_label, &t0, sizeof(t0)); 1198 dfsan_origin t0_o = dfsan_get_origin((long)t0); 1199 struct tm *pt1 = &t1; 1200 dfsan_set_label(j_label, &pt1, sizeof(pt1)); 1201 dfsan_origin pt1_o = dfsan_get_origin((long)pt1); 1202 1203 #ifndef ORIGIN_TRACKING 1204 (void)t0_o; 1205 (void)pt1_o; 1206 #endif 1207 1208 struct tm *ret = localtime_r(&t0, pt1); 1209 assert(ret == &t1); 1210 assert(t1.tm_min == 56); 1211 ASSERT_LABEL(ret, j_label); 1212 ASSERT_INIT_ORIGIN(&ret, pt1_o); 1213 ASSERT_READ_LABEL(&ret, sizeof(ret), j_label); 1214 ASSERT_LABEL(t1.tm_mon, i_label); 1215 ASSERT_ORIGIN(t1.tm_mon, t0_o); 1216 } 1217 1218 void test_getpwuid_r() { 1219 struct passwd pwd; 1220 char buf[1024]; 1221 struct passwd *result; 1222 1223 dfsan_set_label(i_label, &pwd, 4); 1224 DEFINE_AND_SAVE_ORIGINS(pwd) 1225 DEFINE_AND_SAVE_ORIGINS(buf) 1226 int ret = getpwuid_r(0, &pwd, buf, sizeof(buf), &result); 1227 assert(ret == 0); 1228 assert(strcmp(pwd.pw_name, "root") == 0); 1229 assert(result == &pwd); 1230 ASSERT_ZERO_LABEL(ret); 1231 ASSERT_READ_ZERO_LABEL(&pwd, 4); 1232 ASSERT_SAVED_ORIGINS(pwd) 1233 ASSERT_SAVED_ORIGINS(buf) 1234 } 1235 1236 void test_epoll_wait() { 1237 // Set up a pipe to monitor with epoll. 1238 int pipe_fds[2]; 1239 int ret = pipe(pipe_fds); 1240 assert(ret != -1); 1241 1242 // Configure epoll to monitor the pipe. 1243 int epfd = epoll_create1(0); 1244 assert(epfd != -1); 1245 struct epoll_event event; 1246 event.events = EPOLLIN; 1247 event.data.fd = pipe_fds[0]; 1248 ret = epoll_ctl(epfd, EPOLL_CTL_ADD, pipe_fds[0], &event); 1249 assert(ret != -1); 1250 1251 // Test epoll_wait when no events have occurred. 1252 event = {}; 1253 dfsan_set_label(i_label, &event, sizeof(event)); 1254 DEFINE_AND_SAVE_ORIGINS(event) 1255 ret = epoll_wait(epfd, &event, /*maxevents=*/1, /*timeout=*/0); 1256 assert(ret == 0); 1257 assert(event.events == 0); 1258 assert(event.data.fd == 0); 1259 ASSERT_ZERO_LABEL(ret); 1260 ASSERT_READ_LABEL(&event, sizeof(event), i_label); 1261 ASSERT_SAVED_ORIGINS(event) 1262 1263 // Test epoll_wait when an event occurs. 1264 write(pipe_fds[1], "x", 1); 1265 ret = epoll_wait(epfd, &event, /*maxevents=*/1, /*timeout=*/0); 1266 assert(ret == 1); 1267 assert(event.events == EPOLLIN); 1268 assert(event.data.fd == pipe_fds[0]); 1269 ASSERT_ZERO_LABEL(ret); 1270 ASSERT_READ_ZERO_LABEL(&event, sizeof(event)); 1271 ASSERT_SAVED_ORIGINS(event) 1272 1273 // Clean up. 1274 close(epfd); 1275 close(pipe_fds[0]); 1276 close(pipe_fds[1]); 1277 } 1278 1279 void test_poll() { 1280 struct pollfd fd; 1281 fd.fd = 0; 1282 fd.events = POLLIN; 1283 dfsan_set_label(i_label, &fd.revents, sizeof(fd.revents)); 1284 DEFINE_AND_SAVE_ORIGINS(fd) 1285 int ret = poll(&fd, 1, 1); 1286 ASSERT_ZERO_LABEL(ret); 1287 ASSERT_ZERO_LABEL(fd.revents); 1288 ASSERT_SAVED_ORIGINS(fd) 1289 assert(ret >= 0); 1290 } 1291 1292 void test_select() { 1293 struct timeval t; 1294 fd_set fds; 1295 t.tv_sec = 2; 1296 FD_SET(0, &fds); 1297 dfsan_set_label(i_label, &fds, sizeof(fds)); 1298 dfsan_set_label(j_label, &t, sizeof(t)); 1299 DEFINE_AND_SAVE_ORIGINS(fds) 1300 DEFINE_AND_SAVE_ORIGINS(t) 1301 int ret = select(1, &fds, NULL, NULL, &t); 1302 assert(ret >= 0); 1303 ASSERT_ZERO_LABEL(ret); 1304 ASSERT_ZERO_LABEL(t.tv_sec); 1305 ASSERT_READ_ZERO_LABEL(&fds, sizeof(fds)); 1306 ASSERT_SAVED_ORIGINS(fds) 1307 ASSERT_SAVED_ORIGINS(t) 1308 } 1309 1310 void test_sched_getaffinity() { 1311 cpu_set_t mask; 1312 dfsan_set_label(j_label, &mask, 1); 1313 DEFINE_AND_SAVE_ORIGINS(mask) 1314 int ret = sched_getaffinity(0, sizeof(mask), &mask); 1315 assert(ret == 0); 1316 ASSERT_ZERO_LABEL(ret); 1317 ASSERT_READ_ZERO_LABEL(&mask, sizeof(mask)); 1318 ASSERT_SAVED_ORIGINS(mask) 1319 } 1320 1321 void test_sigemptyset() { 1322 sigset_t set; 1323 dfsan_set_label(j_label, &set, 1); 1324 DEFINE_AND_SAVE_ORIGINS(set) 1325 int ret = sigemptyset(&set); 1326 assert(ret == 0); 1327 ASSERT_ZERO_LABEL(ret); 1328 ASSERT_READ_ZERO_LABEL(&set, sizeof(set)); 1329 ASSERT_SAVED_ORIGINS(set) 1330 } 1331 1332 static void SignalHandler(int signo) {} 1333 1334 static void SignalAction(int signo, siginfo_t *si, void *uc) {} 1335 1336 void test_sigaction() { 1337 struct sigaction newact_with_sigaction = {}; 1338 newact_with_sigaction.sa_flags = SA_SIGINFO; 1339 newact_with_sigaction.sa_sigaction = SignalAction; 1340 1341 // Set sigaction to be SignalAction, save the last one into origin_act 1342 struct sigaction origin_act; 1343 dfsan_set_label(j_label, &origin_act, 1); 1344 DEFINE_AND_SAVE_ORIGINS(origin_act) 1345 int ret = sigaction(SIGUSR1, &newact_with_sigaction, &origin_act); 1346 assert(ret == 0); 1347 ASSERT_ZERO_LABEL(ret); 1348 ASSERT_READ_ZERO_LABEL(&origin_act, sizeof(origin_act)); 1349 ASSERT_SAVED_ORIGINS(origin_act) 1350 1351 struct sigaction newact_with_sighandler = {}; 1352 newact_with_sighandler.sa_handler = SignalHandler; 1353 1354 // Set sigaction to be SignalHandler, check the last one is SignalAction 1355 struct sigaction oldact; 1356 assert(0 == sigaction(SIGUSR1, &newact_with_sighandler, &oldact)); 1357 assert(oldact.sa_sigaction == SignalAction); 1358 assert(oldact.sa_flags & SA_SIGINFO); 1359 1360 // Set SIG_IGN or SIG_DFL, and check the previous one is expected. 1361 newact_with_sighandler.sa_handler = SIG_IGN; 1362 assert(0 == sigaction(SIGUSR1, &newact_with_sighandler, &oldact)); 1363 assert(oldact.sa_handler == SignalHandler); 1364 assert((oldact.sa_flags & SA_SIGINFO) == 0); 1365 1366 newact_with_sighandler.sa_handler = SIG_DFL; 1367 assert(0 == sigaction(SIGUSR1, &newact_with_sighandler, &oldact)); 1368 assert(oldact.sa_handler == SIG_IGN); 1369 assert((oldact.sa_flags & SA_SIGINFO) == 0); 1370 1371 // Restore sigaction to the orginal setting, check the last one is SignalHandler 1372 assert(0 == sigaction(SIGUSR1, &origin_act, &oldact)); 1373 assert(oldact.sa_handler == SIG_DFL); 1374 assert((oldact.sa_flags & SA_SIGINFO) == 0); 1375 } 1376 1377 void test_signal() { 1378 // Set signal to be SignalHandler, save the previous one into 1379 // old_signal_handler. 1380 sighandler_t old_signal_handler = signal(SIGHUP, SignalHandler); 1381 ASSERT_ZERO_LABEL(old_signal_handler); 1382 1383 // Set SIG_IGN or SIG_DFL, and check the previous one is expected. 1384 assert(SignalHandler == signal(SIGHUP, SIG_DFL)); 1385 assert(SIG_DFL == signal(SIGHUP, SIG_IGN)); 1386 1387 // Restore signal to old_signal_handler. 1388 assert(SIG_IGN == signal(SIGHUP, old_signal_handler)); 1389 } 1390 1391 void test_sigaltstack() { 1392 stack_t old_altstack = {}; 1393 dfsan_set_label(j_label, &old_altstack, sizeof(old_altstack)); 1394 DEFINE_AND_SAVE_ORIGINS(old_altstack) 1395 int ret = sigaltstack(NULL, &old_altstack); 1396 assert(ret == 0); 1397 ASSERT_ZERO_LABEL(ret); 1398 ASSERT_READ_ZERO_LABEL(&old_altstack, sizeof(old_altstack)); 1399 ASSERT_SAVED_ORIGINS(old_altstack) 1400 } 1401 1402 void test_gettimeofday() { 1403 struct timeval tv; 1404 struct timezone tz; 1405 dfsan_set_label(i_label, &tv, sizeof(tv)); 1406 dfsan_set_label(j_label, &tz, sizeof(tz)); 1407 DEFINE_AND_SAVE_ORIGINS(tv) 1408 DEFINE_AND_SAVE_ORIGINS(tz) 1409 int ret = gettimeofday(&tv, &tz); 1410 assert(ret == 0); 1411 ASSERT_READ_ZERO_LABEL(&tv, sizeof(tv)); 1412 ASSERT_READ_ZERO_LABEL(&tz, sizeof(tz)); 1413 ASSERT_SAVED_ORIGINS(tv) 1414 ASSERT_SAVED_ORIGINS(tz) 1415 } 1416 1417 void *pthread_create_test_cb(void *p) { 1418 assert(p == (void *)1); 1419 ASSERT_ZERO_LABEL(p); 1420 return (void *)2; 1421 } 1422 1423 void test_pthread_create() { 1424 pthread_t pt; 1425 int create_ret = pthread_create(&pt, 0, pthread_create_test_cb, (void *)1); 1426 assert(create_ret == 0); 1427 ASSERT_ZERO_LABEL(create_ret); 1428 void *cbrv; 1429 dfsan_set_label(i_label, &cbrv, sizeof(cbrv)); 1430 DEFINE_AND_SAVE_ORIGINS(cbrv) 1431 int joint_ret = pthread_join(pt, &cbrv); 1432 assert(joint_ret == 0); 1433 assert(cbrv == (void *)2); 1434 ASSERT_ZERO_LABEL(joint_ret); 1435 ASSERT_ZERO_LABEL(cbrv); 1436 ASSERT_SAVED_ORIGINS(cbrv); 1437 } 1438 1439 // Tested by test_pthread_create(). This empty function is here to appease the 1440 // check-wrappers script. 1441 void test_pthread_join() {} 1442 1443 int dl_iterate_phdr_test_cb(struct dl_phdr_info *info, size_t size, 1444 void *data) { 1445 assert(data == (void *)3); 1446 ASSERT_ZERO_LABEL(info); 1447 ASSERT_ZERO_LABEL(size); 1448 ASSERT_ZERO_LABEL(data); 1449 return 0; 1450 } 1451 1452 void test_dl_iterate_phdr() { 1453 dl_iterate_phdr(dl_iterate_phdr_test_cb, (void *)3); 1454 } 1455 1456 // On glibc < 2.27, this symbol is not available. Mark it weak so we can skip 1457 // testing in this case. 1458 __attribute__((weak)) extern "C" void _dl_get_tls_static_info(size_t *sizep, 1459 size_t *alignp); 1460 1461 void test__dl_get_tls_static_info() { 1462 if (!_dl_get_tls_static_info) 1463 return; 1464 size_t sizep = 0, alignp = 0; 1465 dfsan_set_label(i_label, &sizep, sizeof(sizep)); 1466 dfsan_set_label(i_label, &alignp, sizeof(alignp)); 1467 dfsan_origin sizep_o = dfsan_get_origin(sizep); 1468 dfsan_origin alignp_o = dfsan_get_origin(alignp); 1469 #ifndef ORIGIN_TRACKING 1470 (void)sizep_o; 1471 (void)alignp_o; 1472 #endif 1473 _dl_get_tls_static_info(&sizep, &alignp); 1474 ASSERT_ZERO_LABEL(sizep); 1475 ASSERT_ZERO_LABEL(alignp); 1476 ASSERT_ORIGIN(sizep, sizep_o); 1477 ASSERT_ORIGIN(alignp, alignp_o); 1478 } 1479 1480 void test_strrchr() { 1481 char str1[] = "str1str1"; 1482 1483 char *p = str1; 1484 dfsan_set_label(j_label, &p, sizeof(p)); 1485 1486 char *rv = strrchr(p, 'r'); 1487 assert(rv == &str1[6]); 1488 ASSERT_LABEL(rv, j_label); 1489 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, p); 1490 1491 char c = 'r'; 1492 dfsan_set_label(k_label, &c, sizeof(c)); 1493 rv = strrchr(str1, c); 1494 assert(rv == &str1[6]); 1495 #ifdef STRICT_DATA_DEPENDENCIES 1496 ASSERT_ZERO_LABEL(rv); 1497 #else 1498 ASSERT_LABEL(rv, k_label); 1499 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, c); 1500 #endif 1501 1502 dfsan_set_label(i_label, &str1[7], 1); 1503 1504 rv = strrchr(str1, 'r'); 1505 assert(rv == &str1[6]); 1506 #ifdef STRICT_DATA_DEPENDENCIES 1507 ASSERT_ZERO_LABEL(rv); 1508 #else 1509 ASSERT_LABEL(rv, i_label); 1510 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, str1[7]); 1511 #endif 1512 } 1513 1514 void test_strstr() { 1515 char str1[] = "str1str1"; 1516 1517 char *p1 = str1; 1518 dfsan_set_label(k_label, &p1, sizeof(p1)); 1519 char *rv = strstr(p1, "1s"); 1520 assert(rv == &str1[3]); 1521 ASSERT_LABEL(rv, k_label); 1522 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, p1); 1523 1524 char str2[] = "1s"; 1525 char *p2 = str2; 1526 dfsan_set_label(m_label, &p2, sizeof(p2)); 1527 rv = strstr(str1, p2); 1528 assert(rv == &str1[3]); 1529 #ifdef STRICT_DATA_DEPENDENCIES 1530 ASSERT_ZERO_LABEL(rv); 1531 #else 1532 ASSERT_LABEL(rv, m_label); 1533 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, p2); 1534 #endif 1535 1536 dfsan_set_label(n_label, &str2[0], 1); 1537 rv = strstr(str1, str2); 1538 assert(rv == &str1[3]); 1539 #ifdef STRICT_DATA_DEPENDENCIES 1540 ASSERT_ZERO_LABEL(rv); 1541 #else 1542 ASSERT_LABEL(rv, n_label); 1543 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, str2[0]); 1544 #endif 1545 1546 dfsan_set_label(i_label, &str1[3], 1); 1547 dfsan_set_label(j_label, &str1[5], 1); 1548 1549 rv = strstr(str1, "1s"); 1550 assert(rv == &str1[3]); 1551 #ifdef STRICT_DATA_DEPENDENCIES 1552 ASSERT_ZERO_LABEL(rv); 1553 #else 1554 ASSERT_LABEL(rv, i_label); 1555 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, str1[3]); 1556 #endif 1557 1558 rv = strstr(str1, "2s"); 1559 assert(rv == NULL); 1560 #ifdef STRICT_DATA_DEPENDENCIES 1561 ASSERT_ZERO_LABEL(rv); 1562 #else 1563 ASSERT_LABEL(rv, i_j_label); 1564 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, str1[3]); 1565 #endif 1566 } 1567 1568 void test_strpbrk() { 1569 char s[] = "abcdefg"; 1570 char accept[] = "123fd"; 1571 1572 char *p_s = s; 1573 char *p_accept = accept; 1574 1575 dfsan_set_label(n_label, &p_accept, sizeof(p_accept)); 1576 1577 char *rv = strpbrk(p_s, p_accept); 1578 assert(rv == &s[3]); 1579 #ifdef STRICT_DATA_DEPENDENCIES 1580 ASSERT_ZERO_LABEL(rv); 1581 #else 1582 ASSERT_LABEL(rv, n_label); 1583 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, p_accept); 1584 #endif 1585 1586 dfsan_set_label(m_label, &p_s, sizeof(p_s)); 1587 1588 rv = strpbrk(p_s, p_accept); 1589 assert(rv == &s[3]); 1590 #ifdef STRICT_DATA_DEPENDENCIES 1591 ASSERT_LABEL(rv, m_label); 1592 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, p_s); 1593 #else 1594 ASSERT_LABEL(rv, dfsan_union(m_label, n_label)); 1595 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, p_s); 1596 #endif 1597 1598 dfsan_set_label(i_label, &s[5], 1); 1599 dfsan_set_label(j_label, &accept[1], 1); 1600 1601 rv = strpbrk(s, accept); 1602 assert(rv == &s[3]); 1603 #ifdef STRICT_DATA_DEPENDENCIES 1604 ASSERT_ZERO_LABEL(rv); 1605 #else 1606 ASSERT_LABEL(rv, j_label); 1607 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, accept[1]); 1608 #endif 1609 1610 char *ps = s; 1611 dfsan_set_label(j_label, &ps, sizeof(ps)); 1612 1613 rv = strpbrk(ps, "123gf"); 1614 assert(rv == &s[5]); 1615 #ifdef STRICT_DATA_DEPENDENCIES 1616 ASSERT_LABEL(rv, j_label); 1617 #else 1618 ASSERT_LABEL(rv, i_j_label); 1619 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, s[5]); 1620 #endif 1621 1622 rv = strpbrk(ps, "123"); 1623 assert(rv == NULL); 1624 #ifdef STRICT_DATA_DEPENDENCIES 1625 ASSERT_ZERO_LABEL(rv); 1626 #else 1627 ASSERT_LABEL(rv, i_j_label); 1628 ASSERT_INIT_ORIGIN_EQ_ORIGIN(&rv, s[5]); 1629 #endif 1630 } 1631 1632 void test_memchr() { 1633 char str1[] = "str1"; 1634 dfsan_set_label(i_label, &str1[3], 1); 1635 dfsan_set_label(j_label, &str1[4], 1); 1636 1637 char *crv = (char *) memchr(str1, 'r', sizeof(str1)); 1638 assert(crv == &str1[2]); 1639 ASSERT_ZERO_LABEL(crv); 1640 1641 char c = 'r'; 1642 dfsan_set_label(k_label, &c, sizeof(c)); 1643 crv = (char *)memchr(str1, c, sizeof(str1)); 1644 assert(crv == &str1[2]); 1645 #ifdef STRICT_DATA_DEPENDENCIES 1646 ASSERT_ZERO_LABEL(crv); 1647 #else 1648 ASSERT_LABEL(crv, k_label); 1649 ASSERT_EQ_ORIGIN(crv, c); 1650 #endif 1651 1652 char *ptr = str1; 1653 dfsan_set_label(k_label, &ptr, sizeof(ptr)); 1654 crv = (char *)memchr(ptr, 'r', sizeof(str1)); 1655 assert(crv == &str1[2]); 1656 ASSERT_LABEL(crv, k_label); 1657 ASSERT_EQ_ORIGIN(crv, ptr); 1658 1659 crv = (char *) memchr(str1, '1', sizeof(str1)); 1660 assert(crv == &str1[3]); 1661 #ifdef STRICT_DATA_DEPENDENCIES 1662 ASSERT_ZERO_LABEL(crv); 1663 #else 1664 ASSERT_LABEL(crv, i_label); 1665 ASSERT_EQ_ORIGIN(crv, str1[3]); 1666 #endif 1667 1668 crv = (char *) memchr(str1, 'x', sizeof(str1)); 1669 assert(!crv); 1670 #ifdef STRICT_DATA_DEPENDENCIES 1671 ASSERT_ZERO_LABEL(crv); 1672 #else 1673 ASSERT_LABEL(crv, i_j_label); 1674 ASSERT_EQ_ORIGIN(crv, str1[3]); 1675 #endif 1676 } 1677 1678 void alarm_handler(int unused) { 1679 ; 1680 } 1681 1682 void test_nanosleep() { 1683 struct timespec req, rem; 1684 req.tv_sec = 1; 1685 req.tv_nsec = 0; 1686 dfsan_set_label(i_label, &rem, sizeof(rem)); 1687 DEFINE_AND_SAVE_ORIGINS(rem) 1688 1689 // non interrupted 1690 int rv = nanosleep(&req, &rem); 1691 assert(rv == 0); 1692 ASSERT_ZERO_LABEL(rv); 1693 ASSERT_READ_LABEL(&rem, 1, i_label); 1694 ASSERT_SAVED_ORIGINS(rem) 1695 1696 // interrupted by an alarm 1697 signal(SIGALRM, alarm_handler); 1698 req.tv_sec = 3; 1699 alarm(1); 1700 rv = nanosleep(&req, &rem); 1701 assert(rv == -1); 1702 ASSERT_ZERO_LABEL(rv); 1703 ASSERT_READ_ZERO_LABEL(&rem, sizeof(rem)); 1704 ASSERT_SAVED_ORIGINS(rem) 1705 } 1706 1707 void test_socketpair() { 1708 int fd[2]; 1709 dfsan_origin fd_o[2]; 1710 1711 dfsan_set_label(i_label, fd, sizeof(fd)); 1712 fd_o[0] = dfsan_get_origin((long)(fd[0])); 1713 fd_o[1] = dfsan_get_origin((long)(fd[1])); 1714 int rv = socketpair(PF_LOCAL, SOCK_STREAM, 0, fd); 1715 assert(rv == 0); 1716 ASSERT_ZERO_LABEL(rv); 1717 ASSERT_READ_ZERO_LABEL(fd, sizeof(fd)); 1718 ASSERT_ORIGIN(fd[0], fd_o[0]); 1719 ASSERT_ORIGIN(fd[1], fd_o[1]); 1720 } 1721 1722 void test_getpeername() { 1723 int sockfds[2]; 1724 int ret = socketpair(AF_UNIX, SOCK_DGRAM, 0, sockfds); 1725 assert(ret != -1); 1726 1727 struct sockaddr addr = {}; 1728 socklen_t addrlen = sizeof(addr); 1729 dfsan_set_label(i_label, &addr, addrlen); 1730 dfsan_set_label(i_label, &addrlen, sizeof(addrlen)); 1731 DEFINE_AND_SAVE_ORIGINS(addr) 1732 DEFINE_AND_SAVE_ORIGINS(addrlen) 1733 1734 ret = getpeername(sockfds[0], &addr, &addrlen); 1735 assert(ret != -1); 1736 ASSERT_ZERO_LABEL(ret); 1737 ASSERT_ZERO_LABEL(addrlen); 1738 assert(addrlen < sizeof(addr)); 1739 ASSERT_READ_ZERO_LABEL(&addr, addrlen); 1740 ASSERT_READ_LABEL(((char *)&addr) + addrlen, 1, i_label); 1741 ASSERT_SAVED_ORIGINS(addr) 1742 ASSERT_SAVED_ORIGINS(addrlen) 1743 1744 close(sockfds[0]); 1745 close(sockfds[1]); 1746 } 1747 1748 void test_getsockname() { 1749 int sockfd = socket(AF_UNIX, SOCK_DGRAM, 0); 1750 assert(sockfd != -1); 1751 1752 struct sockaddr addr = {}; 1753 socklen_t addrlen = sizeof(addr); 1754 dfsan_set_label(i_label, &addr, addrlen); 1755 dfsan_set_label(i_label, &addrlen, sizeof(addrlen)); 1756 DEFINE_AND_SAVE_ORIGINS(addr) 1757 DEFINE_AND_SAVE_ORIGINS(addrlen) 1758 int ret = getsockname(sockfd, &addr, &addrlen); 1759 assert(ret != -1); 1760 ASSERT_ZERO_LABEL(ret); 1761 ASSERT_ZERO_LABEL(addrlen); 1762 assert(addrlen < sizeof(addr)); 1763 ASSERT_READ_ZERO_LABEL(&addr, addrlen); 1764 ASSERT_READ_LABEL(((char *)&addr) + addrlen, 1, i_label); 1765 ASSERT_SAVED_ORIGINS(addr) 1766 ASSERT_SAVED_ORIGINS(addrlen) 1767 1768 close(sockfd); 1769 } 1770 1771 void test_getsockopt() { 1772 int sockfd = socket(AF_UNIX, SOCK_DGRAM, 0); 1773 assert(sockfd != -1); 1774 1775 int optval[2] = {-1, -1}; 1776 socklen_t optlen = sizeof(optval); 1777 dfsan_set_label(i_label, &optval, sizeof(optval)); 1778 dfsan_set_label(i_label, &optlen, sizeof(optlen)); 1779 DEFINE_AND_SAVE_ORIGINS(optval) 1780 DEFINE_AND_SAVE_ORIGINS(optlen) 1781 int ret = getsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &optval, &optlen); 1782 assert(ret != -1); 1783 assert(optlen == sizeof(int)); 1784 assert(optval[0] == 0); 1785 assert(optval[1] == -1); 1786 ASSERT_ZERO_LABEL(ret); 1787 ASSERT_ZERO_LABEL(optlen); 1788 ASSERT_ZERO_LABEL(optval[0]); 1789 ASSERT_LABEL(optval[1], i_label); 1790 ASSERT_SAVED_ORIGINS(optval) 1791 ASSERT_SAVED_ORIGINS(optlen) 1792 1793 close(sockfd); 1794 } 1795 1796 void test_write() { 1797 int fd = open("/dev/null", O_WRONLY); 1798 1799 char buf[] = "a string"; 1800 int len = strlen(buf); 1801 1802 // The result of a write always unlabeled. 1803 int res = write(fd, buf, len); 1804 assert(res > 0); 1805 ASSERT_ZERO_LABEL(res); 1806 1807 // Label all arguments to write(). 1808 dfsan_set_label(i_label, &(buf[3]), 1); 1809 dfsan_set_label(j_label, &fd, sizeof(fd)); 1810 dfsan_set_label(k_label, &len, sizeof(len)); 1811 1812 // The value returned by write() should have no label. 1813 res = write(fd, buf, len); 1814 ASSERT_ZERO_LABEL(res); 1815 1816 close(fd); 1817 } 1818 1819 template <class T> 1820 void test_sprintf_chunk(const char* expected, const char* format, T arg) { 1821 char buf[512]; 1822 memset(buf, 'a', sizeof(buf)); 1823 1824 char padded_expected[512]; 1825 strcpy(padded_expected, "foo "); 1826 strcat(padded_expected, expected); 1827 strcat(padded_expected, " bar"); 1828 1829 char padded_format[512]; 1830 strcpy(padded_format, "foo "); 1831 strcat(padded_format, format); 1832 strcat(padded_format, " bar"); 1833 1834 // Non labelled arg. 1835 assert(sprintf(buf, padded_format, arg) == strlen(padded_expected)); 1836 assert(strcmp(buf, padded_expected) == 0); 1837 ASSERT_READ_LABEL(buf, strlen(padded_expected), 0); 1838 memset(buf, 'a', sizeof(buf)); 1839 1840 // Labelled arg. 1841 dfsan_set_label(i_label, &arg, sizeof(arg)); 1842 dfsan_origin a_o = dfsan_get_origin((long)(arg)); 1843 #ifndef ORIGIN_TRACKING 1844 (void)a_o; 1845 #endif 1846 assert(sprintf(buf, padded_format, arg) == strlen(padded_expected)); 1847 assert(strcmp(buf, padded_expected) == 0); 1848 ASSERT_READ_LABEL(buf, 4, 0); 1849 ASSERT_READ_LABEL(buf + 4, strlen(padded_expected) - 8, i_label); 1850 ASSERT_INIT_ORIGINS(buf + 4, strlen(padded_expected) - 8, a_o); 1851 ASSERT_READ_LABEL(buf + (strlen(padded_expected) - 4), 4, 0); 1852 } 1853 1854 void test_sprintf() { 1855 char buf[2048]; 1856 memset(buf, 'a', sizeof(buf)); 1857 1858 // Test formatting (no conversion specifier). 1859 assert(sprintf(buf, "Hello world!") == 12); 1860 assert(strcmp(buf, "Hello world!") == 0); 1861 ASSERT_READ_LABEL(buf, sizeof(buf), 0); 1862 1863 // Test for extra arguments. 1864 assert(sprintf(buf, "Hello world!", 42, "hello") == 12); 1865 assert(strcmp(buf, "Hello world!") == 0); 1866 ASSERT_READ_LABEL(buf, sizeof(buf), 0); 1867 1868 // Test formatting & label propagation (multiple conversion specifiers): %s, 1869 // %d, %n, %f, and %%. 1870 const char* s = "world"; 1871 int m = 8; 1872 int d = 27; 1873 dfsan_set_label(k_label, (void *) (s + 1), 2); 1874 dfsan_origin s_o = dfsan_get_origin((long)(s[1])); 1875 dfsan_set_label(i_label, &m, sizeof(m)); 1876 dfsan_origin m_o = dfsan_get_origin((long)m); 1877 dfsan_set_label(j_label, &d, sizeof(d)); 1878 dfsan_origin d_o = dfsan_get_origin((long)d); 1879 #ifndef ORIGIN_TRACKING 1880 (void)s_o; 1881 (void)m_o; 1882 (void)d_o; 1883 #endif 1884 int n; 1885 int r = sprintf(buf, "hello %s, %-d/%d/%d %f %% %n%d", s, 2014, m, d, 1886 12345.6781234, &n, 1000); 1887 assert(r == 42); 1888 assert(strcmp(buf, "hello world, 2014/8/27 12345.678123 % 1000") == 0); 1889 ASSERT_READ_LABEL(buf, 7, 0); 1890 ASSERT_READ_LABEL(buf + 7, 2, k_label); 1891 ASSERT_INIT_ORIGINS(buf + 7, 2, s_o); 1892 ASSERT_READ_LABEL(buf + 9, 9, 0); 1893 ASSERT_READ_LABEL(buf + 18, 1, i_label); 1894 ASSERT_INIT_ORIGINS(buf + 18, 1, m_o); 1895 ASSERT_READ_LABEL(buf + 19, 1, 0); 1896 ASSERT_READ_LABEL(buf + 20, 2, j_label); 1897 ASSERT_INIT_ORIGINS(buf + 20, 2, d_o); 1898 ASSERT_READ_LABEL(buf + 22, 15, 0); 1899 ASSERT_LABEL(r, 0); 1900 assert(n == 38); 1901 1902 // Test formatting & label propagation (single conversion specifier, with 1903 // additional length and precision modifiers). 1904 test_sprintf_chunk("-559038737", "%d", 0xdeadbeef); 1905 test_sprintf_chunk("3735928559", "%u", 0xdeadbeef); 1906 test_sprintf_chunk("12345", "%i", 12345); 1907 test_sprintf_chunk("751", "%o", 0751); 1908 test_sprintf_chunk("babe", "%x", 0xbabe); 1909 test_sprintf_chunk("0000BABE", "%.8X", 0xbabe); 1910 test_sprintf_chunk("-17", "%hhd", 0xdeadbeef); 1911 test_sprintf_chunk("-16657", "%hd", 0xdeadbeef); 1912 test_sprintf_chunk("deadbeefdeadbeef", "%lx", 0xdeadbeefdeadbeef); 1913 test_sprintf_chunk("0xdeadbeefdeadbeef", "%p", 1914 (void *) 0xdeadbeefdeadbeef); 1915 test_sprintf_chunk("18446744073709551615", "%ju", (intmax_t) -1); 1916 test_sprintf_chunk("18446744073709551615", "%zu", (size_t) -1); 1917 test_sprintf_chunk("18446744073709551615", "%tu", (size_t) -1); 1918 1919 test_sprintf_chunk("0x1.f9acffa7eb6bfp-4", "%a", 0.123456); 1920 test_sprintf_chunk("0X1.F9ACFFA7EB6BFP-4", "%A", 0.123456); 1921 test_sprintf_chunk("0.12346", "%.5f", 0.123456); 1922 test_sprintf_chunk("0.123456", "%g", 0.123456); 1923 test_sprintf_chunk("1.234560e-01", "%e", 0.123456); 1924 test_sprintf_chunk("1.234560E-01", "%E", 0.123456); 1925 test_sprintf_chunk("0.1234567891234560", "%.16Lf", 1926 (long double) 0.123456789123456); 1927 1928 test_sprintf_chunk("z", "%c", 'z'); 1929 1930 // %n, %s, %d, %f, and %% already tested 1931 1932 // Test formatting with width passed as an argument. 1933 r = sprintf(buf, "hi %*d my %*s friend %.*f", 3, 1, 6, "dear", 4, 3.14159265359); 1934 assert(r == 30); 1935 assert(strcmp(buf, "hi 1 my dear friend 3.1416") == 0); 1936 } 1937 1938 void test_snprintf() { 1939 char buf[2048]; 1940 memset(buf, 'a', sizeof(buf)); 1941 dfsan_set_label(0, buf, sizeof(buf)); 1942 const char* s = "world"; 1943 int y = 2014; 1944 int m = 8; 1945 int d = 27; 1946 dfsan_set_label(k_label, (void *) (s + 1), 2); 1947 dfsan_origin s_o = dfsan_get_origin((long)(s[1])); 1948 dfsan_set_label(i_label, &y, sizeof(y)); 1949 dfsan_origin y_o = dfsan_get_origin((long)y); 1950 dfsan_set_label(j_label, &m, sizeof(m)); 1951 dfsan_origin m_o = dfsan_get_origin((long)m); 1952 #ifndef ORIGIN_TRACKING 1953 (void)s_o; 1954 (void)y_o; 1955 (void)m_o; 1956 #endif 1957 int r = snprintf(buf, 19, "hello %s, %-d/ %d/%d %f", s, y, m, d, 1958 12345.6781234); 1959 // The return value is the number of bytes that would have been written to 1960 // the final string if enough space had been available. 1961 assert(r == 38); 1962 assert(memcmp(buf, "hello world, 2014/", 19) == 0); 1963 ASSERT_READ_LABEL(buf, 7, 0); 1964 ASSERT_READ_LABEL(buf + 7, 2, k_label); 1965 ASSERT_INIT_ORIGINS(buf + 7, 2, s_o); 1966 ASSERT_READ_LABEL(buf + 9, 4, 0); 1967 ASSERT_READ_LABEL(buf + 13, 4, i_label); 1968 ASSERT_INIT_ORIGINS(buf + 13, 4, y_o); 1969 ASSERT_READ_LABEL(buf + 17, 2, 0); 1970 ASSERT_LABEL(r, 0); 1971 } 1972 1973 // Tested by a seperate source file. This empty function is here to appease the 1974 // check-wrappers script. 1975 void test_fork() {} 1976 1977 int main(void) { 1978 i_label = 1; 1979 j_label = 2; 1980 k_label = 4; 1981 m_label = 8; 1982 n_label = 16; 1983 i_j_label = dfsan_union(i_label, j_label); 1984 assert(i_j_label != i_label); 1985 assert(i_j_label != j_label); 1986 assert(i_j_label != k_label); 1987 1988 test__dl_get_tls_static_info(); 1989 test_bcmp(); 1990 test_clock_gettime(); 1991 test_ctime_r(); 1992 test_dfsan_set_write_callback(); 1993 test_dl_iterate_phdr(); 1994 test_dlopen(); 1995 test_epoll_wait(); 1996 test_fgets(); 1997 test_fork(); 1998 test_fstat(); 1999 test_get_current_dir_name(); 2000 test_getcwd(); 2001 test_getentropy(); 2002 test_gethostname(); 2003 test_getpeername(); 2004 test_getpwuid_r(); 2005 test_getrlimit(); 2006 test_getrusage(); 2007 test_getsockname(); 2008 test_getsockopt(); 2009 test_gettimeofday(); 2010 test_inet_pton(); 2011 test_localtime_r(); 2012 test_memchr(); 2013 test_memcmp(); 2014 test_memcpy(); 2015 test_memmove(); 2016 test_memset(); 2017 test_nanosleep(); 2018 test_poll(); 2019 test_pread(); 2020 test_pthread_create(); 2021 test_pthread_join(); 2022 test_read(); 2023 test_recvmmsg(); 2024 test_recvmsg(); 2025 test_sched_getaffinity(); 2026 test_select(); 2027 test_sigaction(); 2028 test_signal(); 2029 test_sigaltstack(); 2030 test_sigemptyset(); 2031 test_snprintf(); 2032 test_socketpair(); 2033 test_sprintf(); 2034 test_stat(); 2035 test_strcasecmp(); 2036 test_strchr(); 2037 test_strcmp(); 2038 test_strcat(); 2039 test_strcpy(); 2040 test_strdup(); 2041 test_strlen(); 2042 test_strncasecmp(); 2043 test_strncmp(); 2044 test_strncpy(); 2045 test_strpbrk(); 2046 test_strrchr(); 2047 test_strstr(); 2048 test_strtod(); 2049 test_strtol(); 2050 test_strtoll(); 2051 test_strtoul(); 2052 test_strtoull(); 2053 test_time(); 2054 test_write(); 2055 } 2056