NoisyTCP turns a plain TCP listener into a remote Linux crash path
NoisyTCP, tracked as CVE-2026-99288, is a race in the Linux kernel TCP receive path that can end in a kernel panic. The important detail is not a special application feature. The researcher's advisory says an attacker can trigger the flaw against a plain TCP listener, including Nginx, Apache, and SSH servers using default configurations, if the attacker's packets can reach the host.
The bug was introduced by commit 079096f103fa on October 3, 2015 and fixed by commit 4e2b3ef19e0e on November 3, 2026. The advisory calls the exposure almost universal across Linux distributions because the vulnerable code stayed in the kernel for about eleven years.
The race involves a stale request socket
The simpler trigger flow is a request-socket reuse ABA race. One receive context performs a lookup and finds an existing request socket. A second receive context frees that object and reallocates a SYN cookie request at the same slab address. The stale lookup then acquires a reference to the new object and passes a tuple recheck, but the new request has no listener attached. The TCP receive path dereferences the null listener, and the kernel panics.
The race requires packet processing to run in different receive contexts. IPv4 fragments and regular TCP packets can be distributed by their receive hashes. Servers with two or more receive queues, or systems using Receive Packet Steering across CPUs, provide the concurrency this attack needs. A second flow can reach a full child-socket use-after-free, but the advisory describes it as a nested race that is generally harder to trigger.
The impact is remote denial of service at the host level. If an internet-facing web server runs in a container, a kernel panic is not contained by that application boundary. The whole host can go down. That distinction matters for managed hosting, shared virtual machines, and container platforms where a TCP listener is treated as an application concern but the vulnerable code runs in the shared kernel.
Trigger difficulty changes with the host
The advisory's test results show why a proof of concept is not a reliable predictor of exploitation time. Against Nginx, Apache, and SSH servers in QEMU/KVM virtual machines, the carefully tuned proof of concept triggered in roughly five seconds to two minutes. Against Nginx on a quiet bare-metal server with eight receive queues, it took about fourteen hours. The race still exists on both systems; contention and vCPU preemption change how often the required interleaving occurs.
Defenders should therefore avoid two weak conclusions. A crash that does not reproduce quickly does not prove a host is unaffected. A public tool that fails against one machine does not prove the entire fleet is safe. Kernel version, receive queue count, packet distribution, and the availability of attacker-controlled paths all affect reproducibility.
Patch first, then choose a temporary tradeoff
Applying the kernel fix that contains 4e2b3ef19e0e is the priority. The advisory offers two temporary controls when patching cannot happen immediately.
The first is to disable TCP SYN cookies with net.ipv4.tcp_syncookies=0. This blocks the path where a request socket is reconstructed through a SYN cookie. The setting is managed per network namespace, so every container with a separate namespace needs its own check. Disabling SYN cookies also reduces resistance to SYN floods, so it is a tradeoff rather than a free mitigation.
The second is to serialize inbound processing onto one receive queue and disable Receive Packet Steering and Receive Flow Steering. This removes the different receive contexts needed for the race. It can reduce network throughput and is not a universal configuration change for high-traffic systems.
An inventory should include internet-facing kernel versions, load balancers, virtual hosts, container hosts, and the application packages inside them. If a load balancer terminates connections to a vulnerable backend, the backend may still accept TCP from the proxy and remain in scope. Recovery plans should include kernel patching and reboot validation, because installing a package without running the fixed kernel leaves the exposure in place.
Detection and verification
Unexpected kernel panics, reboots without a userspace crash record, and repeated connection churn on exposed listeners deserve review, especially when Nginx, Apache, or SSH processes remain otherwise healthy. Those signals are not proof of NoisyTCP, but they are useful during a known exploitation window.
After remediation, verify that the running kernel, not just the package manager, contains the fixed commit. Check every network namespace and every node in a cluster. Keep SYN-cookie and receive-queue settings documented so a temporary workaround is not mistaken for the permanent fix.
Top comments (0)