NoisyTCP Turns an Ordinary Linux Port Into a Host-Wide Crash Risk

CVE-2026-99288 is an 11-year-old Linux TCP race condition that can let an unauthenticated remote attacker panic a server through an ordinary listening port, taking every container on the host down with it.

QuantumBytz Team
November 22, 2026
Share:
Stylized cutaway illustration of a dual-processor Linux server with incoming network traffic triggering red fault paths across the motherboard and hosted workloads.

Summary

NoisyTCP, tracked as CVE-2026-99288, is an 11-year-old race condition in the Linux TCP stack that can let an unauthenticated remote attacker crash a server through an ordinary listening port. Internet-facing virtual machines and container hosts deserve priority because a kernel panic takes down the host, not only the service that received the traffic.

A Linux server does not need an unusual network daemon or a forgotten management interface to be exposed to NoisyTCP. A reachable Nginx, Apache or SSH port can provide the necessary entry point.

The vulnerability sits in the kernel's handling of incoming TCP connections. Under the right timing conditions, packets processed in different receive contexts can make the kernel use recycled socket memory as though it still represented the earlier connection. The demonstrated result is a NULL pointer dereference and kernel panic.[1][2]

That makes CVE-2026-99288 a remote availability threat. Red Hat rates it Important and says an unauthenticated attacker can crash an affected operating system over the network. Red Hat also states that the demonstrated flaw does not allow data alteration or arbitrary code execution.[3]

There were no public reports of exploitation in the wild in the advisories reviewed for this article.[2][4] That is reassuring, but it is not a reason to defer patching. The affected code dates to Linux 4.4, released in 2016, and many servers process network traffic across multiple receive queues or CPUs.

What actually goes wrong

Linux must find the correct socket whenever a TCP packet arrives. It performs established-socket lookups without taking a conventional lock because this path has to be fast under heavy traffic.

The socket caches use a read-copy-update design that allows memory to be reused while an earlier reader may still retain the old address. After finding a possible match, the kernel takes a reference and checks the connection tuple again. Before the NoisyTCP fix, that second check did not also confirm that the object was still present in the socket hash table.[1][2]

An attacker can try to create a narrow race between two receive contexts. One context retains the address of an old request socket while another frees that object and reuses the same memory for a new request with the same address and port tuple. The stale lookup can then accept the new object as its original match.

The proof of concept uses a request reconstructed through TCP SYN cookies. That request is not in the established-socket hash and has no listening socket attached. When the stale lookup returns it anyway, the TCP receive path follows a NULL listener pointer and panics the kernel.[1]

The upstream correction adds the missing state check. After taking a reference, the lookup now rejects an unhashed object and starts again. Related error paths were also changed to release request references safely.[2]

Why virtual machines can be easier to crash

This is a race, so the attacker has to make two operations overlap in a very small window. Packets must be handled in different receive contexts, normally through a network interface with at least two receive queues or through Receive Packet Steering that distributes work across CPUs.[1]

Those conditions are common in current servers and cloud instances.

Researcher Hyunwoo Kim reported that tuned proof-of-concept traffic crashed default Nginx, Apache and SSH services on QEMU/KVM virtual machines in roughly five seconds to two minutes. A quiet bare-metal Nginx server with eight receive queues took about 14 hours under the reported test conditions.[1]

Those numbers are not universal exploit times. CPU scheduling, NIC configuration, workload, kernel build and traffic conditions can change the result. They do show that the bug is practical enough to treat as more than a theoretical concurrency failure.

Virtualization may make the timing less predictable for the guest and more favorable to the race because a virtual CPU can be preempted at an inconvenient moment. A busy host can also provide the execution variance that a timing-dependent attack needs.

The container blast radius

Containers share the host kernel. That detail turns a network-facing application problem into an infrastructure problem.

If an attacker directs NoisyTCP traffic at a web server inside a container and triggers the kernel panic, the container runtime cannot isolate the failure. The host crashes, taking its other containers and services with it.[1][2]

The same concern applies to Kubernetes worker nodes and other multi-tenant container platforms. A single reachable workload can become the path to a node-wide outage even when the application itself is unprivileged and its filesystem is tightly restricted.

This is not a container escape. The attacker is not shown breaking into the host or reading another container's data. The shared kernel simply means the denial of service occurs below the isolation boundary.

Platform teams should inventory exposed listeners by host and node rather than reviewing only the applications that seem security-sensitive. A basic HTTP endpoint on a shared worker can matter as much as an administrative service when both reach the same vulnerable TCP stack.

Which systems need attention

