CVE-2026-98432

A use-after-free in IPv4 TCP, exploited to root, with patching that moved slower than the vulnerability itself.

TL;DR: CVE-2026-98432 is a use-after-free race in the Linux kernel’s IPv4 TCP handshake code, present since kernel 4.4 (Jan 2016). CVSS 9.8 (Network, Low complexity, No privileges, No interaction). Anthropic demonstrated a remote root exploit via an MPTCP listener on Oct 27, 2026. Upstream fix (commit e3f33b0a1d89) landed Oct 5. Red Hat shipped fixed kernels Nov 1, Ubuntu generic LTS fixed Nov 5–6. Still not in CISA KEV as of Nov 9, 2026. No public exploit code released.


The Bug

The kernel handles a TCP connection like this:

  1. Client sends a SYN (possibly with IP options like Record Route or Timestamp).
  2. Kernel stores the options with the request socket (ireq->ireq_opt).
  3. Handshake completes. tcp_v4_syn_recv_sock() transfers ownership of ireq_opt to the child socket without copying.
  4. Client retransmits the SYN. Another CPU processes this retransmit and builds a SYN-ACK using ip_options_build() on ireq_opt.
  5. If the child socket is torn down between steps 3 and 4, inet_sock_destruct() calls kfree() on ireq_opt.
  6. The SYN-ACK path reads freed memory.

Use after free. Classic.

A second variant affects request-socket migration (net.ipv4.tcp_migrate_req=1 or a BPF_SK_REUSEPORT_SELECT_OR_MIGRATE program), which is off by default on most distros.

IPv6 is not affected — tcp_v6_syn_recv_sock() copies the options instead of transferring.

The Fix

Eric Dumazet wrote the fix. Two kfree() calls became kfree_rcu():

// Before (simplified)
kfree(inet->inet_opt);
kfree(ireq->ireq_opt);

// After
kfree_rcu(inet->inet_opt, inet_opt);
kfree_rcu(ireq->ireq_opt, ireq_opt);

The RCU grace period ensures other CPUs finish reading before the buffer is reclaimed. Commit e3f33b0a1d89 was merged into stable branches on Oct 5, 2026.

Fixed kernel versions: 5.10.272, 5.15.223, 6.1.190, 6.6.159, 6.12.113, 6.18.56, 7.2.10, and 7.3+.

The Exploit

Anthropic’s researcher Xinyang Ge reported the bug. On Oct 27, Anthropic published a blog post describing an exploit chain built by an unreleased internal Claude model:

Stage 1 — KASLR leak: The race is won repeatedly until the kernel sends extra bytes back to the attacker. One of those replies contains a kernel pointer. KASLR defeated.

Stage 2 — Code execution: The same race overflows a buffer, overwrites a callback pointer, and chains existing kernel functions to execute an arbitrary command as root.

The chain took ~48 minutes for the leak, ~5 minutes for execution. Anthropic demonstrated it against a server with an MPTCP listener. The exploit code has not been published.

CVSS and Scores: Why Everyone Disagrees

SourceScoreReasoning
Kernel CNA (kernel.org)9.8 CriticalAV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Red Hat8.1 Important → 9.8 CriticalRace is “complex” to win; most likely DoS, RCE proven but not confirmed in the wild
Amazon Linux9.3CVSS v4.0
SUSE8.1CVSS v3.1

The kernel CNA’s 9.8 assumes an attacker who can send TCP SYNs with IP options, retransmit, and repeat — low complexity. Red Hat initially gave 5.9 (Moderate) because the race is hard to win and only a crash had been observed, then raised to 8.1 after Anthropic’s post, then to 9.8 Critical when they shipped fixed kernels Nov 1.

Distribution Patch Timeline

DateEvent
Oct 5Upstream fix committed
Oct 15CVE published
Oct 16–22Debian 12/13, Oracle UEK ship fixed kernels
Oct 24Kernel CNA assigns CVSS 9.8
Oct 27Anthropic publishes exploit post
Oct 29Amazon Linux 2023 fixes; Go 1.24 enables MPTCP by default
Nov 1RHEL 8, 9, 10 fixed (RHSA-2026:93412–93415)
Nov 2OpenShift 4 still affected
Nov 3SUSE SLES 15 SP7 fixed; Red Hat adds EUS fixes
Nov 5–6Ubuntu generic LTS/interim kernels fixed (-updates)
Nov 6Sophos Firewall hotfix (HF110626.1)

The story here: RHEL and Ubuntu LTS — two of the most widely deployed enterprise Linux platforms — shipped fixed kernels two to three weeks after the upstream fix. Debian and Oracle moved faster. For teams running RHEL 8–10 or Ubuntu 22.04/24.04 LTS on Oct 27, the exploit existed in public for 11 days with no patch available.

Go 1.24 and MPTCP Defaults

The Go Security Team warned that Go 1.24+ enables MPTCP on Linux listening sockets by default. This matters because Anthropic’s RCE exploit required an MPTCP listener.

Mitigation for Go programs:

// Build-time
// godebug multipathtcp=0

// Or at runtime
// GODEBUG=multipathtcp=0

But the underlying bug isn’t specific to MPTCP — it’s in core IPv4 TCP. The Go team says disabling MPTCP is a “fragile” mitigation because a single MPTCP listener leaves the system exposed.

Hunting and Mitigation

No exploitation in the wild has been reported as of Nov 9, 2026. Not in CISA KEV. EPSS ~0.8%, 56th percentile.

Quick checks

  1. Kernel version: uname -r against the fixed-version table above.
  2. MPTCP listener: ss -mptcp -l — any listening ports with MPTCP enabled?
  3. IP options in traffic: nft list ruleset | grep ip options — any firewall rules already filtering them?

Mitigation (temporary, before patch)

Red Hat’s nftables mitigation table (from RHSB-2026-016) drops SYNs with IP options:

table inet cve_2026_98432 {
    chain input {
        meta l4proto tcp tcp optlen > 0 drop
    }
}

This blocks the primary attack path (SYN with IP options) but doesn’t address the request-socket migration variant. It’s a reasonable bridge until you can patch and reboot.

Why This Matters for Practitioners

  1. Patch latency still bites. The upstream fix existed Oct 5. RHEL users didn’t get a fixed kernel until Nov 1. That’s 27 days. If you run RHEL or Ubuntu LTS and haven’t patched, your attack surface is wider than you think.

  2. CVSS 9.8 doesn’t mean “exploited right now.” It means “the math says it should be exploitable.” Anthropic proved it. Red Hat took weeks to agree. The score is a ceiling, not a prediction.

  3. Containers inherit the host kernel. Patching containers doesn’t help — the host kernel is what matters.

  4. MPTCP is a force multiplier. If you run services on MPTCP (Go 1.24+ defaults to it), the RCE path is confirmed. If not, the race still exists but RCE hasn’t been demonstrated without MPTCP.

  5. AI-built exploits are real. Anthropic’s exploit was written by an unreleased Claude model after “initial prompting.” No public exploit code exists yet, but the methodology works: describe the function, run the race 10,000 times, collect the kernel pointer, chain the callback. This is reproducible.

Further Reading