1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 // -Werror is on whether we like it or not, and we're intentionally doing awful 18 // things in this file. GCC is dumb and doesn't have a specific error class for 19 // the fortify failures (it's just -Werror), so we can't use anything more 20 // constrained than disabling all the warnings in the file :( It also won't let 21 // us use system_header in a .cpp file, so we have to #include this from 22 // fortify_test_main.cpp. 23 #pragma GCC system_header 24 25 #include <gtest/gtest.h> 26 #include "BionicDeathTest.h" 27 28 #include <fcntl.h> 29 #include <malloc.h> 30 #include <poll.h> 31 #include <signal.h> 32 #include <stdarg.h> 33 #include <string.h> 34 #include <sys/socket.h> 35 #include <sys/stat.h> 36 #include <sys/types.h> 37 #include <time.h> 38 39 #if __BIONIC__ 40 #define ASSERT_FORTIFY(expr) ASSERT_EXIT(expr, testing::KilledBySignal(SIGABRT), "FORTIFY") 41 #else 42 #define ASSERT_FORTIFY(expr) ASSERT_EXIT(expr, testing::KilledBySignal(SIGABRT), "") 43 #endif 44 45 // Fortify test code needs to run multiple times, so TEST_NAME macro is used to 46 // distinguish different tests. TEST_NAME is defined in compilation command. 47 #define DEATHTEST_PASTER(name) name##_DeathTest 48 #define DEATHTEST_EVALUATOR(name) DEATHTEST_PASTER(name) 49 #define DEATHTEST DEATHTEST_EVALUATOR(TEST_NAME) 50 51 class DEATHTEST : public BionicDeathTest {}; 52 53 #if defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE == 2 54 struct foo { 55 char empty[0]; 56 char one[1]; 57 char a[10]; 58 char b[10]; 59 }; 60 61 #ifndef __clang__ 62 // This test is disabled in clang because clang doesn't properly detect 63 // this buffer overflow. TODO: Fix clang. 64 TEST_F(DEATHTEST, stpncpy_fortified2) { 65 foo myfoo; 66 int copy_amt = atoi("11"); 67 ASSERT_FORTIFY(stpncpy(myfoo.a, "01234567890", copy_amt)); 68 } 69 #endif 70 71 #ifndef __clang__ 72 // This test is disabled in clang because clang doesn't properly detect 73 // this buffer overflow. TODO: Fix clang. 74 TEST_F(DEATHTEST, stpncpy2_fortified2) { 75 foo myfoo; 76 memset(&myfoo, 0, sizeof(myfoo)); 77 myfoo.one[0] = 'A'; // not null terminated string 78 ASSERT_FORTIFY(stpncpy(myfoo.b, myfoo.one, sizeof(myfoo.b))); 79 } 80 #endif 81 82 #ifndef __clang__ 83 // This test is disabled in clang because clang doesn't properly detect 84 // this buffer overflow. TODO: Fix clang. 85 TEST_F(DEATHTEST, strncpy_fortified2) { 86 foo myfoo; 87 int copy_amt = atoi("11"); 88 ASSERT_FORTIFY(strncpy(myfoo.a, "01234567890", copy_amt)); 89 } 90 #endif 91 92 #ifndef __clang__ 93 // This test is disabled in clang because clang doesn't properly detect 94 // this buffer overflow. TODO: Fix clang. 95 TEST_F(DEATHTEST, strncpy2_fortified2) { 96 foo myfoo; 97 memset(&myfoo, 0, sizeof(myfoo)); 98 myfoo.one[0] = 'A'; // not null terminated string 99 ASSERT_FORTIFY(strncpy(myfoo.b, myfoo.one, sizeof(myfoo.b))); 100 } 101 #endif 102 103 #ifndef __clang__ 104 // This test is disabled in clang because clang doesn't properly detect 105 // this buffer overflow. TODO: Fix clang. 106 TEST_F(DEATHTEST, sprintf_fortified2) { 107 foo myfoo; 108 char source_buf[15]; 109 memcpy(source_buf, "12345678901234", 15); 110 ASSERT_FORTIFY(sprintf(myfoo.a, "%s", source_buf)); 111 } 112 #endif 113 114 #ifndef __clang__ 115 // This test is disabled in clang because clang doesn't properly detect 116 // this buffer overflow. TODO: Fix clang. 117 TEST_F(DEATHTEST, sprintf2_fortified2) { 118 foo myfoo; 119 ASSERT_FORTIFY(sprintf(myfoo.a, "0123456789")); 120 } 121 #endif 122 123 #ifndef __clang__ 124 // These tests are disabled in clang because clang doesn't properly detect 125 // this buffer overflow. TODO: Fix clang. 126 static int vsprintf_helper2(const char *fmt, ...) { 127 foo myfoo; 128 va_list va; 129 int result; 130 131 va_start(va, fmt); 132 result = vsprintf(myfoo.a, fmt, va); // should crash here 133 va_end(va); 134 return result; 135 } 136 137 TEST_F(DEATHTEST, vsprintf_fortified2) { 138 ASSERT_FORTIFY(vsprintf_helper2("%s", "0123456789")); 139 } 140 141 TEST_F(DEATHTEST, vsprintf2_fortified2) { 142 ASSERT_FORTIFY(vsprintf_helper2("0123456789")); 143 } 144 #endif 145 146 #ifndef __clang__ 147 // These tests are disabled in clang because clang doesn't properly detect 148 // this buffer overflow. TODO: Fix clang. 149 static int vsnprintf_helper2(const char *fmt, ...) { 150 foo myfoo; 151 va_list va; 152 int result; 153 size_t size = atoi("11"); 154 155 va_start(va, fmt); 156 result = vsnprintf(myfoo.a, size, fmt, va); // should crash here 157 va_end(va); 158 return result; 159 } 160 161 TEST_F(DEATHTEST, vsnprintf_fortified2) { 162 ASSERT_FORTIFY(vsnprintf_helper2("%s", "0123456789")); 163 } 164 165 TEST_F(DEATHTEST, vsnprintf2_fortified2) { 166 ASSERT_FORTIFY(vsnprintf_helper2("0123456789")); 167 } 168 #endif 169 170 #ifndef __clang__ 171 // zero sized target with "\0" source (should fail) 172 // This test is disabled in clang because clang doesn't properly detect 173 // this buffer overflow. TODO: Fix clang. 174 TEST_F(DEATHTEST, stpcpy_fortified2) { 175 #if defined(__BIONIC__) 176 foo myfoo; 177 char* src = strdup(""); 178 ASSERT_FORTIFY(stpcpy(myfoo.empty, src)); 179 free(src); 180 #else // __BIONIC__ 181 GTEST_LOG_(INFO) << "This test does nothing.\n"; 182 #endif // __BIONIC__ 183 } 184 #endif 185 186 #ifndef __clang__ 187 // zero sized target with "\0" source (should fail) 188 // This test is disabled in clang because clang doesn't properly detect 189 // this buffer overflow. TODO: Fix clang. 190 TEST_F(DEATHTEST, strcpy_fortified2) { 191 #if defined(__BIONIC__) 192 foo myfoo; 193 char* src = strdup(""); 194 ASSERT_FORTIFY(strcpy(myfoo.empty, src)); 195 free(src); 196 #else // __BIONIC__ 197 GTEST_LOG_(INFO) << "This test does nothing.\n"; 198 #endif // __BIONIC__ 199 } 200 #endif 201 202 #ifndef __clang__ 203 // zero sized target with longer source (should fail) 204 // This test is disabled in clang because clang doesn't properly detect 205 // this buffer overflow. TODO: Fix clang. 206 TEST_F(DEATHTEST, strcpy2_fortified2) { 207 #if defined(__BIONIC__) 208 foo myfoo; 209 char* src = strdup("1"); 210 ASSERT_FORTIFY(strcpy(myfoo.empty, src)); 211 free(src); 212 #else // __BIONIC__ 213 GTEST_LOG_(INFO) << "This test does nothing.\n"; 214 #endif // __BIONIC__ 215 } 216 #endif 217 218 #ifndef __clang__ 219 // one byte target with longer source (should fail) 220 // This test is disabled in clang because clang doesn't properly detect 221 // this buffer overflow. TODO: Fix clang. 222 TEST_F(DEATHTEST, strcpy3_fortified2) { 223 #if defined(__BIONIC__) 224 foo myfoo; 225 char* src = strdup("12"); 226 ASSERT_FORTIFY(strcpy(myfoo.one, src)); 227 free(src); 228 #else // __BIONIC__ 229 GTEST_LOG_(INFO) << "This test does nothing.\n"; 230 #endif // __BIONIC__ 231 } 232 #endif 233 234 #ifndef __clang__ 235 // This test is disabled in clang because clang doesn't properly detect 236 // this buffer overflow. TODO: Fix clang. 237 TEST_F(DEATHTEST, strchr_fortified2) { 238 #if defined(__BIONIC__) 239 foo myfoo; 240 memcpy(myfoo.a, "0123456789", sizeof(myfoo.a)); 241 myfoo.b[0] = '\0'; 242 ASSERT_FORTIFY(printf("%s", strchr(myfoo.a, 'a'))); 243 #else // __BIONIC__ 244 GTEST_LOG_(INFO) << "This test does nothing.\n"; 245 #endif // __BIONIC__ 246 } 247 #endif 248 249 #ifndef __clang__ 250 // This test is disabled in clang because clang doesn't properly detect 251 // this buffer overflow. TODO: Fix clang. 252 TEST_F(DEATHTEST, strrchr_fortified2) { 253 #if defined(__BIONIC__) 254 foo myfoo; 255 memcpy(myfoo.a, "0123456789", 10); 256 memcpy(myfoo.b, "01234", 6); 257 ASSERT_FORTIFY(printf("%s", strrchr(myfoo.a, 'a'))); 258 #else // __BIONIC__ 259 GTEST_LOG_(INFO) << "This test does nothing.\n"; 260 #endif // __BIONIC__ 261 } 262 #endif 263 264 #ifndef __clang__ 265 // This test is disabled in clang because clang doesn't properly detect 266 // this buffer overflow. TODO: Fix clang. 267 TEST_F(DEATHTEST, strlcpy_fortified2) { 268 #if defined(__BIONIC__) 269 foo myfoo; 270 strcpy(myfoo.a, "01"); 271 size_t n = strlen(myfoo.a); 272 ASSERT_FORTIFY(strlcpy(myfoo.one, myfoo.a, n)); 273 #else // __BIONIC__ 274 GTEST_LOG_(INFO) << "This test does nothing.\n"; 275 #endif // __BIONIC__ 276 } 277 #endif 278 279 #ifndef __clang__ 280 // This test is disabled in clang because clang doesn't properly detect 281 // this buffer overflow. TODO: Fix clang. 282 TEST_F(DEATHTEST, strlcat_fortified2) { 283 #if defined(__BIONIC__) 284 foo myfoo; 285 strcpy(myfoo.a, "01"); 286 myfoo.one[0] = '\0'; 287 size_t n = strlen(myfoo.a); 288 ASSERT_FORTIFY(strlcat(myfoo.one, myfoo.a, n)); 289 #else // __BIONIC__ 290 GTEST_LOG_(INFO) << "This test does nothing.\n"; 291 #endif // __BIONIC__ 292 } 293 #endif 294 295 #ifndef __clang__ 296 // This test is disabled in clang because clang doesn't properly detect 297 // this buffer overflow. TODO: Fix clang. 298 TEST_F(DEATHTEST, strncat_fortified2) { 299 foo myfoo; 300 size_t n = atoi("10"); // avoid compiler optimizations 301 strncpy(myfoo.a, "012345678", n); 302 ASSERT_FORTIFY(strncat(myfoo.a, "9", n)); 303 } 304 #endif 305 306 #ifndef __clang__ 307 // This test is disabled in clang because clang doesn't properly detect 308 // this buffer overflow. TODO: Fix clang. 309 TEST_F(DEATHTEST, strncat2_fortified2) { 310 foo myfoo; 311 myfoo.a[0] = '\0'; 312 size_t n = atoi("10"); // avoid compiler optimizations 313 ASSERT_FORTIFY(strncat(myfoo.a, "0123456789", n)); 314 } 315 #endif 316 317 TEST_F(DEATHTEST, strncat3_fortified2) { 318 foo myfoo; 319 memcpy(myfoo.a, "0123456789", sizeof(myfoo.a)); // unterminated string 320 myfoo.b[0] = '\0'; 321 size_t n = atoi("10"); // avoid compiler optimizations 322 ASSERT_FORTIFY(strncat(myfoo.b, myfoo.a, n)); 323 } 324 325 #ifndef __clang__ 326 // This test is disabled in clang because clang doesn't properly detect 327 // this buffer overflow. TODO: Fix clang. 328 TEST_F(DEATHTEST, strcat_fortified2) { 329 char src[11]; 330 strcpy(src, "0123456789"); 331 foo myfoo; 332 myfoo.a[0] = '\0'; 333 ASSERT_FORTIFY(strcat(myfoo.a, src)); 334 } 335 #endif 336 337 TEST_F(DEATHTEST, strcat2_fortified2) { 338 foo myfoo; 339 memcpy(myfoo.a, "0123456789", sizeof(myfoo.a)); // unterminated string 340 myfoo.b[0] = '\0'; 341 ASSERT_FORTIFY(strcat(myfoo.b, myfoo.a)); 342 } 343 344 TEST_F(DEATHTEST, snprintf_fortified2) { 345 foo myfoo; 346 strcpy(myfoo.a, "012345678"); 347 size_t n = strlen(myfoo.a) + 2; 348 ASSERT_FORTIFY(snprintf(myfoo.b, n, "a%s", myfoo.a)); 349 } 350 351 TEST_F(DEATHTEST, bzero_fortified2) { 352 foo myfoo; 353 memcpy(myfoo.b, "0123456789", sizeof(myfoo.b)); 354 size_t n = atoi("11"); 355 ASSERT_FORTIFY(bzero(myfoo.b, n)); 356 } 357 358 #endif /* defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE=2 */ 359 360 // multibyte target where we over fill (should fail) 361 TEST_F(DEATHTEST, strcpy_fortified) { 362 #if defined(__BIONIC__) 363 char buf[10]; 364 char *orig = strdup("0123456789"); 365 ASSERT_FORTIFY(strcpy(buf, orig)); 366 free(orig); 367 #else // __BIONIC__ 368 GTEST_LOG_(INFO) << "This test does nothing.\n"; 369 #endif // __BIONIC__ 370 } 371 372 // zero sized target with "\0" source (should fail) 373 TEST_F(DEATHTEST, strcpy2_fortified) { 374 #if defined(__BIONIC__) 375 char buf[0]; 376 char *orig = strdup(""); 377 ASSERT_FORTIFY(strcpy(buf, orig)); 378 free(orig); 379 #else // __BIONIC__ 380 GTEST_LOG_(INFO) << "This test does nothing.\n"; 381 #endif // __BIONIC__ 382 } 383 384 // zero sized target with longer source (should fail) 385 TEST_F(DEATHTEST, strcpy3_fortified) { 386 #if defined(__BIONIC__) 387 char buf[0]; 388 char *orig = strdup("1"); 389 ASSERT_FORTIFY(strcpy(buf, orig)); 390 free(orig); 391 #else // __BIONIC__ 392 GTEST_LOG_(INFO) << "This test does nothing.\n"; 393 #endif // __BIONIC__ 394 } 395 396 // one byte target with longer source (should fail) 397 TEST_F(DEATHTEST, strcpy4_fortified) { 398 #if defined(__BIONIC__) 399 char buf[1]; 400 char *orig = strdup("12"); 401 ASSERT_FORTIFY(strcpy(buf, orig)); 402 free(orig); 403 #else // __BIONIC__ 404 GTEST_LOG_(INFO) << "This test does nothing.\n"; 405 #endif // __BIONIC__ 406 } 407 408 TEST_F(DEATHTEST, strlen_fortified) { 409 #if defined(__BIONIC__) 410 char buf[10]; 411 memcpy(buf, "0123456789", sizeof(buf)); 412 ASSERT_FORTIFY(printf("%zd", strlen(buf))); 413 #else // __BIONIC__ 414 GTEST_LOG_(INFO) << "This test does nothing.\n"; 415 #endif // __BIONIC__ 416 } 417 418 TEST_F(DEATHTEST, strchr_fortified) { 419 #if defined(__BIONIC__) 420 char buf[10]; 421 memcpy(buf, "0123456789", sizeof(buf)); 422 ASSERT_FORTIFY(printf("%s", strchr(buf, 'a'))); 423 #else // __BIONIC__ 424 GTEST_LOG_(INFO) << "This test does nothing.\n"; 425 #endif // __BIONIC__ 426 } 427 428 TEST_F(DEATHTEST, strrchr_fortified) { 429 #if defined(__BIONIC__) 430 char buf[10]; 431 memcpy(buf, "0123456789", sizeof(buf)); 432 ASSERT_FORTIFY(printf("%s", strrchr(buf, 'a'))); 433 #else // __BIONIC__ 434 GTEST_LOG_(INFO) << "This test does nothing.\n"; 435 #endif // __BIONIC__ 436 } 437 438 TEST_F(DEATHTEST, strlcpy_fortified) { 439 #if defined(__BIONIC__) 440 char bufa[15]; 441 char bufb[10]; 442 strcpy(bufa, "01234567890123"); 443 size_t n = strlen(bufa); 444 ASSERT_FORTIFY(strlcpy(bufb, bufa, n)); 445 #else // __BIONIC__ 446 GTEST_LOG_(INFO) << "This test does nothing.\n"; 447 #endif // __BIONIC__ 448 } 449 450 TEST_F(DEATHTEST, strlcat_fortified) { 451 #if defined(__BIONIC__) 452 char bufa[15]; 453 char bufb[10]; 454 bufb[0] = '\0'; 455 strcpy(bufa, "01234567890123"); 456 size_t n = strlen(bufa); 457 ASSERT_FORTIFY(strlcat(bufb, bufa, n)); 458 #else // __BIONIC__ 459 GTEST_LOG_(INFO) << "This test does nothing.\n"; 460 #endif // __BIONIC__ 461 } 462 463 TEST_F(DEATHTEST, sprintf_fortified) { 464 char buf[10]; 465 char source_buf[15]; 466 memcpy(source_buf, "12345678901234", 15); 467 ASSERT_FORTIFY(sprintf(buf, "%s", source_buf)); 468 } 469 470 #ifndef __clang__ 471 // This test is disabled in clang because clang doesn't properly detect 472 // this buffer overflow. TODO: Fix clang. 473 TEST_F(DEATHTEST, sprintf_malloc_fortified) { 474 char* buf = (char *) malloc(10); 475 char source_buf[11]; 476 memcpy(source_buf, "1234567890", 11); 477 ASSERT_FORTIFY(sprintf(buf, "%s", source_buf)); 478 free(buf); 479 } 480 #endif 481 482 TEST_F(DEATHTEST, sprintf2_fortified) { 483 char buf[5]; 484 ASSERT_FORTIFY(sprintf(buf, "aaaaa")); 485 } 486 487 static int vsprintf_helper(const char *fmt, ...) { 488 char buf[10]; 489 va_list va; 490 int result; 491 492 va_start(va, fmt); 493 result = vsprintf(buf, fmt, va); // should crash here 494 va_end(va); 495 return result; 496 } 497 498 TEST_F(DEATHTEST, vsprintf_fortified) { 499 ASSERT_FORTIFY(vsprintf_helper("%s", "0123456789")); 500 } 501 502 TEST_F(DEATHTEST, vsprintf2_fortified) { 503 ASSERT_FORTIFY(vsprintf_helper("0123456789")); 504 } 505 506 static int vsnprintf_helper(const char *fmt, ...) { 507 char buf[10]; 508 va_list va; 509 int result; 510 size_t size = atoi("11"); 511 512 va_start(va, fmt); 513 result = vsnprintf(buf, size, fmt, va); // should crash here 514 va_end(va); 515 return result; 516 } 517 518 TEST_F(DEATHTEST, vsnprintf_fortified) { 519 ASSERT_FORTIFY(vsnprintf_helper("%s", "0123456789")); 520 } 521 522 TEST_F(DEATHTEST, vsnprintf2_fortified) { 523 ASSERT_FORTIFY(vsnprintf_helper("0123456789")); 524 } 525 526 TEST_F(DEATHTEST, strncat_fortified) { 527 char buf[10]; 528 size_t n = atoi("10"); // avoid compiler optimizations 529 strncpy(buf, "012345678", n); 530 ASSERT_FORTIFY(strncat(buf, "9", n)); 531 } 532 533 TEST_F(DEATHTEST, strncat2_fortified) { 534 char buf[10]; 535 buf[0] = '\0'; 536 size_t n = atoi("10"); // avoid compiler optimizations 537 ASSERT_FORTIFY(strncat(buf, "0123456789", n)); 538 } 539 540 TEST_F(DEATHTEST, strcat_fortified) { 541 char src[11]; 542 strcpy(src, "0123456789"); 543 char buf[10]; 544 buf[0] = '\0'; 545 ASSERT_FORTIFY(strcat(buf, src)); 546 } 547 548 TEST_F(DEATHTEST, memmove_fortified) { 549 char buf[20]; 550 strcpy(buf, "0123456789"); 551 size_t n = atoi("10"); 552 ASSERT_FORTIFY(memmove(buf + 11, buf, n)); 553 } 554 555 TEST_F(DEATHTEST, memcpy_fortified) { 556 char bufa[10]; 557 char bufb[10]; 558 strcpy(bufa, "012345678"); 559 size_t n = atoi("11"); 560 ASSERT_FORTIFY(memcpy(bufb, bufa, n)); 561 } 562 563 TEST_F(DEATHTEST, memset_fortified) { 564 char buf[10]; 565 size_t n = atoi("11"); 566 ASSERT_FORTIFY(memset(buf, 0, n)); 567 } 568 569 TEST_F(DEATHTEST, stpncpy_fortified) { 570 char bufa[15]; 571 char bufb[10]; 572 strcpy(bufa, "01234567890123"); 573 size_t n = strlen(bufa); 574 ASSERT_FORTIFY(stpncpy(bufb, bufa, n)); 575 } 576 577 TEST_F(DEATHTEST, stpncpy2_fortified) { 578 char dest[11]; 579 char src[10]; 580 memcpy(src, "0123456789", sizeof(src)); // src is not null terminated 581 ASSERT_FORTIFY(stpncpy(dest, src, sizeof(dest))); 582 } 583 584 TEST_F(DEATHTEST, strncpy_fortified) { 585 char bufa[15]; 586 char bufb[10]; 587 strcpy(bufa, "01234567890123"); 588 size_t n = strlen(bufa); 589 ASSERT_FORTIFY(strncpy(bufb, bufa, n)); 590 } 591 592 593 TEST_F(DEATHTEST, strncpy2_fortified) { 594 char dest[11]; 595 char src[10]; 596 memcpy(src, "0123456789", sizeof(src)); // src is not null terminated 597 ASSERT_FORTIFY(strncpy(dest, src, sizeof(dest))); 598 } 599 600 TEST_F(DEATHTEST, snprintf_fortified) { 601 char bufa[15]; 602 char bufb[10]; 603 strcpy(bufa, "0123456789"); 604 size_t n = strlen(bufa) + 1; 605 ASSERT_FORTIFY(snprintf(bufb, n, "%s", bufa)); 606 } 607 608 TEST_F(DEATHTEST, bzero_fortified) { 609 char buf[10]; 610 memcpy(buf, "0123456789", sizeof(buf)); 611 size_t n = atoi("11"); 612 ASSERT_FORTIFY(bzero(buf, n)); 613 } 614 615 TEST_F(DEATHTEST, umask_fortified) { 616 mode_t mask = atoi("1023"); // 01777 in octal 617 ASSERT_FORTIFY(umask(mask)); 618 } 619 620 TEST_F(DEATHTEST, recv_fortified) { 621 size_t data_len = atoi("11"); // suppress compiler optimizations 622 char buf[10]; 623 ASSERT_FORTIFY(recv(0, buf, data_len, 0)); 624 } 625 626 TEST_F(DEATHTEST, send_fortified) { 627 size_t data_len = atoi("11"); // suppress compiler optimizations 628 char buf[10] = {0}; 629 ASSERT_FORTIFY(send(0, buf, data_len, 0)); 630 } 631 632 TEST_F(DEATHTEST, FD_ISSET_fortified) { 633 #if defined(__BIONIC__) // glibc catches this at compile-time. 634 fd_set set; 635 memset(&set, 0, sizeof(set)); 636 ASSERT_FORTIFY(FD_ISSET(-1, &set)); 637 #endif 638 } 639 640 TEST_F(DEATHTEST, FD_ISSET_2_fortified) { 641 char buf[1]; 642 fd_set* set = (fd_set*) buf; 643 ASSERT_FORTIFY(FD_ISSET(0, set)); 644 } 645 646 TEST_F(DEATHTEST, getcwd_fortified) { 647 char buf[1]; 648 size_t ct = atoi("2"); // prevent optimizations 649 ASSERT_FORTIFY(getcwd(buf, ct)); 650 } 651 652 TEST_F(DEATHTEST, pread_fortified) { 653 char buf[1]; 654 size_t ct = atoi("2"); // prevent optimizations 655 int fd = open("/dev/null", O_RDONLY); 656 ASSERT_FORTIFY(pread(fd, buf, ct, 0)); 657 close(fd); 658 } 659 660 TEST_F(DEATHTEST, pread64_fortified) { 661 char buf[1]; 662 size_t ct = atoi("2"); // prevent optimizations 663 int fd = open("/dev/null", O_RDONLY); 664 ASSERT_FORTIFY(pread64(fd, buf, ct, 0)); 665 close(fd); 666 } 667 668 TEST_F(DEATHTEST, pwrite_fortified) { 669 char buf[1] = {0}; 670 size_t ct = atoi("2"); // prevent optimizations 671 int fd = open("/dev/null", O_WRONLY); 672 ASSERT_FORTIFY(pwrite(fd, buf, ct, 0)); 673 close(fd); 674 } 675 676 TEST_F(DEATHTEST, pwrite64_fortified) { 677 char buf[1] = {0}; 678 size_t ct = atoi("2"); // prevent optimizations 679 int fd = open("/dev/null", O_WRONLY); 680 ASSERT_FORTIFY(pwrite64(fd, buf, ct, 0)); 681 close(fd); 682 } 683 684 TEST_F(DEATHTEST, read_fortified) { 685 char buf[1]; 686 size_t ct = atoi("2"); // prevent optimizations 687 int fd = open("/dev/null", O_RDONLY); 688 ASSERT_FORTIFY(read(fd, buf, ct)); 689 close(fd); 690 } 691 692 TEST_F(DEATHTEST, write_fortified) { 693 char buf[1] = {0}; 694 size_t ct = atoi("2"); // prevent optimizations 695 int fd = open("/dev/null", O_WRONLY); 696 ASSERT_EXIT(write(fd, buf, ct), testing::KilledBySignal(SIGABRT), ""); 697 close(fd); 698 } 699 700 TEST_F(DEATHTEST, fread_fortified) { 701 char buf[1]; 702 size_t ct = atoi("2"); // prevent optimizations 703 FILE* fp = fopen("/dev/null", "r"); 704 ASSERT_FORTIFY(fread(buf, 1, ct, fp)); 705 fclose(fp); 706 } 707 708 TEST_F(DEATHTEST, fwrite_fortified) { 709 char buf[1] = {0}; 710 size_t ct = atoi("2"); // prevent optimizations 711 FILE* fp = fopen("/dev/null", "w"); 712 ASSERT_FORTIFY(fwrite(buf, 1, ct, fp)); 713 fclose(fp); 714 } 715 716 TEST_F(DEATHTEST, readlink_fortified) { 717 char buf[1]; 718 size_t ct = atoi("2"); // prevent optimizations 719 ASSERT_FORTIFY(readlink("/dev/null", buf, ct)); 720 } 721 722 TEST_F(DEATHTEST, readlinkat_fortified) { 723 char buf[1]; 724 size_t ct = atoi("2"); // prevent optimizations 725 ASSERT_FORTIFY(readlinkat(AT_FDCWD, "/dev/null", buf, ct)); 726 } 727 728 extern "C" char* __strncat_chk(char*, const char*, size_t, size_t); 729 extern "C" char* __strcat_chk(char*, const char*, size_t); 730 731 TEST(TEST_NAME, strncat) { 732 char buf[10]; 733 memset(buf, 'A', sizeof(buf)); 734 buf[0] = 'a'; 735 buf[1] = '\0'; 736 char* res = __strncat_chk(buf, "01234", sizeof(buf) - strlen(buf) - 1, sizeof(buf)); 737 ASSERT_EQ(buf, res); 738 ASSERT_EQ('a', buf[0]); 739 ASSERT_EQ('0', buf[1]); 740 ASSERT_EQ('1', buf[2]); 741 ASSERT_EQ('2', buf[3]); 742 ASSERT_EQ('3', buf[4]); 743 ASSERT_EQ('4', buf[5]); 744 ASSERT_EQ('\0', buf[6]); 745 ASSERT_EQ('A', buf[7]); 746 ASSERT_EQ('A', buf[8]); 747 ASSERT_EQ('A', buf[9]); 748 } 749 750 TEST(TEST_NAME, strncat2) { 751 char buf[10]; 752 memset(buf, 'A', sizeof(buf)); 753 buf[0] = 'a'; 754 buf[1] = '\0'; 755 char* res = __strncat_chk(buf, "0123456789", 5, sizeof(buf)); 756 ASSERT_EQ(buf, res); 757 ASSERT_EQ('a', buf[0]); 758 ASSERT_EQ('0', buf[1]); 759 ASSERT_EQ('1', buf[2]); 760 ASSERT_EQ('2', buf[3]); 761 ASSERT_EQ('3', buf[4]); 762 ASSERT_EQ('4', buf[5]); 763 ASSERT_EQ('\0', buf[6]); 764 ASSERT_EQ('A', buf[7]); 765 ASSERT_EQ('A', buf[8]); 766 ASSERT_EQ('A', buf[9]); 767 } 768 769 TEST(TEST_NAME, strncat3) { 770 char buf[10]; 771 memset(buf, 'A', sizeof(buf)); 772 buf[0] = '\0'; 773 char* res = __strncat_chk(buf, "0123456789", 5, sizeof(buf)); 774 ASSERT_EQ(buf, res); 775 ASSERT_EQ('0', buf[0]); 776 ASSERT_EQ('1', buf[1]); 777 ASSERT_EQ('2', buf[2]); 778 ASSERT_EQ('3', buf[3]); 779 ASSERT_EQ('4', buf[4]); 780 ASSERT_EQ('\0', buf[5]); 781 ASSERT_EQ('A', buf[6]); 782 ASSERT_EQ('A', buf[7]); 783 ASSERT_EQ('A', buf[8]); 784 ASSERT_EQ('A', buf[9]); 785 } 786 787 TEST(TEST_NAME, strncat4) { 788 char buf[10]; 789 memset(buf, 'A', sizeof(buf)); 790 buf[9] = '\0'; 791 char* res = __strncat_chk(buf, "", 5, sizeof(buf)); 792 ASSERT_EQ(buf, res); 793 ASSERT_EQ('A', buf[0]); 794 ASSERT_EQ('A', buf[1]); 795 ASSERT_EQ('A', buf[2]); 796 ASSERT_EQ('A', buf[3]); 797 ASSERT_EQ('A', buf[4]); 798 ASSERT_EQ('A', buf[5]); 799 ASSERT_EQ('A', buf[6]); 800 ASSERT_EQ('A', buf[7]); 801 ASSERT_EQ('A', buf[8]); 802 ASSERT_EQ('\0', buf[9]); 803 } 804 805 TEST(TEST_NAME, strncat5) { 806 char buf[10]; 807 memset(buf, 'A', sizeof(buf)); 808 buf[0] = 'a'; 809 buf[1] = '\0'; 810 char* res = __strncat_chk(buf, "01234567", 8, sizeof(buf)); 811 ASSERT_EQ(buf, res); 812 ASSERT_EQ('a', buf[0]); 813 ASSERT_EQ('0', buf[1]); 814 ASSERT_EQ('1', buf[2]); 815 ASSERT_EQ('2', buf[3]); 816 ASSERT_EQ('3', buf[4]); 817 ASSERT_EQ('4', buf[5]); 818 ASSERT_EQ('5', buf[6]); 819 ASSERT_EQ('6', buf[7]); 820 ASSERT_EQ('7', buf[8]); 821 ASSERT_EQ('\0', buf[9]); 822 } 823 824 TEST(TEST_NAME, strncat6) { 825 char buf[10]; 826 memset(buf, 'A', sizeof(buf)); 827 buf[0] = 'a'; 828 buf[1] = '\0'; 829 char* res = __strncat_chk(buf, "01234567", 9, sizeof(buf)); 830 ASSERT_EQ(buf, res); 831 ASSERT_EQ('a', buf[0]); 832 ASSERT_EQ('0', buf[1]); 833 ASSERT_EQ('1', buf[2]); 834 ASSERT_EQ('2', buf[3]); 835 ASSERT_EQ('3', buf[4]); 836 ASSERT_EQ('4', buf[5]); 837 ASSERT_EQ('5', buf[6]); 838 ASSERT_EQ('6', buf[7]); 839 ASSERT_EQ('7', buf[8]); 840 ASSERT_EQ('\0', buf[9]); 841 } 842 843 844 TEST(TEST_NAME, strcat) { 845 char buf[10]; 846 memset(buf, 'A', sizeof(buf)); 847 buf[0] = 'a'; 848 buf[1] = '\0'; 849 char* res = __strcat_chk(buf, "01234", sizeof(buf)); 850 ASSERT_EQ(buf, res); 851 ASSERT_EQ('a', buf[0]); 852 ASSERT_EQ('0', buf[1]); 853 ASSERT_EQ('1', buf[2]); 854 ASSERT_EQ('2', buf[3]); 855 ASSERT_EQ('3', buf[4]); 856 ASSERT_EQ('4', buf[5]); 857 ASSERT_EQ('\0', buf[6]); 858 ASSERT_EQ('A', buf[7]); 859 ASSERT_EQ('A', buf[8]); 860 ASSERT_EQ('A', buf[9]); 861 } 862 863 TEST(TEST_NAME, strcat2) { 864 char buf[10]; 865 memset(buf, 'A', sizeof(buf)); 866 buf[0] = 'a'; 867 buf[1] = '\0'; 868 char* res = __strcat_chk(buf, "01234567", sizeof(buf)); 869 ASSERT_EQ(buf, res); 870 ASSERT_EQ('a', buf[0]); 871 ASSERT_EQ('0', buf[1]); 872 ASSERT_EQ('1', buf[2]); 873 ASSERT_EQ('2', buf[3]); 874 ASSERT_EQ('3', buf[4]); 875 ASSERT_EQ('4', buf[5]); 876 ASSERT_EQ('5', buf[6]); 877 ASSERT_EQ('6', buf[7]); 878 ASSERT_EQ('7', buf[8]); 879 ASSERT_EQ('\0', buf[9]); 880 } 881 882 TEST(TEST_NAME, stpncpy) { 883 char src[10]; 884 char dst[10]; 885 memcpy(src, "0123456789", sizeof(src)); // non null terminated string 886 stpncpy(dst, src, sizeof(dst)); 887 ASSERT_EQ('0', dst[0]); 888 ASSERT_EQ('1', dst[1]); 889 ASSERT_EQ('2', dst[2]); 890 ASSERT_EQ('3', dst[3]); 891 ASSERT_EQ('4', dst[4]); 892 ASSERT_EQ('5', dst[5]); 893 ASSERT_EQ('6', dst[6]); 894 ASSERT_EQ('7', dst[7]); 895 ASSERT_EQ('8', dst[8]); 896 ASSERT_EQ('9', dst[9]); 897 } 898 899 TEST(TEST_NAME, stpncpy2) { 900 char src[10]; 901 char dst[15]; 902 memcpy(src, "012345678\0", sizeof(src)); 903 stpncpy(dst, src, sizeof(dst)); 904 ASSERT_EQ('0', dst[0]); 905 ASSERT_EQ('1', dst[1]); 906 ASSERT_EQ('2', dst[2]); 907 ASSERT_EQ('3', dst[3]); 908 ASSERT_EQ('4', dst[4]); 909 ASSERT_EQ('5', dst[5]); 910 ASSERT_EQ('6', dst[6]); 911 ASSERT_EQ('7', dst[7]); 912 ASSERT_EQ('8', dst[8]); 913 ASSERT_EQ('\0', dst[9]); 914 ASSERT_EQ('\0', dst[10]); 915 ASSERT_EQ('\0', dst[11]); 916 ASSERT_EQ('\0', dst[12]); 917 ASSERT_EQ('\0', dst[13]); 918 ASSERT_EQ('\0', dst[14]); 919 } 920 921 TEST(TEST_NAME, strncpy) { 922 char src[10]; 923 char dst[10]; 924 memcpy(src, "0123456789", sizeof(src)); // non null terminated string 925 strncpy(dst, src, sizeof(dst)); 926 ASSERT_EQ('0', dst[0]); 927 ASSERT_EQ('1', dst[1]); 928 ASSERT_EQ('2', dst[2]); 929 ASSERT_EQ('3', dst[3]); 930 ASSERT_EQ('4', dst[4]); 931 ASSERT_EQ('5', dst[5]); 932 ASSERT_EQ('6', dst[6]); 933 ASSERT_EQ('7', dst[7]); 934 ASSERT_EQ('8', dst[8]); 935 ASSERT_EQ('9', dst[9]); 936 } 937 938 TEST(TEST_NAME, strncpy2) { 939 char src[10]; 940 char dst[15]; 941 memcpy(src, "012345678\0", sizeof(src)); 942 strncpy(dst, src, sizeof(dst)); 943 ASSERT_EQ('0', dst[0]); 944 ASSERT_EQ('1', dst[1]); 945 ASSERT_EQ('2', dst[2]); 946 ASSERT_EQ('3', dst[3]); 947 ASSERT_EQ('4', dst[4]); 948 ASSERT_EQ('5', dst[5]); 949 ASSERT_EQ('6', dst[6]); 950 ASSERT_EQ('7', dst[7]); 951 ASSERT_EQ('8', dst[8]); 952 ASSERT_EQ('\0', dst[9]); 953 ASSERT_EQ('\0', dst[10]); 954 ASSERT_EQ('\0', dst[11]); 955 ASSERT_EQ('\0', dst[12]); 956 ASSERT_EQ('\0', dst[13]); 957 ASSERT_EQ('\0', dst[14]); 958 } 959 960 TEST(TEST_NAME, strcat_chk_max_int_size) { 961 char buf[10]; 962 memset(buf, 'A', sizeof(buf)); 963 buf[0] = 'a'; 964 buf[1] = '\0'; 965 char* res = __strcat_chk(buf, "01234567", (size_t)-1); 966 ASSERT_EQ(buf, res); 967 ASSERT_EQ('a', buf[0]); 968 ASSERT_EQ('0', buf[1]); 969 ASSERT_EQ('1', buf[2]); 970 ASSERT_EQ('2', buf[3]); 971 ASSERT_EQ('3', buf[4]); 972 ASSERT_EQ('4', buf[5]); 973 ASSERT_EQ('5', buf[6]); 974 ASSERT_EQ('6', buf[7]); 975 ASSERT_EQ('7', buf[8]); 976 ASSERT_EQ('\0', buf[9]); 977 } 978 979 extern "C" char* __stpcpy_chk(char*, const char*, size_t); 980 981 TEST(TEST_NAME, stpcpy_chk_max_int_size) { 982 char buf[10]; 983 char* res = __stpcpy_chk(buf, "012345678", (size_t)-1); 984 ASSERT_EQ(buf + strlen("012345678"), res); 985 ASSERT_STREQ("012345678", buf); 986 } 987 988 extern "C" char* __strcpy_chk(char*, const char*, size_t); 989 990 TEST(TEST_NAME, strcpy_chk_max_int_size) { 991 char buf[10]; 992 char* res = __strcpy_chk(buf, "012345678", (size_t)-1); 993 ASSERT_EQ(buf, res); 994 ASSERT_STREQ("012345678", buf); 995 } 996 997 extern "C" void* __memcpy_chk(void*, const void*, size_t, size_t); 998 999 TEST(TEST_NAME, memcpy_chk_max_int_size) { 1000 char buf[10]; 1001 void* res = __memcpy_chk(buf, "012345678", sizeof(buf), (size_t)-1); 1002 ASSERT_EQ((void*)buf, res); 1003 ASSERT_EQ('0', buf[0]); 1004 ASSERT_EQ('1', buf[1]); 1005 ASSERT_EQ('2', buf[2]); 1006 ASSERT_EQ('3', buf[3]); 1007 ASSERT_EQ('4', buf[4]); 1008 ASSERT_EQ('5', buf[5]); 1009 ASSERT_EQ('6', buf[6]); 1010 ASSERT_EQ('7', buf[7]); 1011 ASSERT_EQ('8', buf[8]); 1012 ASSERT_EQ('\0', buf[9]); 1013 } 1014 1015 // Verify that macro expansion is done properly for sprintf/snprintf (which 1016 // are defined as macros in stdio.h under clang). 1017 #define CONTENTS "macro expansion" 1018 #define BUF_AND_SIZE(A) A, sizeof(A) 1019 #define BUF_AND_CONTENTS(A) A, CONTENTS 1020 #define BUF_AND_SIZE_AND_CONTENTS(A) A, sizeof(A), CONTENTS 1021 TEST(TEST_NAME, s_n_printf_macro_expansion) { 1022 char buf[BUFSIZ]; 1023 snprintf(BUF_AND_SIZE(buf), CONTENTS); 1024 EXPECT_STREQ(CONTENTS, buf); 1025 1026 snprintf(BUF_AND_SIZE_AND_CONTENTS(buf)); 1027 EXPECT_STREQ(CONTENTS, buf); 1028 1029 sprintf(BUF_AND_CONTENTS(buf)); 1030 EXPECT_STREQ(CONTENTS, buf); 1031 } 1032 1033 TEST_F(DEATHTEST, poll_fortified) { 1034 nfds_t fd_count = atoi("2"); // suppress compiler optimizations 1035 pollfd buf[1] = {{0, POLLIN, 0}}; 1036 // Set timeout to zero to prevent waiting in poll when fortify test fails. 1037 ASSERT_FORTIFY(poll(buf, fd_count, 0)); 1038 } 1039 1040 TEST_F(DEATHTEST, ppoll_fortified) { 1041 nfds_t fd_count = atoi("2"); // suppress compiler optimizations 1042 pollfd buf[1] = {{0, POLLIN, 0}}; 1043 // Set timeout to zero to prevent waiting in ppoll when fortify test fails. 1044 timespec timeout; 1045 timeout.tv_sec = timeout.tv_nsec = 0; 1046 ASSERT_FORTIFY(ppoll(buf, fd_count, &timeout, NULL)); 1047 } 1048
