1 /* @generated by `generate-fortify-tests.lua "wchar"` */ 2 3 #define _FORTIFY_SOURCE 2 4 #define TMPFILE_SIZE (1024 * 32) 5 6 #include <sys/param.h> 7 #include <sys/resource.h> 8 #include <sys/time.h> 9 #include <sys/wait.h> 10 #include <dirent.h> 11 #include <errno.h> 12 #include <fcntl.h> 13 #include <limits.h> 14 #include <poll.h> 15 #include <signal.h> 16 #include <stdio.h> 17 #include <stdlib.h> 18 #include <string.h> 19 #include <strings.h> 20 #include <sysexits.h> 21 #include <unistd.h> 22 #include <wchar.h> 23 #include <atf-c.h> 24 25 static FILE * __unused 26 new_fp(size_t __len) 27 { 28 static char fpbuf[LINE_MAX]; 29 FILE *fp; 30 31 ATF_REQUIRE(__len <= sizeof(fpbuf)); 32 33 memset(fpbuf, 'A', sizeof(fpbuf) - 1); 34 fpbuf[sizeof(fpbuf) - 1] = '\0'; 35 36 fp = fmemopen(fpbuf, sizeof(fpbuf), "rb"); 37 ATF_REQUIRE(fp != NULL); 38 39 return (fp); 40 } 41 42 /* 43 * Create a new symlink to use for readlink(2) style tests, we'll just use a 44 * random target name to have something interesting to look at. 45 */ 46 static const char * __unused 47 new_symlink(size_t __len) 48 { 49 static const char linkname[] = "link"; 50 char target[MAXNAMLEN]; 51 int error; 52 53 ATF_REQUIRE(__len <= sizeof(target)); 54 55 arc4random_buf(target, sizeof(target)); 56 57 error = unlink(linkname); 58 ATF_REQUIRE(error == 0 || errno == ENOENT); 59 60 error = symlink(target, linkname); 61 ATF_REQUIRE(error == 0); 62 63 return (linkname); 64 } 65 66 /* 67 * Constructs a tmpfile that we can use for testing read(2) and friends. 68 */ 69 static int __unused 70 new_tmpfile(void) 71 { 72 char buf[1024]; 73 ssize_t rv; 74 size_t written; 75 int fd; 76 77 fd = open("tmpfile", O_RDWR | O_CREAT | O_TRUNC, 0644); 78 ATF_REQUIRE(fd >= 0); 79 80 written = 0; 81 while (written < TMPFILE_SIZE) { 82 rv = write(fd, buf, sizeof(buf)); 83 ATF_REQUIRE(rv > 0); 84 85 written += rv; 86 } 87 88 ATF_REQUIRE_EQ(0, lseek(fd, 0, SEEK_SET)); 89 return (fd); 90 } 91 92 static void 93 disable_coredumps(void) 94 { 95 struct rlimit rl = { 0 }; 96 97 if (setrlimit(RLIMIT_CORE, &rl) == -1) 98 _exit(EX_OSERR); 99 } 100 101 /* 102 * Replaces stdin with a file that we can actually read from, for tests where 103 * we want a FILE * or fd that we can get data from. 104 */ 105 static void __unused 106 replace_stdin(void) 107 { 108 int fd; 109 110 fd = new_tmpfile(); 111 112 (void)dup2(fd, STDIN_FILENO); 113 if (fd != STDIN_FILENO) 114 close(fd); 115 } 116 117 ATF_TC_WITHOUT_HEAD(wmemcpy_before_end); 118 ATF_TC_BODY(wmemcpy_before_end, tc) 119 { 120 #define BUF &__stack.__buf 121 struct { 122 uint8_t padding_l; 123 wchar_t __buf[42]; 124 uint8_t padding_r; 125 } __stack; 126 const size_t __bufsz __unused = sizeof(__stack.__buf); 127 const size_t __len = 42 - 1; 128 const size_t __idx __unused = __len - 1; 129 wchar_t src[__len + 10]; 130 131 wmemcpy(__stack.__buf, src, __len); 132 #undef BUF 133 134 } 135 136 ATF_TC_WITHOUT_HEAD(wmemcpy_end); 137 ATF_TC_BODY(wmemcpy_end, tc) 138 { 139 #define BUF &__stack.__buf 140 struct { 141 uint8_t padding_l; 142 wchar_t __buf[42]; 143 uint8_t padding_r; 144 } __stack; 145 const size_t __bufsz __unused = sizeof(__stack.__buf); 146 const size_t __len = 42; 147 const size_t __idx __unused = __len - 1; 148 wchar_t src[__len + 10]; 149 150 wmemcpy(__stack.__buf, src, __len); 151 #undef BUF 152 153 } 154 155 ATF_TC_WITHOUT_HEAD(wmemcpy_heap_before_end); 156 ATF_TC_BODY(wmemcpy_heap_before_end, tc) 157 { 158 #define BUF __stack.__buf 159 struct { 160 uint8_t padding_l; 161 wchar_t * __buf; 162 uint8_t padding_r; 163 } __stack; 164 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 165 const size_t __len = 42 - 1; 166 const size_t __idx __unused = __len - 1; 167 wchar_t src[__len + 10]; 168 169 __stack.__buf = malloc(__bufsz); 170 171 wmemcpy(__stack.__buf, src, __len); 172 #undef BUF 173 174 } 175 176 ATF_TC_WITHOUT_HEAD(wmemcpy_heap_end); 177 ATF_TC_BODY(wmemcpy_heap_end, tc) 178 { 179 #define BUF __stack.__buf 180 struct { 181 uint8_t padding_l; 182 wchar_t * __buf; 183 uint8_t padding_r; 184 } __stack; 185 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 186 const size_t __len = 42; 187 const size_t __idx __unused = __len - 1; 188 wchar_t src[__len + 10]; 189 190 __stack.__buf = malloc(__bufsz); 191 192 wmemcpy(__stack.__buf, src, __len); 193 #undef BUF 194 195 } 196 197 ATF_TC_WITHOUT_HEAD(wmemcpy_heap_after_end); 198 ATF_TC_BODY(wmemcpy_heap_after_end, tc) 199 { 200 #define BUF __stack.__buf 201 struct { 202 uint8_t padding_l; 203 wchar_t * __buf; 204 uint8_t padding_r; 205 } __stack; 206 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 207 const size_t __len = 42 + 1; 208 const size_t __idx __unused = __len - 1; 209 pid_t __child; 210 int __status; 211 wchar_t src[__len + 10]; 212 213 __child = fork(); 214 ATF_REQUIRE(__child >= 0); 215 if (__child > 0) 216 goto monitor; 217 218 /* Child */ 219 disable_coredumps(); 220 __stack.__buf = malloc(__bufsz); 221 222 wmemcpy(__stack.__buf, src, __len); 223 _exit(EX_SOFTWARE); /* Should have aborted. */ 224 225 monitor: 226 while (waitpid(__child, &__status, 0) != __child) { 227 ATF_REQUIRE_EQ(EINTR, errno); 228 } 229 230 if (!WIFSIGNALED(__status)) { 231 switch (WEXITSTATUS(__status)) { 232 case EX_SOFTWARE: 233 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 234 break; 235 case EX_OSERR: 236 atf_tc_fail("setrlimit(2) failed"); 237 break; 238 default: 239 atf_tc_fail("child exited with status %d", 240 WEXITSTATUS(__status)); 241 } 242 } else { 243 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 244 } 245 #undef BUF 246 247 } 248 249 ATF_TC_WITHOUT_HEAD(wmempcpy_before_end); 250 ATF_TC_BODY(wmempcpy_before_end, tc) 251 { 252 #define BUF &__stack.__buf 253 struct { 254 uint8_t padding_l; 255 wchar_t __buf[42]; 256 uint8_t padding_r; 257 } __stack; 258 const size_t __bufsz __unused = sizeof(__stack.__buf); 259 const size_t __len = 42 - 1; 260 const size_t __idx __unused = __len - 1; 261 wchar_t src[__len + 10]; 262 263 wmempcpy(__stack.__buf, src, __len); 264 #undef BUF 265 266 } 267 268 ATF_TC_WITHOUT_HEAD(wmempcpy_end); 269 ATF_TC_BODY(wmempcpy_end, tc) 270 { 271 #define BUF &__stack.__buf 272 struct { 273 uint8_t padding_l; 274 wchar_t __buf[42]; 275 uint8_t padding_r; 276 } __stack; 277 const size_t __bufsz __unused = sizeof(__stack.__buf); 278 const size_t __len = 42; 279 const size_t __idx __unused = __len - 1; 280 wchar_t src[__len + 10]; 281 282 wmempcpy(__stack.__buf, src, __len); 283 #undef BUF 284 285 } 286 287 ATF_TC_WITHOUT_HEAD(wmempcpy_heap_before_end); 288 ATF_TC_BODY(wmempcpy_heap_before_end, tc) 289 { 290 #define BUF __stack.__buf 291 struct { 292 uint8_t padding_l; 293 wchar_t * __buf; 294 uint8_t padding_r; 295 } __stack; 296 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 297 const size_t __len = 42 - 1; 298 const size_t __idx __unused = __len - 1; 299 wchar_t src[__len + 10]; 300 301 __stack.__buf = malloc(__bufsz); 302 303 wmempcpy(__stack.__buf, src, __len); 304 #undef BUF 305 306 } 307 308 ATF_TC_WITHOUT_HEAD(wmempcpy_heap_end); 309 ATF_TC_BODY(wmempcpy_heap_end, tc) 310 { 311 #define BUF __stack.__buf 312 struct { 313 uint8_t padding_l; 314 wchar_t * __buf; 315 uint8_t padding_r; 316 } __stack; 317 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 318 const size_t __len = 42; 319 const size_t __idx __unused = __len - 1; 320 wchar_t src[__len + 10]; 321 322 __stack.__buf = malloc(__bufsz); 323 324 wmempcpy(__stack.__buf, src, __len); 325 #undef BUF 326 327 } 328 329 ATF_TC_WITHOUT_HEAD(wmempcpy_heap_after_end); 330 ATF_TC_BODY(wmempcpy_heap_after_end, tc) 331 { 332 #define BUF __stack.__buf 333 struct { 334 uint8_t padding_l; 335 wchar_t * __buf; 336 uint8_t padding_r; 337 } __stack; 338 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 339 const size_t __len = 42 + 1; 340 const size_t __idx __unused = __len - 1; 341 pid_t __child; 342 int __status; 343 wchar_t src[__len + 10]; 344 345 __child = fork(); 346 ATF_REQUIRE(__child >= 0); 347 if (__child > 0) 348 goto monitor; 349 350 /* Child */ 351 disable_coredumps(); 352 __stack.__buf = malloc(__bufsz); 353 354 wmempcpy(__stack.__buf, src, __len); 355 _exit(EX_SOFTWARE); /* Should have aborted. */ 356 357 monitor: 358 while (waitpid(__child, &__status, 0) != __child) { 359 ATF_REQUIRE_EQ(EINTR, errno); 360 } 361 362 if (!WIFSIGNALED(__status)) { 363 switch (WEXITSTATUS(__status)) { 364 case EX_SOFTWARE: 365 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 366 break; 367 case EX_OSERR: 368 atf_tc_fail("setrlimit(2) failed"); 369 break; 370 default: 371 atf_tc_fail("child exited with status %d", 372 WEXITSTATUS(__status)); 373 } 374 } else { 375 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 376 } 377 #undef BUF 378 379 } 380 381 ATF_TC_WITHOUT_HEAD(wmemmove_before_end); 382 ATF_TC_BODY(wmemmove_before_end, tc) 383 { 384 #define BUF &__stack.__buf 385 struct { 386 uint8_t padding_l; 387 wchar_t __buf[42]; 388 uint8_t padding_r; 389 } __stack; 390 const size_t __bufsz __unused = sizeof(__stack.__buf); 391 const size_t __len = 42 - 1; 392 const size_t __idx __unused = __len - 1; 393 wchar_t src[__len + 10]; 394 395 wmemmove(__stack.__buf, src, __len); 396 #undef BUF 397 398 } 399 400 ATF_TC_WITHOUT_HEAD(wmemmove_end); 401 ATF_TC_BODY(wmemmove_end, tc) 402 { 403 #define BUF &__stack.__buf 404 struct { 405 uint8_t padding_l; 406 wchar_t __buf[42]; 407 uint8_t padding_r; 408 } __stack; 409 const size_t __bufsz __unused = sizeof(__stack.__buf); 410 const size_t __len = 42; 411 const size_t __idx __unused = __len - 1; 412 wchar_t src[__len + 10]; 413 414 wmemmove(__stack.__buf, src, __len); 415 #undef BUF 416 417 } 418 419 ATF_TC_WITHOUT_HEAD(wmemmove_heap_before_end); 420 ATF_TC_BODY(wmemmove_heap_before_end, tc) 421 { 422 #define BUF __stack.__buf 423 struct { 424 uint8_t padding_l; 425 wchar_t * __buf; 426 uint8_t padding_r; 427 } __stack; 428 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 429 const size_t __len = 42 - 1; 430 const size_t __idx __unused = __len - 1; 431 wchar_t src[__len + 10]; 432 433 __stack.__buf = malloc(__bufsz); 434 435 wmemmove(__stack.__buf, src, __len); 436 #undef BUF 437 438 } 439 440 ATF_TC_WITHOUT_HEAD(wmemmove_heap_end); 441 ATF_TC_BODY(wmemmove_heap_end, tc) 442 { 443 #define BUF __stack.__buf 444 struct { 445 uint8_t padding_l; 446 wchar_t * __buf; 447 uint8_t padding_r; 448 } __stack; 449 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 450 const size_t __len = 42; 451 const size_t __idx __unused = __len - 1; 452 wchar_t src[__len + 10]; 453 454 __stack.__buf = malloc(__bufsz); 455 456 wmemmove(__stack.__buf, src, __len); 457 #undef BUF 458 459 } 460 461 ATF_TC_WITHOUT_HEAD(wmemmove_heap_after_end); 462 ATF_TC_BODY(wmemmove_heap_after_end, tc) 463 { 464 #define BUF __stack.__buf 465 struct { 466 uint8_t padding_l; 467 wchar_t * __buf; 468 uint8_t padding_r; 469 } __stack; 470 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 471 const size_t __len = 42 + 1; 472 const size_t __idx __unused = __len - 1; 473 pid_t __child; 474 int __status; 475 wchar_t src[__len + 10]; 476 477 __child = fork(); 478 ATF_REQUIRE(__child >= 0); 479 if (__child > 0) 480 goto monitor; 481 482 /* Child */ 483 disable_coredumps(); 484 __stack.__buf = malloc(__bufsz); 485 486 wmemmove(__stack.__buf, src, __len); 487 _exit(EX_SOFTWARE); /* Should have aborted. */ 488 489 monitor: 490 while (waitpid(__child, &__status, 0) != __child) { 491 ATF_REQUIRE_EQ(EINTR, errno); 492 } 493 494 if (!WIFSIGNALED(__status)) { 495 switch (WEXITSTATUS(__status)) { 496 case EX_SOFTWARE: 497 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 498 break; 499 case EX_OSERR: 500 atf_tc_fail("setrlimit(2) failed"); 501 break; 502 default: 503 atf_tc_fail("child exited with status %d", 504 WEXITSTATUS(__status)); 505 } 506 } else { 507 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 508 } 509 #undef BUF 510 511 } 512 513 ATF_TC_WITHOUT_HEAD(wmemset_before_end); 514 ATF_TC_BODY(wmemset_before_end, tc) 515 { 516 #define BUF &__stack.__buf 517 struct { 518 uint8_t padding_l; 519 wchar_t __buf[42]; 520 uint8_t padding_r; 521 } __stack; 522 const size_t __bufsz __unused = sizeof(__stack.__buf); 523 const size_t __len = 42 - 1; 524 const size_t __idx __unused = __len - 1; 525 526 wmemset(__stack.__buf, L'0', __len); 527 #undef BUF 528 529 } 530 531 ATF_TC_WITHOUT_HEAD(wmemset_end); 532 ATF_TC_BODY(wmemset_end, tc) 533 { 534 #define BUF &__stack.__buf 535 struct { 536 uint8_t padding_l; 537 wchar_t __buf[42]; 538 uint8_t padding_r; 539 } __stack; 540 const size_t __bufsz __unused = sizeof(__stack.__buf); 541 const size_t __len = 42; 542 const size_t __idx __unused = __len - 1; 543 544 wmemset(__stack.__buf, L'0', __len); 545 #undef BUF 546 547 } 548 549 ATF_TC_WITHOUT_HEAD(wmemset_heap_before_end); 550 ATF_TC_BODY(wmemset_heap_before_end, tc) 551 { 552 #define BUF __stack.__buf 553 struct { 554 uint8_t padding_l; 555 wchar_t * __buf; 556 uint8_t padding_r; 557 } __stack; 558 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 559 const size_t __len = 42 - 1; 560 const size_t __idx __unused = __len - 1; 561 562 __stack.__buf = malloc(__bufsz); 563 564 wmemset(__stack.__buf, L'0', __len); 565 #undef BUF 566 567 } 568 569 ATF_TC_WITHOUT_HEAD(wmemset_heap_end); 570 ATF_TC_BODY(wmemset_heap_end, tc) 571 { 572 #define BUF __stack.__buf 573 struct { 574 uint8_t padding_l; 575 wchar_t * __buf; 576 uint8_t padding_r; 577 } __stack; 578 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 579 const size_t __len = 42; 580 const size_t __idx __unused = __len - 1; 581 582 __stack.__buf = malloc(__bufsz); 583 584 wmemset(__stack.__buf, L'0', __len); 585 #undef BUF 586 587 } 588 589 ATF_TC_WITHOUT_HEAD(wmemset_heap_after_end); 590 ATF_TC_BODY(wmemset_heap_after_end, tc) 591 { 592 #define BUF __stack.__buf 593 struct { 594 uint8_t padding_l; 595 wchar_t * __buf; 596 uint8_t padding_r; 597 } __stack; 598 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 599 const size_t __len = 42 + 1; 600 const size_t __idx __unused = __len - 1; 601 pid_t __child; 602 int __status; 603 604 __child = fork(); 605 ATF_REQUIRE(__child >= 0); 606 if (__child > 0) 607 goto monitor; 608 609 /* Child */ 610 disable_coredumps(); 611 __stack.__buf = malloc(__bufsz); 612 613 wmemset(__stack.__buf, L'0', __len); 614 _exit(EX_SOFTWARE); /* Should have aborted. */ 615 616 monitor: 617 while (waitpid(__child, &__status, 0) != __child) { 618 ATF_REQUIRE_EQ(EINTR, errno); 619 } 620 621 if (!WIFSIGNALED(__status)) { 622 switch (WEXITSTATUS(__status)) { 623 case EX_SOFTWARE: 624 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 625 break; 626 case EX_OSERR: 627 atf_tc_fail("setrlimit(2) failed"); 628 break; 629 default: 630 atf_tc_fail("child exited with status %d", 631 WEXITSTATUS(__status)); 632 } 633 } else { 634 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 635 } 636 #undef BUF 637 638 } 639 640 ATF_TC_WITHOUT_HEAD(wcpcpy_before_end); 641 ATF_TC_BODY(wcpcpy_before_end, tc) 642 { 643 #define BUF &__stack.__buf 644 struct { 645 uint8_t padding_l; 646 wchar_t __buf[42]; 647 uint8_t padding_r; 648 } __stack; 649 const size_t __bufsz __unused = sizeof(__stack.__buf); 650 const size_t __len = 42 - 1; 651 const size_t __idx __unused = __len - 1; 652 wchar_t src[__len]; 653 654 wmemset(__stack.__buf, 0, __len); 655 wmemset(src, 'A', __len - 1); 656 src[__len - 1] = '\0'; 657 658 wcpcpy(__stack.__buf, src); 659 #undef BUF 660 661 } 662 663 ATF_TC_WITHOUT_HEAD(wcpcpy_end); 664 ATF_TC_BODY(wcpcpy_end, tc) 665 { 666 #define BUF &__stack.__buf 667 struct { 668 uint8_t padding_l; 669 wchar_t __buf[42]; 670 uint8_t padding_r; 671 } __stack; 672 const size_t __bufsz __unused = sizeof(__stack.__buf); 673 const size_t __len = 42; 674 const size_t __idx __unused = __len - 1; 675 wchar_t src[__len]; 676 677 wmemset(__stack.__buf, 0, __len); 678 wmemset(src, 'A', __len - 1); 679 src[__len - 1] = '\0'; 680 681 wcpcpy(__stack.__buf, src); 682 #undef BUF 683 684 } 685 686 ATF_TC_WITHOUT_HEAD(wcpcpy_heap_before_end); 687 ATF_TC_BODY(wcpcpy_heap_before_end, tc) 688 { 689 #define BUF __stack.__buf 690 struct { 691 uint8_t padding_l; 692 wchar_t * __buf; 693 uint8_t padding_r; 694 } __stack; 695 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 696 const size_t __len = 42 - 1; 697 const size_t __idx __unused = __len - 1; 698 wchar_t src[__len]; 699 700 __stack.__buf = malloc(__bufsz); 701 wmemset(__stack.__buf, 0, __len); 702 wmemset(src, 'A', __len - 1); 703 src[__len - 1] = '\0'; 704 705 wcpcpy(__stack.__buf, src); 706 #undef BUF 707 708 } 709 710 ATF_TC_WITHOUT_HEAD(wcpcpy_heap_end); 711 ATF_TC_BODY(wcpcpy_heap_end, tc) 712 { 713 #define BUF __stack.__buf 714 struct { 715 uint8_t padding_l; 716 wchar_t * __buf; 717 uint8_t padding_r; 718 } __stack; 719 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 720 const size_t __len = 42; 721 const size_t __idx __unused = __len - 1; 722 wchar_t src[__len]; 723 724 __stack.__buf = malloc(__bufsz); 725 wmemset(__stack.__buf, 0, __len); 726 wmemset(src, 'A', __len - 1); 727 src[__len - 1] = '\0'; 728 729 wcpcpy(__stack.__buf, src); 730 #undef BUF 731 732 } 733 734 ATF_TC_WITHOUT_HEAD(wcpcpy_heap_after_end); 735 ATF_TC_BODY(wcpcpy_heap_after_end, tc) 736 { 737 #define BUF __stack.__buf 738 struct { 739 uint8_t padding_l; 740 wchar_t * __buf; 741 uint8_t padding_r; 742 } __stack; 743 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 744 const size_t __len = 42 + 1; 745 const size_t __idx __unused = __len - 1; 746 pid_t __child; 747 int __status; 748 wchar_t src[__len]; 749 750 __child = fork(); 751 ATF_REQUIRE(__child >= 0); 752 if (__child > 0) 753 goto monitor; 754 755 /* Child */ 756 disable_coredumps(); 757 __stack.__buf = malloc(__bufsz); 758 wmemset(__stack.__buf, 0, __len); 759 wmemset(src, 'A', __len - 1); 760 src[__len - 1] = '\0'; 761 762 wcpcpy(__stack.__buf, src); 763 _exit(EX_SOFTWARE); /* Should have aborted. */ 764 765 monitor: 766 while (waitpid(__child, &__status, 0) != __child) { 767 ATF_REQUIRE_EQ(EINTR, errno); 768 } 769 770 if (!WIFSIGNALED(__status)) { 771 switch (WEXITSTATUS(__status)) { 772 case EX_SOFTWARE: 773 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 774 break; 775 case EX_OSERR: 776 atf_tc_fail("setrlimit(2) failed"); 777 break; 778 default: 779 atf_tc_fail("child exited with status %d", 780 WEXITSTATUS(__status)); 781 } 782 } else { 783 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 784 } 785 #undef BUF 786 787 } 788 789 ATF_TC_WITHOUT_HEAD(wcpncpy_before_end); 790 ATF_TC_BODY(wcpncpy_before_end, tc) 791 { 792 #define BUF &__stack.__buf 793 struct { 794 uint8_t padding_l; 795 wchar_t __buf[42]; 796 uint8_t padding_r; 797 } __stack; 798 const size_t __bufsz __unused = sizeof(__stack.__buf); 799 const size_t __len = 42 - 1; 800 const size_t __idx __unused = __len - 1; 801 wchar_t src[__len]; 802 803 wmemset(__stack.__buf, 0, __len); 804 wmemset(src, 'A', __len - 1); 805 src[__len - 1] = '\0'; 806 807 wcpncpy(__stack.__buf, src, __len); 808 #undef BUF 809 810 } 811 812 ATF_TC_WITHOUT_HEAD(wcpncpy_end); 813 ATF_TC_BODY(wcpncpy_end, tc) 814 { 815 #define BUF &__stack.__buf 816 struct { 817 uint8_t padding_l; 818 wchar_t __buf[42]; 819 uint8_t padding_r; 820 } __stack; 821 const size_t __bufsz __unused = sizeof(__stack.__buf); 822 const size_t __len = 42; 823 const size_t __idx __unused = __len - 1; 824 wchar_t src[__len]; 825 826 wmemset(__stack.__buf, 0, __len); 827 wmemset(src, 'A', __len - 1); 828 src[__len - 1] = '\0'; 829 830 wcpncpy(__stack.__buf, src, __len); 831 #undef BUF 832 833 } 834 835 ATF_TC_WITHOUT_HEAD(wcpncpy_heap_before_end); 836 ATF_TC_BODY(wcpncpy_heap_before_end, tc) 837 { 838 #define BUF __stack.__buf 839 struct { 840 uint8_t padding_l; 841 wchar_t * __buf; 842 uint8_t padding_r; 843 } __stack; 844 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 845 const size_t __len = 42 - 1; 846 const size_t __idx __unused = __len - 1; 847 wchar_t src[__len]; 848 849 __stack.__buf = malloc(__bufsz); 850 wmemset(__stack.__buf, 0, __len); 851 wmemset(src, 'A', __len - 1); 852 src[__len - 1] = '\0'; 853 854 wcpncpy(__stack.__buf, src, __len); 855 #undef BUF 856 857 } 858 859 ATF_TC_WITHOUT_HEAD(wcpncpy_heap_end); 860 ATF_TC_BODY(wcpncpy_heap_end, tc) 861 { 862 #define BUF __stack.__buf 863 struct { 864 uint8_t padding_l; 865 wchar_t * __buf; 866 uint8_t padding_r; 867 } __stack; 868 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 869 const size_t __len = 42; 870 const size_t __idx __unused = __len - 1; 871 wchar_t src[__len]; 872 873 __stack.__buf = malloc(__bufsz); 874 wmemset(__stack.__buf, 0, __len); 875 wmemset(src, 'A', __len - 1); 876 src[__len - 1] = '\0'; 877 878 wcpncpy(__stack.__buf, src, __len); 879 #undef BUF 880 881 } 882 883 ATF_TC_WITHOUT_HEAD(wcpncpy_heap_after_end); 884 ATF_TC_BODY(wcpncpy_heap_after_end, tc) 885 { 886 #define BUF __stack.__buf 887 struct { 888 uint8_t padding_l; 889 wchar_t * __buf; 890 uint8_t padding_r; 891 } __stack; 892 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 893 const size_t __len = 42 + 1; 894 const size_t __idx __unused = __len - 1; 895 pid_t __child; 896 int __status; 897 wchar_t src[__len]; 898 899 __child = fork(); 900 ATF_REQUIRE(__child >= 0); 901 if (__child > 0) 902 goto monitor; 903 904 /* Child */ 905 disable_coredumps(); 906 __stack.__buf = malloc(__bufsz); 907 wmemset(__stack.__buf, 0, __len); 908 wmemset(src, 'A', __len - 1); 909 src[__len - 1] = '\0'; 910 911 wcpncpy(__stack.__buf, src, __len); 912 _exit(EX_SOFTWARE); /* Should have aborted. */ 913 914 monitor: 915 while (waitpid(__child, &__status, 0) != __child) { 916 ATF_REQUIRE_EQ(EINTR, errno); 917 } 918 919 if (!WIFSIGNALED(__status)) { 920 switch (WEXITSTATUS(__status)) { 921 case EX_SOFTWARE: 922 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 923 break; 924 case EX_OSERR: 925 atf_tc_fail("setrlimit(2) failed"); 926 break; 927 default: 928 atf_tc_fail("child exited with status %d", 929 WEXITSTATUS(__status)); 930 } 931 } else { 932 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 933 } 934 #undef BUF 935 936 } 937 938 ATF_TC_WITHOUT_HEAD(wcscat_before_end); 939 ATF_TC_BODY(wcscat_before_end, tc) 940 { 941 #define BUF &__stack.__buf 942 struct { 943 uint8_t padding_l; 944 wchar_t __buf[42]; 945 uint8_t padding_r; 946 } __stack; 947 const size_t __bufsz __unused = sizeof(__stack.__buf); 948 const size_t __len = 42 - 1; 949 const size_t __idx __unused = __len - 1; 950 wchar_t src[__len]; 951 952 wmemset(__stack.__buf, 0, __len); 953 wmemset(src, 'A', __len - 1); 954 src[__len - 1] = '\0'; 955 956 wcscat(__stack.__buf, src); 957 #undef BUF 958 959 } 960 961 ATF_TC_WITHOUT_HEAD(wcscat_end); 962 ATF_TC_BODY(wcscat_end, tc) 963 { 964 #define BUF &__stack.__buf 965 struct { 966 uint8_t padding_l; 967 wchar_t __buf[42]; 968 uint8_t padding_r; 969 } __stack; 970 const size_t __bufsz __unused = sizeof(__stack.__buf); 971 const size_t __len = 42; 972 const size_t __idx __unused = __len - 1; 973 wchar_t src[__len]; 974 975 wmemset(__stack.__buf, 0, __len); 976 wmemset(src, 'A', __len - 1); 977 src[__len - 1] = '\0'; 978 979 wcscat(__stack.__buf, src); 980 #undef BUF 981 982 } 983 984 ATF_TC_WITHOUT_HEAD(wcscat_heap_before_end); 985 ATF_TC_BODY(wcscat_heap_before_end, tc) 986 { 987 #define BUF __stack.__buf 988 struct { 989 uint8_t padding_l; 990 wchar_t * __buf; 991 uint8_t padding_r; 992 } __stack; 993 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 994 const size_t __len = 42 - 1; 995 const size_t __idx __unused = __len - 1; 996 wchar_t src[__len]; 997 998 __stack.__buf = malloc(__bufsz); 999 wmemset(__stack.__buf, 0, __len); 1000 wmemset(src, 'A', __len - 1); 1001 src[__len - 1] = '\0'; 1002 1003 wcscat(__stack.__buf, src); 1004 #undef BUF 1005 1006 } 1007 1008 ATF_TC_WITHOUT_HEAD(wcscat_heap_end); 1009 ATF_TC_BODY(wcscat_heap_end, tc) 1010 { 1011 #define BUF __stack.__buf 1012 struct { 1013 uint8_t padding_l; 1014 wchar_t * __buf; 1015 uint8_t padding_r; 1016 } __stack; 1017 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1018 const size_t __len = 42; 1019 const size_t __idx __unused = __len - 1; 1020 wchar_t src[__len]; 1021 1022 __stack.__buf = malloc(__bufsz); 1023 wmemset(__stack.__buf, 0, __len); 1024 wmemset(src, 'A', __len - 1); 1025 src[__len - 1] = '\0'; 1026 1027 wcscat(__stack.__buf, src); 1028 #undef BUF 1029 1030 } 1031 1032 ATF_TC_WITHOUT_HEAD(wcscat_heap_after_end); 1033 ATF_TC_BODY(wcscat_heap_after_end, tc) 1034 { 1035 #define BUF __stack.__buf 1036 struct { 1037 uint8_t padding_l; 1038 wchar_t * __buf; 1039 uint8_t padding_r; 1040 } __stack; 1041 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1042 const size_t __len = 42 + 1; 1043 const size_t __idx __unused = __len - 1; 1044 pid_t __child; 1045 int __status; 1046 wchar_t src[__len]; 1047 1048 __child = fork(); 1049 ATF_REQUIRE(__child >= 0); 1050 if (__child > 0) 1051 goto monitor; 1052 1053 /* Child */ 1054 disable_coredumps(); 1055 __stack.__buf = malloc(__bufsz); 1056 wmemset(__stack.__buf, 0, __len); 1057 wmemset(src, 'A', __len - 1); 1058 src[__len - 1] = '\0'; 1059 1060 wcscat(__stack.__buf, src); 1061 _exit(EX_SOFTWARE); /* Should have aborted. */ 1062 1063 monitor: 1064 while (waitpid(__child, &__status, 0) != __child) { 1065 ATF_REQUIRE_EQ(EINTR, errno); 1066 } 1067 1068 if (!WIFSIGNALED(__status)) { 1069 switch (WEXITSTATUS(__status)) { 1070 case EX_SOFTWARE: 1071 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1072 break; 1073 case EX_OSERR: 1074 atf_tc_fail("setrlimit(2) failed"); 1075 break; 1076 default: 1077 atf_tc_fail("child exited with status %d", 1078 WEXITSTATUS(__status)); 1079 } 1080 } else { 1081 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1082 } 1083 #undef BUF 1084 1085 } 1086 1087 ATF_TC_WITHOUT_HEAD(wcslcat_before_end); 1088 ATF_TC_BODY(wcslcat_before_end, tc) 1089 { 1090 #define BUF &__stack.__buf 1091 struct { 1092 uint8_t padding_l; 1093 wchar_t __buf[42]; 1094 uint8_t padding_r; 1095 } __stack; 1096 const size_t __bufsz __unused = sizeof(__stack.__buf); 1097 const size_t __len = 42 - 1; 1098 const size_t __idx __unused = __len - 1; 1099 wchar_t src[__len]; 1100 1101 wmemset(__stack.__buf, 0, __len); 1102 wmemset(src, 'A', __len - 1); 1103 src[__len - 1] = '\0'; 1104 1105 wcslcat(__stack.__buf, src, __len); 1106 #undef BUF 1107 1108 } 1109 1110 ATF_TC_WITHOUT_HEAD(wcslcat_end); 1111 ATF_TC_BODY(wcslcat_end, tc) 1112 { 1113 #define BUF &__stack.__buf 1114 struct { 1115 uint8_t padding_l; 1116 wchar_t __buf[42]; 1117 uint8_t padding_r; 1118 } __stack; 1119 const size_t __bufsz __unused = sizeof(__stack.__buf); 1120 const size_t __len = 42; 1121 const size_t __idx __unused = __len - 1; 1122 wchar_t src[__len]; 1123 1124 wmemset(__stack.__buf, 0, __len); 1125 wmemset(src, 'A', __len - 1); 1126 src[__len - 1] = '\0'; 1127 1128 wcslcat(__stack.__buf, src, __len); 1129 #undef BUF 1130 1131 } 1132 1133 ATF_TC_WITHOUT_HEAD(wcslcat_heap_before_end); 1134 ATF_TC_BODY(wcslcat_heap_before_end, tc) 1135 { 1136 #define BUF __stack.__buf 1137 struct { 1138 uint8_t padding_l; 1139 wchar_t * __buf; 1140 uint8_t padding_r; 1141 } __stack; 1142 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1143 const size_t __len = 42 - 1; 1144 const size_t __idx __unused = __len - 1; 1145 wchar_t src[__len]; 1146 1147 __stack.__buf = malloc(__bufsz); 1148 wmemset(__stack.__buf, 0, __len); 1149 wmemset(src, 'A', __len - 1); 1150 src[__len - 1] = '\0'; 1151 1152 wcslcat(__stack.__buf, src, __len); 1153 #undef BUF 1154 1155 } 1156 1157 ATF_TC_WITHOUT_HEAD(wcslcat_heap_end); 1158 ATF_TC_BODY(wcslcat_heap_end, tc) 1159 { 1160 #define BUF __stack.__buf 1161 struct { 1162 uint8_t padding_l; 1163 wchar_t * __buf; 1164 uint8_t padding_r; 1165 } __stack; 1166 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1167 const size_t __len = 42; 1168 const size_t __idx __unused = __len - 1; 1169 wchar_t src[__len]; 1170 1171 __stack.__buf = malloc(__bufsz); 1172 wmemset(__stack.__buf, 0, __len); 1173 wmemset(src, 'A', __len - 1); 1174 src[__len - 1] = '\0'; 1175 1176 wcslcat(__stack.__buf, src, __len); 1177 #undef BUF 1178 1179 } 1180 1181 ATF_TC_WITHOUT_HEAD(wcslcat_heap_after_end); 1182 ATF_TC_BODY(wcslcat_heap_after_end, tc) 1183 { 1184 #define BUF __stack.__buf 1185 struct { 1186 uint8_t padding_l; 1187 wchar_t * __buf; 1188 uint8_t padding_r; 1189 } __stack; 1190 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1191 const size_t __len = 42 + 1; 1192 const size_t __idx __unused = __len - 1; 1193 pid_t __child; 1194 int __status; 1195 wchar_t src[__len]; 1196 1197 __child = fork(); 1198 ATF_REQUIRE(__child >= 0); 1199 if (__child > 0) 1200 goto monitor; 1201 1202 /* Child */ 1203 disable_coredumps(); 1204 __stack.__buf = malloc(__bufsz); 1205 wmemset(__stack.__buf, 0, __len); 1206 wmemset(src, 'A', __len - 1); 1207 src[__len - 1] = '\0'; 1208 1209 wcslcat(__stack.__buf, src, __len); 1210 _exit(EX_SOFTWARE); /* Should have aborted. */ 1211 1212 monitor: 1213 while (waitpid(__child, &__status, 0) != __child) { 1214 ATF_REQUIRE_EQ(EINTR, errno); 1215 } 1216 1217 if (!WIFSIGNALED(__status)) { 1218 switch (WEXITSTATUS(__status)) { 1219 case EX_SOFTWARE: 1220 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1221 break; 1222 case EX_OSERR: 1223 atf_tc_fail("setrlimit(2) failed"); 1224 break; 1225 default: 1226 atf_tc_fail("child exited with status %d", 1227 WEXITSTATUS(__status)); 1228 } 1229 } else { 1230 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1231 } 1232 #undef BUF 1233 1234 } 1235 1236 ATF_TC_WITHOUT_HEAD(wcsncat_before_end); 1237 ATF_TC_BODY(wcsncat_before_end, tc) 1238 { 1239 #define BUF &__stack.__buf 1240 struct { 1241 uint8_t padding_l; 1242 wchar_t __buf[42]; 1243 uint8_t padding_r; 1244 } __stack; 1245 const size_t __bufsz __unused = sizeof(__stack.__buf); 1246 const size_t __len = 42 - 1; 1247 const size_t __idx __unused = __len - 1; 1248 wchar_t src[__len]; 1249 1250 wmemset(__stack.__buf, 0, __len); 1251 wmemset(src, 'A', __len - 1); 1252 src[__len - 1] = '\0'; 1253 1254 wcsncat(__stack.__buf, src, __len); 1255 #undef BUF 1256 1257 } 1258 1259 ATF_TC_WITHOUT_HEAD(wcsncat_end); 1260 ATF_TC_BODY(wcsncat_end, tc) 1261 { 1262 #define BUF &__stack.__buf 1263 struct { 1264 uint8_t padding_l; 1265 wchar_t __buf[42]; 1266 uint8_t padding_r; 1267 } __stack; 1268 const size_t __bufsz __unused = sizeof(__stack.__buf); 1269 const size_t __len = 42; 1270 const size_t __idx __unused = __len - 1; 1271 wchar_t src[__len]; 1272 1273 wmemset(__stack.__buf, 0, __len); 1274 wmemset(src, 'A', __len - 1); 1275 src[__len - 1] = '\0'; 1276 1277 wcsncat(__stack.__buf, src, __len); 1278 #undef BUF 1279 1280 } 1281 1282 ATF_TC_WITHOUT_HEAD(wcsncat_heap_before_end); 1283 ATF_TC_BODY(wcsncat_heap_before_end, tc) 1284 { 1285 #define BUF __stack.__buf 1286 struct { 1287 uint8_t padding_l; 1288 wchar_t * __buf; 1289 uint8_t padding_r; 1290 } __stack; 1291 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1292 const size_t __len = 42 - 1; 1293 const size_t __idx __unused = __len - 1; 1294 wchar_t src[__len]; 1295 1296 __stack.__buf = malloc(__bufsz); 1297 wmemset(__stack.__buf, 0, __len); 1298 wmemset(src, 'A', __len - 1); 1299 src[__len - 1] = '\0'; 1300 1301 wcsncat(__stack.__buf, src, __len); 1302 #undef BUF 1303 1304 } 1305 1306 ATF_TC_WITHOUT_HEAD(wcsncat_heap_end); 1307 ATF_TC_BODY(wcsncat_heap_end, tc) 1308 { 1309 #define BUF __stack.__buf 1310 struct { 1311 uint8_t padding_l; 1312 wchar_t * __buf; 1313 uint8_t padding_r; 1314 } __stack; 1315 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1316 const size_t __len = 42; 1317 const size_t __idx __unused = __len - 1; 1318 wchar_t src[__len]; 1319 1320 __stack.__buf = malloc(__bufsz); 1321 wmemset(__stack.__buf, 0, __len); 1322 wmemset(src, 'A', __len - 1); 1323 src[__len - 1] = '\0'; 1324 1325 wcsncat(__stack.__buf, src, __len); 1326 #undef BUF 1327 1328 } 1329 1330 ATF_TC_WITHOUT_HEAD(wcsncat_heap_after_end); 1331 ATF_TC_BODY(wcsncat_heap_after_end, tc) 1332 { 1333 #define BUF __stack.__buf 1334 struct { 1335 uint8_t padding_l; 1336 wchar_t * __buf; 1337 uint8_t padding_r; 1338 } __stack; 1339 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1340 const size_t __len = 42 + 1; 1341 const size_t __idx __unused = __len - 1; 1342 pid_t __child; 1343 int __status; 1344 wchar_t src[__len]; 1345 1346 __child = fork(); 1347 ATF_REQUIRE(__child >= 0); 1348 if (__child > 0) 1349 goto monitor; 1350 1351 /* Child */ 1352 disable_coredumps(); 1353 __stack.__buf = malloc(__bufsz); 1354 wmemset(__stack.__buf, 0, __len); 1355 wmemset(src, 'A', __len - 1); 1356 src[__len - 1] = '\0'; 1357 1358 wcsncat(__stack.__buf, src, __len); 1359 _exit(EX_SOFTWARE); /* Should have aborted. */ 1360 1361 monitor: 1362 while (waitpid(__child, &__status, 0) != __child) { 1363 ATF_REQUIRE_EQ(EINTR, errno); 1364 } 1365 1366 if (!WIFSIGNALED(__status)) { 1367 switch (WEXITSTATUS(__status)) { 1368 case EX_SOFTWARE: 1369 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1370 break; 1371 case EX_OSERR: 1372 atf_tc_fail("setrlimit(2) failed"); 1373 break; 1374 default: 1375 atf_tc_fail("child exited with status %d", 1376 WEXITSTATUS(__status)); 1377 } 1378 } else { 1379 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1380 } 1381 #undef BUF 1382 1383 } 1384 1385 ATF_TC_WITHOUT_HEAD(wcscpy_before_end); 1386 ATF_TC_BODY(wcscpy_before_end, tc) 1387 { 1388 #define BUF &__stack.__buf 1389 struct { 1390 uint8_t padding_l; 1391 wchar_t __buf[42]; 1392 uint8_t padding_r; 1393 } __stack; 1394 const size_t __bufsz __unused = sizeof(__stack.__buf); 1395 const size_t __len = 42 - 1; 1396 const size_t __idx __unused = __len - 1; 1397 wchar_t src[__len]; 1398 1399 wmemset(__stack.__buf, 0, __len); 1400 wmemset(src, 'A', __len - 1); 1401 src[__len - 1] = '\0'; 1402 1403 wcscpy(__stack.__buf, src); 1404 #undef BUF 1405 1406 } 1407 1408 ATF_TC_WITHOUT_HEAD(wcscpy_end); 1409 ATF_TC_BODY(wcscpy_end, tc) 1410 { 1411 #define BUF &__stack.__buf 1412 struct { 1413 uint8_t padding_l; 1414 wchar_t __buf[42]; 1415 uint8_t padding_r; 1416 } __stack; 1417 const size_t __bufsz __unused = sizeof(__stack.__buf); 1418 const size_t __len = 42; 1419 const size_t __idx __unused = __len - 1; 1420 wchar_t src[__len]; 1421 1422 wmemset(__stack.__buf, 0, __len); 1423 wmemset(src, 'A', __len - 1); 1424 src[__len - 1] = '\0'; 1425 1426 wcscpy(__stack.__buf, src); 1427 #undef BUF 1428 1429 } 1430 1431 ATF_TC_WITHOUT_HEAD(wcscpy_heap_before_end); 1432 ATF_TC_BODY(wcscpy_heap_before_end, tc) 1433 { 1434 #define BUF __stack.__buf 1435 struct { 1436 uint8_t padding_l; 1437 wchar_t * __buf; 1438 uint8_t padding_r; 1439 } __stack; 1440 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1441 const size_t __len = 42 - 1; 1442 const size_t __idx __unused = __len - 1; 1443 wchar_t src[__len]; 1444 1445 __stack.__buf = malloc(__bufsz); 1446 wmemset(__stack.__buf, 0, __len); 1447 wmemset(src, 'A', __len - 1); 1448 src[__len - 1] = '\0'; 1449 1450 wcscpy(__stack.__buf, src); 1451 #undef BUF 1452 1453 } 1454 1455 ATF_TC_WITHOUT_HEAD(wcscpy_heap_end); 1456 ATF_TC_BODY(wcscpy_heap_end, tc) 1457 { 1458 #define BUF __stack.__buf 1459 struct { 1460 uint8_t padding_l; 1461 wchar_t * __buf; 1462 uint8_t padding_r; 1463 } __stack; 1464 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1465 const size_t __len = 42; 1466 const size_t __idx __unused = __len - 1; 1467 wchar_t src[__len]; 1468 1469 __stack.__buf = malloc(__bufsz); 1470 wmemset(__stack.__buf, 0, __len); 1471 wmemset(src, 'A', __len - 1); 1472 src[__len - 1] = '\0'; 1473 1474 wcscpy(__stack.__buf, src); 1475 #undef BUF 1476 1477 } 1478 1479 ATF_TC_WITHOUT_HEAD(wcscpy_heap_after_end); 1480 ATF_TC_BODY(wcscpy_heap_after_end, tc) 1481 { 1482 #define BUF __stack.__buf 1483 struct { 1484 uint8_t padding_l; 1485 wchar_t * __buf; 1486 uint8_t padding_r; 1487 } __stack; 1488 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1489 const size_t __len = 42 + 1; 1490 const size_t __idx __unused = __len - 1; 1491 pid_t __child; 1492 int __status; 1493 wchar_t src[__len]; 1494 1495 __child = fork(); 1496 ATF_REQUIRE(__child >= 0); 1497 if (__child > 0) 1498 goto monitor; 1499 1500 /* Child */ 1501 disable_coredumps(); 1502 __stack.__buf = malloc(__bufsz); 1503 wmemset(__stack.__buf, 0, __len); 1504 wmemset(src, 'A', __len - 1); 1505 src[__len - 1] = '\0'; 1506 1507 wcscpy(__stack.__buf, src); 1508 _exit(EX_SOFTWARE); /* Should have aborted. */ 1509 1510 monitor: 1511 while (waitpid(__child, &__status, 0) != __child) { 1512 ATF_REQUIRE_EQ(EINTR, errno); 1513 } 1514 1515 if (!WIFSIGNALED(__status)) { 1516 switch (WEXITSTATUS(__status)) { 1517 case EX_SOFTWARE: 1518 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1519 break; 1520 case EX_OSERR: 1521 atf_tc_fail("setrlimit(2) failed"); 1522 break; 1523 default: 1524 atf_tc_fail("child exited with status %d", 1525 WEXITSTATUS(__status)); 1526 } 1527 } else { 1528 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1529 } 1530 #undef BUF 1531 1532 } 1533 1534 ATF_TC_WITHOUT_HEAD(wcslcpy_before_end); 1535 ATF_TC_BODY(wcslcpy_before_end, tc) 1536 { 1537 #define BUF &__stack.__buf 1538 struct { 1539 uint8_t padding_l; 1540 wchar_t __buf[42]; 1541 uint8_t padding_r; 1542 } __stack; 1543 const size_t __bufsz __unused = sizeof(__stack.__buf); 1544 const size_t __len = 42 - 1; 1545 const size_t __idx __unused = __len - 1; 1546 wchar_t src[__len]; 1547 1548 wmemset(__stack.__buf, 0, __len); 1549 wmemset(src, 'A', __len - 1); 1550 src[__len - 1] = '\0'; 1551 1552 wcslcpy(__stack.__buf, src, __len); 1553 #undef BUF 1554 1555 } 1556 1557 ATF_TC_WITHOUT_HEAD(wcslcpy_end); 1558 ATF_TC_BODY(wcslcpy_end, tc) 1559 { 1560 #define BUF &__stack.__buf 1561 struct { 1562 uint8_t padding_l; 1563 wchar_t __buf[42]; 1564 uint8_t padding_r; 1565 } __stack; 1566 const size_t __bufsz __unused = sizeof(__stack.__buf); 1567 const size_t __len = 42; 1568 const size_t __idx __unused = __len - 1; 1569 wchar_t src[__len]; 1570 1571 wmemset(__stack.__buf, 0, __len); 1572 wmemset(src, 'A', __len - 1); 1573 src[__len - 1] = '\0'; 1574 1575 wcslcpy(__stack.__buf, src, __len); 1576 #undef BUF 1577 1578 } 1579 1580 ATF_TC_WITHOUT_HEAD(wcslcpy_heap_before_end); 1581 ATF_TC_BODY(wcslcpy_heap_before_end, tc) 1582 { 1583 #define BUF __stack.__buf 1584 struct { 1585 uint8_t padding_l; 1586 wchar_t * __buf; 1587 uint8_t padding_r; 1588 } __stack; 1589 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1590 const size_t __len = 42 - 1; 1591 const size_t __idx __unused = __len - 1; 1592 wchar_t src[__len]; 1593 1594 __stack.__buf = malloc(__bufsz); 1595 wmemset(__stack.__buf, 0, __len); 1596 wmemset(src, 'A', __len - 1); 1597 src[__len - 1] = '\0'; 1598 1599 wcslcpy(__stack.__buf, src, __len); 1600 #undef BUF 1601 1602 } 1603 1604 ATF_TC_WITHOUT_HEAD(wcslcpy_heap_end); 1605 ATF_TC_BODY(wcslcpy_heap_end, tc) 1606 { 1607 #define BUF __stack.__buf 1608 struct { 1609 uint8_t padding_l; 1610 wchar_t * __buf; 1611 uint8_t padding_r; 1612 } __stack; 1613 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1614 const size_t __len = 42; 1615 const size_t __idx __unused = __len - 1; 1616 wchar_t src[__len]; 1617 1618 __stack.__buf = malloc(__bufsz); 1619 wmemset(__stack.__buf, 0, __len); 1620 wmemset(src, 'A', __len - 1); 1621 src[__len - 1] = '\0'; 1622 1623 wcslcpy(__stack.__buf, src, __len); 1624 #undef BUF 1625 1626 } 1627 1628 ATF_TC_WITHOUT_HEAD(wcslcpy_heap_after_end); 1629 ATF_TC_BODY(wcslcpy_heap_after_end, tc) 1630 { 1631 #define BUF __stack.__buf 1632 struct { 1633 uint8_t padding_l; 1634 wchar_t * __buf; 1635 uint8_t padding_r; 1636 } __stack; 1637 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1638 const size_t __len = 42 + 1; 1639 const size_t __idx __unused = __len - 1; 1640 pid_t __child; 1641 int __status; 1642 wchar_t src[__len]; 1643 1644 __child = fork(); 1645 ATF_REQUIRE(__child >= 0); 1646 if (__child > 0) 1647 goto monitor; 1648 1649 /* Child */ 1650 disable_coredumps(); 1651 __stack.__buf = malloc(__bufsz); 1652 wmemset(__stack.__buf, 0, __len); 1653 wmemset(src, 'A', __len - 1); 1654 src[__len - 1] = '\0'; 1655 1656 wcslcpy(__stack.__buf, src, __len); 1657 _exit(EX_SOFTWARE); /* Should have aborted. */ 1658 1659 monitor: 1660 while (waitpid(__child, &__status, 0) != __child) { 1661 ATF_REQUIRE_EQ(EINTR, errno); 1662 } 1663 1664 if (!WIFSIGNALED(__status)) { 1665 switch (WEXITSTATUS(__status)) { 1666 case EX_SOFTWARE: 1667 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1668 break; 1669 case EX_OSERR: 1670 atf_tc_fail("setrlimit(2) failed"); 1671 break; 1672 default: 1673 atf_tc_fail("child exited with status %d", 1674 WEXITSTATUS(__status)); 1675 } 1676 } else { 1677 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1678 } 1679 #undef BUF 1680 1681 } 1682 1683 ATF_TC_WITHOUT_HEAD(wcsncpy_before_end); 1684 ATF_TC_BODY(wcsncpy_before_end, tc) 1685 { 1686 #define BUF &__stack.__buf 1687 struct { 1688 uint8_t padding_l; 1689 wchar_t __buf[42]; 1690 uint8_t padding_r; 1691 } __stack; 1692 const size_t __bufsz __unused = sizeof(__stack.__buf); 1693 const size_t __len = 42 - 1; 1694 const size_t __idx __unused = __len - 1; 1695 wchar_t src[__len]; 1696 1697 wmemset(__stack.__buf, 0, __len); 1698 wmemset(src, 'A', __len - 1); 1699 src[__len - 1] = '\0'; 1700 1701 wcsncpy(__stack.__buf, src, __len); 1702 #undef BUF 1703 1704 } 1705 1706 ATF_TC_WITHOUT_HEAD(wcsncpy_end); 1707 ATF_TC_BODY(wcsncpy_end, tc) 1708 { 1709 #define BUF &__stack.__buf 1710 struct { 1711 uint8_t padding_l; 1712 wchar_t __buf[42]; 1713 uint8_t padding_r; 1714 } __stack; 1715 const size_t __bufsz __unused = sizeof(__stack.__buf); 1716 const size_t __len = 42; 1717 const size_t __idx __unused = __len - 1; 1718 wchar_t src[__len]; 1719 1720 wmemset(__stack.__buf, 0, __len); 1721 wmemset(src, 'A', __len - 1); 1722 src[__len - 1] = '\0'; 1723 1724 wcsncpy(__stack.__buf, src, __len); 1725 #undef BUF 1726 1727 } 1728 1729 ATF_TC_WITHOUT_HEAD(wcsncpy_heap_before_end); 1730 ATF_TC_BODY(wcsncpy_heap_before_end, tc) 1731 { 1732 #define BUF __stack.__buf 1733 struct { 1734 uint8_t padding_l; 1735 wchar_t * __buf; 1736 uint8_t padding_r; 1737 } __stack; 1738 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1739 const size_t __len = 42 - 1; 1740 const size_t __idx __unused = __len - 1; 1741 wchar_t src[__len]; 1742 1743 __stack.__buf = malloc(__bufsz); 1744 wmemset(__stack.__buf, 0, __len); 1745 wmemset(src, 'A', __len - 1); 1746 src[__len - 1] = '\0'; 1747 1748 wcsncpy(__stack.__buf, src, __len); 1749 #undef BUF 1750 1751 } 1752 1753 ATF_TC_WITHOUT_HEAD(wcsncpy_heap_end); 1754 ATF_TC_BODY(wcsncpy_heap_end, tc) 1755 { 1756 #define BUF __stack.__buf 1757 struct { 1758 uint8_t padding_l; 1759 wchar_t * __buf; 1760 uint8_t padding_r; 1761 } __stack; 1762 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1763 const size_t __len = 42; 1764 const size_t __idx __unused = __len - 1; 1765 wchar_t src[__len]; 1766 1767 __stack.__buf = malloc(__bufsz); 1768 wmemset(__stack.__buf, 0, __len); 1769 wmemset(src, 'A', __len - 1); 1770 src[__len - 1] = '\0'; 1771 1772 wcsncpy(__stack.__buf, src, __len); 1773 #undef BUF 1774 1775 } 1776 1777 ATF_TC_WITHOUT_HEAD(wcsncpy_heap_after_end); 1778 ATF_TC_BODY(wcsncpy_heap_after_end, tc) 1779 { 1780 #define BUF __stack.__buf 1781 struct { 1782 uint8_t padding_l; 1783 wchar_t * __buf; 1784 uint8_t padding_r; 1785 } __stack; 1786 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42); 1787 const size_t __len = 42 + 1; 1788 const size_t __idx __unused = __len - 1; 1789 pid_t __child; 1790 int __status; 1791 wchar_t src[__len]; 1792 1793 __child = fork(); 1794 ATF_REQUIRE(__child >= 0); 1795 if (__child > 0) 1796 goto monitor; 1797 1798 /* Child */ 1799 disable_coredumps(); 1800 __stack.__buf = malloc(__bufsz); 1801 wmemset(__stack.__buf, 0, __len); 1802 wmemset(src, 'A', __len - 1); 1803 src[__len - 1] = '\0'; 1804 1805 wcsncpy(__stack.__buf, src, __len); 1806 _exit(EX_SOFTWARE); /* Should have aborted. */ 1807 1808 monitor: 1809 while (waitpid(__child, &__status, 0) != __child) { 1810 ATF_REQUIRE_EQ(EINTR, errno); 1811 } 1812 1813 if (!WIFSIGNALED(__status)) { 1814 switch (WEXITSTATUS(__status)) { 1815 case EX_SOFTWARE: 1816 atf_tc_fail("FORTIFY_SOURCE failed to abort"); 1817 break; 1818 case EX_OSERR: 1819 atf_tc_fail("setrlimit(2) failed"); 1820 break; 1821 default: 1822 atf_tc_fail("child exited with status %d", 1823 WEXITSTATUS(__status)); 1824 } 1825 } else { 1826 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status)); 1827 } 1828 #undef BUF 1829 1830 } 1831 1832 ATF_TP_ADD_TCS(tp) 1833 { 1834 ATF_TP_ADD_TC(tp, wmemcpy_before_end); 1835 ATF_TP_ADD_TC(tp, wmemcpy_end); 1836 ATF_TP_ADD_TC(tp, wmemcpy_heap_before_end); 1837 ATF_TP_ADD_TC(tp, wmemcpy_heap_end); 1838 ATF_TP_ADD_TC(tp, wmemcpy_heap_after_end); 1839 ATF_TP_ADD_TC(tp, wmempcpy_before_end); 1840 ATF_TP_ADD_TC(tp, wmempcpy_end); 1841 ATF_TP_ADD_TC(tp, wmempcpy_heap_before_end); 1842 ATF_TP_ADD_TC(tp, wmempcpy_heap_end); 1843 ATF_TP_ADD_TC(tp, wmempcpy_heap_after_end); 1844 ATF_TP_ADD_TC(tp, wmemmove_before_end); 1845 ATF_TP_ADD_TC(tp, wmemmove_end); 1846 ATF_TP_ADD_TC(tp, wmemmove_heap_before_end); 1847 ATF_TP_ADD_TC(tp, wmemmove_heap_end); 1848 ATF_TP_ADD_TC(tp, wmemmove_heap_after_end); 1849 ATF_TP_ADD_TC(tp, wmemset_before_end); 1850 ATF_TP_ADD_TC(tp, wmemset_end); 1851 ATF_TP_ADD_TC(tp, wmemset_heap_before_end); 1852 ATF_TP_ADD_TC(tp, wmemset_heap_end); 1853 ATF_TP_ADD_TC(tp, wmemset_heap_after_end); 1854 ATF_TP_ADD_TC(tp, wcpcpy_before_end); 1855 ATF_TP_ADD_TC(tp, wcpcpy_end); 1856 ATF_TP_ADD_TC(tp, wcpcpy_heap_before_end); 1857 ATF_TP_ADD_TC(tp, wcpcpy_heap_end); 1858 ATF_TP_ADD_TC(tp, wcpcpy_heap_after_end); 1859 ATF_TP_ADD_TC(tp, wcpncpy_before_end); 1860 ATF_TP_ADD_TC(tp, wcpncpy_end); 1861 ATF_TP_ADD_TC(tp, wcpncpy_heap_before_end); 1862 ATF_TP_ADD_TC(tp, wcpncpy_heap_end); 1863 ATF_TP_ADD_TC(tp, wcpncpy_heap_after_end); 1864 ATF_TP_ADD_TC(tp, wcscat_before_end); 1865 ATF_TP_ADD_TC(tp, wcscat_end); 1866 ATF_TP_ADD_TC(tp, wcscat_heap_before_end); 1867 ATF_TP_ADD_TC(tp, wcscat_heap_end); 1868 ATF_TP_ADD_TC(tp, wcscat_heap_after_end); 1869 ATF_TP_ADD_TC(tp, wcslcat_before_end); 1870 ATF_TP_ADD_TC(tp, wcslcat_end); 1871 ATF_TP_ADD_TC(tp, wcslcat_heap_before_end); 1872 ATF_TP_ADD_TC(tp, wcslcat_heap_end); 1873 ATF_TP_ADD_TC(tp, wcslcat_heap_after_end); 1874 ATF_TP_ADD_TC(tp, wcsncat_before_end); 1875 ATF_TP_ADD_TC(tp, wcsncat_end); 1876 ATF_TP_ADD_TC(tp, wcsncat_heap_before_end); 1877 ATF_TP_ADD_TC(tp, wcsncat_heap_end); 1878 ATF_TP_ADD_TC(tp, wcsncat_heap_after_end); 1879 ATF_TP_ADD_TC(tp, wcscpy_before_end); 1880 ATF_TP_ADD_TC(tp, wcscpy_end); 1881 ATF_TP_ADD_TC(tp, wcscpy_heap_before_end); 1882 ATF_TP_ADD_TC(tp, wcscpy_heap_end); 1883 ATF_TP_ADD_TC(tp, wcscpy_heap_after_end); 1884 ATF_TP_ADD_TC(tp, wcslcpy_before_end); 1885 ATF_TP_ADD_TC(tp, wcslcpy_end); 1886 ATF_TP_ADD_TC(tp, wcslcpy_heap_before_end); 1887 ATF_TP_ADD_TC(tp, wcslcpy_heap_end); 1888 ATF_TP_ADD_TC(tp, wcslcpy_heap_after_end); 1889 ATF_TP_ADD_TC(tp, wcsncpy_before_end); 1890 ATF_TP_ADD_TC(tp, wcsncpy_end); 1891 ATF_TP_ADD_TC(tp, wcsncpy_heap_before_end); 1892 ATF_TP_ADD_TC(tp, wcsncpy_heap_end); 1893 ATF_TP_ADD_TC(tp, wcsncpy_heap_after_end); 1894 return (atf_no_error()); 1895 } 1896