git: 1ace24b30cad - main - include: ssp: fortify <sys/uio.h>

Go to: [ bottom of page ] [ top of archives ] [ this month ]
From: Kyle Evans <kevans_at_FreeBSD.org>
Date: Sat, 13 Jul 2024 05:23:06 UTC
The branch main has been updated by kevans:

URL: https://cgit.FreeBSD.org/src/commit/?id=1ace24b30cad59c8ae509d0c690aa55b8df73136

commit 1ace24b30cad59c8ae509d0c690aa55b8df73136
Author:     Kyle Evans <kevans@FreeBSD.org>
AuthorDate: 2024-07-13 05:16:12 +0000
Commit:     Kyle Evans <kevans@FreeBSD.org>
CommitDate: 2024-07-13 05:16:25 +0000

    include: ssp: fortify <sys/uio.h>
    
    Check both the buffer size of the iov object itself, as well as that
    of each indidvidually io base.
    
    Reviewed by:    markj
    Sponsored by:   Klara, Inc.
    Sponsored by:   Stormshield
    Differential Revision:  https://reviews.freebsd.org/D45684
---
 include/ssp/Makefile                             |   2 +-
 include/ssp/ssp.h                                |  16 +
 include/ssp/uio.h                                |  53 ++
 lib/libc/sys/readv.c                             |   3 +-
 lib/libc/tests/secure/Makefile                   |   1 +
 lib/libc/tests/secure/fortify_poll_test.c        |   1 +
 lib/libc/tests/secure/fortify_random_test.c      |   1 +
 lib/libc/tests/secure/fortify_stdio_test.c       |   1 +
 lib/libc/tests/secure/fortify_stdlib_test.c      |   1 +
 lib/libc/tests/secure/fortify_string_test.c      |   1 +
 lib/libc/tests/secure/fortify_strings_test.c     |   1 +
 lib/libc/tests/secure/fortify_uio_test.c         | 804 +++++++++++++++++++++++
 lib/libc/tests/secure/fortify_unistd_test.c      |   1 +
 lib/libc/tests/secure/fortify_wchar_test.c       |   1 +
 lib/libc/tests/secure/generate-fortify-tests.lua |  60 ++
 sys/sys/uio.h                                    |   4 +
 16 files changed, 949 insertions(+), 2 deletions(-)

diff --git a/include/ssp/Makefile b/include/ssp/Makefile
index d6e0e0698e36..e6c5a1e6c15e 100644
--- a/include/ssp/Makefile
+++ b/include/ssp/Makefile
@@ -1,4 +1,4 @@
-INCS=	poll.h random.h ssp.h stdio.h stdlib.h string.h strings.h unistd.h
+INCS=	poll.h random.h ssp.h stdio.h stdlib.h string.h strings.h uio.h unistd.h
 INCS+=	wchar.h
 INCSDIR=	${INCLUDEDIR}/ssp
 
diff --git a/include/ssp/ssp.h b/include/ssp/ssp.h
index 6ebc23288391..bdc14137d45b 100644
--- a/include/ssp/ssp.h
+++ b/include/ssp/ssp.h
@@ -101,9 +101,25 @@ __ssp_overlap(const void *leftp, const void *rightp, __size_t sz)
 	return (SIZE_MAX - sz < right || left < right + sz);
 }
 
+#include <sys/_iovec.h>
+
 __BEGIN_DECLS
 void __stack_chk_fail(void) __dead2;
 void __chk_fail(void) __dead2;
 __END_DECLS
 
+__ssp_inline void
+__ssp_check_iovec(const struct iovec *iov, int iovcnt)
+{
+	const size_t iovsz = __ssp_bos(iov);
+
+	if (iovsz != (size_t)-1 && iovsz / sizeof(*iov) < (size_t)iovcnt)
+		__chk_fail();
+
+	for (int i = 0; i < iovcnt; i++) {
+		if (__ssp_bos(iov[i].iov_base) < iov[i].iov_len)
+			__chk_fail();
+	}
+}
+
 #endif /* _SSP_SSP_H_ */
