CVE-2026-99288: NoisyTCP Linux Kernel Flaw Enables Remote Server Crashes

CVE-2026-99288: NoisyTCP Linux Kernel Flaw Enables Remote Server Crashes

SOC Prime Team
SOC Prime Team linkedin icon Follow

A newly disclosed Linux kernel vulnerability, tracked as CVE-2026-99288 and dubbed NoisyTCP, can enable an unauthenticated remote attacker to crash vulnerable Linux systems by sending specially crafted TCP traffic to an exposed listening service. The issue resides in the kernel TCP networking subsystem and can affect common server workloads such as Nginx, Apache, and SSH without requiring authentication or an unusual application configuration.

The vulnerability remained in the Linux kernel for roughly 11 years after being introduced in October 2015. Red Hat rates the issue Important with a CVSS 3.1 score of 7.5, noting that successful exploitation can cause an operating-system-level denial of service. Current public research does not demonstrate arbitrary code execution as a reliable attack outcome.

The risk is particularly relevant to organizations operating internet-facing Linux infrastructure because exploitation occurs before authentication. If a vulnerable service running inside a container is targeted, the resulting kernel panic can affect the underlying host rather than only the individual container, potentially disrupting multiple workloads simultaneously.

Organizations can strengthen their defenses against emerging vulnerability exploitation with SOC Prime’s AI-Native Detection Intelligence Platform, helping security teams operationalize threat intelligence and accelerate threat hunting and detection engineering across SIEM, EDR, XDR, and Data Lake environments.

Detect CVE-2026-99288 by monitoring suspicious TCP behavior preceding kernel instability, unexpected host reboots, and Linux kernel panic events on externally reachable systems. Since NoisyTCP operates at the kernel networking layer, defenders should correlate host-level telemetry with network activity instead of relying exclusively on application logs.

Contact Sales

CVE-2026-99288 analysis

CVE-2026-99288 affects the Linux kernel’s TCP established-socket lookup logic. TCP established ehash lookups operate without traditional locking, while the relevant socket caches use SLAB_TYPESAFE_BY_RCU, which allows memory to be reused before an RCU reader holding the previous address has completed its operation.

After finding a matching tuple, functions such as __inet_lookup_established() and __inet6_lookup_established() obtain a reference and repeat the tuple validation. The vulnerable implementation does not verify whether the replacement object is already hashed. If memory is reused for another socket with the same tuple, a stale lookup can therefore acquire a reference to the new object before it is fully integrated into the expected socket state.

One demonstrated attack path involves the reuse of a request socket through SYN cookies. While one receive context retains a stale reference to an existing request socket, another context can free that object and allocate a new SYN cookie request at the same slab address. Because the tuple remains the same, the stale lookup can acquire a reference to the replacement object and pass the tuple check.

The newly created request socket, however, has not yet been hashed and has a NULL rsk_listener. When the Linux TCP receive path later attempts to use the listener, it dereferences the NULL pointer. This results in a kernel panic and causes the operating system to crash.

Successful exploitation requires the stale lookup and socket reuse to occur concurrently in separate receive contexts. Researchers found that this can be achieved by exploiting differences in receive hashing between IPv4 fragments and ordinary TCP packets. Consequently, systems with two or more RX queues, or environments where Receive Packet Steering distributes traffic across multiple CPUs, can provide the concurrency necessary to trigger the race.

The CVE-2026-99288 PoC demonstrates that exploitation time depends heavily on the target environment. Against Nginx, Apache, and SSH servers running with default configurations on QEMU/KVM virtual machines, the researcher was able to reproduce the crash in approximately five seconds to two minutes. By comparison, triggering the issue on a quiet bare-metal Nginx server with eight RX queues took roughly 14 hours even with race timing tuned for the specific system.

Virtualization can make the race more practical because vCPU preemption introduces additional scheduling variance. Nevertheless, the underlying weakness is not limited to virtual machines or a specific server application. Any directly reachable vulnerable Linux host exposing a TCP listener can potentially be targeted when the required concurrency conditions exist.

The vulnerability originated in Linux kernel commit 079096f103fa, introduced on October 3, 2015 with Linux 4.4. The upstream correction, commit 4e2b3ef19e0e, was merged on November 3, 2026. The fix causes established socket lookups to reject unhashed objects, release the acquired reference, and restart the lookup instead of continuing with an unsafe reused socket.

The Linux kernel CVE team lists 6.12.117, 6.18.63, and 7.3.4 among the stable kernel versions containing the correction. However, distribution vendors can backport patches independently, so administrators should rely on the advisory for their specific Linux distribution rather than assume that a version number alone determines exposure.

For CVE-2026-99288 detection, security teams should correlate Linux kernel logs, system availability telemetry, and network activity. Potential indicators include kernel NULL pointer dereference events, kernel panics associated with tcp_v4_rcv, unexplained server reboots, and unusual bursts of TCP traffic immediately preceding system failure.

