git: ae0f27b235b8 - stable/15 - tcp: Handle read-only mbufs in tcp_pulloutofband()

From: Mark Johnston <markj_at_FreeBSD.org>
Date: Tue, 17 Nov 2026 17:06:19 UTC
The branch stable/15 has been updated by markj:

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

commit ae0f27b235b8f13f3cd397dabd4d50a284051b06
Author:     Mark Johnston <markj@FreeBSD.org>
AuthorDate: 2026-11-14 18:52:06 +0000
Commit:     Mark Johnston <markj@FreeBSD.org>
CommitDate: 2026-11-17 16:57:23 +0000

    tcp: Handle read-only mbufs in tcp_pulloutofband()
    
    tcp_pulloutofband() is used to implement the urgent flag: it pulls a
    byte out of the data stream, to be returned to the recevier when MSG_OOB
    is specified.  That function extracts the byte assuming that the mbuf is
    safe to modify, which may not be the case, e.g., when transmitting file
    data with sendfile().  This flaw can be exploited by a local user to
    obtain root privileges.
    
    Generalize this subroutine so that it handles read-only mbufs as well.
    
    Add some regression tests.
    
    Approved by:    so
    Security:       FreeBSD-SA-26:93.tcp
    Security:       CVE-2026-127748
    Reported by:    OpenAI Security Research Team
    Reviewed by:    tuexen
    Sponsored by:   The FreeBSD Foundation
    Differential Revision:  https://reviews.freebsd.org/D61411
---
 sys/netinet/tcp_input.c     |  94 ++++++++------
 sys/netinet/tcp_var.h       |   2 -
 tests/sys/netinet/Makefile  |   1 +
 tests/sys/netinet/tcp_oob.c | 303 ++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 362 insertions(+), 38 deletions(-)

diff --git a/sys/netinet/tcp_input.c b/sys/netinet/tcp_input.c
index ea032550dfed..03c9117891e8 100644
--- a/sys/netinet/tcp_input.c
+++ b/sys/netinet/tcp_input.c
@@ -1452,6 +1452,62 @@ tcp_autorcvbuf(struct mbuf *m, struct tcphdr *th, struct socket *so,
 	return (newsize);
 }
 
