ENGINEERING

NoisyTCP (CVE-2026-99288): anyone who can reach a TCP port can crash an unpatched Linux server. How to check yours

NoisyTCP (CVE-2026-99288) is a race in the Linux kernel’s TCP code that Hyunwoo Kim reported and fixed. The embargo ended and the CVE was published on November 10. Anyone who can send TCP packets to a listening port can crash the kernel, with no credentials, against nginx, Apache or SSH running with their default settings. The bug has been in the kernel since 4.4 (2015).

Red Hat rates it Important (CVSS 7.5). Asked whether it’s remote code execution, Kim answers “Not yet”: he has a limited, lab-only exploit against virtual machines and is still working on a general-purpose one. His repository has the write-up but no exploit code. On QEMU/KVM virtual machines his proof of concept crashed servers in 5 seconds to 2 minutes.

Where the fixes are

The upstream fix, “inet: reject unhashed sockets during established lookups”, is in 6.12.117, 6.18.63 and 7.3.4. As of November 15 the 6.6, 6.1, 5.15 and 5.10 lines don’t have it upstream.

DistributionStatus on November 15
Debian 12 (bookworm)Fixed in 6.1.192-1 (DLA-4906-1)
Debian 13 (trixie)Fixed in 6.12.117-1 (DSA-6628-1)
Ubuntu (all supported releases)“Needs triage”, no fixed kernel yet
RHEL 8, 9 and 10Affected, no fixed kernel yet. RHEL 6 and 7 aren’t affected

What triggers it

The kernel looks up established TCP connections without taking a lock, and the memory those connection objects live in can be reused while a lookup is still holding an old address. If that memory gets reused for a new SYN cookie request on the same connection, the lookup can return the new request, which has no listener attached, and the kernel reads through that empty pointer and panics. Kim’s write-up describes a second path that can give a use-after-free, which he calls hard to trigger.

The race needs two packets processed at the same moment on different CPUs, so it reaches servers with two or more network receive queues, or with RPS (Receive Packet Steering) turned on. On a quiet bare-metal server with 8 receive queues it took Kim about 14 hours with a tuned proof of concept. A crash in a containerized web server takes down the whole host.

Check one machine

Is the running kernel fixed. Check the distribution’s kernel changelog instead of the version number, since distributions backport fixes into kernels with older-looking versions. On Ubuntu:

zgrep -cE 'CVE-2026-99288|reject unhashed sockets during established lookups' /usr/share/doc/linux-modules-$(uname -r)/changelog.Debian.gz

On Debian, the changelog is in /usr/share/doc/linux-image-$(uname -r)/changelog.Debian.gz. On RHEL, Rocky and Alma:

rpm -q --changelog kernel-core-$(uname -r) | grep -cE 'CVE-2026-99288|reject unhashed sockets during established lookups'

Anything above 0 means the kernel you’re running has the fix. The commands look for the patch title too, because a kernel built before the CVE number existed lists the fix only by its title (that caught the CVE-2026-98432 check out earlier this month).

How many receive queues, and is RPS on. Swap eth0 for your interface:

ethtool -l eth0
cat /sys/class/net/eth0/queues/rx-*/rps_cpus

Under “Current hardware settings”, a Combined or RX count above 1, or any rps_cpus value that isn’t all zeros, is enough for the race. Read the count from ethtool rather than the queues folder: on Hyper-V’s network driver, after ethtool -L eth0 combined 1 the folder still lists the old number of queues.

The two stopgaps

Kim suggests two for servers that can’t take a fixed kernel yet.

  1. Turn off SYN cookies. sudo sysctl -w net.ipv4.tcp_syncookies=0 closes the path his proof of concept uses, where a request is rebuilt from a SYN cookie. It doesn’t close the second path. It’s set per network namespace, so each container with its own network needs it too. Most distributions default it to 1. Kim warns it weakens protection against SYN floods. On my lab VM, normal traffic ran at the same rate with it off, and during a SYN flood the server lost traffic with cookies on or off.
  2. Use a single receive queue. sudo ethtool -L eth0 combined 1, on the interface that faces the internet, with RPS and RFS off. The race needs two receive contexts, so one queue removes it. My lab VM ran at the same rate on one queue, but Hyper-V was already putting every packet on one queue there. On a server that spreads traffic across queues, all the receive work moves to one CPU, which can cap network throughput under heavy load.

On a server where neither is acceptable, keep it off the open internet until the kernel lands, and reboot into the fixed kernel as soon as your distribution ships it.

What the stopgaps cost on my lab VMs

The server was my Ubuntu 26.04 VM (4 vCPUs, nginx, on Hyper-V) and the client my Rocky 9.8 VM. Each run was 20 seconds of ab with 100 connections at a time and a new TCP connection for every request, so every request went through the handshake. I can’t tell you whether either stopgap stops the crash, because Kim hasn’t released his proof of concept.

Setting, normal trafficRequests per second
Default (SYN cookies on, 4 receive queues)7,459 to 9,679 over 5 runs
SYN cookies off9,199
One receive queue8,882 and 9,020

The kernel only sends SYN cookies once the SYN queue fills up, and without a flood the cookie counter stayed at 0 in every run.

Hyper-V delivered every packet to the first receive queue even with four set up, so my VM was already running on one queue. On a physical server with a multi-queue NIC, one queue puts all the receive work on one CPU. I didn’t have one to test that on, so measure it under your own load before you rely on it.

Then I ran the same load during a SYN flood from the Rocky VM (hping3 with spoofed sources, 50,000 to 80,000 packets a second). With SYN cookies on, the Ubuntu VM spent its CPU answering the flood and stopped serving: all 5 runs ended with the client timing out. With SYN cookies off, the kernel dropped the flood’s SYNs once its queue was full, and it kept letting in a client it had talked to before (about 6,000 requests a second in 3 runs). When I made every client look new (net.ipv4.tcp_no_metrics_save=1), one of two runs collapsed too. I wouldn’t predict from this what a flood does on your hardware.

What I found on my lab VMs

Both of my Linux lab VMs are exposed. My Ubuntu 26.04 VM runs 7.0.0-43-generic, whose changelog doesn’t list the fix, with 4 receive queues per interface and SSH, HTTP and HTTPS listening. My Rocky 9.8 VM runs 5.14.0-687.64.1.el9_8 (the kernel that fixed CVE-2026-98432 two weeks ago) with 2 receive queues and SSH listening. Both are virtual machines, the setup where Kim’s proof of concept was fastest. I didn’t try to crash either one.

Doing it with RFF

The RFF Script Library has a new Linux entry, NoisyTCP (CVE-2026-99288) - Exposure Check (Linux). It checks the running kernel against the distribution’s changelog (by CVE number or patch title), reports whether a fixed kernel is installed but not booted yet, and lists what decides how reachable the race is: receive queues, RPS, the SYN cookie setting, whether the machine is a VM and which TCP ports listen off loopback. I ran it on both lab VMs, and both came back VULNERABLE with the details above. I’ll run it again when Ubuntu and Red Hat ship their kernels.

RFF is free for your first 100 endpoints: getrff.com.

Sources

One email per new post, nothing else. Unsubscribe in one click. Or use the RSS feed.

Comments

Comments use GitHub Discussions, so you'll need a GitHub account to post. Corrections are especially welcome.