The bug was introduced by kernel commit 079096f103fa in October 2015 and remained latent for about 11 years. The upstream fix is commit 4e2b3ef19e0e, titled inet: reject unhashed sockets during established lookups.[1][2]

The NVD record identifies Linux 4.4 and later as affected and lists fixed upstream releases including 6.12.117, 6.18.63 and 7.3.4.[2] Distribution kernels do not map cleanly to those version numbers. Vendors backport security fixes while retaining an older-looking kernel release, so comparing only the output of uname -r with an upstream version can produce the wrong answer.

Use the distribution's CVE tracker and package advisory. Check the running kernel first:

uname -r

Then inspect the installed kernel packages:

# Debian and Ubuntu
dpkg-query -W 'linux-image*' 2>/dev/null

# RHEL, AlmaLinux, Rocky Linux, Oracle Linux and Fedora
rpm -q kernel kernel-core 2>/dev/null

A package update is not enough if the machine has not rebooted into the new kernel. After the maintenance window, run uname -r again and confirm that the running version matches a package your vendor marks as fixed.

Appliances need separate attention. Firewalls, storage systems, hyperconverged platforms and other products may contain Linux without exposing their kernel package management to customers. Ask the vendor whether the product includes the NoisyTCP fix rather than attempting an unsupported kernel replacement.[4]

Patch first; mitigate only when you cannot reboot

Installing the vendor's corrected kernel and rebooting is the proper fix. The documented workarounds carry operational costs and do not remove the vulnerable code.

One temporary mitigation disables TCP SYN cookies:

sudo sysctl -w net.ipv4.tcp_syncookies=0

That blocks the demonstrated request-socket path, but it weakens the server's protection against SYN-flood attacks. The setting is also per network namespace. A container with its own network namespace needs the setting applied there as well as on the host.[1][3]

The researcher also described a second, harder-to-trigger use-after-free path that does not depend on SYN cookies. Disabling SYN cookies therefore should not be presented as complete protection.[1]

The other mitigation serializes receive processing by reducing the exposed interface to one RX queue and disabling RPS and RFS. This prevents the cross-context race but can cut network throughput and may not be supported by every physical or virtual NIC. Interface management or a reboot may also reset the change.[1]

Either workaround can trade one availability risk for another. Use one only when the exposure is serious and a corrected kernel cannot be loaded immediately. Document the change, monitor its effect and remove it after patching.

A practical response plan

Start with systems that accept TCP connections from the internet or other untrusted networks. Give extra weight to cloud virtual machines, shared container hosts and nodes whose outage would remove many workloads at once.

For each system:

  1. Record the running kernel and vendor package version.
  2. Check the vendor's CVE-2026-99288 advisory rather than relying on the upstream version alone.
  3. Install the corrected kernel package when available.
  4. Reboot the system through the normal high-availability process.
  5. Confirm the new kernel with uname -r after the reboot.
  6. Check that services, network queues and monitoring returned normally.
  7. Review Linux-based appliances with their manufacturers.

Teams that cannot patch immediately should reduce unnecessary exposure. Remove unused listeners, restrict management ports to trusted networks, and confirm that load balancers or firewalls prevent direct access where possible. Those measures do not repair the kernel, but they reduce the number of sources able to reach it.

Do not run an untrusted proof of concept against production. A successful test is a host crash, and reproducing the race may cause the exact outage the maintenance work is intended to prevent.

Keep the impact in proportion

NoisyTCP deserves quick action because it reaches the kernel through common services and can disrupt an entire host. Its long affected history and container-host blast radius make the inventory problem substantial.

The public evidence still has clear limits. The demonstrated result is denial of service. Red Hat says the flaw does not permit data alteration or arbitrary code execution, and current advisories report no known exploitation in the wild.[2][3][4]

That distinction should shape the response. This is not evidence that exposed Linux servers have already been silently compromised. It is a reason to patch a broad, remotely reachable crash condition before someone turns reliable research into routine disruption.

Sources

[1] Hyunwoo Kim on oss-security — NoisyTCP technical disclosure

[2] NIST National Vulnerability Database — CVE-2026-99288

[3] Red Hat Security — CVE-2026-99288

[4] Sophos advisory — Linux kernel TCP vulnerability NoisyTCP

[5] AlmaLinux — NoisyTCP patched kernels and mitigation guidance

QuantumBytz Team

The QuantumBytz Editorial Team covers cutting-edge computing infrastructure, including quantum computing, AI systems, Linux performance, HPC, and enterprise tooling. Our mission is to provide accurate, in-depth technical content for infrastructure professionals.

Learn more about our editorial team