+/*
+ * Pull out of band byte out of a segment so
+ * it doesn't appear in the user's data queue.
+ * It is still reflected in the segment length for
+ * sequencing purposes.
+ */
+static int
+tcp_pulloutofband(struct socket *so, struct tcphdr *th, struct mbuf *m,
+    int off)
+{
+	int cnt = off + th->th_urp - 1;
+
+	while (cnt >= 0) {
+		if (m->m_len > cnt) {
+			struct tcpcb *tp = sototcpcb(so);
+			char ub;
+
+			INP_WLOCK_ASSERT(tptoinpcb(tp));
+
+			m_copydata(m, cnt, 1, &ub);
+			if (cnt == 0) {
+				m->m_data++;
+				m->m_len--;
+			} else if (m->m_len - 1 == cnt) {
+				m->m_len--;
+			} else if (M_WRITABLE(m)) {
+				char *cp;
+
+				cp = mtodo(m, cnt);
+				memmove(cp, cp + 1, m->m_len - cnt - 1);
+				m->m_len--;
+			} else {
+				struct mbuf *n;
+
+				n = m_copym(m, cnt + 1, m->m_len - cnt - 1,
+				    M_NOWAIT);
+				if (n == NULL)
+					return (ENOBUFS);
+				n->m_next = m->m_next;
+				m->m_next = n;
+				m->m_len = cnt;
+			}
+			tp->t_iobc = ub;
+			tp->t_oobflags |= TCPOOB_HAVEDATA;
+			if ((m->m_flags & M_PKTHDR) != 0)
+				m->m_pkthdr.len--;
+			return (0);
+		}
+		cnt -= m->m_len;
+		m = m->m_next;
+		if (m == NULL)
+			break;
+	}
+	panic("tcp_pulloutofband");
+}
+
 int
 tcp_input(struct mbuf **mp, int *offp, int proto)
 {
@@ -3121,7 +3177,8 @@ step6:
 		if (th->th_urp <= (uint32_t)tlen &&
 		    !(so->so_options & SO_OOBINLINE)) {
 			/* hdr drop is delayed */
-			tcp_pulloutofband(so, th, m, drop_hdrlen);
+			if (tcp_pulloutofband(so, th, m, drop_hdrlen) != 0)
+				goto drop;
 		}
 	} else {
 		/*
@@ -3569,41 +3626,6 @@ tcp_dooptions(struct tcpopt *to, u_char *cp, int cnt, int flags)
 	}
 }
 
-/*
- * Pull out of band byte out of a segment so
- * it doesn't appear in the user's data queue.
- * It is still reflected in the segment length for
- * sequencing purposes.
- */
-void
-tcp_pulloutofband(struct socket *so, struct tcphdr *th, struct mbuf *m,
-    int off)
-{
-	int cnt = off + th->th_urp - 1;
-
-	while (cnt >= 0) {
-		if (m->m_len > cnt) {
-			char *cp = mtod(m, caddr_t) + cnt;
-			struct tcpcb *tp = sototcpcb(so);
-
-			INP_WLOCK_ASSERT(tptoinpcb(tp));
-
-			tp->t_iobc = *cp;
-			tp->t_oobflags |= TCPOOB_HAVEDATA;
-			bcopy(cp+1, cp, (unsigned)(m->m_len - cnt - 1));
-			m->m_len--;
-			if (m->m_flags & M_PKTHDR)
-				m->m_pkthdr.len--;
-			return;
-		}
-		cnt -= m->m_len;
-		m = m->m_next;
-		if (m == NULL)
-			break;
-	}
-	panic("tcp_pulloutofband");
-}
-
 /*
  * Collect new round-trip time estimate
  * and update averages and current timeout.
diff --git a/sys/netinet/tcp_var.h b/sys/netinet/tcp_var.h
index 6e787387ef19..bbf11bfafd90 100644
--- a/sys/netinet/tcp_var.h
+++ b/sys/netinet/tcp_var.h
@@ -1413,8 +1413,6 @@ void	 tcp_reass_global_init(void);
 void	 tcp_reass_flush(struct tcpcb *);
 void	 tcp_dooptions(struct tcpopt *, u_char *, int, int);
 void	 tcp_dropwithreset(struct mbuf *, struct tcphdr *, struct tcpcb *, int);
-void	tcp_pulloutofband(struct socket *,
-		     struct tcphdr *, struct mbuf *, int);
 void	tcp_xmit_timer(struct tcpcb *, int);
 void	tcp_newreno_partial_ack(struct tcpcb *, struct tcphdr *);
 void	cc_ack_received(struct tcpcb *tp, struct tcphdr *th,
diff --git a/tests/sys/netinet/Makefile b/tests/sys/netinet/Makefile
index d3588480071f..b8bee4ee62a5 100644
--- a/tests/sys/netinet/Makefile
+++ b/tests/sys/netinet/Makefile
@@ -14,6 +14,7 @@ ATF_TESTS_C=	broadcast \
 		tcp_connect_port_test \
 		tcp_implied_connect \
 		tcp_md5_getsockopt \
+		tcp_oob \
 		udp_bindings \
 		udp_io
 
diff --git a/tests/sys/netinet/tcp_oob.c b/tests/sys/netinet/tcp_oob.c
new file mode 100644
index 000000000000..42d2a72fb038
--- /dev/null
+++ b/tests/sys/netinet/tcp_oob.c
@@ -0,0 +1,303 @@
+/*
+ * Copyright (c) 2026 Mark Johnston <markj@FreeBSD.org>
+ *
+ * This software was written by Mark Johnston under sponsorship from
+ * the FreeBSD Foundation.
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <atf-c.h>
+
+/* Never appears in in-band data generated by fill(). */
+static const char oob_byte = 'A';
+
+static void
+fill(char *buf, size_t len, size_t off)
+{
+	for (size_t i = 0; i < len; i++)
+		buf[i] = 'a' + (i + off) % 26;
+}
+
+static void
+tcp_socketpair(int sd[2], int domain)
+{
+	struct sockaddr_in sin;
+	struct sockaddr_in6 sin6;
+	struct sockaddr *sinp;
+	int ls;
+
+	if (domain == PF_INET) {
+		memset(&sin, 0, sizeof(sin));
+		sin.sin_family = AF_INET;
+		sin.sin_len = sizeof(sin);
+		sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+		sin.sin_port = htons(0);
+		sinp = (struct sockaddr *)&sin;
+	} else {
+		ATF_REQUIRE(domain == PF_INET6);
+		memset(&sin6, 0, sizeof(sin6));
+		sin6.sin6_family = AF_INET6;
+		sin6.sin6_len = sizeof(sin6);
+		sin6.sin6_addr = in6addr_loopback;
+		sin6.sin6_port = htons(0);
+		sinp = (struct sockaddr *)&sin6;
+	}
+
+	ls = socket(domain, SOCK_STREAM, 0);
+	ATF_REQUIRE_MSG(ls >= 0, "socket: %s", strerror(errno));
+	ATF_REQUIRE_MSG(bind(ls, (struct sockaddr *)sinp, sinp->sa_len) == 0,
+	    "bind: %s", strerror(errno));
+	ATF_REQUIRE_MSG(getsockname(ls, (struct sockaddr *)sinp,
+	    &(socklen_t){ sinp->sa_len }) == 0,
+	    "getsockname: %s", strerror(errno));
+	ATF_REQUIRE_MSG(listen(ls, 1) == 0, "listen: %s", strerror(errno));
+
+	sd[0] = socket(domain, SOCK_STREAM, 0);
+	ATF_REQUIRE_MSG(sd[0] >= 0, "socket: %s", strerror(errno));
+	ATF_REQUIRE_MSG(connect(sd[0], (struct sockaddr *)sinp, sinp->sa_len) ==
+	    0, "connect: %s", strerror(errno));
+	sd[1] = accept(ls, NULL, NULL);
+	ATF_REQUIRE_MSG(sd[1] >= 0, "accept: %s", strerror(errno));
+	ATF_REQUIRE(close(ls) == 0);
+
+	ATF_REQUIRE_MSG(setsockopt(sd[0], IPPROTO_TCP, TCP_NODELAY,
+	    &(int){ 1 }, sizeof(int)) == 0, "setsockopt: %s", strerror(errno));
+	ATF_REQUIRE_MSG(setsockopt(sd[1], IPPROTO_TCP, TCP_NODELAY,
+	    &(int){ 1 }, sizeof(int)) == 0, "setsockopt: %s", strerror(errno));
+}
+
+static void
+sendit(int s, const void *buf, size_t len, int flags)
+{
+	ssize_t n;
+
+	n = send(s, buf, len, flags);
+	ATF_REQUIRE_MSG(n >= 0, "send: %s", strerror(errno));
+	ATF_REQUIRE((size_t)n == len);
+}
+
+static void
+recvit(int s, const char *expected, size_t len)
+{
+	char buf[16384];
+	size_t off;
+	ssize_t n;
+
+	for (off = 0; off < len; off += n) {
+		n = recv(s, buf, MIN(sizeof(buf), len - off), 0);
+		ATF_REQUIRE_MSG(n >= 0, "recv: %s", strerror(errno));
+		ATF_REQUIRE_MSG(n != 0, "EOF after %zu of %zu bytes", off, len);
+		for (ssize_t i = 0; i < n; i++)
+			ATF_REQUIRE_MSG(buf[i] == expected[off + i],
+			    "byte %zu is wrong (%x vs %x)", off + i,
+			    buf[i], expected[off + i]);
+	}
+}
+
+static void
+recv_oob(int s, char *cp)
+{
+	struct pollfd pfd;
+	ssize_t n;
+	int atmark, error;
+
+	pfd.fd = s;
+	pfd.events = POLLPRI;
+	error = poll(&pfd, 1, 10 * 1000);
+	ATF_REQUIRE_EQ(error, 1);
+	atmark = sockatmark(s);
+	ATF_REQUIRE_EQ(atmark, 1);
+
+	for (int i = 0; i < 1000; i++) {
+		n = recv(s, cp, 1, MSG_OOB);
+		if (n < 0) {
+			ATF_REQUIRE_EQ(errno, EWOULDBLOCK);
+		} else {
+			ATF_REQUIRE_EQ(n, 1);
+			break;
+		}
+		usleep(10000);
+	}
+}
+
+/*
+ * Try sending an OOB byte at different offsets in a stream, and with varying
+ * write sizes, so as to hopefully test handling of the urgent pointer with
+ * different mbuf storage types.
+ */
+static void
+oob_offsets_test(int domain)
+{
+#define	OOB_MAXOFF	(8192 + 512)
+#define	SUFFIXLEN	17
+	char buf[OOB_MAXOFF + 1], data[OOB_MAXOFF + SUFFIXLEN];
+	int sd[2];
+	char c;
+
+	fill(data, sizeof(data), 0);
+	tcp_socketpair(sd, domain);
+
+	for (size_t off = 0; off <= OOB_MAXOFF; off++) {
+		for (int split = 0; split < 2; split++) {
+
+			if (split) {
+				/* The urgent byte ends a larger write. */
+				memcpy(buf, data, off);
+				buf[off] = oob_byte;
+				sendit(sd[0], buf, off + 1, MSG_OOB);
+			} else {
+				if (off > 0)
+					sendit(sd[0], data, off, 0);
+				sendit(sd[0], &oob_byte, 1, MSG_OOB);
+			}
+			sendit(sd[0], data, SUFFIXLEN, 0);
+			recvit(sd[1], data, off);
+			recv_oob(sd[1], &c);
+			ATF_REQUIRE_MSG(c == oob_byte,
+			    "offset %zu, %d: urgent byte is %x, expected %x",
+			    off, split, c, oob_byte);
+			recvit(sd[1], data, SUFFIXLEN);
+		}
+	}
+
+	ATF_REQUIRE(close(sd[0]) == 0);
+	ATF_REQUIRE_MSG(recv(sd[1], &c, 1, 0) == 0,
+	    "unexpected data in stream");
+	ATF_REQUIRE(close(sd[1]) == 0);
+#undef OOB_MAXOFF
+#undef SUFFIXLEN
+}
+
+ATF_TC_WITHOUT_HEAD(oob_offsets);
+ATF_TC_BODY(oob_offsets, tc)
+{
+	oob_offsets_test(PF_INET);
+}
+
+ATF_TC_WITHOUT_HEAD(oob_offsets6);
+ATF_TC_BODY(oob_offsets6, tc)
+{
+	oob_offsets_test(PF_INET6);
+}
+
+/*
+ * Send file data with sendfile(2) and then an urgent byte, with the whole file
+ * still in flight.  Try different file sizes.  Make sure the backing file isn't
+ * modified.
+ */
+static void
+oob_sendfile_test(int domain)
+{
+	const size_t sendfile_sizes[] = {
+		1, 100, 1000, 4096, 8192, 65535, 65536, 65537, 100000, 131072,
+		131073, 200000, 262144, 524289,
+	};
+	char *buf, *expected;
+
+	expected = malloc(sendfile_sizes[nitems(sendfile_sizes) - 1]);
+	ATF_REQUIRE(expected != NULL);
+	buf = malloc(sendfile_sizes[nitems(sendfile_sizes) - 1]);
+	ATF_REQUIRE(buf != NULL);
+
+	for (size_t i = 0; i < nitems(sendfile_sizes); i++) {
+		char path[NAME_MAX];
+		off_t sbytes;
+		size_t size;
+		ssize_t n;
+		int fd, sd[2], sbsize, rbsize;
+
+		size = sendfile_sizes[i];
+		fill(expected, size, i);
+
+		snprintf(path, sizeof(path), "file%zu", i);
+		fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0644);
+		ATF_REQUIRE_MSG(fd >= 0, "open: %s", strerror(errno));
+		n = write(fd, expected, size);
+		ATF_REQUIRE_MSG(n >= 0, "write: %s", strerror(errno));
+		ATF_REQUIRE_EQ(n, (ssize_t)size);
+
+		tcp_socketpair(sd, domain);
+
+		/*
+		 * Let sendfile() queue the whole file without blocking, but
+		 * keep the receive window small so that the file is still in
+		 * flight when the urgent byte is sent, wrapping the urgent
+		 * pointer for the larger files.
+		 */
+		sbsize = size + 65536;
+		ATF_REQUIRE_MSG(setsockopt(sd[0], SOL_SOCKET, SO_SNDBUF,
+		    &sbsize, sizeof(sbsize)) == 0,
+		    "setsockopt: %s", strerror(errno));
+		rbsize = 65536;
+		ATF_REQUIRE_MSG(setsockopt(sd[1], SOL_SOCKET, SO_RCVBUF,
+		    &rbsize, sizeof(rbsize)) == 0,
+		    "setsockopt: %s", strerror(errno));
+
+		ATF_REQUIRE_MSG(sendfile(fd, sd[0], 0, size, NULL, &sbytes,
+		    0) == 0,
+		    "sendfile: %s", strerror(errno));
+		ATF_REQUIRE_EQ(sbytes, (off_t)size);
+		sendit(sd[0], &oob_byte, 1, MSG_OOB);
+		ATF_REQUIRE(close(sd[0]) == 0);
+
+		for (;;) {
+			char null[65536];
+
+			n = recv(sd[1], null, sizeof(null), 0);
+			ATF_REQUIRE_MSG(n >= 0, "recv: %s", strerror(errno));
+			if (n == 0)
+				break;
+		}
+		ATF_REQUIRE(close(sd[1]) == 0);
+
+		/* Did the file somehow get modified? */
+		n = pread(fd, buf, size, 0);
+		ATF_REQUIRE_MSG(n >= 0, "pread: %s", strerror(errno));
+		ATF_REQUIRE_EQ(n, (ssize_t)size);
+		for (size_t j = 0; j < size; j++) {
+			ATF_REQUIRE_MSG(buf[j] == expected[j],
+			    "file size %zu was modified at offset %zu",
+			    size, j);
+		}
+		ATF_REQUIRE(close(fd) == 0);
+		ATF_REQUIRE(unlink(path) == 0);
+	}
+}
+
+ATF_TC_WITHOUT_HEAD(oob_sendfile);
+ATF_TC_BODY(oob_sendfile, tc)
+{
+	oob_sendfile_test(PF_INET);
+}
+
+ATF_TC_WITHOUT_HEAD(oob_sendfile6);
+ATF_TC_BODY(oob_sendfile6, tc)
+{
+	oob_sendfile_test(PF_INET6);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+	ATF_TP_ADD_TC(tp, oob_offsets);
+	ATF_TP_ADD_TC(tp, oob_offsets6);
+	ATF_TP_ADD_TC(tp, oob_sendfile);
+	ATF_TP_ADD_TC(tp, oob_sendfile6);
+	return (atf_no_error());
+}