Most Linux kernel bugs that make headlines need an attacker who is already on the machine. NoisyTCP does not. CVE-2026-99288 is a flaw in the code that matches incoming TCP packets to open connections. An attacker who can reach a listening service over the network, with no username or password, can use it to trigger a kernel panic and take the whole operating system down.

The bug has been in the kernel since October 2015, according to The Register, which reports that it affects almost all Linux distributions. The upstream fix was committed on November 3. Technical details were published on November 15, when the coordinated disclosure embargo ended. Red Hat rates the flaw Important. If your servers face the internet, put this kernel update at the front of the queue.

What's actually broken?

Every TCP packet that arrives at a Linux host has to be matched to the socket it belongs to. A socket is the kernel's internal record of one network connection. For connections that are already established, the kernel looks this up in a hash table called the "ehash." To keep busy servers fast, that lookup is lockless. It reads the table without taking a lock that would stop other CPU cores from changing it at the same moment.

According to the description in the NVD record, the memory that holds these sockets is allocated with a kernel setting called SLAB_TYPESAFE_BY_RCU. In plain terms, when a socket is freed, its memory can be reused for a new socket before another core has finished reading the old one. That design is deliberate and safe as long as the code doing the lookup checks that what it found is still valid. The established-connection lookup did not check whether the socket it found was still hashed, meaning still entered in the table. In the crash the kernel developers reproduced, the lookup returned a new, unhashed request socket that had a NULL listener pointer. The result is a NULL pointer dereference in tcp_v4_rcv(), the function that handles incoming IPv4 TCP traffic, and the kernel panics.

The upstream patch title describes the fix: "inet: reject unhashed sockets during established lookups." Red Hat classifies the weakness as CWE-476, a NULL pointer dereference.

Who found it, and how bad is it in practice?

The Register credits Hyunwoo Kim, the researcher also behind the Dirty Frag disclosure in May. Because the bug is a race, the attacker has to win a timing window, so the crash is a matter of probability rather than a single packet. Kim's own testing shows that the window is wide enough:

  • On QEMU/KVM virtual machines, Kim crashed Nginx, Apache and SSH servers in anywhere from 5 seconds to 2 minutes.
  • On bare-metal hardware, after tailoring his exploit to the target, he needed roughly 14 hours to crash a server running Nginx.

Fourteen hours sounds reassuring until you remember that an attacker can leave a script running overnight. The Register also reports that Nginx, Apache and SSH can all be vulnerable in their default configurations, so no unusual setup is needed. It adds that the attacker needs access to an open TCP port on a system that processes incoming traffic across multiple receive queues or CPUs.

Containers raise the stakes. All containers on a host share one kernel, so a crash triggered through a service running inside a container can take down the host and every workload on it. For multi-tenant platforms and Kubernetes nodes, one exposed pod can mean a full node outage.

Can it be used for more than a crash?

The sources describe NoisyTCP as a denial-of-service bug, with a caveat. Red Hat's assessment is that an unauthenticated remote attacker can cause an immediate OS crash, with no data alteration and no arbitrary code execution. The Register notes that Kim also identified a second exploitation path involving a use-after-free, which is considerably harder to pull off. That is a class of memory bug that sometimes can be turned into code execution. However, Kim says he has built only a limited exploit against virtual machines in a lab, and he has not demonstrated general-purpose remote code execution. For now, the confirmed impact is a remote crash. Watch for updates on the use-after-free path.

How serious do the vendors think it is?

Ratings so far are incomplete. The Red Hat advisory rates it Important and gives a CVSS v3.1 base score of 7.5 (vector AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H). Red Hat notes its scores can differ from NVD and other vendors because they reflect Red Hat's own products. NVD published the CVE on November 10 but, as of its record, has not assigned its own CVSS score and lists the entry with status "Received." The Debian Security Tracker carries the upstream kernel description, including the crash trace, and lists fixed packages for its supported releases.

Whatever number a scoring body eventually assigns, an unauthenticated remote reboot button for your servers is an availability incident if you run public services. Treat it at the higher end of the severity range.

What It Means for Defenders

Who is affected: Linux systems running a kernel that includes the 2015-era code and lacks the November fix. According to The Register, that covers almost every distribution. The highest risk falls on hosts with TCP services reachable from untrusted networks, such as web servers running Nginx or Apache, SSH bastions, and load-balanced fleets. Container hosts and Kubernetes nodes are also high on the list, because a crash triggered through one container can take down the shared kernel.

Patch: The fix was committed upstream on November 3, and NVD's references list four stable-tree commits on git.kernel.org. NVD's record marks these kernel releases as containing the fix: 6.12.117, 6.18.63 and 7.3.4 (and 7.4-rc2 for mainline). The Debian tracker lists fixed packages of 6.1.192-2 for bookworm (security), 6.12.117-1 for trixie (security) and 7.3.4-1 for unstable. For other distributions, check your vendor's advisory: Red Hat (Bugzilla 2570103), Ubuntu or your cloud provider's image notes. Install the kernel build that includes the "reject unhashed sockets during established lookups" change. A kernel fix only takes effect after a reboot, or after a livepatch if your vendor ships one. Schedule the reboot rather than assuming the update alone protects you.

If you can't update yet: Red Hat lists two mitigations, and each has a cost.

  • Disable SYN cookies by setting the net.ipv4.tcp_syncookies kernel parameter to 0. SYN cookies are a kernel defense against connection-flood (SYN flood) attacks. Red Hat says this blocks the path where a request socket is reconstructed through a SYN cookie, but it lowers protection against SYN floods, so weigh the trade-off on internet-facing hosts. The setting applies per network namespace, so each container with its own network namespace needs the change applied separately. Changing it only on the host does not cover containers.
  • Serialize packet receive processing to a single receive (RX) queue on the network interface that takes external traffic, and disable RPS/RFS (Receive Packet Steering and Receive Flow Steering, which spread incoming traffic across CPU cores). Red Hat says the flaw requires different RX contexts to race concurrently, so this can block the race. The Register notes that limiting packet processing can hurt network performance, so test it before rolling it out widely.

Prioritize and monitor: Patch internet-facing and multi-tenant hosts first, then internal systems. Watch for unexplained kernel panics or reboots on exposed servers, especially crash traces that mention tcp_v4_rcv. Those are worth investigating rather than writing off as flaky hardware. Organizations working through CMMC or similar frameworks should log the patch decision and any temporary mitigation in their flaw-remediation records, since a known, remotely triggerable kernel bug is the kind of item an assessor may ask about.

The use-after-free path is not a demonstrated general remote code execution threat, but it is one more reason to patch instead of relying on workarounds.

Sources