CVE-2026-98432 (CVSS 9.8): Inside the Linux Kernel TCP/MPTCP Race Use-After-Free & How Claude Synthesized a Remote Root Exploit in Under 60 Minutes

CVE-2026-98432 Linux Kernel TCP MPTCP Race Use-After-Free and Claude AI Root Exploit
📌
Security Roundup Series: Week of October 30, 2026 • 8 min read deep dive
🚨
Vulnerability Intelligence: CVE ID: CVE-2026-98432 (CWE-416 (Use After Free) & CWE-362 (Concurrent Execution Race Condition)) Severity: CRITICAL (REMOTE KERNEL USE-AFTER-FREE RCE) (CVSS 9.8) Threat Actor: Demonstrated by Anthropic Frontier Red-Team (Claude Autonomous Synthesis in <60 Mins) Status: Critical Public Disclosure & AI-Generated Root RCE PoC Demonstrated Late October 2026 Affected Systems: Linux Kernel IPv4 TCP / Multipath TCP (MPTCP) Stack (Linux 4.4 through 6.x prior to RCU patch) Fixed In: Upstream Commit: "ipv4: free inet_opt and ireq_opt after an RCU grace period" (Distro Kernel Updates)

A remote, unauthenticated CVSS 9.8 Use-After-Free (UAF) vulnerability in the Linux kernel’s TCP/IP stack is every infrastructure engineer’s worst nightmare. This week, the disclosure of CVE-2026-98432 delivered a double shockwave across the industry: not only does a subtle lockless race condition in tcp_v4_syn_recv_sock() allow remote attackers to corrupt kernel heap memory on Linux servers running Multipath TCP (MPTCP) listeners—a protocol now enabled by default in modern application runtimes like Go 1.24+—but AI safety researchers at Anthropic demonstrated that their frontier Claude model autonomously analyzed the vulnerability, defeated Kernel Address Space Layout Randomization (KASLR), and synthesized a working remote root code-execution exploit chain in under one hour.

CVE-2026-98432 Linux Kernel TCP/MPTCP Race Use-After-Free Diagram
Kernel memory lifecycle of CVE-2026-98432: lockless SYN processing in tcp_v4_syn_recv_sock(), premature kfree() of ireq->ireq_opt, MPTCP race amplification, and RCU grace-period remediation.

Root Cause Analysis: Uncopied ireq_opt Ownership Meets Lockless SYN Processing

To understand CVE-2026-98432, we must examine how the Linux kernel transitions an incoming IPv4 TCP connection from a lightweight request_sock (created upon receiving a SYN packet) into a full child sock structure (created upon receiving the final handshake ACK inside tcp_v4_syn_recv_sock()).

When a client includes IPv4 options in the initial connection packets, the kernel stores a pointer to a dynamically allocated struct ip_options_rcu inside ireq->ireq_opt. Historically (since Linux 4.4), when tcp_v4_syn_recv_sock() instantiated the child socket, it transferred ownership of that pointer directly without performing a deep copy:

/* Vulnerable pattern in net/ipv4/tcp_ipv4.c: tcp_v4_syn_recv_sock() */
struct sock *tcp_v4_syn_recv_sock(const struct sock *sk, struct sk_buff *skb,
                                  struct request_sock *req,
                                  struct dst_entry *dst,
                                  struct request_sock *req_unhash,
                                  bool *own_req)
{
    struct inet_request_sock *ireq = inet_rsk(req);
    struct inet_sock *newinet;
    /* ... */
    newinet = inet_sk(newsk);
    /* Ownership of ireq->ireq_opt is moved directly without RCU copy/protection */
    rcu_assign_pointer(newinet->inet_opt, rcu_dereference(ireq->ireq_opt));
    ireq->ireq_opt = NULL;
    /* ... */
}

Why Modern Kernels Race on ireq_opt

In older Linux kernels, the entire 3-way handshake state transition was serialized under the main listening socket lock. However, to scale to millions of concurrent connections per second on multi-core servers, modern Linux kernels process request sockets locklessly across CPUs. While CPU A is executing tcp_v4_syn_recv_sock()—or while a subflow/request migration occurs (such as via Multipath TCP or net.ipv4.tcp_migrate_req=1)—CPU B can concurrently process a retransmitted SYN with updated IP options or tear down a cloned request socket.

Because the cleanup path freed the old ireq_opt / inet_opt structure immediately using a plain kfree() instead of deferring deallocation until all concurrent RCU readers finished via kfree_rcu(), CPU A is left holding a dangling pointer in the slab allocator (kmalloc-64 / kmalloc-96).


Why Multipath TCP (MPTCP) and Go 1.24+ Massively Expand the Attack Surface

Triggering a narrow lockless race window over the public internet against a standard single-path TCP socket is difficult. However, Multipath TCP (MPTCP)—which allows a single transport connection to stripe data across multiple network paths and subflows using MP_CAPABLE and MP_JOIN TCP options—dramatically widens the race window by allowing an attacker to orchestrate concurrent subflow handshakes and request socket state transitions against the same listener.

⚠️
Hidden Enterprise Exposure: Go 1.24+ Enables MPTCP by Default! Many Linux administrators assume MPTCP is unused in their fleet because they never manually configured it. However, starting with Go 1.24, the Go standard library (net.Listen) enables Multipath TCP by default on listening TCP sockets whenever the underlying Linux kernel supports MPTCP (net.mptcp.enabled=1, the default on Ubuntu, RHEL 9, and Debian). Any cloud-native Go microservice, Kubernetes ingress controller, or agent compiled with Go 1.24+ on an unpatched Linux host is a potential remote target for CVE-2026-98432.

How Claude Synthesized a KASLR Bypass & Root Exploit in Under 60 Minutes

To evaluate the offensive frontier capabilities of modern AI models, Anthropic researchers tasked Claude with analyzing the kernel patch and developing a proof-of-concept exploit. In less than 60 minutes of autonomous iteration, the model:

  1. Pinned the Race Window: Crafted a multi-threaded packet transmitter that sprays concurrent MPTCP subflow handshakes paired with IPv4 timestamp/record-route options to reliably trigger the kfree() while newinet->inet_opt remains referenced.
  2. Cross-Cache / Slab Spray for KASLR Leak: Reclaimed the freed ip_options_rcu slab slot with an overlapping kernel object containing kernel text pointers, then read the reflected IP options back in outbound TCP SYN-ACK / ACK packet headers over the wire to defeat KASLR remotely.
  3. Controlled Function Pointer Hijack: Overwrote a socket timer/destruct callback pointer to pivot execution into a kernel ROP / call_usermodehelper() payload—executing arbitrary shell commands as root.

Immediate Mitigation & Kernel Remediation

🛡️
Zero-Downtime Live Mitigations Before Kernel Reboot (CVE-2026-98432) # 1. Immediately disable Multipath TCP and TCP request migration via sysctl sudo sysctl -w net.mptcp.enabled=0 sudo sysctl -w net.ipv4.tcp_migrate_req=0 # Persist across reboots: cat <<'EOF' | sudo tee /etc/sysctl.d/99-mitigate-cve-2026-98432.conf net.mptcp.enabled = 0 net.ipv4.tcp_migrate_req = 0 EOF # 2. Drop inbound packets containing MPTCP options (TCP Option 30) or IPv4 options via nftables sudo nft add table inet colibrisec_guard sudo nft add chain inet colibrisec_guard input { type filter hook input priority -150 ; } sudo nft add rule inet colibrisec_guard input tcp option mptcp exists counter drop sudo nft add rule inet colibrisec_guard input ip hdrlength > 20 tcp flags syn counter drop

Read more