The NoisyTCP vulnerability gives an unauthenticated remote attacker a path to crash an exposed Linux server through ordinary TCP traffic. Security researcher Hyunwoo Kim publicly disclosed CVE-2026-99288 on November 15, 2026 in the America/Los_Angeles timezone, after the coordinated embargo expired. The reported impact is a kernel panic, not confirmed remote code execution, but the operational consequence can still be severe.
One successful trigger against a containerized web service can take down the entire host and every workload sharing its kernel. If your organization runs internet-facing Linux virtual machines, container nodes, web servers, or SSH gateways, identify the running kernel and receive-queue configuration now. Patch where a supported fix exists, use temporary mitigations carefully where it does not, and verify the kernel actually running after reboot.
Key Takeaway: NoisyTCP is a host-level availability risk. A container boundary does not contain a Linux kernel panic.
What the NoisyTCP vulnerability changes
Kim's oss-security advisory describes NoisyTCP as a pre-authentication remote corruption flaw in the Linux kernel's TCP established-socket lookup path. An attacker does not need a valid account or an unusual application. The vulnerable path can be reached through plain TCP listeners such as Nginx, Apache, and SSH when packets can reach the server directly.
The race occurs when one receive context retains a stale socket lookup while another frees and reallocates a request socket. The stale lookup can then acquire a reference to the new object, pass the tuple check, and return a socket whose listener pointer is null. The TCP receive path dereferences that pointer and panics the kernel.
Two conditions make the documented trigger practical:
- packets are processed concurrently through two or more RX queues
- Receive Packet Steering or similar processing distributes traffic across CPUs
Modern virtual machines and multi-core servers commonly meet those conditions. The researcher's tests reportedly triggered the crash against QEMU/KVM virtual machines in roughly 5 seconds to 2 minutes. A carefully tuned proof of concept needed about 14 hours against a quiet bare-metal Nginx server with eight RX queues, which shows that environment and timing matter.
The disclosure also describes a more complex remote use-after-free path, but it does not claim reliable code execution. Defenders should preserve that distinction. The demonstrated and actionable risk is remote denial of service through a kernel panic.
Common Mistake: Calling NoisyTCP a confirmed Linux remote code execution flaw. Current public evidence supports a remote crash, while the harder corruption path has not been shown as practical RCE.
Which Linux systems need urgent review
The researcher says the vulnerable code entered the kernel on October 3, 2015 and was fixed upstream on November 3, 2026. That broad window means version numbers alone can mislead you because enterprise distributions backport fixes without adopting a new upstream release number.
Prioritize systems that combine four characteristics:
- A Linux kernel that does not include the NoisyTCP fix.
- A reachable IPv4 TCP listener such as HTTPS, SSH, a reverse proxy, or an application port.
- Multiple hardware or virtual receive queues, or RPS/RFS enabled.
- A workload where a host crash would interrupt several services or critical transactions.
Start with internet-facing container nodes, Kubernetes workers, public reverse proxies, remote-access servers, and shared virtual machines. Next, review internally reachable infrastructure where an infected endpoint or untrusted tenant could send crafted traffic.
Do not exclude a host because its application runs in a container. Containers share the host kernel, so the documented panic can stop every container on that node. The same reasoning applies to a server with several systemd services or virtual network appliances consolidated on one Linux guest.
Debian's CVE tracker shows why distribution-specific evidence matters. It lists fixed packages for supported Debian branches, while older package versions remain vulnerable. Your pass condition should come from the vendor advisory for the exact distribution, release, architecture, and kernel stream you operate.
The response should resemble the disciplined inventory used for the Xen hypervisor vulnerabilities: list each host, its workload owners, update source, maintenance path, current running version, and reboot status. A package marked installed is not proof that a fixed kernel is active.
How to find exposure without unsafe testing
You do not need to run the researcher's proof of concept against production. Build exposure from configuration and version evidence instead.
Collect these facts from each Linux host:
- distribution, release, architecture, and package kernel version
- output of
uname -rfor the running kernel - externally and internally reachable TCP listeners
- RX and combined queue counts for internet-facing interfaces
- RPS and RFS configuration for those interfaces
- SYN cookie configuration in the host and relevant network namespaces
- container or service dependencies that would fall with the host
Use ss -ltn to identify TCP listeners, then compare them with firewall, load-balancer, and cloud security-group rules. A listening socket bound to all interfaces is not necessarily internet reachable, while a service behind destination NAT may be exposed even if the local view looks private.
Use ethtool -l <interface> where supported to inspect queue capacity and current settings. Review /sys/class/net/<interface>/queues/rx-*/rps_cpus for Receive Packet Steering. Virtual interfaces, bonded devices, and cloud networking can complicate the path, so validate the interface that actually receives untrusted traffic.
Finally, query the distribution's security tracker or vendor package metadata. Do not compare only with upstream versions. Backported fixes can make an older-looking enterprise kernel safe, while an unpatched custom kernel with a newer marketing label may still be exposed.
Pro Tip: Record both the installed kernel package and
uname -r. The first shows what should start next; the second shows what is protecting the host now.
Patch NoisyTCP without creating an outage
The preferred response is a vendor-supported kernel that includes the upstream fix. Apply the distribution update through an authenticated repository, schedule a reboot, and confirm that the bootloader selected the expected build.
For redundant services, patch in a controlled sequence:
- Confirm healthy capacity and a working rollback path.
- Drain one node or remove it from the load balancer.
- Install the approved kernel update.
- Reboot the host.
- Verify the running kernel and service health.
- Return the node to service before moving to the next one.
Do not patch every member of a cluster simultaneously unless the architecture and recovery plan explicitly support it. A rushed fleet update can create the outage you are trying to prevent.
CIQ's NoisyTCP guidance provides one example of distribution-specific fixed package tables and verification steps. Treat those versions as relevant to the named Rocky Linux and CIQ variants, not as universal Linux targets.
For unsupported or custom kernels, prefer rebuilding on a supported distribution stream rather than carrying an emergency local patch indefinitely. If a vendor has not yet released a fixed package, document the gap, restrict reachability, and apply a temporary mitigation only after testing its tradeoffs.
The OpenSSH password bypass response guide makes a useful parallel: package status, effective configuration, and actual network reachability answer different questions. You need all three before closing a vulnerability ticket.
Temporary mitigations and their costs
Kim documents two temporary options for systems that cannot receive a fixed kernel immediately. Neither should become a permanent substitute for patching.
Disable SYN cookies
Disabling net.ipv4.tcp_syncookies blocks the documented path that reconstructs a request socket through a SYN cookie. The setting is managed per network namespace, so changing it only on the host may not cover containers with separate namespaces.
This choice reduces protection against SYN-flood attacks. Test capacity, rate limiting, upstream denial-of-service defenses, and connection behavior before applying it broadly. Record every namespace changed so the mitigation can be reversed after patching.
Reduce receive-path concurrency
The second option is to reduce the externally facing interface to one RX queue and disable RPS and RFS. That removes the concurrent receive contexts required by the race.
The cost is potential throughput and latency degradation. On busy gateways, storage systems, proxies, or high-volume application nodes, forcing packet processing through one queue can create a performance bottleneck. Benchmark the change under representative load and monitor CPU saturation, packet drops, and service response time.
Network isolation is a third operational control even though it does not repair the kernel. Remove unnecessary public listeners, restrict management ports to trusted sources, and place unpatched hosts behind filtering that prevents arbitrary clients from reaching TCP services. This can reduce immediate exposure while teams arrange a safe reboot.
Key Stat: The documented race can panic some virtual machines in under two minutes, while a bare-metal trigger may take hours. High attack complexity changes probability, not business impact.
Verify the fix and investigate suspicious crashes
After reboot, confirm the running kernel with uname -r and compare it with the exact fixed package listed by your distribution. Check that the host returned with the expected network queues, firewall policy, load-balancer registration, container workloads, storage mounts, and monitoring agents.
If you used a temporary mitigation, reverse it only after the fixed kernel is running. Confirm that SYN cookies or multi-queue processing return to the intended baseline, then monitor for unexpected performance changes.
A historical crash is not proof of NoisyTCP exploitation. Kernel panics can result from hardware failures, driver defects, unrelated kernel bugs, and administrative mistakes. Preserve evidence and look for correlation instead of assigning cause from one symptom.
Review:
- kernel panic traces and crash dumps
- inbound connection volume before the event
- repeated IPv4 fragmentation or SYN patterns
- firewall, flow, load-balancer, and packet-capture records
- similar crashes across hosts with the same kernel and network design
- unexpected restarts followed by application or container recovery events
If the host runs critical services, enable and test crash-dump collection before the next incident. Store logs and flow records somewhere the affected host cannot erase during a panic.
The response lessons from the Cisco firewall zero-day availability flaw also apply here. A remotely triggered restart is an operational security event even when current evidence does not show data theft or code execution.
A 24-hour NoisyTCP response plan
In the first two hours, identify internet-facing Linux hosts with reachable TCP services and collect their running kernel, distribution advisory status, queue configuration, and workload criticality. Prioritize shared container hosts and single points of failure.
By hour eight, patch redundant high-risk systems in controlled waves. Where no supported package is available, restrict network exposure and test one temporary mitigation on representative infrastructure before fleet rollout.
By hour 24, verify every rebooted host against the vendor's fixed-version evidence. Track exceptions with an owner, a mitigation, a maintenance date, and a measurable closure condition. Feed any unexplained kernel panics into incident review with preserved network and crash evidence.
The vulnerability triage backlog guide can help keep those exceptions from becoming permanent. A NoisyTCP ticket should close only when the running kernel is verified fixed, the host is retired, or a time-bounded risk decision is formally accepted.
The NoisyTCP vulnerability is a reminder that an ordinary network listener can inherit risk from code far below the application. Treat the kernel as shared production infrastructure, patch with service continuity in mind, and prove the running state after every reboot. That is how you turn a broad Linux disclosure into a controlled, auditable response.