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