Eleven Years Hiding. One Packet Crashes the Server.

Some bugs hide for a few weeks. This one hid for eleven years — inside the networking code of nearly every Linux server on the internet. All it takes to wake it up is a stream of crafted packets. No login. No password. The server just falls over.

Researcher Hyunwoo Kim disclosed the flaw, dubbed NoisyTCP, on November 16. Tracked as CVE-2026-99288 and rated 7.5 out of 10 by Red Hat, the bug has sat in the Linux kernel’s TCP stack since October 2015. Almost every Linux distribution ships it. Millions of systems are exposed.

What happened

Triggering it takes choreography. The attacker must spread packet processing across different receive queues, which is why the flaw needs a server with two or more RX queues, or one where receive packet steering (RPS) distributes work across multiple CPUs — both common on real servers. The trick uses the difference in how IPv4 fragments and regular TCP packets are hashed, steering traffic so a stale lookup and a socket free happen together. Servers running Nginx, Apache, or SSH with default configuration are all in scope, as is any plain TCP listener an attacker can reach directly.

The race window is narrow: against a quiet bare-metal server, triggering the crash can take a long time. Against a busy server, the odds improve — the kind of server nobody can afford to lose.

NoisyTCP attack chain: crafted TCP packets open a race in the Linux TCP stack, a socket is freed mid-processing, and the kernel crashes
How NoisyTCP turns crafted packets into a kernel crash.

Not the other Linux TCP bug

Do not confuse this with the Linux TCP flaw from a few weeks ago. CVE-2026-98432, a 9.8-severity bug from researchers at Anthropic, lets an unauthenticated remote attacker execute code as root — a full takeover, which we covered when it landed. NoisyTCP is the second Linux TCP bug in under a month, but a different beast: for now, it crashes servers. It does not alter data and it does not hand the attacker code execution.

The “for now” matters. Kim says research into deeper exploitation is ongoing, and a use-after-free in the same code path could, in the worst case, open the door to more — though he cautions this kind of exploitation is generally hard to trigger without special techniques. So today this is a denial-of-service bug. Tomorrow it might be something worse, and the researcher who found it has a track record worth taking seriously, having disclosed the Dirty Frag privilege-escalation chain in May and the Januscape virtual-machine escape in July.

Why it matters

A crash is not a breach, and it is tempting to file this under “annoying, not dangerous” — a mistake. A kernel panic takes the entire machine down — web server, SSH access, every service — and if the attacker keeps sending traffic, the server can be kept down or forced into a reboot loop. For a public-facing web server or a jump host, that is an outage an attacker can trigger at will, from anywhere, without credentials.

The exposure is unusually broad: Nginx and Apache are two of the most widely deployed web servers in the world, SSH is the standard way administrators reach their machines, and the vulnerable code has been in the kernel for over a decade. Unauthenticated crashes that take a service down with almost no effort are not new, but a remotely triggerable kernel panic in the TCP stack itself is about as fundamental as it gets. Add the patch lag — the fix is upstream since early November and in some distro packages, but not all distributions have shipped it yet — and the gap is real.

What to do now

1. Patch the kernel. Check your distribution’s advisory for CVE-2026-99288 and apply the fixed kernel as soon as your vendor ships it. Confirm the running version after a reboot (uname -r): a patched package that has not been booted into protects nothing. Prioritize internet-facing systems first: web servers, SSH hosts, and anything with a plain TCP listener reachable from the network.

2. If you cannot patch yet, slow the race down. Red Hat recommends disabling SYN cookies and serializing packet processing to a single RX queue, removing the concurrency the exploit needs. Know the trade-off: turning SYN cookies off weakens protection against SYN flood attacks, so treat this as a temporary shield — and put the patch on the calendar the moment it is available.

3. Map what is actually exposed. List the TCP listeners on every Linux host facing the internet or an untrusted network (ss -tlnp shows them) and ask whether each one needs to be reachable at all. Anything that does not need direct exposure belongs behind a firewall, a load balancer, or a VPN.

4. Watch for unexplained panics. A kernel panic or sudden reboot on a Linux server is now a signal worth investigating, not just a ticket to close. Check kernel logs for NULL pointer dereference crashes and correlate timing with traffic spikes; treat a repeat pattern as a possible exploitation attempt while you push the patch through.

NoisyTCP defense: patch the kernel first, mitigate with SYN cookies off and a single RX queue, and check which listeners are exposed
Patch first, mitigate while you wait, and check what is exposed.

Eleven years is a long time for a bug to sit in the world’s most widely used server operating system. The era of TCP remote exploits has begun — and the cheapest defense is still the oldest one: patch fast, know what you expose, and do not assume a crash-only bug will stay crash-only.

Comments

This site uses Akismet to reduce spam. Learn how your comment data is processed.