diff --git a/include/ssp/uio.h b/include/ssp/uio.h
new file mode 100644
index 000000000000..adf1dcbb3d67
--- /dev/null
+++ b/include/ssp/uio.h
@@ -0,0 +1,53 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause
+ *
+ * Copyright (c) 2024, Klara, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef _SSP_UIO_H_
+#define _SSP_UIO_H_
+
+#include <ssp/ssp.h>
+
+#if __SSP_FORTIFY_LEVEL > 0
+
+__BEGIN_DECLS
+
+__ssp_redirect_raw_impl(ssize_t, readv, readv,
+    (int fd, const struct iovec *iov, int iovcnt))
+{
+	__ssp_check_iovec(iov, iovcnt);
+	return (__ssp_real(readv)(fd, iov, iovcnt));
+}
+
+__ssp_redirect_raw_impl(ssize_t, preadv, preadv,
+    (int fd, const struct iovec *iov, int iovcnt, off_t offset))
+{
+	__ssp_check_iovec(iov, iovcnt);
+	return (__ssp_real(preadv)(fd, iov, iovcnt, offset));
+}
+
+__END_DECLS
+
+#endif /* __SSP_FORTIFY_LEVEL > 0 */
+#endif /* _SSP_UIO_H_ */
diff --git a/lib/libc/sys/readv.c b/lib/libc/sys/readv.c
index 78a529254fa0..d58dba1fc47e 100644
--- a/lib/libc/sys/readv.c
+++ b/lib/libc/sys/readv.c
@@ -33,13 +33,14 @@
 #include <sys/syscall.h>
 #include <sys/uio.h>
 #include <unistd.h>
+#include <ssp/ssp.h>
 #include "libc_private.h"
 
 __weak_reference(__sys_readv, __readv);
 
 #pragma weak readv
 ssize_t
-readv(int fd, const struct iovec *iov, int iovcnt)
+__ssp_real(readv)(int fd, const struct iovec *iov, int iovcnt)
 {
 	return (INTERPOS_SYS(readv, fd, iov, iovcnt));
 }
diff --git a/lib/libc/tests/secure/Makefile b/lib/libc/tests/secure/Makefile
index 87c491d9cf2f..7aa9212b97a8 100644
--- a/lib/libc/tests/secure/Makefile
+++ b/lib/libc/tests/secure/Makefile
@@ -4,6 +4,7 @@ TESTSDIR:=	${TESTSBASE}/${RELDIR:C/libc\/tests/libc/}
 
 # sys/ headers
 FORTIFY_TCATS+=	random
+FORTIFY_TCATS+=	uio
 
 # non-sys/ headers
 FORTIFY_TCATS+=	poll
diff --git a/lib/libc/tests/secure/fortify_poll_test.c b/lib/libc/tests/secure/fortify_poll_test.c
index 2723052ac501..83c0f68b0daa 100644
--- a/lib/libc/tests/secure/fortify_poll_test.c
+++ b/lib/libc/tests/secure/fortify_poll_test.c
@@ -7,6 +7,7 @@
 #include <sys/random.h>
 #include <sys/resource.h>
 #include <sys/time.h>
+#include <sys/uio.h>
 #include <sys/wait.h>
 #include <dirent.h>
 #include <errno.h>
diff --git a/lib/libc/tests/secure/fortify_random_test.c b/lib/libc/tests/secure/fortify_random_test.c
index b89410a702d0..1eb18cfcaaf4 100644
--- a/lib/libc/tests/secure/fortify_random_test.c
+++ b/lib/libc/tests/secure/fortify_random_test.c
@@ -7,6 +7,7 @@
 #include <sys/random.h>
 #include <sys/resource.h>
 #include <sys/time.h>
+#include <sys/uio.h>
 #include <sys/wait.h>
 #include <dirent.h>
 #include <errno.h>