Traditional CVE-2026-99288 IOCs such as malicious file hashes, payload URLs, or attacker-controlled domains are less relevant because exploitation can occur entirely through network traffic without dropping malware on the target. Defenders should therefore prioritize behavioral evidence, crash telemetry, TCP connection patterns, fragmentation activity, SYN traffic, and repeated host resets.

As of November 17, 2026, there is no confirmed evidence that the vulnerability is being actively exploited in real-world attacks. Public research demonstrates remote denial of service, while Red Hat explicitly states that exploitation does not provide data modification or arbitrary code execution.

Security teams seeking additional details for CVE-2026-99288 should consult the Linux kernel CVE announcement, vendor-specific advisories, and the original NoisyTCP disclosure because fixed package versions and backport availability can vary significantly across Linux distributions.

CVE-2026-99288 Mitigation

The most effective remediation is to install an updated kernel containing the upstream correction or the corresponding security backport supplied by the Linux distribution vendor. The Linux kernel CVE team recommends updating to the latest stable kernel rather than cherry-picking an individual change whenever possible.

For CVE-2026-99288 mitigation, organizations should first inventory externally reachable Linux servers and identify systems exposing TCP services such as Nginx, Apache, SSH, proxies, gateways, and other network-facing workloads. Virtual machines with multiple RX queues, environments using RPS, and hosts supporting multiple critical containers should receive particularly high patching priority.

Administrators should verify their running kernel rather than only checking whether the operating system’s package manager recently installed updates. A patched kernel package does not protect the system until the server has rebooted into that kernel.

When immediate patching is not possible, Hyunwoo Kim and Red Hat document two temporary mitigations. One approach is to disable SYN cookies:

sudo sysctl -w net.ipv4.tcp_syncookies=0

This prevents the demonstrated path in which a request socket is reconstructed through a SYN cookie. However, disabling the feature reduces protection against SYN flood attacks, so administrators should carefully evaluate the operational and security trade-offs. The setting is maintained per network namespace and may therefore need to be applied individually to containers using separate namespaces.

A second temporary measure is to reduce packet handling to a single RX queue and disable Receive Packet Steering and Receive Flow Steering. Since exploitation depends on separate RX contexts racing concurrently, serializing packet processing can prevent the demonstrated condition. This approach can affect network performance and should be evaluated before deployment in production environments.

Organizations should additionally reduce unnecessary public exposure of administrative and infrastructure services, restrict TCP access to trusted networks where operationally possible, and ensure centralized collection of kernel logs and crash telemetry. These controls cannot substitute for patching but can help reduce attack surface and improve incident investigation.

FAQ

What is CVE-2026-99288 and how does it work?

CVE-2026-99288, also known as NoisyTCP, is a Linux kernel TCP race condition affecting lockless established-socket lookups. Under specific timing conditions, recycled socket memory can be referenced before the replacement object has been fully initialized and hashed. A remote attacker can manipulate TCP traffic to trigger a NULL pointer dereference, resulting in a kernel panic and denial of service.

When was CVE-2026-99288 first discovered?

The precise date on which Hyunwoo Kim privately discovered the vulnerability has not been publicly disclosed. The correction entered the Linux networking development process in late October 2026 and was merged upstream on November 3. The Linux kernel CNA publicly announced the vulnerability on November 10, 2026, while Kim released the detailed NoisyTCP research after the coordinated disclosure embargo expired on November 15–16.

What is the impact of CVE-2026-99288 on systems?

Successful exploitation can remotely crash the Linux kernel and take the entire operating system offline without authentication. If the affected host runs containers or multiple services, a kernel panic can disrupt all workloads sharing that kernel. Current evidence demonstrates denial of service rather than reliable remote code execution.

Can CVE-2026-99288 still affect me in 2026?

Yes. Systems remain exposed when they run a vulnerable kernel that does not contain the upstream correction or a vendor backport. Because the underlying bug dates back to Linux 4.4 in 2015, many kernel branches and Linux distributions may be affected. Administrators should verify the latest security advisory for their distribution because patch availability continues to change as vendors release backports.

How can I protect myself from CVE-2026-99288?

Apply a vendor-provided kernel update containing the NoisyTCP correction and reboot the system into the patched kernel. If immediate updating is impossible, evaluate temporary measures such as disabling SYN cookies or reducing packet processing to a single RX queue with RPS and RFS disabled. Organizations should also limit unnecessary TCP exposure and monitor Linux hosts for kernel panics, unexpected reboots, and suspicious network activity.

Join SOC Prime's Detection as Code platform to improve visibility into threats most relevant to your business. To help you get started and drive immediate value, book a meeting now with SOC Prime experts.

More CVEs Articles