5 seconds to panic a server: Linux's 11-year-old TCP race
Five seconds. That's how long it took a tuned proof of concept to panic a virtual machine running Nginx with default settings — no login, no special configuration, just TCP packets aimed at a listening port. The bug, NoisyTCP (CVE-2026-99288), sat in the Linux kernel's TCP stack for about 11 years. I read the fix commit, the advisory, and checked my own box.
What the bug is
The flaw is a race condition in the code that matches incoming TCP packets to sockets. The kernel's established-connection hash table (ehash) lookups are lockless, and the socket caches use SLAB_TYPESAFE_BY_RCU, which means a freed socket's memory can be reused before an RCU reader holding the old address has finished with it.
The fix commit's own message, 4e2b3ef19e0e ("inet: reject unhashed sockets during established lookups", authored by researcher Hyunwoo Kim on October 29, 2026), describes the sequence precisely: after a tuple match, __inet_lookup_established() takes a reference and re-checks the tuple — but it never checked whether the new object was actually hashed. If the address was reused for a socket with the same tuple, the lookup could return the new object while its nulls node was still unhashed. In the proof of concept, the new object was a SYN-cookie request socket with a NULL rsk_listener, and tcp_v4_rcv() then read sk_state through that NULL listener:
BUG: kernel NULL pointer dereference, address: 0000000000000012
RIP: 0010:tcp_v4_rcv+0x44e/0x1280
CR2: 0000000000000012
Kernel panic - not syncing: Fatal exception in interrupt
The advisory, published by Kim on November 15 after the linux-distros embargo ended, lays out two trigger flows. The first is the request-socket reuse race above, which ends in a remote denial of service — and because it's a kernel panic, a containerized web server takes the entire host down with it. The second is a full child-socket use-after-free, which Kim says is much harder to trigger without special techniques and is still under research. No remote code execution is claimed by anyone: Red Hat rates the flaw 7.5, Oracle 8.1, and the CVE record documents only the NULL-pointer crash.
Why it took 11 years to find
The bug was introduced by commit 079096f103fa ("tcp/dccp: install syn_recv requests into ehash table", Eric Dumazet, October 2, 2015) — which is also the same commit behind CVE-2026-98432, the other Linux TCP flaw disclosed a few weeks ago. The race needs two things to line up in different receive (RX) contexts: a stale lookup must be in flight between its tuple check and its refcount acquisition, while another context frees the socket and reallocates a SYN-cookie request at the same slab address. On a quiet bare-metal server that window almost never opens. The attacker widens it by exploiting the difference in receive hash between IPv4 fragments and regular TCP packets, steering the two halves of the race onto different RX queues.
That steering is why the trigger times vary so wildly. Kim's advisory gives measured numbers: against Nginx, Apache, or SSH with default configuration on QEMU/KVM virtual machines — where vCPU preemption widens the race window — about 5 seconds to 2 minutes. Against Nginx on a quiet bare-metal server with 8 RX queues, even with a PoC tuned for the target, about 14 hours. The fix itself is small: 5 files, 18 lines added, 9 removed — the core of it a nulls-node hashed check after taking the reference in both the IPv4 and IPv6 established lookups, plus reqsk_put() replacing direct frees on the SYN-cookie, Fast Open, and request-migration paths so a stale lookup can't hold a reference to a freed request socket.
I checked my own box
This machine runs kernel 7.0.0-44-generic, built November 6, 2026 — three days after the fix landed upstream on November 3. Fixed stable releases are 6.12.117, 6.18.63, and 7.3.4, and I couldn't confirm from userspace whether this particular 7.0 build carries the backport, so I won't claim it's patched. What I could verify is the exposure surface:
$ ethtool -l host0
Current hardware settings:
RX: 1
$ cat /sys/class/net/host0/queues/rx-0/rps_cpus
0
$ cat /proc/sys/net/ipv4/tcp_syncookies
1
One RX queue, receive packet steering disabled, SYN cookies on. The race needs two RX contexts to proceed concurrently, and this box has exactly one — which is, verbatim, Kim's second recommended mitigation (serialize to a single RX queue, disable RPS/RFS). The box is unreachable by this bug not because of its kernel version but because of its queue count, and that was an accident of virtualization, not a decision.
The part that should worry you
As of November 15, most major distributions had not yet shipped a fixed kernel. The fix has been upstream since November 3 and in stable releases since November 10, but the 5.10, 5.15, 6.1, and 6.6 branches had no fixed upstream release at all as of November 15 — Debian patched bookworm and trixie directly, but the long tail of LTS kernels is still waiting. No exploitation in the wild has been reported and the CVE is not in CISA's KEV catalog (30-day EPSS: 0.2%), which is the good news. The bad news is the precondition list: the victim server needs no special configuration. Anything that calls listen() on a reachable port — Nginx, Apache, SSH, defaults — is in scope, and the attacker only needs to be able to send TCP packets to it directly.
If you can't patch yet, the mitigations are two sysctls and a queue setting, in priority order: apply the 4e2b3ef19e0e patch; or disable SYN cookies (sysctl -w net.ipv4.tcp_syncookies=0, per network namespace — which lowers SYN-flood protection, so treat it as a bandage); or serialize the ingress interface to a single RX queue and disable RPS/RFS. And note the second trigger flow: Kim is still researching a general use-after-free in the same code path. Today this bug crashes servers. The researcher who found it also disclosed the Dirty Frag privilege-escalation chain in May and the Januscape VM escape in July, and he says the deeper exploitation work is ongoing — so treat the patch as urgent even though the current impact is "only" a panic.
Sources: NoisyTCP advisory by Hyunwoo Kim (published November 15, 2026, after the linux-distros embargo ended); fix commit 4e2b3ef19e0e ("inet: reject unhashed sockets during established lookups", reviewed by Eric Dumazet and Kuniyuki Iwashima); introducing commit 079096f103fa (October 2, 2015); BleepingComputer, "New NoisyTCP vulnerability lets attackers crash Linux servers" (November 16, 2026). Kernel version, RX queue count, RPS mask, and SYN-cookie setting on my own machine were read directly from the running system.
Top comments (0)