diff --git a/lib/libc/tests/secure/fortify_stdio_test.c b/lib/libc/tests/secure/fortify_stdio_test.c
index a19bfebba1bb..75f81c0a0750 100644
--- a/lib/libc/tests/secure/fortify_stdio_test.c
+++ b/lib/libc/tests/secure/fortify_stdio_test.c
@@ -7,6 +7,7 @@
 #include <sys/random.h>
 #include <sys/resource.h>
 #include <sys/time.h>
+#include <sys/uio.h>
 #include <sys/wait.h>
 #include <dirent.h>
 #include <errno.h>
diff --git a/lib/libc/tests/secure/fortify_stdlib_test.c b/lib/libc/tests/secure/fortify_stdlib_test.c
index 47f4157b5a01..8556e1110156 100644
--- a/lib/libc/tests/secure/fortify_stdlib_test.c
+++ b/lib/libc/tests/secure/fortify_stdlib_test.c
@@ -7,6 +7,7 @@
 #include <sys/random.h>
 #include <sys/resource.h>
 #include <sys/time.h>
+#include <sys/uio.h>
 #include <sys/wait.h>
 #include <dirent.h>
 #include <errno.h>
diff --git a/lib/libc/tests/secure/fortify_string_test.c b/lib/libc/tests/secure/fortify_string_test.c
index 6a4f08705602..70f247b09e39 100644
--- a/lib/libc/tests/secure/fortify_string_test.c
+++ b/lib/libc/tests/secure/fortify_string_test.c
@@ -7,6 +7,7 @@
 #include <sys/random.h>
 #include <sys/resource.h>
 #include <sys/time.h>
+#include <sys/uio.h>
 #include <sys/wait.h>
 #include <dirent.h>
 #include <errno.h>
diff --git a/lib/libc/tests/secure/fortify_strings_test.c b/lib/libc/tests/secure/fortify_strings_test.c
index ec6340e77f74..e6a8ea0291de 100644
--- a/lib/libc/tests/secure/fortify_strings_test.c
+++ b/lib/libc/tests/secure/fortify_strings_test.c
@@ -7,6 +7,7 @@
 #include <sys/random.h>
 #include <sys/resource.h>
 #include <sys/time.h>
+#include <sys/uio.h>
 #include <sys/wait.h>
 #include <dirent.h>
 #include <errno.h>
