CVE-2026-98432: Remote Root via a Race in the Linux TCP Stack

A critical use-after-free race condition in the Linux kernel's IPv4 TCP stack, CVE-2026-98432, allows unauthenticated remote attackers to execute code as root on servers with MPTCP listeners. The vulnerability affects kernels since 4.4 and is amplified by Go 1.24+'s default MPTCP enablement.

On October 27, 2026, Anthropic's Frontier Red Team disclosed an exploit for CVE-2026-98432 — a critical use-after-free race condition in the Linux kernel's IPv4 TCP stack that allows unauthenticated remote attackers to execute arbitrary commands as root on servers running Multipath TCP (MPTCP) listeners. The vulnerability has been present since Linux 4.4, making it one of the longest-standing kernel flaws with a demonstrated remote root exploit.

The Go Security Team's subsequent warning that Go 1.24+ enables MPTCP by default on Linux listening sockets dramatically expanded the potential attack surface, meaning many services may be exposed without their operators knowing.

What is MPTCP and Why It Matters

Multipath TCP (MPTCP) is a TCP extension defined in RFC 8684 that allows a single connection to use multiple network paths simultaneously — for example, combining Wi-Fi and cellular data on a mobile device. It improves performance and reliability by aggregating bandwidth across interfaces.

On Linux, applications must explicitly request MPTCP when opening a socket via setsockopt(). However, the Go standard library changed its default behaviour in version 1.24: net.ListenConfig now enables MPTCP on Linux listening sockets automatically where the kernel supports it. This means reverse proxies, exporters, container tools, and any Go-based network service may be listening with MPTCP without their operators configuring it.

The underlying vulnerability is not specific to MPTCP. However, remote code execution has only been publicly demonstrated against servers with an MPTCP listener open. Systems without MPTCP listeners remain vulnerable to the race condition triggering failed handshakes, but not to the full exploit chain.

Vulnerability Details

CVE-2026-98432 is a race condition in how the kernel frees IPv4 options attached to an incoming TCP connection. The Linux kernel CVE team assigned it a CVSS v3.1 score of 9.8 (Critical).

How the Race Works

The vulnerability manifests during the TCP three-way handshake:

  1. A client sends a SYN packet, potentially carrying IPv4 options such as Record Route or Timestamp.
  2. The kernel tracks the half-open connection in a request socket (request_sock) and replies with a SYNACK.
  3. When the handshake completes, tcp_v4_syn_recv_sock() transfers ownership of the IP options from the request socket to the child socket without copying them — it passes a pointer.

Meanwhile, on another CPU:

  1. A retransmitted SYN for the same request socket is processed, building a new SYNACK from the same options structure.
  2. The first thread completes the handshake and frees the options with kfree() via inet_sock_destruct().
  3. The second thread's ip_options_build() reads from the now-freed memory — a use-after-free.

Since Linux 4.4, request sockets have been processed without the listener lock, meaning the child socket can be freed while the SYNACK is still being built. A similar code path exists when TCP request socket migration is enabled (net.ipv4.tcp_migrate_req=1).

IPv6 is not affected by this first attack path because the kernel copies options there instead of transferring ownership.

The Exploit Chain

Anthropic's exploit operates in two stages:

Stage 1 — Kernel Memory Leak (KASLR Bypass): The race condition causes the kernel to read an attacker-controlled length field and send back extra bytes through the SYNACK reply. By analysing the leaked data, the attacker identifies a kernel pointer, defeating KASLR. In Anthropic's tests, this stage took approximately 48 minutes of repeated attempts.

Stage 2 — Remote Code Execution: The same bug triggers a buffer overflow that overwrites a callback pointer in kernel memory. The attacker chains existing kernel functions up to a shell command of their choice running as root. This stage took approximately 5 additional minutes in Anthropic's demonstration.

A lost race only causes the individual connection setup to fail — the system keeps running. The attacker can retry indefinitely until the timing works out.

Affected Versions

The vulnerability affects Linux kernels dating back to version 4.4. On maintained stable branches, the vulnerable ranges are:

  • 5.10 through 5.10.271
  • 5.15 through 5.15.222
  • 6.1 through 6.1.189
  • 6.6 through 6.6.158
  • 6.12 through 6.12.112
  • 6.18 through 6.18.55
  • 7.2 through 7.2.9

Kernels from 4.4 onward on branches that no longer receive stable updates are also affected.

Distribution Status (as of October 30, 2026)

Distribution Status Details
Debian 12 (bookworm) Fixed linux 6.1.190-1 (DLA-4841-1), plus a 6.12 package
Debian 13 (trixie) Fixed linux 6.12.113-1 (DSA-6568-1)
Ubuntu 22.04 LTS In Progress Fixes targeted but not yet released
Ubuntu 24.04 LTS In Progress Fixes targeted but not yet released
Ubuntu 26.04 LTS In Progress Fixes targeted but not yet released
Ubuntu 26.10 In Progress Fixes targeted but not yet released
RHEL 8 No Fix Affected; no fixed kernel released
RHEL 9 No Fix Affected; no fixed kernel released
RHEL 10 No Fix Affected; no fixed kernel released
RHEL 7 Not Affected Kernel does not contain vulnerable code
SUSE Fixed Packages available for supported releases
Oracle Linux Fixed Packages available for supported releases
Amazon Linux 2023 Fixed Packages available for supported releases

Patch Analysis

Eric Dumazet authored the fix, which was committed upstream on October 5, 2026. The patch replaces kfree() with kfree_rcu() in both destructors:

--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ void inet_sock_destruct(struct sock *sk)
-\tkfree(rcu_dereference_protected(inet->inet_opt, 1));
+\tkfree_rcu(rcu_dereference_protected(inet->inet_opt, 1), rcu);

