NoisyTCP (CVE-2026-99288): An 11-Year-Old Linux TCP Race Lets Anyone on the Internet Panic Default Nginx, Apache and SSH Servers

A lockless socket-lookup race lets unauthenticated TCP traffic crash Linux hosts; VMs fall in seconds, containers take the whole node down, and patches are out.
Most remote kernel bugs need something unusual on the target: an exotic protocol, a rare sysctl, a firewall rule nobody else uses. NoisyTCP (CVE-2026-99288) needs none of that. A server that calls listen() on a TCP port and accepts packets straight from the internet is enough to be in scope, and that describes a stock Nginx, Apache or OpenSSH install on almost every Linux distribution shipped in the last eleven years.
The bug was found by researcher Hyunwoo Kim, who went through the linux-distros embargo process before making it public this weekend. The impact confirmed today is a remote kernel panic, so a denial of service. No login, no user interaction and no foothold on the box are needed.
What actually goes wrong
When a TCP packet arrives, the kernel looks up the matching connection in its established-socket hash table (the "ehash"). To stay fast, that lookup is lockless. The reader finds a socket first and takes a reference to it afterwards. NoisyTCP lives in the gap between those two steps.
- One CPU looks up a pending connection (a request socket) and finds it in the table.
- Before that CPU takes its reference, a second CPU frees the same request socket.
- The second CPU then rebuilds a new request for the same address and port tuple from a SYN cookie, and the slab allocator hands back the same memory address.
- The first CPU now takes a reference to the new object. Its tuple check passes because the addresses really do match.
- The rebuilt request has no listening socket attached yet. The receive path follows that empty listener pointer, and the kernel panics.
This is the classic ABA problem: the memory looks like the thing you were holding because it sits at the same address with the same contents, but it is a different object. The flaw came in with a commit dated 3 October 2015, during the TCP listener rework that went into the Linux 4.4 era, and it stayed hidden until now.
Why the bug is called "noisy"
A race this narrow normally needs two packets to land on two different CPUs at almost exactly the same moment. The trick in NoisyTCP is to arrange that from outside. IPv4 fragments and ordinary TCP segments are hashed differently by the NIC's receive-side scaling, so an attacker can mix the two and push packets for the same connection onto different receive queues. Then they keep up the traffic (the "noise") until the timing lines up.
That makes the target's environment the deciding factor:
- Virtual machines fall fast. Against default Nginx, Apache and SSH in QEMU/KVM guests, the researcher reports a crash in about 5 seconds to 2 minutes. When the hypervisor pauses a vCPU halfway through the lookup, the race window stretches from nanoseconds to milliseconds.
- Quiet bare metal holds out much longer. A physical server with 8 receive queues took about 14 hours to crash, even with a proof of concept tuned to its timing.
- Single-queue machines are out of reach. The race needs two receive contexts working at once, so a host with one RX queue and no RPS/RFS steering cannot be hit this way.
The uncomfortable part is that the cloud VMs most organisations run their public web servers on are the best case for the attacker.
Containers do not contain this
Because the crash happens in the shared kernel, a container offers no isolation from it. If one internet-facing container on a node is hit, the whole host panics, along with every other workload on it. On a Kubernetes node that means every pod scheduled there restarts together, and a sustained attack can keep knocking nodes over as the scheduler moves the workloads elsewhere.
Is it more than a crash?
So far, no. Red Hat states the flaw does not allow data tampering or code execution, and the researcher says their own exploit is "very limited" and lab-specific. Even so, two details are worth keeping in mind. The advisory describes a second path, an ABA race on a full child socket, that can end in a remote use-after-free, although it is currently hard to trigger. And the researcher openly says a general-purpose exploit is "still under research". Red Hat's preliminary CVSS vector rates confidentiality and integrity as High even though its own statement rules both out. The scoring is clearly not settled yet, so treat this as a bug that may still get worse.
Patch status
- Upstream: fixed by commit
4e2b3ef19e0e("inet: reject unhashed sockets during established lookups"), merged on 3 November 2026. After taking its reference, the lookup now checks that the socket is still hashed and that the tuple still matches, and restarts if either check fails. The SYN cookie, Fast Open and request-migration error paths were also cleaned up. - Stable kernels: 6.12.117, 6.18.63 and 7.3.4 carry the fix.
- Debian: fixed in bookworm (6.1.192-2), trixie (6.12.117-1) and sid (7.3.4-1). Forky's 7.2.15-1 is still listed as vulnerable.
- Red Hat: rated Important (preliminary CVSS 7.5). At the time of writing, its CVE page lists workarounds but no fixed packages.
Check what you are running with uname -r and compare it with your distribution's security tracker, not just the upstream version number. Vendors backport fixes, so a lower-looking version string can still be patched.
If you cannot reboot yet
There are two stopgaps, and both have a cost.
- Turn off SYN cookies:
sudo sysctl -w net.ipv4.tcp_syncookies=0. This removes the path that rebuilds the request socket. The setting is per network namespace, so it has to be applied inside every container with its own network stack, not only on the host. It also leaves you exposed to SYN floods, so if you already depend on an upstream DDoS filter or load balancer, check that it really absorbs SYN floods before relying on this. - Collapse to one receive queue: reduce the internet-facing interface to a single RX queue (for example
ethtool -L <iface> combined 1) and disable RPS/RFS. This blocks the race completely but costs throughput on busy hosts.
A third, structural option is to put a proxy or load balancer in front so that it terminates TCP and your Linux hosts never receive raw packets from the internet. The researcher notes that the attacker must be able to send packets directly to the server.
The Reef take
NoisyTCP is a reminder that "default configuration" is not the same as "safe configuration". It is also a reminder that virtualisation changes the timing so much that a race which looks impractical on paper can become a five-second attack in a cloud VM. Prioritise patching your internet-facing VMs and container hosts, then bare metal. Make sure any SYN cookie workaround reaches every network namespace, and remove it once the patched kernel is booted.
