NoisyTCP lets attackers crash a Linux server over one open TCP port, eleven years after it shipped
CVE-2026-99288, dubbed NoisyTCP, lets an unauthenticated attacker panic an entire Linux host from a single open TCP port, including through a container. Apply the November 3 kernel fix as soon as your distribution ships it.
November 3, 2026. The fix for CVE-2026-99288 lands in the upstream Linux kernel. November 15, 2026. Hyunwoo Kim, the researcher who exposed Dirty Frag in May, publishes the details after the disclosure embargo lifts. October 2015. The date the flaw, dubbed NoisyTCP, was introduced. Why it matters: a memory race in Linux’s TCP stack lets an attacker crash a whole host remotely, with no credentials — and a container does not contain the blast radius.
A race in the TCP stack, invisible for eleven years
The bug is buried in the kernel’s TCP networking code. Two parts of the kernel can trip over each other while processing incoming traffic: one tries to use memory that has already been freed — a classic use-after-free — and the kernel panics, taking the whole machine down.
No special configuration is required. Services such as Nginx, Apache, and SSH are vulnerable out of the box, as long as they listen on a reachable TCP port and the system processes traffic across multiple receive queues or CPUs. The attacker needs neither authentication nor credentials — just the ability to reach an open port.
The trigger is precisely that plurality. On a modern server, a network card spreads incoming packets across multiple receive queues — often one per CPU, via Receive Side Scaling — and several kernel paths process those queues in parallel. It is that parallelism that opens the race: while one path finishes freeing a memory structure, another still reaches into it. A server pinned to a single queue is in practice less exposed, which is why the workaround exists — and why virtual machines, whose queues are easier to saturate, fall faster.
The most awkward consequence concerns containerized workloads. Because the flaw lives in the kernel, crashing a web server inside a container can take down the underlying host and everything running on it. Container isolation protects processes, not the kernel they share.
Virtual machines in five seconds, bare metal in fourteen hours
Hyunwoo Kim measured how effective the attack is per target. On QEMU/KVM virtual machines, he brought down Nginx, Apache, and SSH servers in five seconds to two minutes. Bare-metal hardware fights back harder: even after tailoring his exploit to the machine, it took him about fourteen hours to crash a physical Nginx server.
The gap makes sense: on a VM, the timing of receive queues and CPU load is more predictable and easier to provoke. On bare metal, the race window is harder to hit. But “harder” does not mean impossible — the bare-metal demonstration exists.
That asymmetry carries a counterintuitive security consequence: virtualized infrastructure — precisely the kind that packs the most tenants onto the fewest machines — is the most exposed, because the race window is easiest to open there. A hoster or private cloud that exposes VMs to third parties should patch its hypervisors first, ahead of its bare-metal fleet.
The researcher also identified a second exploitation path through a distinct use-after-free condition. It is considerably harder to trigger than a plain crash, and while it theoretically opens the door to code execution, Kim has only demonstrated a limited exploit against virtual machines in a lab — no general-purpose remote code execution. For now, the confirmed impact is remote denial of service.
Hyunwoo Kim is the same researcher who found Dirty Frag in May, a local privilege-escalation bug whose working exploit went public before patches were ready. That history matters for triage: what is confirmed today as a crash is only the first rung of what a race like this can become, and a researcher with a track record of turning kernel races into working exploits suggests the ceiling is not fixed. Assume the bar to exploitation keeps dropping.
What the fix changes, and what it does not
The fix was committed to the upstream kernel on November 3. Red Hat rated the flaw Important, assigning a CVSS score of 7.5. The high score reflects the lack of authentication and the scope: one open port is enough, and the whole machine falls.
For administrators, the real work starts at publication: checking whether their distribution has actually shipped the patched kernel. A flaw fixed upstream on November 3 protects no one until it reaches the packages of Ubuntu, Debian, RHEL, Alpine, or whichever distribution you actually run.
The 7.5 score reads “high severity”, but it undersells the operational reality. A use-after-free that panics the kernel does not take down one service: it takes down every service on the host at once, and every reboot is a full outage, not a partial degradation. On a hypervisor running dozens of virtual machines, the right question is not “is this service up to date?” but “is every kernel under my responsibility patched?”
Whether you are exposed, and how to hold without rebooting
Diagnosis starts with the kernel version. The fix landed upstream on November 3, but each distribution backports it at its own pace:
uname -r Compare the output against your distribution’s security advisory — Red Hat has already published its notice (score CVSS 7.5), others will follow. Do not just check your container images: the flaw lives in the host kernel, shared by every container running on it.
If the fix is not yet available, the two workarounds translate into concrete settings. Disabling SYN cookies means writing 0 to net.ipv4.tcp_syncookies:
sysctl -w net.ipv4.tcp_syncookies=0 …and repeating the operation in each of your containers’ network namespaces, since the setting is per-namespace. Restricting to a single receive queue, the other option, means reducing the number of RSS queues or pinning IRQs — a more invasive change to calibrate with your network team.
Neither is harmless: the first reopens the door to SYN floods, the second costs throughput. Both are justified only as a stopgap on hosts that cannot reboot, and both should be reverted the moment the patched kernel is installed.
The verdict
Patch as soon as your distribution publishes the fixed kernel, and treat every server exposing a TCP port as a target. The flaw needs no credentials and no special configuration, and the CVSS 7.5 undersells the operational impact: a panicking host is also a rebooting host that can fall over again. Check the kernel version of your hosts, not just your container images — the host kernel is what counts here.
In the meantime, choose a workaround only if patching is genuinely impossible. Disabling SYN cookies trades one protection for another; restricting to a single receive queue sacrifices throughput. Both should be revisited immediately after patching. And if your continuity plan rests on a kernel crash recovering without a reboot, Kmorph’s approach shows it is possible — but no recovery tool beats the absence of a crash.
Finally, file this alongside your other remote-triggerable kernel bugs rather than treating it as a networking oddity. The fix is small, the exposure is broad, and the class — races in the TCP receive path — is the kind that keeps producing variants. NoisyTCP is the second kernel flaw Hyunwoo Kim has surfaced this year, and both arrived with the same lesson: patching once is cheap, patching the same class repeatedly is where the cost hides.