1 /* @generated by `generate-fortify-tests.lua "unistd"` */
2
3 #define _FORTIFY_SOURCE 2
4 #define TMPFILE_SIZE (1024 * 32)
5
6 #include <sys/param.h>
7 #include <sys/jail.h>
8 #include <sys/random.h>
9 #include <sys/resource.h>
10 #include <sys/select.h>
11 #include <sys/socket.h>
12 #include <sys/time.h>
13 #include <sys/uio.h>
14 #include <sys/wait.h>
15 #include <dirent.h>
16 #include <errno.h>
17 #include <fcntl.h>
18 #include <limits.h>
19 #include <poll.h>
20 #include <signal.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <strings.h>
25 #include <sysexits.h>
26 #include <unistd.h>
27 #include <wchar.h>
28 #include <atf-c.h>
29
30 static FILE * __unused
new_fp(size_t __len)31 new_fp(size_t __len)
32 {
33 static char fpbuf[LINE_MAX];
34 FILE *fp;
35
36 ATF_REQUIRE(__len <= sizeof(fpbuf));
37
38 memset(fpbuf, 'A', sizeof(fpbuf) - 1);
39 fpbuf[sizeof(fpbuf) - 1] = '\0';
40
41 fp = fmemopen(fpbuf, sizeof(fpbuf), "rb");
42 ATF_REQUIRE(fp != NULL);
43
44 return (fp);
45 }
46
47 /*
48 * Create a new symlink to use for readlink(2) style tests, we'll just use a
49 * random target name to have something interesting to look at.
50 */
51 static const char * __unused
new_symlink(size_t __len)52 new_symlink(size_t __len)
53 {
54 static const char linkname[] = "link";
55 char target[MAXNAMLEN];
56 int error;
57
58 ATF_REQUIRE(__len <= sizeof(target));
59
60 arc4random_buf(target, sizeof(target));
61
62 error = unlink(linkname);
63 ATF_REQUIRE(error == 0 || errno == ENOENT);
64
65 error = symlink(target, linkname);
66 ATF_REQUIRE(error == 0);
67
68 return (linkname);
69 }
70
71 /*
72 * For our purposes, first descriptor will be the reader; we'll send both
73 * raw data and a control message over it so that the result can be used for
74 * any of our recv*() tests.
75 */
76 static void __unused
new_socket(int sock[2])77 new_socket(int sock[2])
78 {
79 unsigned char ctrl[CMSG_SPACE(sizeof(int))] = { 0 };
80 static char sockbuf[256];
81 ssize_t rv;
82 size_t total = 0;
83 struct msghdr hdr = { 0 };
84 struct cmsghdr *cmsg;
85 int error, fd;
86
87 error = socketpair(AF_UNIX, SOCK_STREAM, 0, sock);
88 ATF_REQUIRE(error == 0);
89
90 while (total != sizeof(sockbuf)) {
91 rv = send(sock[1], &sockbuf[total], sizeof(sockbuf) - total, 0);
92
93 ATF_REQUIRE_MSG(rv > 0,
94 "expected bytes sent, got %zd with %zu left (size %zu, total %zu)",
95 rv, sizeof(sockbuf) - total, sizeof(sockbuf), total);
96 ATF_REQUIRE_MSG(total + (size_t)rv <= sizeof(sockbuf),
97 "%zd exceeds total %zu", rv, sizeof(sockbuf));
98 total += rv;
99 }
100
101 hdr.msg_control = ctrl;
102 hdr.msg_controllen = sizeof(ctrl);
103
104 cmsg = CMSG_FIRSTHDR(&hdr);
105 cmsg->cmsg_level = SOL_SOCKET;
106 cmsg->cmsg_type = SCM_RIGHTS;
107 cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
108 fd = STDIN_FILENO;
109 memcpy(CMSG_DATA(cmsg), &fd, sizeof(fd));
110
111 error = sendmsg(sock[1], &hdr, 0);
112 ATF_REQUIRE(error != -1);
113 }
114
115 /*
116 * Constructs a tmpfile that we can use for testing read(2) and friends.
117 */
118 static int __unused
new_tmpfile(void)119 new_tmpfile(void)
120 {
121 char buf[1024];
122 ssize_t rv;
123 size_t written;
124 int fd;
125
126 fd = open("tmpfile", O_RDWR | O_CREAT | O_TRUNC, 0644);
127 ATF_REQUIRE(fd >= 0);
128
129 written = 0;
130 while (written < TMPFILE_SIZE) {
131 rv = write(fd, buf, sizeof(buf));
132 ATF_REQUIRE(rv > 0);
133
134 written += rv;
135 }
136
137 ATF_REQUIRE_EQ(0, lseek(fd, 0, SEEK_SET));
138 return (fd);
139 }
140
141 static void
disable_coredumps(void)142 disable_coredumps(void)
143 {
144 struct rlimit rl = { 0 };
145
146 if (setrlimit(RLIMIT_CORE, &rl) == -1)
147 _exit(EX_OSERR);
148 }
149
150 /*
151 * Replaces stdin with a file that we can actually read from, for tests where
152 * we want a FILE * or fd that we can get data from.
153 */
154 static void __unused
replace_stdin(void)155 replace_stdin(void)
156 {
157 int fd;
158
159 fd = new_tmpfile();
160
161 (void)dup2(fd, STDIN_FILENO);
162 if (fd != STDIN_FILENO)
163 close(fd);
164 }
165
166 #define JAIL_HOSTNAME "host.example.com"
167 #define JAIL_DOMAINNAME "example.com"
168 static void
dhost_jail(void)169 dhost_jail(void)
170 {
171 struct iovec iov[4];
172 int jid;
173
174 iov[0].iov_base = __DECONST(char *, "host.hostname");
175 iov[0].iov_len = sizeof("host.hostname");
176 iov[1].iov_base = __DECONST(char *, JAIL_HOSTNAME);
177 iov[1].iov_len = sizeof(JAIL_HOSTNAME);
178 iov[2].iov_base = __DECONST(char *, "host.domainname");
179 iov[2].iov_len = sizeof("host.domainname");
180 iov[3].iov_base = __DECONST(char *, JAIL_DOMAINNAME);
181 iov[3].iov_len = sizeof(JAIL_DOMAINNAME);
182
183 jid = jail_set(iov, nitems(iov), JAIL_CREATE | JAIL_ATTACH);
184 ATF_REQUIRE_MSG(jid > 0, "Jail creation failed: %s", strerror(errno));
185 }
186
187 ATF_TC(getcwd_before_end);
ATF_TC_HEAD(getcwd_before_end,tc)188 ATF_TC_HEAD(getcwd_before_end, tc)
189 {
190 }
ATF_TC_BODY(getcwd_before_end,tc)191 ATF_TC_BODY(getcwd_before_end, tc)
192 {
193 #define BUF &__stack.__buf
194 struct {
195 uint8_t padding_l;
196 unsigned char __buf[8];
197 uint8_t padding_r;
198 } __stack;
199 const size_t __bufsz __unused = sizeof(__stack.__buf);
200 const size_t __len = 8 - 1;
201 const size_t __idx __unused = __len - 1;
202
203 getcwd(__stack.__buf, __len);
204 #undef BUF
205
206 }
207
208 ATF_TC(getcwd_end);
ATF_TC_HEAD(getcwd_end,tc)209 ATF_TC_HEAD(getcwd_end, tc)
210 {
211 }
ATF_TC_BODY(getcwd_end,tc)212 ATF_TC_BODY(getcwd_end, tc)
213 {
214 #define BUF &__stack.__buf
215 struct {
216 uint8_t padding_l;
217 unsigned char __buf[8];
218 uint8_t padding_r;
219 } __stack;
220 const size_t __bufsz __unused = sizeof(__stack.__buf);
221 const size_t __len = 8;
222 const size_t __idx __unused = __len - 1;
223
224 getcwd(__stack.__buf, __len);
225 #undef BUF
226
227 }
228
229 ATF_TC(getcwd_heap_before_end);
ATF_TC_HEAD(getcwd_heap_before_end,tc)230 ATF_TC_HEAD(getcwd_heap_before_end, tc)
231 {
232 }
ATF_TC_BODY(getcwd_heap_before_end,tc)233 ATF_TC_BODY(getcwd_heap_before_end, tc)
234 {
235 #define BUF __stack.__buf
236 struct {
237 uint8_t padding_l;
238 unsigned char * __buf;
239 uint8_t padding_r;
240 } __stack;
241 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (8);
242 const size_t __len = 8 - 1;
243 const size_t __idx __unused = __len - 1;
244
245 __stack.__buf = malloc(__bufsz);
246
247 getcwd(__stack.__buf, __len);
248 #undef BUF
249
250 }
251
252 ATF_TC(getcwd_heap_end);
ATF_TC_HEAD(getcwd_heap_end,tc)253 ATF_TC_HEAD(getcwd_heap_end, tc)
254 {
255 }
ATF_TC_BODY(getcwd_heap_end,tc)256 ATF_TC_BODY(getcwd_heap_end, tc)
257 {
258 #define BUF __stack.__buf
259 struct {
260 uint8_t padding_l;
261 unsigned char * __buf;
262 uint8_t padding_r;
263 } __stack;
264 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (8);
265 const size_t __len = 8;
266 const size_t __idx __unused = __len - 1;
267
268 __stack.__buf = malloc(__bufsz);
269
270 getcwd(__stack.__buf, __len);
271 #undef BUF
272
273 }
274
275 ATF_TC(getcwd_heap_after_end);
ATF_TC_HEAD(getcwd_heap_after_end,tc)276 ATF_TC_HEAD(getcwd_heap_after_end, tc)
277 {
278 }
ATF_TC_BODY(getcwd_heap_after_end,tc)279 ATF_TC_BODY(getcwd_heap_after_end, tc)
280 {
281 #define BUF __stack.__buf
282 struct {
283 uint8_t padding_l;
284 unsigned char * __buf;
285 uint8_t padding_r;
286 } __stack;
287 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (8);
288 const size_t __len = 8 + 1;
289 const size_t __idx __unused = __len - 1;
290 pid_t __child;
291 int __status;
292
293 __child = fork();
294 ATF_REQUIRE(__child >= 0);
295 if (__child > 0)
296 goto monitor;
297
298 /* Child */
299 disable_coredumps();
300 __stack.__buf = malloc(__bufsz);
301
302 getcwd(__stack.__buf, __len);
303 _exit(EX_SOFTWARE); /* Should have aborted. */
304
305 monitor:
306 while (waitpid(__child, &__status, 0) != __child) {
307 ATF_REQUIRE_EQ(EINTR, errno);
308 }
309
310 if (!WIFSIGNALED(__status)) {
311 switch (WEXITSTATUS(__status)) {
312 case EX_SOFTWARE:
313 atf_tc_fail("FORTIFY_SOURCE failed to abort");
314 break;
315 case EX_OSERR:
316 atf_tc_fail("setrlimit(2) failed");
317 break;
318 default:
319 atf_tc_fail("child exited with status %d",
320 WEXITSTATUS(__status));
321 }
322 } else {
323 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
324 }
325 #undef BUF
326
327 }
328
329 ATF_TC(getgrouplist_before_end);
ATF_TC_HEAD(getgrouplist_before_end,tc)330 ATF_TC_HEAD(getgrouplist_before_end, tc)
331 {
332 }
ATF_TC_BODY(getgrouplist_before_end,tc)333 ATF_TC_BODY(getgrouplist_before_end, tc)
334 {
335 #define BUF &__stack.__buf
336 struct {
337 uint8_t padding_l;
338 gid_t __buf[4];
339 uint8_t padding_r;
340 } __stack;
341 const size_t __bufsz __unused = sizeof(__stack.__buf);
342 const size_t __len = 4 - 1;
343 const size_t __idx __unused = __len - 1;
344 int intlen = (int)__len;
345
346 getgrouplist("root", 0, __stack.__buf, &intlen);
347 #undef BUF
348
349 }
350
351 ATF_TC(getgrouplist_end);
ATF_TC_HEAD(getgrouplist_end,tc)352 ATF_TC_HEAD(getgrouplist_end, tc)
353 {
354 }
ATF_TC_BODY(getgrouplist_end,tc)355 ATF_TC_BODY(getgrouplist_end, tc)
356 {
357 #define BUF &__stack.__buf
358 struct {
359 uint8_t padding_l;
360 gid_t __buf[4];
361 uint8_t padding_r;
362 } __stack;
363 const size_t __bufsz __unused = sizeof(__stack.__buf);
364 const size_t __len = 4;
365 const size_t __idx __unused = __len - 1;
366 int intlen = (int)__len;
367
368 getgrouplist("root", 0, __stack.__buf, &intlen);
369 #undef BUF
370
371 }
372
373 ATF_TC(getgrouplist_heap_before_end);
ATF_TC_HEAD(getgrouplist_heap_before_end,tc)374 ATF_TC_HEAD(getgrouplist_heap_before_end, tc)
375 {
376 }
ATF_TC_BODY(getgrouplist_heap_before_end,tc)377 ATF_TC_BODY(getgrouplist_heap_before_end, tc)
378 {
379 #define BUF __stack.__buf
380 struct {
381 uint8_t padding_l;
382 gid_t * __buf;
383 uint8_t padding_r;
384 } __stack;
385 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4);
386 const size_t __len = 4 - 1;
387 const size_t __idx __unused = __len - 1;
388 int intlen = (int)__len;
389
390 __stack.__buf = malloc(__bufsz);
391
392 getgrouplist("root", 0, __stack.__buf, &intlen);
393 #undef BUF
394
395 }
396
397 ATF_TC(getgrouplist_heap_end);
ATF_TC_HEAD(getgrouplist_heap_end,tc)398 ATF_TC_HEAD(getgrouplist_heap_end, tc)
399 {
400 }
ATF_TC_BODY(getgrouplist_heap_end,tc)401 ATF_TC_BODY(getgrouplist_heap_end, tc)
402 {
403 #define BUF __stack.__buf
404 struct {
405 uint8_t padding_l;
406 gid_t * __buf;
407 uint8_t padding_r;
408 } __stack;
409 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4);
410 const size_t __len = 4;
411 const size_t __idx __unused = __len - 1;
412 int intlen = (int)__len;
413
414 __stack.__buf = malloc(__bufsz);
415
416 getgrouplist("root", 0, __stack.__buf, &intlen);
417 #undef BUF
418
419 }
420
421 ATF_TC(getgrouplist_heap_after_end);
ATF_TC_HEAD(getgrouplist_heap_after_end,tc)422 ATF_TC_HEAD(getgrouplist_heap_after_end, tc)
423 {
424 }
ATF_TC_BODY(getgrouplist_heap_after_end,tc)425 ATF_TC_BODY(getgrouplist_heap_after_end, tc)
426 {
427 #define BUF __stack.__buf
428 struct {
429 uint8_t padding_l;
430 gid_t * __buf;
431 uint8_t padding_r;
432 } __stack;
433 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4);
434 const size_t __len = 4 + 1;
435 const size_t __idx __unused = __len - 1;
436 pid_t __child;
437 int __status;
438 int intlen = (int)__len;
439
440 __child = fork();
441 ATF_REQUIRE(__child >= 0);
442 if (__child > 0)
443 goto monitor;
444
445 /* Child */
446 disable_coredumps();
447 __stack.__buf = malloc(__bufsz);
448
449 getgrouplist("root", 0, __stack.__buf, &intlen);
450 _exit(EX_SOFTWARE); /* Should have aborted. */
451
452 monitor:
453 while (waitpid(__child, &__status, 0) != __child) {
454 ATF_REQUIRE_EQ(EINTR, errno);
455 }
456
457 if (!WIFSIGNALED(__status)) {
458 switch (WEXITSTATUS(__status)) {
459 case EX_SOFTWARE:
460 atf_tc_fail("FORTIFY_SOURCE failed to abort");
461 break;
462 case EX_OSERR:
463 atf_tc_fail("setrlimit(2) failed");
464 break;
465 default:
466 atf_tc_fail("child exited with status %d",
467 WEXITSTATUS(__status));
468 }
469 } else {
470 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
471 }
472 #undef BUF
473
474 }
475
476 ATF_TC(getgroups_before_end);
ATF_TC_HEAD(getgroups_before_end,tc)477 ATF_TC_HEAD(getgroups_before_end, tc)
478 {
479 }
ATF_TC_BODY(getgroups_before_end,tc)480 ATF_TC_BODY(getgroups_before_end, tc)
481 {
482 #define BUF &__stack.__buf
483 struct {
484 uint8_t padding_l;
485 gid_t __buf[4];
486 uint8_t padding_r;
487 } __stack;
488 const size_t __bufsz __unused = sizeof(__stack.__buf);
489 const size_t __len = 4 - 1;
490 const size_t __idx __unused = __len - 1;
491
492 getgroups(__len, __stack.__buf);
493 #undef BUF
494
495 }
496
497 ATF_TC(getgroups_end);
ATF_TC_HEAD(getgroups_end,tc)498 ATF_TC_HEAD(getgroups_end, tc)
499 {
500 }
ATF_TC_BODY(getgroups_end,tc)501 ATF_TC_BODY(getgroups_end, tc)
502 {
503 #define BUF &__stack.__buf
504 struct {
505 uint8_t padding_l;
506 gid_t __buf[4];
507 uint8_t padding_r;
508 } __stack;
509 const size_t __bufsz __unused = sizeof(__stack.__buf);
510 const size_t __len = 4;
511 const size_t __idx __unused = __len - 1;
512
513 getgroups(__len, __stack.__buf);
514 #undef BUF
515
516 }
517
518 ATF_TC(getgroups_heap_before_end);
ATF_TC_HEAD(getgroups_heap_before_end,tc)519 ATF_TC_HEAD(getgroups_heap_before_end, tc)
520 {
521 }
ATF_TC_BODY(getgroups_heap_before_end,tc)522 ATF_TC_BODY(getgroups_heap_before_end, tc)
523 {
524 #define BUF __stack.__buf
525 struct {
526 uint8_t padding_l;
527 gid_t * __buf;
528 uint8_t padding_r;
529 } __stack;
530 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4);
531 const size_t __len = 4 - 1;
532 const size_t __idx __unused = __len - 1;
533
534 __stack.__buf = malloc(__bufsz);
535
536 getgroups(__len, __stack.__buf);
537 #undef BUF
538
539 }
540
541 ATF_TC(getgroups_heap_end);
ATF_TC_HEAD(getgroups_heap_end,tc)542 ATF_TC_HEAD(getgroups_heap_end, tc)
543 {
544 }
ATF_TC_BODY(getgroups_heap_end,tc)545 ATF_TC_BODY(getgroups_heap_end, tc)
546 {
547 #define BUF __stack.__buf
548 struct {
549 uint8_t padding_l;
550 gid_t * __buf;
551 uint8_t padding_r;
552 } __stack;
553 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4);
554 const size_t __len = 4;
555 const size_t __idx __unused = __len - 1;
556
557 __stack.__buf = malloc(__bufsz);
558
559 getgroups(__len, __stack.__buf);
560 #undef BUF
561
562 }
563
564 ATF_TC(getgroups_heap_after_end);
ATF_TC_HEAD(getgroups_heap_after_end,tc)565 ATF_TC_HEAD(getgroups_heap_after_end, tc)
566 {
567 }
ATF_TC_BODY(getgroups_heap_after_end,tc)568 ATF_TC_BODY(getgroups_heap_after_end, tc)
569 {
570 #define BUF __stack.__buf
571 struct {
572 uint8_t padding_l;
573 gid_t * __buf;
574 uint8_t padding_r;
575 } __stack;
576 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4);
577 const size_t __len = 4 + 1;
578 const size_t __idx __unused = __len - 1;
579 pid_t __child;
580 int __status;
581
582 __child = fork();
583 ATF_REQUIRE(__child >= 0);
584 if (__child > 0)
585 goto monitor;
586
587 /* Child */
588 disable_coredumps();
589 __stack.__buf = malloc(__bufsz);
590
591 getgroups(__len, __stack.__buf);
592 _exit(EX_SOFTWARE); /* Should have aborted. */
593
594 monitor:
595 while (waitpid(__child, &__status, 0) != __child) {
596 ATF_REQUIRE_EQ(EINTR, errno);
597 }
598
599 if (!WIFSIGNALED(__status)) {
600 switch (WEXITSTATUS(__status)) {
601 case EX_SOFTWARE:
602 atf_tc_fail("FORTIFY_SOURCE failed to abort");
603 break;
604 case EX_OSERR:
605 atf_tc_fail("setrlimit(2) failed");
606 break;
607 default:
608 atf_tc_fail("child exited with status %d",
609 WEXITSTATUS(__status));
610 }
611 } else {
612 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
613 }
614 #undef BUF
615
616 }
617
618 ATF_TC(getloginclass_before_end);
ATF_TC_HEAD(getloginclass_before_end,tc)619 ATF_TC_HEAD(getloginclass_before_end, tc)
620 {
621 }
ATF_TC_BODY(getloginclass_before_end,tc)622 ATF_TC_BODY(getloginclass_before_end, tc)
623 {
624 #define BUF &__stack.__buf
625 struct {
626 uint8_t padding_l;
627 unsigned char __buf[42];
628 uint8_t padding_r;
629 } __stack;
630 const size_t __bufsz __unused = sizeof(__stack.__buf);
631 const size_t __len = 42 - 1;
632 const size_t __idx __unused = __len - 1;
633
634 getloginclass(__stack.__buf, __len);
635 #undef BUF
636
637 }
638
639 ATF_TC(getloginclass_end);
ATF_TC_HEAD(getloginclass_end,tc)640 ATF_TC_HEAD(getloginclass_end, tc)
641 {
642 }
ATF_TC_BODY(getloginclass_end,tc)643 ATF_TC_BODY(getloginclass_end, tc)
644 {
645 #define BUF &__stack.__buf
646 struct {
647 uint8_t padding_l;
648 unsigned char __buf[42];
649 uint8_t padding_r;
650 } __stack;
651 const size_t __bufsz __unused = sizeof(__stack.__buf);
652 const size_t __len = 42;
653 const size_t __idx __unused = __len - 1;
654
655 getloginclass(__stack.__buf, __len);
656 #undef BUF
657
658 }
659
660 ATF_TC(getloginclass_heap_before_end);
ATF_TC_HEAD(getloginclass_heap_before_end,tc)661 ATF_TC_HEAD(getloginclass_heap_before_end, tc)
662 {
663 }
ATF_TC_BODY(getloginclass_heap_before_end,tc)664 ATF_TC_BODY(getloginclass_heap_before_end, tc)
665 {
666 #define BUF __stack.__buf
667 struct {
668 uint8_t padding_l;
669 unsigned char * __buf;
670 uint8_t padding_r;
671 } __stack;
672 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
673 const size_t __len = 42 - 1;
674 const size_t __idx __unused = __len - 1;
675
676 __stack.__buf = malloc(__bufsz);
677
678 getloginclass(__stack.__buf, __len);
679 #undef BUF
680
681 }
682
683 ATF_TC(getloginclass_heap_end);
ATF_TC_HEAD(getloginclass_heap_end,tc)684 ATF_TC_HEAD(getloginclass_heap_end, tc)
685 {
686 }
ATF_TC_BODY(getloginclass_heap_end,tc)687 ATF_TC_BODY(getloginclass_heap_end, tc)
688 {
689 #define BUF __stack.__buf
690 struct {
691 uint8_t padding_l;
692 unsigned char * __buf;
693 uint8_t padding_r;
694 } __stack;
695 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
696 const size_t __len = 42;
697 const size_t __idx __unused = __len - 1;
698
699 __stack.__buf = malloc(__bufsz);
700
701 getloginclass(__stack.__buf, __len);
702 #undef BUF
703
704 }
705
706 ATF_TC(getloginclass_heap_after_end);
ATF_TC_HEAD(getloginclass_heap_after_end,tc)707 ATF_TC_HEAD(getloginclass_heap_after_end, tc)
708 {
709 }
ATF_TC_BODY(getloginclass_heap_after_end,tc)710 ATF_TC_BODY(getloginclass_heap_after_end, tc)
711 {
712 #define BUF __stack.__buf
713 struct {
714 uint8_t padding_l;
715 unsigned char * __buf;
716 uint8_t padding_r;
717 } __stack;
718 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
719 const size_t __len = 42 + 1;
720 const size_t __idx __unused = __len - 1;
721 pid_t __child;
722 int __status;
723
724 __child = fork();
725 ATF_REQUIRE(__child >= 0);
726 if (__child > 0)
727 goto monitor;
728
729 /* Child */
730 disable_coredumps();
731 __stack.__buf = malloc(__bufsz);
732
733 getloginclass(__stack.__buf, __len);
734 _exit(EX_SOFTWARE); /* Should have aborted. */
735
736 monitor:
737 while (waitpid(__child, &__status, 0) != __child) {
738 ATF_REQUIRE_EQ(EINTR, errno);
739 }
740
741 if (!WIFSIGNALED(__status)) {
742 switch (WEXITSTATUS(__status)) {
743 case EX_SOFTWARE:
744 atf_tc_fail("FORTIFY_SOURCE failed to abort");
745 break;
746 case EX_OSERR:
747 atf_tc_fail("setrlimit(2) failed");
748 break;
749 default:
750 atf_tc_fail("child exited with status %d",
751 WEXITSTATUS(__status));
752 }
753 } else {
754 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
755 }
756 #undef BUF
757
758 }
759
760 ATF_TC(pread_before_end);
ATF_TC_HEAD(pread_before_end,tc)761 ATF_TC_HEAD(pread_before_end, tc)
762 {
763 }
ATF_TC_BODY(pread_before_end,tc)764 ATF_TC_BODY(pread_before_end, tc)
765 {
766 #define BUF &__stack.__buf
767 struct {
768 uint8_t padding_l;
769 unsigned char __buf[41];
770 uint8_t padding_r;
771 } __stack;
772 const size_t __bufsz __unused = sizeof(__stack.__buf);
773 const size_t __len = 41 - 1;
774 const size_t __idx __unused = __len - 1;
775 int fd;
776
777 fd = new_tmpfile(); /* Cannot fail */
778
779 pread(fd, __stack.__buf, __len, 0);
780 #undef BUF
781
782 }
783
784 ATF_TC(pread_end);
ATF_TC_HEAD(pread_end,tc)785 ATF_TC_HEAD(pread_end, tc)
786 {
787 }
ATF_TC_BODY(pread_end,tc)788 ATF_TC_BODY(pread_end, tc)
789 {
790 #define BUF &__stack.__buf
791 struct {
792 uint8_t padding_l;
793 unsigned char __buf[41];
794 uint8_t padding_r;
795 } __stack;
796 const size_t __bufsz __unused = sizeof(__stack.__buf);
797 const size_t __len = 41;
798 const size_t __idx __unused = __len - 1;
799 int fd;
800
801 fd = new_tmpfile(); /* Cannot fail */
802
803 pread(fd, __stack.__buf, __len, 0);
804 #undef BUF
805
806 }
807
808 ATF_TC(pread_heap_before_end);
ATF_TC_HEAD(pread_heap_before_end,tc)809 ATF_TC_HEAD(pread_heap_before_end, tc)
810 {
811 }
ATF_TC_BODY(pread_heap_before_end,tc)812 ATF_TC_BODY(pread_heap_before_end, tc)
813 {
814 #define BUF __stack.__buf
815 struct {
816 uint8_t padding_l;
817 unsigned char * __buf;
818 uint8_t padding_r;
819 } __stack;
820 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41);
821 const size_t __len = 41 - 1;
822 const size_t __idx __unused = __len - 1;
823 int fd;
824
825 __stack.__buf = malloc(__bufsz);
826 fd = new_tmpfile(); /* Cannot fail */
827
828 pread(fd, __stack.__buf, __len, 0);
829 #undef BUF
830
831 }
832
833 ATF_TC(pread_heap_end);
ATF_TC_HEAD(pread_heap_end,tc)834 ATF_TC_HEAD(pread_heap_end, tc)
835 {
836 }
ATF_TC_BODY(pread_heap_end,tc)837 ATF_TC_BODY(pread_heap_end, tc)
838 {
839 #define BUF __stack.__buf
840 struct {
841 uint8_t padding_l;
842 unsigned char * __buf;
843 uint8_t padding_r;
844 } __stack;
845 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41);
846 const size_t __len = 41;
847 const size_t __idx __unused = __len - 1;
848 int fd;
849
850 __stack.__buf = malloc(__bufsz);
851 fd = new_tmpfile(); /* Cannot fail */
852
853 pread(fd, __stack.__buf, __len, 0);
854 #undef BUF
855
856 }
857
858 ATF_TC(pread_heap_after_end);
ATF_TC_HEAD(pread_heap_after_end,tc)859 ATF_TC_HEAD(pread_heap_after_end, tc)
860 {
861 }
ATF_TC_BODY(pread_heap_after_end,tc)862 ATF_TC_BODY(pread_heap_after_end, tc)
863 {
864 #define BUF __stack.__buf
865 struct {
866 uint8_t padding_l;
867 unsigned char * __buf;
868 uint8_t padding_r;
869 } __stack;
870 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41);
871 const size_t __len = 41 + 1;
872 const size_t __idx __unused = __len - 1;
873 pid_t __child;
874 int __status;
875 int fd;
876
877 __child = fork();
878 ATF_REQUIRE(__child >= 0);
879 if (__child > 0)
880 goto monitor;
881
882 /* Child */
883 disable_coredumps();
884 __stack.__buf = malloc(__bufsz);
885 fd = new_tmpfile(); /* Cannot fail */
886
887 pread(fd, __stack.__buf, __len, 0);
888 _exit(EX_SOFTWARE); /* Should have aborted. */
889
890 monitor:
891 while (waitpid(__child, &__status, 0) != __child) {
892 ATF_REQUIRE_EQ(EINTR, errno);
893 }
894
895 if (!WIFSIGNALED(__status)) {
896 switch (WEXITSTATUS(__status)) {
897 case EX_SOFTWARE:
898 atf_tc_fail("FORTIFY_SOURCE failed to abort");
899 break;
900 case EX_OSERR:
901 atf_tc_fail("setrlimit(2) failed");
902 break;
903 default:
904 atf_tc_fail("child exited with status %d",
905 WEXITSTATUS(__status));
906 }
907 } else {
908 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
909 }
910 #undef BUF
911
912 }
913
914 ATF_TC(read_before_end);
ATF_TC_HEAD(read_before_end,tc)915 ATF_TC_HEAD(read_before_end, tc)
916 {
917 }
ATF_TC_BODY(read_before_end,tc)918 ATF_TC_BODY(read_before_end, tc)
919 {
920 #define BUF &__stack.__buf
921 struct {
922 uint8_t padding_l;
923 unsigned char __buf[41];
924 uint8_t padding_r;
925 } __stack;
926 const size_t __bufsz __unused = sizeof(__stack.__buf);
927 const size_t __len = 41 - 1;
928 const size_t __idx __unused = __len - 1;
929 int fd;
930
931 fd = new_tmpfile(); /* Cannot fail */
932
933 read(fd, __stack.__buf, __len);
934 #undef BUF
935
936 }
937
938 ATF_TC(read_end);
ATF_TC_HEAD(read_end,tc)939 ATF_TC_HEAD(read_end, tc)
940 {
941 }
ATF_TC_BODY(read_end,tc)942 ATF_TC_BODY(read_end, tc)
943 {
944 #define BUF &__stack.__buf
945 struct {
946 uint8_t padding_l;
947 unsigned char __buf[41];
948 uint8_t padding_r;
949 } __stack;
950 const size_t __bufsz __unused = sizeof(__stack.__buf);
951 const size_t __len = 41;
952 const size_t __idx __unused = __len - 1;
953 int fd;
954
955 fd = new_tmpfile(); /* Cannot fail */
956
957 read(fd, __stack.__buf, __len);
958 #undef BUF
959
960 }
961
962 ATF_TC(read_heap_before_end);
ATF_TC_HEAD(read_heap_before_end,tc)963 ATF_TC_HEAD(read_heap_before_end, tc)
964 {
965 }
ATF_TC_BODY(read_heap_before_end,tc)966 ATF_TC_BODY(read_heap_before_end, tc)
967 {
968 #define BUF __stack.__buf
969 struct {
970 uint8_t padding_l;
971 unsigned char * __buf;
972 uint8_t padding_r;
973 } __stack;
974 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41);
975 const size_t __len = 41 - 1;
976 const size_t __idx __unused = __len - 1;
977 int fd;
978
979 __stack.__buf = malloc(__bufsz);
980 fd = new_tmpfile(); /* Cannot fail */
981
982 read(fd, __stack.__buf, __len);
983 #undef BUF
984
985 }
986
987 ATF_TC(read_heap_end);
ATF_TC_HEAD(read_heap_end,tc)988 ATF_TC_HEAD(read_heap_end, tc)
989 {
990 }
ATF_TC_BODY(read_heap_end,tc)991 ATF_TC_BODY(read_heap_end, tc)
992 {
993 #define BUF __stack.__buf
994 struct {
995 uint8_t padding_l;
996 unsigned char * __buf;
997 uint8_t padding_r;
998 } __stack;
999 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41);
1000 const size_t __len = 41;
1001 const size_t __idx __unused = __len - 1;
1002 int fd;
1003
1004 __stack.__buf = malloc(__bufsz);
1005 fd = new_tmpfile(); /* Cannot fail */
1006
1007 read(fd, __stack.__buf, __len);
1008 #undef BUF
1009
1010 }
1011
1012 ATF_TC(read_heap_after_end);
ATF_TC_HEAD(read_heap_after_end,tc)1013 ATF_TC_HEAD(read_heap_after_end, tc)
1014 {
1015 }
ATF_TC_BODY(read_heap_after_end,tc)1016 ATF_TC_BODY(read_heap_after_end, tc)
1017 {
1018 #define BUF __stack.__buf
1019 struct {
1020 uint8_t padding_l;
1021 unsigned char * __buf;
1022 uint8_t padding_r;
1023 } __stack;
1024 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (41);
1025 const size_t __len = 41 + 1;
1026 const size_t __idx __unused = __len - 1;
1027 pid_t __child;
1028 int __status;
1029 int fd;
1030
1031 __child = fork();
1032 ATF_REQUIRE(__child >= 0);
1033 if (__child > 0)
1034 goto monitor;
1035
1036 /* Child */
1037 disable_coredumps();
1038 __stack.__buf = malloc(__bufsz);
1039 fd = new_tmpfile(); /* Cannot fail */
1040
1041 read(fd, __stack.__buf, __len);
1042 _exit(EX_SOFTWARE); /* Should have aborted. */
1043
1044 monitor:
1045 while (waitpid(__child, &__status, 0) != __child) {
1046 ATF_REQUIRE_EQ(EINTR, errno);
1047 }
1048
1049 if (!WIFSIGNALED(__status)) {
1050 switch (WEXITSTATUS(__status)) {
1051 case EX_SOFTWARE:
1052 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1053 break;
1054 case EX_OSERR:
1055 atf_tc_fail("setrlimit(2) failed");
1056 break;
1057 default:
1058 atf_tc_fail("child exited with status %d",
1059 WEXITSTATUS(__status));
1060 }
1061 } else {
1062 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1063 }
1064 #undef BUF
1065
1066 }
1067
1068 ATF_TC(readlink_before_end);
ATF_TC_HEAD(readlink_before_end,tc)1069 ATF_TC_HEAD(readlink_before_end, tc)
1070 {
1071 }
ATF_TC_BODY(readlink_before_end,tc)1072 ATF_TC_BODY(readlink_before_end, tc)
1073 {
1074 #define BUF &__stack.__buf
1075 struct {
1076 uint8_t padding_l;
1077 unsigned char __buf[42];
1078 uint8_t padding_r;
1079 } __stack;
1080 const size_t __bufsz __unused = sizeof(__stack.__buf);
1081 const size_t __len = 42 - 1;
1082 const size_t __idx __unused = __len - 1;
1083 const char *path;
1084
1085 path = new_symlink(__len); /* Cannot fail */
1086
1087 readlink(path, __stack.__buf, __len);
1088 #undef BUF
1089
1090 }
1091
1092 ATF_TC(readlink_end);
ATF_TC_HEAD(readlink_end,tc)1093 ATF_TC_HEAD(readlink_end, tc)
1094 {
1095 }
ATF_TC_BODY(readlink_end,tc)1096 ATF_TC_BODY(readlink_end, tc)
1097 {
1098 #define BUF &__stack.__buf
1099 struct {
1100 uint8_t padding_l;
1101 unsigned char __buf[42];
1102 uint8_t padding_r;
1103 } __stack;
1104 const size_t __bufsz __unused = sizeof(__stack.__buf);
1105 const size_t __len = 42;
1106 const size_t __idx __unused = __len - 1;
1107 const char *path;
1108
1109 path = new_symlink(__len); /* Cannot fail */
1110
1111 readlink(path, __stack.__buf, __len);
1112 #undef BUF
1113
1114 }
1115
1116 ATF_TC(readlink_heap_before_end);
ATF_TC_HEAD(readlink_heap_before_end,tc)1117 ATF_TC_HEAD(readlink_heap_before_end, tc)
1118 {
1119 }
ATF_TC_BODY(readlink_heap_before_end,tc)1120 ATF_TC_BODY(readlink_heap_before_end, tc)
1121 {
1122 #define BUF __stack.__buf
1123 struct {
1124 uint8_t padding_l;
1125 unsigned char * __buf;
1126 uint8_t padding_r;
1127 } __stack;
1128 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1129 const size_t __len = 42 - 1;
1130 const size_t __idx __unused = __len - 1;
1131 const char *path;
1132
1133 __stack.__buf = malloc(__bufsz);
1134 path = new_symlink(__len); /* Cannot fail */
1135
1136 readlink(path, __stack.__buf, __len);
1137 #undef BUF
1138
1139 }
1140
1141 ATF_TC(readlink_heap_end);
ATF_TC_HEAD(readlink_heap_end,tc)1142 ATF_TC_HEAD(readlink_heap_end, tc)
1143 {
1144 }
ATF_TC_BODY(readlink_heap_end,tc)1145 ATF_TC_BODY(readlink_heap_end, tc)
1146 {
1147 #define BUF __stack.__buf
1148 struct {
1149 uint8_t padding_l;
1150 unsigned char * __buf;
1151 uint8_t padding_r;
1152 } __stack;
1153 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1154 const size_t __len = 42;
1155 const size_t __idx __unused = __len - 1;
1156 const char *path;
1157
1158 __stack.__buf = malloc(__bufsz);
1159 path = new_symlink(__len); /* Cannot fail */
1160
1161 readlink(path, __stack.__buf, __len);
1162 #undef BUF
1163
1164 }
1165
1166 ATF_TC(readlink_heap_after_end);
ATF_TC_HEAD(readlink_heap_after_end,tc)1167 ATF_TC_HEAD(readlink_heap_after_end, tc)
1168 {
1169 }
ATF_TC_BODY(readlink_heap_after_end,tc)1170 ATF_TC_BODY(readlink_heap_after_end, tc)
1171 {
1172 #define BUF __stack.__buf
1173 struct {
1174 uint8_t padding_l;
1175 unsigned char * __buf;
1176 uint8_t padding_r;
1177 } __stack;
1178 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1179 const size_t __len = 42 + 1;
1180 const size_t __idx __unused = __len - 1;
1181 pid_t __child;
1182 int __status;
1183 const char *path;
1184
1185 __child = fork();
1186 ATF_REQUIRE(__child >= 0);
1187 if (__child > 0)
1188 goto monitor;
1189
1190 /* Child */
1191 disable_coredumps();
1192 __stack.__buf = malloc(__bufsz);
1193 path = new_symlink(__len); /* Cannot fail */
1194
1195 readlink(path, __stack.__buf, __len);
1196 _exit(EX_SOFTWARE); /* Should have aborted. */
1197
1198 monitor:
1199 while (waitpid(__child, &__status, 0) != __child) {
1200 ATF_REQUIRE_EQ(EINTR, errno);
1201 }
1202
1203 if (!WIFSIGNALED(__status)) {
1204 switch (WEXITSTATUS(__status)) {
1205 case EX_SOFTWARE:
1206 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1207 break;
1208 case EX_OSERR:
1209 atf_tc_fail("setrlimit(2) failed");
1210 break;
1211 default:
1212 atf_tc_fail("child exited with status %d",
1213 WEXITSTATUS(__status));
1214 }
1215 } else {
1216 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1217 }
1218 #undef BUF
1219
1220 }
1221
1222 ATF_TC(readlinkat_before_end);
ATF_TC_HEAD(readlinkat_before_end,tc)1223 ATF_TC_HEAD(readlinkat_before_end, tc)
1224 {
1225 }
ATF_TC_BODY(readlinkat_before_end,tc)1226 ATF_TC_BODY(readlinkat_before_end, tc)
1227 {
1228 #define BUF &__stack.__buf
1229 struct {
1230 uint8_t padding_l;
1231 unsigned char __buf[42];
1232 uint8_t padding_r;
1233 } __stack;
1234 const size_t __bufsz __unused = sizeof(__stack.__buf);
1235 const size_t __len = 42 - 1;
1236 const size_t __idx __unused = __len - 1;
1237 const char *path;
1238
1239 path = new_symlink(__len); /* Cannot fail */
1240
1241 readlinkat(AT_FDCWD, path, __stack.__buf, __len);
1242 #undef BUF
1243
1244 }
1245
1246 ATF_TC(readlinkat_end);
ATF_TC_HEAD(readlinkat_end,tc)1247 ATF_TC_HEAD(readlinkat_end, tc)
1248 {
1249 }
ATF_TC_BODY(readlinkat_end,tc)1250 ATF_TC_BODY(readlinkat_end, tc)
1251 {
1252 #define BUF &__stack.__buf
1253 struct {
1254 uint8_t padding_l;
1255 unsigned char __buf[42];
1256 uint8_t padding_r;
1257 } __stack;
1258 const size_t __bufsz __unused = sizeof(__stack.__buf);
1259 const size_t __len = 42;
1260 const size_t __idx __unused = __len - 1;
1261 const char *path;
1262
1263 path = new_symlink(__len); /* Cannot fail */
1264
1265 readlinkat(AT_FDCWD, path, __stack.__buf, __len);
1266 #undef BUF
1267
1268 }
1269
1270 ATF_TC(readlinkat_heap_before_end);
ATF_TC_HEAD(readlinkat_heap_before_end,tc)1271 ATF_TC_HEAD(readlinkat_heap_before_end, tc)
1272 {
1273 }
ATF_TC_BODY(readlinkat_heap_before_end,tc)1274 ATF_TC_BODY(readlinkat_heap_before_end, tc)
1275 {
1276 #define BUF __stack.__buf
1277 struct {
1278 uint8_t padding_l;
1279 unsigned char * __buf;
1280 uint8_t padding_r;
1281 } __stack;
1282 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1283 const size_t __len = 42 - 1;
1284 const size_t __idx __unused = __len - 1;
1285 const char *path;
1286
1287 __stack.__buf = malloc(__bufsz);
1288 path = new_symlink(__len); /* Cannot fail */
1289
1290 readlinkat(AT_FDCWD, path, __stack.__buf, __len);
1291 #undef BUF
1292
1293 }
1294
1295 ATF_TC(readlinkat_heap_end);
ATF_TC_HEAD(readlinkat_heap_end,tc)1296 ATF_TC_HEAD(readlinkat_heap_end, tc)
1297 {
1298 }
ATF_TC_BODY(readlinkat_heap_end,tc)1299 ATF_TC_BODY(readlinkat_heap_end, tc)
1300 {
1301 #define BUF __stack.__buf
1302 struct {
1303 uint8_t padding_l;
1304 unsigned char * __buf;
1305 uint8_t padding_r;
1306 } __stack;
1307 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1308 const size_t __len = 42;
1309 const size_t __idx __unused = __len - 1;
1310 const char *path;
1311
1312 __stack.__buf = malloc(__bufsz);
1313 path = new_symlink(__len); /* Cannot fail */
1314
1315 readlinkat(AT_FDCWD, path, __stack.__buf, __len);
1316 #undef BUF
1317
1318 }
1319
1320 ATF_TC(readlinkat_heap_after_end);
ATF_TC_HEAD(readlinkat_heap_after_end,tc)1321 ATF_TC_HEAD(readlinkat_heap_after_end, tc)
1322 {
1323 }
ATF_TC_BODY(readlinkat_heap_after_end,tc)1324 ATF_TC_BODY(readlinkat_heap_after_end, tc)
1325 {
1326 #define BUF __stack.__buf
1327 struct {
1328 uint8_t padding_l;
1329 unsigned char * __buf;
1330 uint8_t padding_r;
1331 } __stack;
1332 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1333 const size_t __len = 42 + 1;
1334 const size_t __idx __unused = __len - 1;
1335 pid_t __child;
1336 int __status;
1337 const char *path;
1338
1339 __child = fork();
1340 ATF_REQUIRE(__child >= 0);
1341 if (__child > 0)
1342 goto monitor;
1343
1344 /* Child */
1345 disable_coredumps();
1346 __stack.__buf = malloc(__bufsz);
1347 path = new_symlink(__len); /* Cannot fail */
1348
1349 readlinkat(AT_FDCWD, path, __stack.__buf, __len);
1350 _exit(EX_SOFTWARE); /* Should have aborted. */
1351
1352 monitor:
1353 while (waitpid(__child, &__status, 0) != __child) {
1354 ATF_REQUIRE_EQ(EINTR, errno);
1355 }
1356
1357 if (!WIFSIGNALED(__status)) {
1358 switch (WEXITSTATUS(__status)) {
1359 case EX_SOFTWARE:
1360 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1361 break;
1362 case EX_OSERR:
1363 atf_tc_fail("setrlimit(2) failed");
1364 break;
1365 default:
1366 atf_tc_fail("child exited with status %d",
1367 WEXITSTATUS(__status));
1368 }
1369 } else {
1370 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1371 }
1372 #undef BUF
1373
1374 }
1375
1376 ATF_TC(getdomainname_before_end);
ATF_TC_HEAD(getdomainname_before_end,tc)1377 ATF_TC_HEAD(getdomainname_before_end, tc)
1378 {
1379 atf_tc_set_md_var(tc, "require.user", "root");
1380 }
ATF_TC_BODY(getdomainname_before_end,tc)1381 ATF_TC_BODY(getdomainname_before_end, tc)
1382 {
1383 #define BUF &__stack.__buf
1384 struct {
1385 uint8_t padding_l;
1386 unsigned char __buf[12];
1387 uint8_t padding_r;
1388 } __stack;
1389 const size_t __bufsz __unused = sizeof(__stack.__buf);
1390 const size_t __len = 12 - 1;
1391 const size_t __idx __unused = __len - 1;
1392
1393 dhost_jail();
1394 getdomainname(__stack.__buf, __len);
1395 #undef BUF
1396
1397 }
1398
1399 ATF_TC(getdomainname_end);
ATF_TC_HEAD(getdomainname_end,tc)1400 ATF_TC_HEAD(getdomainname_end, tc)
1401 {
1402 atf_tc_set_md_var(tc, "require.user", "root");
1403 }
ATF_TC_BODY(getdomainname_end,tc)1404 ATF_TC_BODY(getdomainname_end, tc)
1405 {
1406 #define BUF &__stack.__buf
1407 struct {
1408 uint8_t padding_l;
1409 unsigned char __buf[12];
1410 uint8_t padding_r;
1411 } __stack;
1412 const size_t __bufsz __unused = sizeof(__stack.__buf);
1413 const size_t __len = 12;
1414 const size_t __idx __unused = __len - 1;
1415
1416 dhost_jail();
1417 getdomainname(__stack.__buf, __len);
1418 #undef BUF
1419
1420 }
1421
1422 ATF_TC(getdomainname_heap_before_end);
ATF_TC_HEAD(getdomainname_heap_before_end,tc)1423 ATF_TC_HEAD(getdomainname_heap_before_end, tc)
1424 {
1425 atf_tc_set_md_var(tc, "require.user", "root");
1426 }
ATF_TC_BODY(getdomainname_heap_before_end,tc)1427 ATF_TC_BODY(getdomainname_heap_before_end, tc)
1428 {
1429 #define BUF __stack.__buf
1430 struct {
1431 uint8_t padding_l;
1432 unsigned char * __buf;
1433 uint8_t padding_r;
1434 } __stack;
1435 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (12);
1436 const size_t __len = 12 - 1;
1437 const size_t __idx __unused = __len - 1;
1438
1439 dhost_jail();
1440 __stack.__buf = malloc(__bufsz);
1441
1442 getdomainname(__stack.__buf, __len);
1443 #undef BUF
1444
1445 }
1446
1447 ATF_TC(getdomainname_heap_end);
ATF_TC_HEAD(getdomainname_heap_end,tc)1448 ATF_TC_HEAD(getdomainname_heap_end, tc)
1449 {
1450 atf_tc_set_md_var(tc, "require.user", "root");
1451 }
ATF_TC_BODY(getdomainname_heap_end,tc)1452 ATF_TC_BODY(getdomainname_heap_end, tc)
1453 {
1454 #define BUF __stack.__buf
1455 struct {
1456 uint8_t padding_l;
1457 unsigned char * __buf;
1458 uint8_t padding_r;
1459 } __stack;
1460 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (12);
1461 const size_t __len = 12;
1462 const size_t __idx __unused = __len - 1;
1463
1464 dhost_jail();
1465 __stack.__buf = malloc(__bufsz);
1466
1467 getdomainname(__stack.__buf, __len);
1468 #undef BUF
1469
1470 }
1471
1472 ATF_TC(getdomainname_heap_after_end);
ATF_TC_HEAD(getdomainname_heap_after_end,tc)1473 ATF_TC_HEAD(getdomainname_heap_after_end, tc)
1474 {
1475 atf_tc_set_md_var(tc, "require.user", "root");
1476 }
ATF_TC_BODY(getdomainname_heap_after_end,tc)1477 ATF_TC_BODY(getdomainname_heap_after_end, tc)
1478 {
1479 #define BUF __stack.__buf
1480 struct {
1481 uint8_t padding_l;
1482 unsigned char * __buf;
1483 uint8_t padding_r;
1484 } __stack;
1485 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (12);
1486 const size_t __len = 12 + 1;
1487 const size_t __idx __unused = __len - 1;
1488 pid_t __child;
1489 int __status;
1490
1491 dhost_jail();
1492 __child = fork();
1493 ATF_REQUIRE(__child >= 0);
1494 if (__child > 0)
1495 goto monitor;
1496
1497 /* Child */
1498 disable_coredumps();
1499 __stack.__buf = malloc(__bufsz);
1500
1501 getdomainname(__stack.__buf, __len);
1502 _exit(EX_SOFTWARE); /* Should have aborted. */
1503
1504 monitor:
1505 while (waitpid(__child, &__status, 0) != __child) {
1506 ATF_REQUIRE_EQ(EINTR, errno);
1507 }
1508
1509 if (!WIFSIGNALED(__status)) {
1510 switch (WEXITSTATUS(__status)) {
1511 case EX_SOFTWARE:
1512 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1513 break;
1514 case EX_OSERR:
1515 atf_tc_fail("setrlimit(2) failed");
1516 break;
1517 default:
1518 atf_tc_fail("child exited with status %d",
1519 WEXITSTATUS(__status));
1520 }
1521 } else {
1522 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1523 }
1524 #undef BUF
1525
1526 }
1527
1528 ATF_TC(getentropy_before_end);
ATF_TC_HEAD(getentropy_before_end,tc)1529 ATF_TC_HEAD(getentropy_before_end, tc)
1530 {
1531 }
ATF_TC_BODY(getentropy_before_end,tc)1532 ATF_TC_BODY(getentropy_before_end, tc)
1533 {
1534 #define BUF &__stack.__buf
1535 struct {
1536 uint8_t padding_l;
1537 unsigned char __buf[42];
1538 uint8_t padding_r;
1539 } __stack;
1540 const size_t __bufsz __unused = sizeof(__stack.__buf);
1541 const size_t __len = 42 - 1;
1542 const size_t __idx __unused = __len - 1;
1543
1544 getentropy(__stack.__buf, __len);
1545 #undef BUF
1546
1547 }
1548
1549 ATF_TC(getentropy_end);
ATF_TC_HEAD(getentropy_end,tc)1550 ATF_TC_HEAD(getentropy_end, tc)
1551 {
1552 }
ATF_TC_BODY(getentropy_end,tc)1553 ATF_TC_BODY(getentropy_end, tc)
1554 {
1555 #define BUF &__stack.__buf
1556 struct {
1557 uint8_t padding_l;
1558 unsigned char __buf[42];
1559 uint8_t padding_r;
1560 } __stack;
1561 const size_t __bufsz __unused = sizeof(__stack.__buf);
1562 const size_t __len = 42;
1563 const size_t __idx __unused = __len - 1;
1564
1565 getentropy(__stack.__buf, __len);
1566 #undef BUF
1567
1568 }
1569
1570 ATF_TC(getentropy_heap_before_end);
ATF_TC_HEAD(getentropy_heap_before_end,tc)1571 ATF_TC_HEAD(getentropy_heap_before_end, tc)
1572 {
1573 }
ATF_TC_BODY(getentropy_heap_before_end,tc)1574 ATF_TC_BODY(getentropy_heap_before_end, tc)
1575 {
1576 #define BUF __stack.__buf
1577 struct {
1578 uint8_t padding_l;
1579 unsigned char * __buf;
1580 uint8_t padding_r;
1581 } __stack;
1582 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1583 const size_t __len = 42 - 1;
1584 const size_t __idx __unused = __len - 1;
1585
1586 __stack.__buf = malloc(__bufsz);
1587
1588 getentropy(__stack.__buf, __len);
1589 #undef BUF
1590
1591 }
1592
1593 ATF_TC(getentropy_heap_end);
ATF_TC_HEAD(getentropy_heap_end,tc)1594 ATF_TC_HEAD(getentropy_heap_end, tc)
1595 {
1596 }
ATF_TC_BODY(getentropy_heap_end,tc)1597 ATF_TC_BODY(getentropy_heap_end, tc)
1598 {
1599 #define BUF __stack.__buf
1600 struct {
1601 uint8_t padding_l;
1602 unsigned char * __buf;
1603 uint8_t padding_r;
1604 } __stack;
1605 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1606 const size_t __len = 42;
1607 const size_t __idx __unused = __len - 1;
1608
1609 __stack.__buf = malloc(__bufsz);
1610
1611 getentropy(__stack.__buf, __len);
1612 #undef BUF
1613
1614 }
1615
1616 ATF_TC(getentropy_heap_after_end);
ATF_TC_HEAD(getentropy_heap_after_end,tc)1617 ATF_TC_HEAD(getentropy_heap_after_end, tc)
1618 {
1619 }
ATF_TC_BODY(getentropy_heap_after_end,tc)1620 ATF_TC_BODY(getentropy_heap_after_end, tc)
1621 {
1622 #define BUF __stack.__buf
1623 struct {
1624 uint8_t padding_l;
1625 unsigned char * __buf;
1626 uint8_t padding_r;
1627 } __stack;
1628 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
1629 const size_t __len = 42 + 1;
1630 const size_t __idx __unused = __len - 1;
1631 pid_t __child;
1632 int __status;
1633
1634 __child = fork();
1635 ATF_REQUIRE(__child >= 0);
1636 if (__child > 0)
1637 goto monitor;
1638
1639 /* Child */
1640 disable_coredumps();
1641 __stack.__buf = malloc(__bufsz);
1642
1643 getentropy(__stack.__buf, __len);
1644 _exit(EX_SOFTWARE); /* Should have aborted. */
1645
1646 monitor:
1647 while (waitpid(__child, &__status, 0) != __child) {
1648 ATF_REQUIRE_EQ(EINTR, errno);
1649 }
1650
1651 if (!WIFSIGNALED(__status)) {
1652 switch (WEXITSTATUS(__status)) {
1653 case EX_SOFTWARE:
1654 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1655 break;
1656 case EX_OSERR:
1657 atf_tc_fail("setrlimit(2) failed");
1658 break;
1659 default:
1660 atf_tc_fail("child exited with status %d",
1661 WEXITSTATUS(__status));
1662 }
1663 } else {
1664 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1665 }
1666 #undef BUF
1667
1668 }
1669
1670 ATF_TC(gethostname_before_end);
ATF_TC_HEAD(gethostname_before_end,tc)1671 ATF_TC_HEAD(gethostname_before_end, tc)
1672 {
1673 atf_tc_set_md_var(tc, "require.user", "root");
1674 }
ATF_TC_BODY(gethostname_before_end,tc)1675 ATF_TC_BODY(gethostname_before_end, tc)
1676 {
1677 #define BUF &__stack.__buf
1678 struct {
1679 uint8_t padding_l;
1680 unsigned char __buf[17];
1681 uint8_t padding_r;
1682 } __stack;
1683 const size_t __bufsz __unused = sizeof(__stack.__buf);
1684 const size_t __len = 17 - 1;
1685 const size_t __idx __unused = __len - 1;
1686
1687 dhost_jail();
1688 gethostname(__stack.__buf, __len);
1689 #undef BUF
1690
1691 }
1692
1693 ATF_TC(gethostname_end);
ATF_TC_HEAD(gethostname_end,tc)1694 ATF_TC_HEAD(gethostname_end, tc)
1695 {
1696 atf_tc_set_md_var(tc, "require.user", "root");
1697 }
ATF_TC_BODY(gethostname_end,tc)1698 ATF_TC_BODY(gethostname_end, tc)
1699 {
1700 #define BUF &__stack.__buf
1701 struct {
1702 uint8_t padding_l;
1703 unsigned char __buf[17];
1704 uint8_t padding_r;
1705 } __stack;
1706 const size_t __bufsz __unused = sizeof(__stack.__buf);
1707 const size_t __len = 17;
1708 const size_t __idx __unused = __len - 1;
1709
1710 dhost_jail();
1711 gethostname(__stack.__buf, __len);
1712 #undef BUF
1713
1714 }
1715
1716 ATF_TC(gethostname_heap_before_end);
ATF_TC_HEAD(gethostname_heap_before_end,tc)1717 ATF_TC_HEAD(gethostname_heap_before_end, tc)
1718 {
1719 atf_tc_set_md_var(tc, "require.user", "root");
1720 }
ATF_TC_BODY(gethostname_heap_before_end,tc)1721 ATF_TC_BODY(gethostname_heap_before_end, tc)
1722 {
1723 #define BUF __stack.__buf
1724 struct {
1725 uint8_t padding_l;
1726 unsigned char * __buf;
1727 uint8_t padding_r;
1728 } __stack;
1729 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (17);
1730 const size_t __len = 17 - 1;
1731 const size_t __idx __unused = __len - 1;
1732
1733 dhost_jail();
1734 __stack.__buf = malloc(__bufsz);
1735
1736 gethostname(__stack.__buf, __len);
1737 #undef BUF
1738
1739 }
1740
1741 ATF_TC(gethostname_heap_end);
ATF_TC_HEAD(gethostname_heap_end,tc)1742 ATF_TC_HEAD(gethostname_heap_end, tc)
1743 {
1744 atf_tc_set_md_var(tc, "require.user", "root");
1745 }
ATF_TC_BODY(gethostname_heap_end,tc)1746 ATF_TC_BODY(gethostname_heap_end, tc)
1747 {
1748 #define BUF __stack.__buf
1749 struct {
1750 uint8_t padding_l;
1751 unsigned char * __buf;
1752 uint8_t padding_r;
1753 } __stack;
1754 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (17);
1755 const size_t __len = 17;
1756 const size_t __idx __unused = __len - 1;
1757
1758 dhost_jail();
1759 __stack.__buf = malloc(__bufsz);
1760
1761 gethostname(__stack.__buf, __len);
1762 #undef BUF
1763
1764 }
1765
1766 ATF_TC(gethostname_heap_after_end);
ATF_TC_HEAD(gethostname_heap_after_end,tc)1767 ATF_TC_HEAD(gethostname_heap_after_end, tc)
1768 {
1769 atf_tc_set_md_var(tc, "require.user", "root");
1770 }
ATF_TC_BODY(gethostname_heap_after_end,tc)1771 ATF_TC_BODY(gethostname_heap_after_end, tc)
1772 {
1773 #define BUF __stack.__buf
1774 struct {
1775 uint8_t padding_l;
1776 unsigned char * __buf;
1777 uint8_t padding_r;
1778 } __stack;
1779 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (17);
1780 const size_t __len = 17 + 1;
1781 const size_t __idx __unused = __len - 1;
1782 pid_t __child;
1783 int __status;
1784
1785 dhost_jail();
1786 __child = fork();
1787 ATF_REQUIRE(__child >= 0);
1788 if (__child > 0)
1789 goto monitor;
1790
1791 /* Child */
1792 disable_coredumps();
1793 __stack.__buf = malloc(__bufsz);
1794
1795 gethostname(__stack.__buf, __len);
1796 _exit(EX_SOFTWARE); /* Should have aborted. */
1797
1798 monitor:
1799 while (waitpid(__child, &__status, 0) != __child) {
1800 ATF_REQUIRE_EQ(EINTR, errno);
1801 }
1802
1803 if (!WIFSIGNALED(__status)) {
1804 switch (WEXITSTATUS(__status)) {
1805 case EX_SOFTWARE:
1806 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1807 break;
1808 case EX_OSERR:
1809 atf_tc_fail("setrlimit(2) failed");
1810 break;
1811 default:
1812 atf_tc_fail("child exited with status %d",
1813 WEXITSTATUS(__status));
1814 }
1815 } else {
1816 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1817 }
1818 #undef BUF
1819
1820 }
1821
1822 ATF_TC(getlogin_r_before_end);
ATF_TC_HEAD(getlogin_r_before_end,tc)1823 ATF_TC_HEAD(getlogin_r_before_end, tc)
1824 {
1825 }
ATF_TC_BODY(getlogin_r_before_end,tc)1826 ATF_TC_BODY(getlogin_r_before_end, tc)
1827 {
1828 #define BUF &__stack.__buf
1829 struct {
1830 uint8_t padding_l;
1831 unsigned char __buf[MAXLOGNAME + 1];
1832 uint8_t padding_r;
1833 } __stack;
1834 const size_t __bufsz __unused = sizeof(__stack.__buf);
1835 const size_t __len = MAXLOGNAME + 1 - 1;
1836 const size_t __idx __unused = __len - 1;
1837
1838 getlogin_r(__stack.__buf, __len);
1839 #undef BUF
1840
1841 }
1842
1843 ATF_TC(getlogin_r_end);
ATF_TC_HEAD(getlogin_r_end,tc)1844 ATF_TC_HEAD(getlogin_r_end, tc)
1845 {
1846 }
ATF_TC_BODY(getlogin_r_end,tc)1847 ATF_TC_BODY(getlogin_r_end, tc)
1848 {
1849 #define BUF &__stack.__buf
1850 struct {
1851 uint8_t padding_l;
1852 unsigned char __buf[MAXLOGNAME + 1];
1853 uint8_t padding_r;
1854 } __stack;
1855 const size_t __bufsz __unused = sizeof(__stack.__buf);
1856 const size_t __len = MAXLOGNAME + 1;
1857 const size_t __idx __unused = __len - 1;
1858
1859 getlogin_r(__stack.__buf, __len);
1860 #undef BUF
1861
1862 }
1863
1864 ATF_TC(getlogin_r_heap_before_end);
ATF_TC_HEAD(getlogin_r_heap_before_end,tc)1865 ATF_TC_HEAD(getlogin_r_heap_before_end, tc)
1866 {
1867 }
ATF_TC_BODY(getlogin_r_heap_before_end,tc)1868 ATF_TC_BODY(getlogin_r_heap_before_end, tc)
1869 {
1870 #define BUF __stack.__buf
1871 struct {
1872 uint8_t padding_l;
1873 unsigned char * __buf;
1874 uint8_t padding_r;
1875 } __stack;
1876 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (MAXLOGNAME + 1);
1877 const size_t __len = MAXLOGNAME + 1 - 1;
1878 const size_t __idx __unused = __len - 1;
1879
1880 __stack.__buf = malloc(__bufsz);
1881
1882 getlogin_r(__stack.__buf, __len);
1883 #undef BUF
1884
1885 }
1886
1887 ATF_TC(getlogin_r_heap_end);
ATF_TC_HEAD(getlogin_r_heap_end,tc)1888 ATF_TC_HEAD(getlogin_r_heap_end, tc)
1889 {
1890 }
ATF_TC_BODY(getlogin_r_heap_end,tc)1891 ATF_TC_BODY(getlogin_r_heap_end, tc)
1892 {
1893 #define BUF __stack.__buf
1894 struct {
1895 uint8_t padding_l;
1896 unsigned char * __buf;
1897 uint8_t padding_r;
1898 } __stack;
1899 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (MAXLOGNAME + 1);
1900 const size_t __len = MAXLOGNAME + 1;
1901 const size_t __idx __unused = __len - 1;
1902
1903 __stack.__buf = malloc(__bufsz);
1904
1905 getlogin_r(__stack.__buf, __len);
1906 #undef BUF
1907
1908 }
1909
1910 ATF_TC(getlogin_r_heap_after_end);
ATF_TC_HEAD(getlogin_r_heap_after_end,tc)1911 ATF_TC_HEAD(getlogin_r_heap_after_end, tc)
1912 {
1913 }
ATF_TC_BODY(getlogin_r_heap_after_end,tc)1914 ATF_TC_BODY(getlogin_r_heap_after_end, tc)
1915 {
1916 #define BUF __stack.__buf
1917 struct {
1918 uint8_t padding_l;
1919 unsigned char * __buf;
1920 uint8_t padding_r;
1921 } __stack;
1922 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (MAXLOGNAME + 1);
1923 const size_t __len = MAXLOGNAME + 1 + 1;
1924 const size_t __idx __unused = __len - 1;
1925 pid_t __child;
1926 int __status;
1927
1928 __child = fork();
1929 ATF_REQUIRE(__child >= 0);
1930 if (__child > 0)
1931 goto monitor;
1932
1933 /* Child */
1934 disable_coredumps();
1935 __stack.__buf = malloc(__bufsz);
1936
1937 getlogin_r(__stack.__buf, __len);
1938 _exit(EX_SOFTWARE); /* Should have aborted. */
1939
1940 monitor:
1941 while (waitpid(__child, &__status, 0) != __child) {
1942 ATF_REQUIRE_EQ(EINTR, errno);
1943 }
1944
1945 if (!WIFSIGNALED(__status)) {
1946 switch (WEXITSTATUS(__status)) {
1947 case EX_SOFTWARE:
1948 atf_tc_fail("FORTIFY_SOURCE failed to abort");
1949 break;
1950 case EX_OSERR:
1951 atf_tc_fail("setrlimit(2) failed");
1952 break;
1953 default:
1954 atf_tc_fail("child exited with status %d",
1955 WEXITSTATUS(__status));
1956 }
1957 } else {
1958 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
1959 }
1960 #undef BUF
1961
1962 }
1963
1964 ATF_TC(ttyname_r_before_end);
ATF_TC_HEAD(ttyname_r_before_end,tc)1965 ATF_TC_HEAD(ttyname_r_before_end, tc)
1966 {
1967 }
ATF_TC_BODY(ttyname_r_before_end,tc)1968 ATF_TC_BODY(ttyname_r_before_end, tc)
1969 {
1970 #define BUF &__stack.__buf
1971 struct {
1972 uint8_t padding_l;
1973 unsigned char __buf[42];
1974 uint8_t padding_r;
1975 } __stack;
1976 const size_t __bufsz __unused = sizeof(__stack.__buf);
1977 const size_t __len = 42 - 1;
1978 const size_t __idx __unused = __len - 1;
1979 int fd;
1980
1981 fd = STDIN_FILENO;
1982 if (!isatty(fd))
1983 atf_tc_skip("stdin is not an fd");
1984
1985 ttyname_r(fd, __stack.__buf, __len);
1986 #undef BUF
1987
1988 }
1989
1990 ATF_TC(ttyname_r_end);
ATF_TC_HEAD(ttyname_r_end,tc)1991 ATF_TC_HEAD(ttyname_r_end, tc)
1992 {
1993 }
ATF_TC_BODY(ttyname_r_end,tc)1994 ATF_TC_BODY(ttyname_r_end, tc)
1995 {
1996 #define BUF &__stack.__buf
1997 struct {
1998 uint8_t padding_l;
1999 unsigned char __buf[42];
2000 uint8_t padding_r;
2001 } __stack;
2002 const size_t __bufsz __unused = sizeof(__stack.__buf);
2003 const size_t __len = 42;
2004 const size_t __idx __unused = __len - 1;
2005 int fd;
2006
2007 fd = STDIN_FILENO;
2008 if (!isatty(fd))
2009 atf_tc_skip("stdin is not an fd");
2010
2011 ttyname_r(fd, __stack.__buf, __len);
2012 #undef BUF
2013
2014 }
2015
2016 ATF_TC(ttyname_r_heap_before_end);
ATF_TC_HEAD(ttyname_r_heap_before_end,tc)2017 ATF_TC_HEAD(ttyname_r_heap_before_end, tc)
2018 {
2019 }
ATF_TC_BODY(ttyname_r_heap_before_end,tc)2020 ATF_TC_BODY(ttyname_r_heap_before_end, tc)
2021 {
2022 #define BUF __stack.__buf
2023 struct {
2024 uint8_t padding_l;
2025 unsigned char * __buf;
2026 uint8_t padding_r;
2027 } __stack;
2028 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
2029 const size_t __len = 42 - 1;
2030 const size_t __idx __unused = __len - 1;
2031 int fd;
2032
2033 fd = STDIN_FILENO;
2034 if (!isatty(fd))
2035 atf_tc_skip("stdin is not an fd");
2036
2037 __stack.__buf = malloc(__bufsz);
2038
2039 ttyname_r(fd, __stack.__buf, __len);
2040 #undef BUF
2041
2042 }
2043
2044 ATF_TC(ttyname_r_heap_end);
ATF_TC_HEAD(ttyname_r_heap_end,tc)2045 ATF_TC_HEAD(ttyname_r_heap_end, tc)
2046 {
2047 }
ATF_TC_BODY(ttyname_r_heap_end,tc)2048 ATF_TC_BODY(ttyname_r_heap_end, tc)
2049 {
2050 #define BUF __stack.__buf
2051 struct {
2052 uint8_t padding_l;
2053 unsigned char * __buf;
2054 uint8_t padding_r;
2055 } __stack;
2056 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
2057 const size_t __len = 42;
2058 const size_t __idx __unused = __len - 1;
2059 int fd;
2060
2061 fd = STDIN_FILENO;
2062 if (!isatty(fd))
2063 atf_tc_skip("stdin is not an fd");
2064
2065 __stack.__buf = malloc(__bufsz);
2066
2067 ttyname_r(fd, __stack.__buf, __len);
2068 #undef BUF
2069
2070 }
2071
2072 ATF_TC(ttyname_r_heap_after_end);
ATF_TC_HEAD(ttyname_r_heap_after_end,tc)2073 ATF_TC_HEAD(ttyname_r_heap_after_end, tc)
2074 {
2075 }
ATF_TC_BODY(ttyname_r_heap_after_end,tc)2076 ATF_TC_BODY(ttyname_r_heap_after_end, tc)
2077 {
2078 #define BUF __stack.__buf
2079 struct {
2080 uint8_t padding_l;
2081 unsigned char * __buf;
2082 uint8_t padding_r;
2083 } __stack;
2084 const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
2085 const size_t __len = 42 + 1;
2086 const size_t __idx __unused = __len - 1;
2087 pid_t __child;
2088 int __status;
2089 int fd;
2090
2091 fd = STDIN_FILENO;
2092 if (!isatty(fd))
2093 atf_tc_skip("stdin is not an fd");
2094
2095 __child = fork();
2096 ATF_REQUIRE(__child >= 0);
2097 if (__child > 0)
2098 goto monitor;
2099
2100 /* Child */
2101 disable_coredumps();
2102 __stack.__buf = malloc(__bufsz);
2103
2104 ttyname_r(fd, __stack.__buf, __len);
2105 _exit(EX_SOFTWARE); /* Should have aborted. */
2106
2107 monitor:
2108 while (waitpid(__child, &__status, 0) != __child) {
2109 ATF_REQUIRE_EQ(EINTR, errno);
2110 }
2111
2112 if (!WIFSIGNALED(__status)) {
2113 switch (WEXITSTATUS(__status)) {
2114 case EX_SOFTWARE:
2115 atf_tc_fail("FORTIFY_SOURCE failed to abort");
2116 break;
2117 case EX_OSERR:
2118 atf_tc_fail("setrlimit(2) failed");
2119 break;
2120 default:
2121 atf_tc_fail("child exited with status %d",
2122 WEXITSTATUS(__status));
2123 }
2124 } else {
2125 ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
2126 }
2127 #undef BUF
2128
2129 }
2130
ATF_TP_ADD_TCS(tp)2131 ATF_TP_ADD_TCS(tp)
2132 {
2133 ATF_TP_ADD_TC(tp, getcwd_before_end);
2134 ATF_TP_ADD_TC(tp, getcwd_end);
2135 ATF_TP_ADD_TC(tp, getcwd_heap_before_end);
2136 ATF_TP_ADD_TC(tp, getcwd_heap_end);
2137 ATF_TP_ADD_TC(tp, getcwd_heap_after_end);
2138 ATF_TP_ADD_TC(tp, getgrouplist_before_end);
2139 ATF_TP_ADD_TC(tp, getgrouplist_end);
2140 ATF_TP_ADD_TC(tp, getgrouplist_heap_before_end);
2141 ATF_TP_ADD_TC(tp, getgrouplist_heap_end);
2142 ATF_TP_ADD_TC(tp, getgrouplist_heap_after_end);
2143 ATF_TP_ADD_TC(tp, getgroups_before_end);
2144 ATF_TP_ADD_TC(tp, getgroups_end);
2145 ATF_TP_ADD_TC(tp, getgroups_heap_before_end);
2146 ATF_TP_ADD_TC(tp, getgroups_heap_end);
2147 ATF_TP_ADD_TC(tp, getgroups_heap_after_end);
2148 ATF_TP_ADD_TC(tp, getloginclass_before_end);
2149 ATF_TP_ADD_TC(tp, getloginclass_end);
2150 ATF_TP_ADD_TC(tp, getloginclass_heap_before_end);
2151 ATF_TP_ADD_TC(tp, getloginclass_heap_end);
2152 ATF_TP_ADD_TC(tp, getloginclass_heap_after_end);
2153 ATF_TP_ADD_TC(tp, pread_before_end);
2154 ATF_TP_ADD_TC(tp, pread_end);
2155 ATF_TP_ADD_TC(tp, pread_heap_before_end);
2156 ATF_TP_ADD_TC(tp, pread_heap_end);
2157 ATF_TP_ADD_TC(tp, pread_heap_after_end);
2158 ATF_TP_ADD_TC(tp, read_before_end);
2159 ATF_TP_ADD_TC(tp, read_end);
2160 ATF_TP_ADD_TC(tp, read_heap_before_end);
2161 ATF_TP_ADD_TC(tp, read_heap_end);
2162 ATF_TP_ADD_TC(tp, read_heap_after_end);
2163 ATF_TP_ADD_TC(tp, readlink_before_end);
2164 ATF_TP_ADD_TC(tp, readlink_end);
2165 ATF_TP_ADD_TC(tp, readlink_heap_before_end);
2166 ATF_TP_ADD_TC(tp, readlink_heap_end);
2167 ATF_TP_ADD_TC(tp, readlink_heap_after_end);
2168 ATF_TP_ADD_TC(tp, readlinkat_before_end);
2169 ATF_TP_ADD_TC(tp, readlinkat_end);
2170 ATF_TP_ADD_TC(tp, readlinkat_heap_before_end);
2171 ATF_TP_ADD_TC(tp, readlinkat_heap_end);
2172 ATF_TP_ADD_TC(tp, readlinkat_heap_after_end);
2173 ATF_TP_ADD_TC(tp, getdomainname_before_end);
2174 ATF_TP_ADD_TC(tp, getdomainname_end);
2175 ATF_TP_ADD_TC(tp, getdomainname_heap_before_end);
2176 ATF_TP_ADD_TC(tp, getdomainname_heap_end);
2177 ATF_TP_ADD_TC(tp, getdomainname_heap_after_end);
2178 ATF_TP_ADD_TC(tp, getentropy_before_end);
2179 ATF_TP_ADD_TC(tp, getentropy_end);
2180 ATF_TP_ADD_TC(tp, getentropy_heap_before_end);
2181 ATF_TP_ADD_TC(tp, getentropy_heap_end);
2182 ATF_TP_ADD_TC(tp, getentropy_heap_after_end);
2183 ATF_TP_ADD_TC(tp, gethostname_before_end);
2184 ATF_TP_ADD_TC(tp, gethostname_end);
2185 ATF_TP_ADD_TC(tp, gethostname_heap_before_end);
2186 ATF_TP_ADD_TC(tp, gethostname_heap_end);
2187 ATF_TP_ADD_TC(tp, gethostname_heap_after_end);
2188 ATF_TP_ADD_TC(tp, getlogin_r_before_end);
2189 ATF_TP_ADD_TC(tp, getlogin_r_end);
2190 ATF_TP_ADD_TC(tp, getlogin_r_heap_before_end);
2191 ATF_TP_ADD_TC(tp, getlogin_r_heap_end);
2192 ATF_TP_ADD_TC(tp, getlogin_r_heap_after_end);
2193 ATF_TP_ADD_TC(tp, ttyname_r_before_end);
2194 ATF_TP_ADD_TC(tp, ttyname_r_end);
2195 ATF_TP_ADD_TC(tp, ttyname_r_heap_before_end);
2196 ATF_TP_ADD_TC(tp, ttyname_r_heap_end);
2197 ATF_TP_ADD_TC(tp, ttyname_r_heap_after_end);
2198 return (atf_no_error());
2199 }
2200