diff --git a/lib/libc/tests/secure/fortify_uio_test.c b/lib/libc/tests/secure/fortify_uio_test.c
new file mode 100644
index 000000000000..56d7cf5d9a84
--- /dev/null
+++ b/lib/libc/tests/secure/fortify_uio_test.c
@@ -0,0 +1,804 @@
+/* @generated by `generate-fortify-tests.lua "uio"` */
+
+#define	_FORTIFY_SOURCE	2
+#define	TMPFILE_SIZE	(1024 * 32)
+
+#include <sys/param.h>
+#include <sys/random.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+#include <sys/uio.h>
+#include <sys/wait.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <poll.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <sysexits.h>
+#include <unistd.h>
+#include <wchar.h>
+#include <atf-c.h>
+
+static FILE * __unused
+new_fp(size_t __len)
+{
+	static char fpbuf[LINE_MAX];
+	FILE *fp;
+
+	ATF_REQUIRE(__len <= sizeof(fpbuf));
+
+	memset(fpbuf, 'A', sizeof(fpbuf) - 1);
+	fpbuf[sizeof(fpbuf) - 1] = '\0';
+
+	fp = fmemopen(fpbuf, sizeof(fpbuf), "rb");
+	ATF_REQUIRE(fp != NULL);
+
+	return (fp);
+}
+
+/*
+ * Create a new symlink to use for readlink(2) style tests, we'll just use a
+ * random target name to have something interesting to look at.
+ */
+static const char * __unused
+new_symlink(size_t __len)
+{
+	static const char linkname[] = "link";
+	char target[MAXNAMLEN];
+	int error;
+
+	ATF_REQUIRE(__len <= sizeof(target));
+
+	arc4random_buf(target, sizeof(target));
+
+	error = unlink(linkname);
+	ATF_REQUIRE(error == 0 || errno == ENOENT);
+
+	error = symlink(target, linkname);
+	ATF_REQUIRE(error == 0);
+
+	return (linkname);
+}
+
+/*
+ * Constructs a tmpfile that we can use for testing read(2) and friends.
+ */
+static int __unused
+new_tmpfile(void)
+{
+	char buf[1024];
+	ssize_t rv;
+	size_t written;
+	int fd;
+
+	fd = open("tmpfile", O_RDWR | O_CREAT | O_TRUNC, 0644);
+	ATF_REQUIRE(fd >= 0);
+
+	written = 0;
+	while (written < TMPFILE_SIZE) {
+		rv = write(fd, buf, sizeof(buf));
+		ATF_REQUIRE(rv > 0);
+
+		written += rv;
+	}
+
+	ATF_REQUIRE_EQ(0, lseek(fd, 0, SEEK_SET));
+	return (fd);
+}
+
+static void
+disable_coredumps(void)
+{
+	struct rlimit rl = { 0 };
+
+	if (setrlimit(RLIMIT_CORE, &rl) == -1)
+		_exit(EX_OSERR);
+}
+
+/*
+ * Replaces stdin with a file that we can actually read from, for tests where
+ * we want a FILE * or fd that we can get data from.
+ */
+static void __unused
+replace_stdin(void)
+{
+	int fd;
+
+	fd = new_tmpfile();
+
+	(void)dup2(fd, STDIN_FILENO);
+	if (fd != STDIN_FILENO)
+		close(fd);
+}
+
+ATF_TC_WITHOUT_HEAD(readv_before_end);
+ATF_TC_BODY(readv_before_end, tc)
+{
+#define BUF &__stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec __buf[2];
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(__stack.__buf);
+	const size_t __len = 2 - 1;
+	const size_t __idx __unused = __len - 1;
+
+	readv(STDIN_FILENO, __stack.__buf, __len);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(readv_end);
+ATF_TC_BODY(readv_end, tc)
+{
+#define BUF &__stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec __buf[2];
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(__stack.__buf);
+	const size_t __len = 2;
+	const size_t __idx __unused = __len - 1;
+
+	readv(STDIN_FILENO, __stack.__buf, __len);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(readv_after_end);
+ATF_TC_BODY(readv_after_end, tc)
+{
+#define BUF &__stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec __buf[2];
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(__stack.__buf);
+	const size_t __len = 2 + 1;
+	const size_t __idx __unused = __len - 1;
+	pid_t __child;
+	int __status;
+
+	__child = fork();
+	ATF_REQUIRE(__child >= 0);
+	if (__child > 0)
+		goto monitor;
+
+	/* Child */
+	disable_coredumps();
+	readv(STDIN_FILENO, __stack.__buf, __len);
+	_exit(EX_SOFTWARE);	/* Should have aborted. */
+
+monitor:
+	while (waitpid(__child, &__status, 0) != __child) {
+		ATF_REQUIRE_EQ(EINTR, errno);
+	}
+
+	if (!WIFSIGNALED(__status)) {
+		switch (WEXITSTATUS(__status)) {
+		case EX_SOFTWARE:
+			atf_tc_fail("FORTIFY_SOURCE failed to abort");
+			break;
+		case EX_OSERR:
+			atf_tc_fail("setrlimit(2) failed");
+			break;
+		default:
+			atf_tc_fail("child exited with status %d",
+			    WEXITSTATUS(__status));
+		}
+	} else {
+		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
+	}
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(readv_heap_before_end);
+ATF_TC_BODY(readv_heap_before_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (2);
+	const size_t __len = 2 - 1;
+	const size_t __idx __unused = __len - 1;
+
+	__stack.__buf = malloc(__bufsz);
+
+	readv(STDIN_FILENO, __stack.__buf, __len);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(readv_heap_end);
+ATF_TC_BODY(readv_heap_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (2);
+	const size_t __len = 2;
+	const size_t __idx __unused = __len - 1;
+
+	__stack.__buf = malloc(__bufsz);
+
+	readv(STDIN_FILENO, __stack.__buf, __len);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(readv_heap_after_end);
+ATF_TC_BODY(readv_heap_after_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (2);
+	const size_t __len = 2 + 1;
+	const size_t __idx __unused = __len - 1;
+	pid_t __child;
+	int __status;
+
+	__child = fork();
+	ATF_REQUIRE(__child >= 0);
+	if (__child > 0)
+		goto monitor;
+
+	/* Child */
+	disable_coredumps();
+	__stack.__buf = malloc(__bufsz);
+
+	readv(STDIN_FILENO, __stack.__buf, __len);
+	_exit(EX_SOFTWARE);	/* Should have aborted. */
+
+monitor:
+	while (waitpid(__child, &__status, 0) != __child) {
+		ATF_REQUIRE_EQ(EINTR, errno);
+	}
+
+	if (!WIFSIGNALED(__status)) {
+		switch (WEXITSTATUS(__status)) {
+		case EX_SOFTWARE:
+			atf_tc_fail("FORTIFY_SOURCE failed to abort");
+			break;
+		case EX_OSERR:
+			atf_tc_fail("setrlimit(2) failed");
+			break;
+		default:
+			atf_tc_fail("child exited with status %d",
+			    WEXITSTATUS(__status));
+		}
+	} else {
+		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
+	}
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(readv_iov_before_end);
+ATF_TC_BODY(readv_iov_before_end, tc)
+{
+#define BUF &__stack.__buf
+	struct {
+		uint8_t padding_l;
+		unsigned char __buf[42];
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(__stack.__buf);
+	const size_t __len = 42 - 1;
+	const size_t __idx __unused = __len - 1;
+	struct iovec iov[1];
+
+	iov[0].iov_base = __stack.__buf;
+	iov[0].iov_len = __len;
+
+	replace_stdin();
+
+	readv(STDIN_FILENO, iov, nitems(iov));
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(readv_iov_end);
+ATF_TC_BODY(readv_iov_end, tc)
+{
+#define BUF &__stack.__buf
+	struct {
+		uint8_t padding_l;
+		unsigned char __buf[42];
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(__stack.__buf);
+	const size_t __len = 42;
+	const size_t __idx __unused = __len - 1;
+	struct iovec iov[1];
+
+	iov[0].iov_base = __stack.__buf;
+	iov[0].iov_len = __len;
+
+	replace_stdin();
+
+	readv(STDIN_FILENO, iov, nitems(iov));
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(readv_iov_heap_before_end);
+ATF_TC_BODY(readv_iov_heap_before_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		unsigned char * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
+	const size_t __len = 42 - 1;
+	const size_t __idx __unused = __len - 1;
+	struct iovec iov[1];
+
+	__stack.__buf = malloc(__bufsz);
+	iov[0].iov_base = __stack.__buf;
+	iov[0].iov_len = __len;
+
+	replace_stdin();
+
+	readv(STDIN_FILENO, iov, nitems(iov));
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(readv_iov_heap_end);
+ATF_TC_BODY(readv_iov_heap_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		unsigned char * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
+	const size_t __len = 42;
+	const size_t __idx __unused = __len - 1;
+	struct iovec iov[1];
+
+	__stack.__buf = malloc(__bufsz);
+	iov[0].iov_base = __stack.__buf;
+	iov[0].iov_len = __len;
+
+	replace_stdin();
+
+	readv(STDIN_FILENO, iov, nitems(iov));
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(readv_iov_heap_after_end);
+ATF_TC_BODY(readv_iov_heap_after_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		unsigned char * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
+	const size_t __len = 42 + 1;
+	const size_t __idx __unused = __len - 1;
+	pid_t __child;
+	int __status;
+	struct iovec iov[1];
+
+	__child = fork();
+	ATF_REQUIRE(__child >= 0);
+	if (__child > 0)
+		goto monitor;
+
+	/* Child */
+	disable_coredumps();
+	__stack.__buf = malloc(__bufsz);
+	iov[0].iov_base = __stack.__buf;
+	iov[0].iov_len = __len;
+
+	replace_stdin();
+
+	readv(STDIN_FILENO, iov, nitems(iov));
+	_exit(EX_SOFTWARE);	/* Should have aborted. */
+
+monitor:
+	while (waitpid(__child, &__status, 0) != __child) {
+		ATF_REQUIRE_EQ(EINTR, errno);
+	}
+
+	if (!WIFSIGNALED(__status)) {
+		switch (WEXITSTATUS(__status)) {
+		case EX_SOFTWARE:
+			atf_tc_fail("FORTIFY_SOURCE failed to abort");
+			break;
+		case EX_OSERR:
+			atf_tc_fail("setrlimit(2) failed");
+			break;
+		default:
+			atf_tc_fail("child exited with status %d",
+			    WEXITSTATUS(__status));
+		}
+	} else {
+		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
+	}
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(preadv_before_end);
+ATF_TC_BODY(preadv_before_end, tc)
+{
+#define BUF &__stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec __buf[2];
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(__stack.__buf);
+	const size_t __len = 2 - 1;
+	const size_t __idx __unused = __len - 1;
+
+	preadv(STDIN_FILENO, __stack.__buf, __len, 0);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(preadv_end);
+ATF_TC_BODY(preadv_end, tc)
+{
+#define BUF &__stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec __buf[2];
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(__stack.__buf);
+	const size_t __len = 2;
+	const size_t __idx __unused = __len - 1;
+
+	preadv(STDIN_FILENO, __stack.__buf, __len, 0);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(preadv_after_end);
+ATF_TC_BODY(preadv_after_end, tc)
+{
+#define BUF &__stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec __buf[2];
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(__stack.__buf);
+	const size_t __len = 2 + 1;
+	const size_t __idx __unused = __len - 1;
+	pid_t __child;
+	int __status;
+
+	__child = fork();
+	ATF_REQUIRE(__child >= 0);
+	if (__child > 0)
+		goto monitor;
+
+	/* Child */
+	disable_coredumps();
+	preadv(STDIN_FILENO, __stack.__buf, __len, 0);
+	_exit(EX_SOFTWARE);	/* Should have aborted. */
+
+monitor:
+	while (waitpid(__child, &__status, 0) != __child) {
+		ATF_REQUIRE_EQ(EINTR, errno);
+	}
+
+	if (!WIFSIGNALED(__status)) {
+		switch (WEXITSTATUS(__status)) {
+		case EX_SOFTWARE:
+			atf_tc_fail("FORTIFY_SOURCE failed to abort");
+			break;
+		case EX_OSERR:
+			atf_tc_fail("setrlimit(2) failed");
+			break;
+		default:
+			atf_tc_fail("child exited with status %d",
+			    WEXITSTATUS(__status));
+		}
+	} else {
+		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
+	}
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(preadv_heap_before_end);
+ATF_TC_BODY(preadv_heap_before_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (2);
+	const size_t __len = 2 - 1;
+	const size_t __idx __unused = __len - 1;
+
+	__stack.__buf = malloc(__bufsz);
+
+	preadv(STDIN_FILENO, __stack.__buf, __len, 0);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(preadv_heap_end);
+ATF_TC_BODY(preadv_heap_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (2);
+	const size_t __len = 2;
+	const size_t __idx __unused = __len - 1;
+
+	__stack.__buf = malloc(__bufsz);
+
+	preadv(STDIN_FILENO, __stack.__buf, __len, 0);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(preadv_heap_after_end);
+ATF_TC_BODY(preadv_heap_after_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		struct iovec * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (2);
+	const size_t __len = 2 + 1;
+	const size_t __idx __unused = __len - 1;
+	pid_t __child;
+	int __status;
+
+	__child = fork();
+	ATF_REQUIRE(__child >= 0);
+	if (__child > 0)
+		goto monitor;
+
+	/* Child */
+	disable_coredumps();
+	__stack.__buf = malloc(__bufsz);
+
+	preadv(STDIN_FILENO, __stack.__buf, __len, 0);
+	_exit(EX_SOFTWARE);	/* Should have aborted. */
+
+monitor:
+	while (waitpid(__child, &__status, 0) != __child) {
+		ATF_REQUIRE_EQ(EINTR, errno);
+	}
+
+	if (!WIFSIGNALED(__status)) {
+		switch (WEXITSTATUS(__status)) {
+		case EX_SOFTWARE:
+			atf_tc_fail("FORTIFY_SOURCE failed to abort");
+			break;
+		case EX_OSERR:
+			atf_tc_fail("setrlimit(2) failed");
+			break;
+		default:
+			atf_tc_fail("child exited with status %d",
+			    WEXITSTATUS(__status));
+		}
+	} else {
+		ATF_REQUIRE_EQ(SIGABRT, WTERMSIG(__status));
+	}
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(preadv_iov_before_end);
+ATF_TC_BODY(preadv_iov_before_end, tc)
+{
+#define BUF &__stack.__buf
+	struct {
+		uint8_t padding_l;
+		unsigned char __buf[42];
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(__stack.__buf);
+	const size_t __len = 42 - 1;
+	const size_t __idx __unused = __len - 1;
+	struct iovec iov[1];
+
+	iov[0].iov_base = __stack.__buf;
+	iov[0].iov_len = __len;
+
+	replace_stdin();
+
+	preadv(STDIN_FILENO, iov, nitems(iov), 0);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(preadv_iov_end);
+ATF_TC_BODY(preadv_iov_end, tc)
+{
+#define BUF &__stack.__buf
+	struct {
+		uint8_t padding_l;
+		unsigned char __buf[42];
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(__stack.__buf);
+	const size_t __len = 42;
+	const size_t __idx __unused = __len - 1;
+	struct iovec iov[1];
+
+	iov[0].iov_base = __stack.__buf;
+	iov[0].iov_len = __len;
+
+	replace_stdin();
+
+	preadv(STDIN_FILENO, iov, nitems(iov), 0);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(preadv_iov_heap_before_end);
+ATF_TC_BODY(preadv_iov_heap_before_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		unsigned char * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
+	const size_t __len = 42 - 1;
+	const size_t __idx __unused = __len - 1;
+	struct iovec iov[1];
+
+	__stack.__buf = malloc(__bufsz);
+	iov[0].iov_base = __stack.__buf;
+	iov[0].iov_len = __len;
+
+	replace_stdin();
+
+	preadv(STDIN_FILENO, iov, nitems(iov), 0);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(preadv_iov_heap_end);
+ATF_TC_BODY(preadv_iov_heap_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		unsigned char * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
+	const size_t __len = 42;
+	const size_t __idx __unused = __len - 1;
+	struct iovec iov[1];
+
+	__stack.__buf = malloc(__bufsz);
+	iov[0].iov_base = __stack.__buf;
+	iov[0].iov_len = __len;
+
+	replace_stdin();
+
+	preadv(STDIN_FILENO, iov, nitems(iov), 0);
+#undef BUF
+
+}
+
+ATF_TC_WITHOUT_HEAD(preadv_iov_heap_after_end);
+ATF_TC_BODY(preadv_iov_heap_after_end, tc)
+{
+#define BUF __stack.__buf
+	struct {
+		uint8_t padding_l;
+		unsigned char * __buf;
+		uint8_t padding_r;
+	} __stack;
+	const size_t __bufsz __unused = sizeof(*__stack.__buf) * (42);
+	const size_t __len = 42 + 1;
+	const size_t __idx __unused = __len - 1;
+	pid_t __child;
+	int __status;
+	struct iovec iov[1];
+
+	__child = fork();
+	ATF_REQUIRE(__child >= 0);
*** 188 LINES SKIPPED ***