--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ static tcp_v4_reqsk_destructor(struct request_sock *req)
-\tkfree(rcu_dereference_protected(inet_rsk(req)->ireq_opt, 1));
+\tkfree_rcu(rcu_dereference_protected(inet_rsk(req)->ireq_opt, 1), rcu);

kfree_rcu() waits for an RCU (Read-Copy-Update) grace period before freeing memory, ensuring that readers on other CPUs have finished their access. This eliminates the window where one CPU frees options while another is still reading them.

The fix is included in stable releases: 5.10.272, 5.15.223, 6.1.190, 6.6.159, 6.12.113, 6.18.56, 7.2.10, and the mainline 7.3.

Mitigation

Upgrade to one of the patched stable kernel versions listed above for your distribution. This is the only permanent solution.

Temporary sysctl Mitigations

The following settings disable MPTCP and TCP request migration until the next reboot:

sudo sysctl -w net.mptcp.enabled=0
sudo sysctl -w net.ipv4.tcp_migrate_req=0

To make these persistent across reboots:

sudo tee /etc/sysctl.d/99-cve-2026-98432.conf <<'EOF'
net.mptcp.enabled = 0
net.ipv4.tcp_migrate_req = 0
EOF
sudo sysctl --system

Important: Disabling MPTCP alone does not prevent exploitation of the underlying race condition — it only removes the exploit path that has been publicly demonstrated. Blocking packets containing IPv4 options (Record Route, Timestamp) may provide additional protection but can disrupt applications that depend on those options.

Go-Specific Mitigations

If you run Go services built with version 1.24 or later:

  • Set GODEBUG=multipathtcp=0 at runtime to disable MPTCP per-process
  • Add godebug multipathtcp=0 in go.mod at build time
  • Call SetMultipathTCP(false) explicitly when opening listeners

The Go Security Team has described this as a fragile mitigation — a single forgotten listener is enough to re-expose the system. Kernel patching remains the recommended path.

Detection

Check for MPTCP Listeners

ss -mptcp -tlnp

Or inspect /proc/net/mptcp:

cat /proc/net/mptcp

If the file is empty or non-existent, MPTCP is not enabled on the system. If it contains entries, services are using MPTCP listeners and may be exposed.

Check Kernel Version

uname -r

Compare against the affected version ranges listed above. Systems running kernels outside those ranges (e.g., 4.3 or earlier, or patched versions like 6.1.190+) are not vulnerable.

Impact Analysis

Cloud Image Attack Chain

Many cloud and container images ship with Alpine Linux or minimal Debian bases that enable MPTCP. An attacker who compromises a lower-privilege user (e.g., the default alpine user) can use the kernel exploit to escalate to root, then access passwordless doas or sudo configurations to complete the chain:

  1. Compromise alpine user (default credentials on many images)
  2. Kernel exploit → root via CVE-2026-98432
  3. Passwordless doas/sudo → full system control
  4. Container escape → host compromise

AI-Driven Discovery Implications

Anthropic's report was generated using an unreleased Claude model that autonomously identified and exploited five distinct attack chains against the Linux kernel. This demonstrates a new class of threat: AI models capable of discovering and weaponising kernel vulnerabilities without human guidance. The 53-minute total exploit time (48 min leak + 5 min RCE) shows these exploits are practical, not theoretical.

Timeline

  • October 5, 2026 — Fix committed upstream by Eric Dumazet
  • October 15, 2026 — CVE-2026-98432 published by the Linux kernel CNA; CVSS 9.8 assigned
  • October 27, 2026 — Anthropic's Frontier Red Team discloses the exploit via an unreleased Claude model
  • October 29, 2026 — Go Security Team warns that Go 1.24+ enables MPTCP by default
  • October 30, 2026 — Debian ships fixed kernels; Ubuntu and Red Hat still in progress

CVE-2026-98432 is not the only recent MPTCP vulnerability. Notable related flaws include:

  • CVE-2026-68170 — Stale skb->sk reference on subflow close (use-after-free, introduced in 6.19, fixed in 7.1.6/7.2-rc5)
  • CVE-2026-68169 — Userspace path manager use-after-free via TOCTOU race (local, Moderate)
  • CVE-2026-46158 — ADD_ADDR retransmission socket reference leak (local DoS, Moderate)
  • CVE-2026-46170 — ADD_ADDR retransmission timer DoS via socket refcount issue (local, Moderate)
  • CVE-2026-98438 — Uninitialised value in mptcp_write_data_fin (introduced in 7.1, fixed in 7.2.7/7.3-rc3)

These highlight the MPTCP subsystem as an active area of kernel development with a relatively high bug density due to its complexity and relative recency in mainstream kernels.

Conclusion

CVE-2026-98432 represents a convergence of several concerning trends: a 22-year-old kernel code path (Linux 4.4 was released in 2015), an exploit chain discovered autonomously by AI, and a popular programming language default that silently expands the attack surface. The combination of a critical severity score, practical remote root exploit, and delayed distribution patching makes this a high-priority vulnerability for all Linux administrators.

The immediate action items are clear:

  1. Audit for MPTCP listeners using ss -mptcp
  2. Apply patched kernels from your distribution (or the sysctl workaround if no patch is available)
  3. Review Go services running 1.24+ and disable MPTCP where kernel patches are unavailable
  4. Monitor for distribution-specific advisories — Ubuntu and RHEL fixes were still in progress as of October 30

This article is based on publicly available information from Akamai, LWN.net, BleepingComputer, and the Linux kernel CVE announcements. No exploit code has been published by Anthropic.