NoisyTCP: An 11-Year-Old Linux Kernel Flaw Can Crash Any Default Nginx, Apache or SSH Server — No Login Required

NoisyTCP: An 11-Year-Old Linux Kernel Flaw Can Crash Any Default Nginx, Apache or SSH Server — No Login Required

NoisyTCP: An 11-Year-Old Linux Kernel Flaw Can Crash Any Default Nginx, Apache or SSH Server — No Login Required

Some vulnerabilities need a special configuration to bite. NoisyTCP needs only a server that listens. Security researcher Hyunwoo Kim (publishing as @v4bel) disclosed this week that an 11-year-old flaw in the Linux kernel's TCP networking stack — tracked as CVE-2026-99288 — lets an unauthenticated attacker crash nearly any Linux server that receives TCP packets directly, including Nginx, Apache and SSH services running their default configuration. The pre-auth remote corruption flaw stems from a NULL pointer dereference: crafted TCP packets exploit the timing between SYN cookie handling and socket hashing to drive a race condition during lockless socket lookups, triggering a kernel panic that takes down the entire host.

The bug has been latent since October 2015 (introduced in commit 079096f103fa) and affects almost every Linux distribution shipped since. The trigger mechanics are precise: a stale ehash lookup and the freeing and reallocation of an existing request socket must proceed concurrently in different receive contexts — which is exactly what happens on any server with two or more RX queues, or where RPS distributes packets across multiple CPUs. A recycled socket can be dereferenced before it is properly initialized, and the TCP receive path then follows a NULL listener into a kernel panic. "Due to a race condition during lockless socket lookups, recycled socket memory can be accessed before it is properly initialized and hashed," the Red Hat security team explained — "a remote attacker could exploit this issue by generating network traffic that drives socket reuse, triggering a NULL pointer dereference and kernel crash that results in a Denial of Service."

Two limits keep NoisyTCP in the DoS category for now. First, the race window is narrow: against VMs on QEMU/KVM, where vCPU preemption introduces timing variance, Kim's proof-of-concept crashed servers in 5 seconds to 2 minutes — but against a quiet bare-metal server with 8 RX queues, even a carefully tuned exploit took about 14 hours. Second, the second trigger path, a full child socket ABA race, can theoretically reach use-after-free, but nested race scenarios make general-purpose exploitation "generally hard to trigger" so far. Notably, because the flaw lives in the kernel rather than the application, a containerized web server does not sandbox the blast radius — crashing the kernel takes down the entire host. The fix was merged into the mainline kernel on November 3 (commit 4e2b3ef19e0e), but distribution kernels will take weeks to propagate it everywhere.

What Should You Do?

  1. Apply the 4e2b3ef19e0e patch or a distro kernel carrying it as soon as your vendor ships one — this is the priority remediation, and everything else is a stopgap.
  2. If you can't patch immediately, disable SYN cookies: sudo sysctl -w net.ipv4.tcp_syncookies=0. This blocks the path where a request socket is reconstructed through a SYN cookie — but it lowers your protection against SYN floods, and the setting is per network namespace, so apply it inside each container too.
  3. Or serialize to a single RX queue on interfaces receiving external traffic and disable RPS/RFS — the race needs concurrent RX contexts, so removing them blocks the trigger at the cost of receive throughput.
  4. Prioritize VM-hosted and multi-queue public-facing servers. Exploitation speed depends on execution variance: virtualized frontends crashed in minutes in testing, while quiet bare-metal hosts resisted for hours — but "slower" is not "safe."

The WAF Angle

NoisyTCP crashes the kernel before your web server sees the request, so no WAF rule set can block it — a crafted SYN handshake never becomes an HTTP transaction to inspect. That makes it a clean reminder of where the request path actually begins: your reverse proxy, load balancer and WAF terminate TCP on their own stacks, which means a hardened edge platform (with its own, patchable kernel in front) can absorb malformed TCP traffic on behalf of origin servers behind it. The same edge-termination logic that shields origins from slowloris-style connection abuse also buys you time here. Meanwhile, the pattern is familiar from coverage like the Fragnesia kernel flaw: the Linux kernel's TCP and memory-management code paths keep producing bugs with no application-layer countermeasure — kernel patch hygiene, not HTTP-layer filtering, is the only real floor.

Sources