NoisyTCP (CVE-2026-99288): The 11-Year-Old Linux TCP Race That Crashes Servers

The CyberSec Guru

NoisyTCP (CVE-2026-99288)

If you like this post, then please share it:

Buy me A Coffee!

Support The CyberSec Guru’s Mission

🔐 Fuel the cybersecurity crusade by buying me a coffee! Why your support matters: Zero paywalls: Keep the main content 100% free for learners worldwide.

“Your coffee keeps the servers running and the knowledge flowing in our fight against cybercrime.”☕ Support My Work

Buy Me a Coffee Button

On 15 November 2026 at 16:00 UTC, Hyunwoo Kim posted an advisory to the oss-security mailing list for a bug he had found, reported and patched himself. He calls it NoisyTCP, and it is tracked as CVE-2026-99288: a pre-authentication race condition in the Linux kernel’s TCP receive path that lets a remote attacker panic a server using crafted TCP packets alone. The attacker needs no credentials, no application bug and no exotic configuration. A stock Nginx, Apache or SSH listener is enough, as long as the attacker’s packets can reach it and the machine processes incoming traffic on more than one receive queue or CPU.

In Kim’s testing, QEMU/KVM guests running those services with default settings crashed in anywhere from five seconds to two minutes. A quiet bare-metal Nginx server with eight receive queues held out for about fourteen hours against a proof of concept tuned for that hardware.

The defect has been in the kernel since October 2015, so it shipped in effectively every distribution kernel from Linux 4.4 (January 2016) onward. The fix, commit 4e2b3ef19e0e (“inet: reject unhashed sockets during established lookups”), was applied upstream on 3 November 2026. A week later the kernel CVE team published the identifier, and the full write-up appeared twelve days after the fix. This is not a zero-day, and the demonstrated impact is denial of service, not code execution. But the bug lives in the kernel and not in any application, so a successful crash against a containerized web server takes down the entire host and every other container on it. For an availability-only bug, that shared fate is reason enough to drop other work.

Why the Linux TCP established-connection lookup is lockless

Every incoming TCP segment has to be matched to the socket that owns it, and a busy server does that millions of times per second. Linux performs the established-connection lookup against ehash, a hash table indexed by the connection’s four-tuple, without taking a global lock. Each bucket is an hlist_nulls chain, a variant of the kernel’s hash lists whose terminal “nulls” marker encodes the bucket index, so a lockless reader can tell when it has been moved onto a different chain and restart the walk. Every segment goes through __inet_lookup_established() for IPv4 or __inet6_lookup_established() for IPv6. The function walks the chain under RCU, compares tuples, and on a match takes a reference on the socket before using it.

How request sockets ended up in the same hash table

Request sockets take part in this machinery because of a performance change from 2015. Before it, the ACK that completes a three-way handshake had to be routed to the listener, and the listener’s lock serialised the search for the embryonic connection. Eric Dumazet’s commit 079096f103fa (“tcp/dccp: install syn_recv requests into ehash table”) moved half-open connections, represented by lightweight request_sock objects in the TCP_NEW_SYN_RECV state, into the same table as full sockets. According to the commit message, ACK packets could then find SYN_RECV pseudo-sockets “without having to find and lock the listener,” which “in nominal conditions halves pressure on listener lock.”

A request socket embeds the common struct sock header, carries its own reference count, and holds a pointer, rsk_listener, back to the listener that created it. From then on, the receive path could meet a request socket directly in a lockless hash walk, and the lifetime rules for these short-lived objects became load-bearing for the entire fast path.

What SLAB_TYPESAFE_BY_RCU does and does not promise

Lockless walking works because the slab caches behind sockets and request sockets are created with SLAB_TYPESAFE_BY_RCU, and the exact semantics of that flag matter a great deal here. It guarantees type stability and nothing more. The slab page is not returned to the page allocator until an RCU grace period has elapsed, so a reader dereferencing a stale address always finds a valid object of the same type, though possibly a different, freshly allocated one. The fix’s commit message says so directly: “memory can be reused before an RCU reader that retained its old address has finished.”

The lookup protocol is built around that hazard. After a tuple match, the reader attempts refcount_inc_not_zero() on the candidate. If that succeeds, it repeats the tuple and network namespace comparison, because the object it just pinned may be a recycled impostor. Only if the second check passes does the lookup return the socket. For a decade that recheck was considered sufficient. NoisyTCP shows it was not: a matching tuple says nothing about whether the object is in a state the receive path can safely consume.

How the NoisyTCP race condition works

The impostor comes from the SYN cookie path, one of the kernel’s oldest defences against SYN floods. When a listener’s SYN backlog overflows and net.ipv4.tcp_syncookies is at its usual default of 1, the kernel stops allocating state for new SYNs and answers with a SYN+ACK whose initial sequence number is a cryptographic cookie. If the client completes the handshake, cookie_v4_check() validates the cookie and rebuilds a request socket on the spot so the connection can be promoted to a full child socket.

That rebuilt request is a transient internal object. It is allocated with no listener attached, so its rsk_listener is NULL, and it is never inserted into ehash. It lives just long enough for tcp_get_cookie_sock() to build the child, and that function publishes a reference count on it. The published count is the detail that turns a harmless internal object into a trap for a concurrent lookup.

📬 Stay Ahead of Cyber Threats

Get the latest cybersecurity news, critical vulnerabilities, threat intelligence, tutorials, and exclusive giveaways delivered straight to your inbox. No spam. Unsubscribe anytime.

An ABA problem across two CPUs

Kim describes the race as a textbook ABA problem played out across two receive contexts, normally two CPUs. The first CPU runs a lockless lookup, finds a legitimate hashed request socket for a connection the attacker controls, loads its address and matches its tuple. Before it takes a reference, the second CPU drives the connection’s teardown or completion and frees the request socket. The slab allocator immediately hands the same address to a new SYN cookie request for the same four-tuple.

The first CPU now runs refcount_inc_not_zero() and succeeds, because the reference it acquires is the one tcp_get_cookie_sock() published on the new object. The tuple recheck passes too, since the new request was built for the same connection. Every validation the lookup knows how to perform says the object is fine. The object is unhashed and has no listener, though, and when tcp_v4_rcv() handles it as a TCP_NEW_SYN_RECV socket it switches to req->rsk_listener and reads the listener’s state through a NULL pointer.

What the crash log shows

The crash log in the commit message confirms the whole scenario, and it is worth reading closely. The fault is a supervisor read at address 0x12, a small offset from NULL where the listener’s struct sock should have been. The instruction pointer sits inside tcp_v4_rcv(), and the call trace runs up through ip_local_deliver_finish(), netif_receive_skb_list_internal() and virtnet_poll(), the virtio-net NAPI poll routine, on a 7.3.0 mainline build. The crashing context is swapper/4, PID 0, so the packet was processed in softirq context on an idle CPU, and the kernel ends with “Fatal exception in interrupt.”

That last line has an operational consequence. An oops taken in interrupt context always panics, whatever panic_on_oops is set to, so no tuning knob lets the machine survive it. The host dies, and if the listener was a container’s web server, the shared kernel takes every neighbouring container down with it.

How IPv4 fragments put one flow on two CPUs

The obvious objection is that a single connection should never be processed by two CPUs at once, and on a correctly steered receive path it usually is not. Receive Side Scaling hashes each packet’s four-tuple in the NIC and maps the flow to one receive queue. Receive Packet Steering applies the same idea in software, spreading flows across CPUs by hash. NoisyTCP’s precondition is defeating that affinity, and Kim’s advisory names the trick: “the difference in receive hash between IPv4 fragments and regular TCP packets.”

A non-initial IPv4 fragment carries no transport header, so neither the NIC’s RSS logic nor the kernel’s flow dissector can see ports. Hashing falls back to the address pair, which generally lands the fragment on a different queue, and therefore a different CPU, than the unfragmented segments of the same connection. An attacker who mixes fragmented and normal packets for one tuple forces packets of a single connection into genuinely concurrent receive contexts, which is the execution pattern the race requires.

That is why the advisory limits the bug to servers with two or more RX queues, or with RPS enabled, and says nothing about netfilter rules, unusual socket options or application behaviour. Kim’s FAQ on GitHub says many kernel bugs need a rarely used configuration to fire, but “this one triggers even when the server does nothing more than call listen().” Multi-queue receive processing is the default on modern server NICs and on cloud instances with more than one vCPU, so the precondition describes most of the internet-facing Linux fleet. The fragment technique also shows that the steering layer’s idea of a flow and the transport layer’s idea of a connection differ, and the attacker chooses which packets are fragments.

Why VMs crash in seconds and bare metal takes 14 hours

The gap between Kim’s two benchmarks is the most operationally interesting number in the advisory. The race window runs from the first tuple check to the reference acquisition, a span of nanoseconds on an undisturbed CPU. On a QEMU/KVM guest, the hypervisor can deschedule a vCPU in the middle of that window, stretching it to scheduling timescales and letting the other receive context finish the entire free-and-reallocate sequence before the lookup resumes. That is why default Nginx, Apache and SSH servers on VMs fell in five seconds to two minutes. On a quiet bare-metal server with eight queues, nothing interrupts the lookup at the right moment except real contention, and even a PoC with timing tuned for that machine needed roughly fourteen hours to win the race once.

Two conclusions follow, and they point in opposite directions. In the cloud, where the vulnerable listener runs on a preemptible vCPU with multi-queue virtio networking, NoisyTCP is a practical, fast, unauthenticated host kill. The virtnet_poll frame in the crash trace shows Kim demonstrated it in exactly that environment. On a lightly loaded physical server, exploitation is a waiting game and not an instant outage. That matters for threat modelling, but it does not make the machine safe.

The exploitability of a kernel race depends on the code and on the environment it runs in. The virtualisation that makes cloud infrastructure elastic also makes its timing friendlier to attackers, because a busy, preemptible host is noisy by design and the race feeds on noise.

Is NoisyTCP remote code execution?

Not as demonstrated. Kim’s advisory describes a second trigger flow, a “full child socket ABA race” against fully established sockets. He says it can produce a remote use-after-free but needs nested race scenarios to succeed and is “generally hard to trigger without using special techniques.” The status of that path needs care. The discussion of the full socket race was dropped from the patch’s commit message during review. The version history of the netdev series lists “drop the full socket race discussion (Eric)” among the v2 changes Eric Dumazet requested, and the merged commit message documents only the SYN cookie crash.

Asked in his FAQ whether NoisyTCP is a TCP RCE, Kim answered “Not yet. and basically, no.” He explained that he has written only a very limited, lab-specific exploit aimed at VM servers and is still researching a general-purpose one, while “remote DoS can be achieved without much difficulty.” The public GitHub repository contains the write-up and no exploit code. TuxCare’s analysis notes that no exploitation in the wild had been reported as of 16 November, and Red Hat states plainly that the flaw “does not allow data alteration or arbitrary code execution.”

NoisyTCP vs CVE-2026-98432: two TCP bugs from the same 2015 commit

NoisyTCP is easy to confuse with its louder sibling. CVE-2026-98432, disclosed in October, traces back to the same 2015 commit and involved a genuine use-after-free of IPv4 request options. tcp_v4_syn_recv_sock() transfers ownership of ireq->ireq_opt to the child socket, and the options could be freed without waiting for an RCU grace period while lockless readers still held them. Upstream fixed it on 5 October by deferring the free, in a commit titled “ipv4: free inet_opt and ireq_opt after an RCU grace period”. That bug carried a 9.8 severity and had a demonstrated unauthenticated remote code execution behind it.

NoisyTCP sits earlier in the receive path, in the lookup itself, so the October patch does nothing for it. Administrators who treated the two closely timed TCP CVEs as one remediation event are still exposed. Assuming NoisyTCP is another 9.8 RCE overstates what has actually been shown.

The NoisyTCP fix: what the kernel patches change

Rejecting unhashed sockets in the lookup

The merged fix is small in concept and careful in execution. After the lookup takes its reference, it now checks whether the socket’s nulls node is unhashed, in both the IPv4 and IPv6 established lookups. If the node is unhashed or the tuple no longer matches, it drops the reference and restarts the walk. That single invariant, that a returned socket must actually be in the hash table, closes the SYN cookie impostor case. It also cleans up two older staleness hazards the commit message names: lookups racing with the TIME_WAIT hashdance, where an established socket is replaced by a timewait socket, and lookups racing with a request being replaced by its child. In both cases the lookup now restarts and finds the current object.

The patch also converts direct frees to reqsk_put() in the failure paths of the SYN cookie, TCP Fast Open and request migration code. An unhashed request with a published reference count can now have a transient reference held by a stale lookup, so freeing it outright would create the very use-after-free the patch is trying to prevent.

The refcount ordering regression from 2019

The companion patch is the subtler half of the story, and it exposes a cross-subsystem regression that had been hiding since 2019. As the second patch in the series explains, before commit fb041bb7c0a9 (“locking/refcount: Consolidate implementations of refcount_t”), default builds implemented refcount_inc_not_zero() on top of atomic_add_unless(), which provided full memory ordering on success. The consolidation removed that guarantee on weakly ordered architectures. On arm64 or POWER, the tuple recheck that follows the reference acquisition could therefore be reordered ahead of the acquisition itself, validating state the teardown path had already changed.

The fix, 5b5d8f351dd9 (“net: restore refcount ordering for lockless socket access”), switches the established lookups, inet_twsk_purge() and bpf_sk_assign() to refcount_inc_not_zero_acquire(). It also uses refcount_set_release() wherever reference counts are published: the SYN cookie path, TCP Fast Open child creation, request migration and the TIME_WAIT hashdance. On x86-64 the reordering is not observable, which is why Kim’s crashes were all demonstrable on VMs without any of this. The ordering patch is what makes the revalidation meaningful on the rest of the hardware Linux runs on.

Review history and the wider refcount audit

The series went through five revisions between 23 and 30 October. Dumazet asked for the unhashed checks to be split from the ordering changes and noted that backports to trees without the new refcount helpers would need adjustment, and Kuniyuki Iwashima extended the acquire ordering to bpf_sk_assign(). The backport caveat has a practical edge. TuxCare reports that 5b5d8f351dd9 was not part of the 6.12.117, 6.18.63 or 7.3.4 stable releases, so operators on arm64 and POWER should check that their kernels carry both commits.

The audit is still running. A follow-up series posted by Hang Nan in mid-November converts the two remaining sites in the network stack with the same shape: mptcp_token_get_sock(), remotely reachable through an inbound MP_JOIN SYN on an MPTCP-enabled listener, and reuseport_migrate_sock(). It also documents that the other ninety-odd refcount_inc_not_zero() callers in net/ either hold an RCU section across their uses or never revalidate state after taking the reference. The rule the series establishes, in spirit, is that whenever a lockless lookup takes a reference and then re-reads state that teardown mutates, the acquisition must carry acquire ordering, or the re-read proves nothing.

CVSS score for CVE-2026-99288: a vector that contradicts its own description

The severity metadata for this CVE does not describe the vulnerability its own page describes. Red Hat rates NoisyTCP Important with a preliminary CVSS 3.1 score of 7.5 and the vector AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, which says the attacker needs low privileges and can compromise confidentiality and integrity. The statement directly above that vector says an unauthenticated remote attacker can trigger an immediate operating system crash without privileges, and that the flaw permits neither data alteration nor code execution.

TuxCare rescored the vector to match the prose, AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H, and obtained 5.9, a Medium, while stressing that this is a hypothetical calculation and not a published score. The NVD entry had no assessment of its own as of 16 November, and Canonical’s tracker assigns the issue Medium priority.

Attack complexity is the one metric everyone should agree on. It is high, because winning a race that is nanoseconds wide is not push-button on every target. The practical risk ranking for an internet-facing fleet does not fall out of the base score, though. A pre-authentication crash of an entire container host, reachable through any exposed TCP port and demonstrable in seconds against the virtualised multi-queue environments that dominate cloud deployments, is an availability emergency whether the arithmetic says 7.5 or 5.9. If Red Hat revises the vector downward to match its own description, any patch SLA driven purely by the CVSS number will quietly deprioritise it. I would triage by the description and the deployment shape.

NoisyTCP patch status by kernel and distribution

The complete remediation is a kernel carrying 4e2b3ef19e0e, plus 5b5d8f351dd9 on weakly ordered architectures. Upstream, the fix shipped in stable releases 6.12.117, 6.18.63 and 7.3.4, and mainline 7.4-rc2 carries it. The 7.2 stable branch reached end of life at 7.2.15 on 1 November, two days before the fix landed, so anything still on 7.2 must move to 7.3.4 or take a distribution backport. Older upstream stable branches (6.6, 6.1 and the 5.x series) had no fixed release at disclosure time, which is where vendor backports earn their keep.

As of 16 November, the distribution picture was uneven. Debian fixed trixie with linux 6.12.117-1 (DSA-6628-1) and bookworm with 6.1.192-1 (DLA-4906-1). Oracle shipped fixed UEK kernels on 12 and 13 November under ELSA-2026-500630 through 500632, and CIQ published patched kernels for its commercial Rocky Linux builds on 15 November. Red Hat lists RHEL 8, 9 and 10 and OpenShift as affected with no errata yet. Most community rebuilds show the same status, although AlmaLinux put backported kernels for versions 8, 9 and 10 in its testing repository on 16 November, ahead of Red Hat. Ubuntu’s tracker shows its supported kernels vulnerable with fixes pending. RHEL 6 and 7 and CentOS 7 are not affected because the vulnerable code predates their kernels.

The Debian bookworm case shows why you should verify. Upstream 6.1.192 does not contain the fix, but Debian’s 6.1.192-1 package does, because the fix was backported. Version strings can mislead in both directions, so check the installed package against your vendor’s advisory or changelog. On Debian, this answers the question for the booted kernel:

bash

zgrep -c CVE-2026-99288 /usr/share/doc/linux-image-$(uname -r)/changelog*.gz

How to check whether your server is exposed to NoisyTCP

The race precondition is visible from userspace:

bash

ethtool -l eth0
grep . /sys/class/net/eth0/queues/rx-*/rps_cpus

A current RX or combined channel count above one, or any nonzero rps_cpus mask, means the host can process one flow on multiple CPUs and meets the concurrency requirement.

NoisyTCP workarounds if you cannot patch yet

Until a fixed kernel is running, Kim’s advisory offers two stopgaps, and both cost something real.

The first is disabling SYN cookies with sysctl -w net.ipv4.tcp_syncookies=0. That removes the allocation pattern the demonstrated crash depends on. The setting is per network namespace, so it must be applied inside every container that has its own namespace, and it strips the listener’s defence against SYN floods, a painful concession for exactly the internet-facing services most at risk from NoisyTCP. AlmaLinux adds that it covers only the crash described above, because Kim’s second, harder-to-trigger variant does not go through SYN cookies.

The second attacks the concurrency itself:

bash

ethtool -L eth0 combined 1
for q in /sys/class/net/eth0/queues/rx-*/rps_cpus; do echo 0 > "$q"; done
sysctl -w net.core.rps_sock_flow_entries=0

This reduces the external interface to a single receive queue (use rx 1 instead of combined 1 on NICs with separate RX channels) and disables RPS and RFS. That removes the second receive context the race requires, at the cost of collapsing all receive processing onto one core. Changing channel counts can briefly drop the link on some physical NICs, so keep console access available. The ethtool change will not survive a reboot unless your network configuration reapplies it.

Neither workaround repairs the lookup logic. They make the race unavailable, which is different from fixed. Test both in staging and revert them once a patched kernel is confirmed running.

Why the NoisyTCP bug survived eleven years

The bug lasted this long even though nobody was ignoring this code. Every component involved is individually correct and heavily reviewed: the nulls-list walk, the typesafe-by-RCU allocation scheme, the match-refcount-recheck protocol, the stateless cookie reconstruction and the multi-queue steering. The vulnerability exists only in their composition, in an interleaving that needs two receive contexts, a freed and recycled slab address, a same-tuple replacement object in a partially initialised state, and a reference count published at exactly the wrong moment. Fuzzers rarely produce that choreography by accident, static analysis does not see across subsystem contracts, and production traffic hit the window so rarely that a crash would have looked like noise.

The 2019 refcount consolidation adds a second lesson. A change in the locking subsystem quietly weakened an ordering guarantee the network stack had relied on for years, and nothing in the type system or the review process connected the two. It took a researcher willing to tune race timing against specific hardware, and then sit through a fourteen-hour run on bare metal, to make the failure reproducible enough to fix.

Kim’s recent record suggests this seam is productive. BleepingComputer notes that he disclosed Dirty Frag, a local privilege escalation chaining RxRPC and xfrm-ESP page-cache write flaws, in May, and Januscape, a sixteen-year-old VM escape, in July. Two CVEs in two months trace back to a single 2015 commit, and the ordering audit is still finding fresh sites in MPTCP and reuseport code. My reading is that the lockless listener design is working through a decade of accumulated assumptions.

NoisyTCP remediation checklist for Linux admins

For operators, the immediate work is unglamorous. Inventory internet-facing hosts for the multi-queue precondition. Verify fixes against vendor changelogs and not version numbers. Confirm both commits on arm64 and POWER. Treat the container host as the shared-fate domain it is, because a kernel panic ignores namespace boundaries.

For kernel developers, the safety of a lockless fast path rests on its documented lifetime and ordering contracts, and those contracts need re-examining every time a subsystem underneath them changes.

NoisyTCP FAQ

What is NoisyTCP?

NoisyTCP (CVE-2026-99288) is a race condition in the Linux kernel’s lockless TCP established-connection lookup. A remote, unauthenticated attacker can use crafted TCP packets to make the kernel dereference a NULL listener pointer, which panics the whole machine.

Which Linux kernels are affected by CVE-2026-99288?

The defect entered the kernel in October 2015, so effectively every distribution kernel from Linux 4.4 (January 2016) onward is affected until it carries commit 4e2b3ef19e0e. Upstream fixes shipped in 6.12.117, 6.18.63 and 7.3.4. RHEL 6 and 7 and CentOS 7 are not affected.

Can NoisyTCP be used for remote code execution?

Not as demonstrated. Kim describes a second, much harder variant that could produce a remote use-after-free, but he says NoisyTCP is “Not yet” a TCP RCE, and Red Hat states the flaw does not allow arbitrary code execution. The demonstrated impact is denial of service.

How do I know whether my server is exposed?

Run ethtool -l eth0 and check the RX or combined channel count, then check the rps_cpus masks under /sys/class/net/eth0/queues. More than one channel or any nonzero mask means one flow can be processed on multiple CPUs, which is the precondition for the race.

What is the fastest NoisyTCP workaround?

Disabling SYN cookies with sysctl -w net.ipv4.tcp_syncookies=0 blocks the demonstrated crash path, but it must be applied in every network namespace and removes SYN flood protection. Limiting the external interface to one receive queue and disabling RPS and RFS removes the concurrency the race needs, at a cost in throughput.

Does the October TCP patch for CVE-2026-98432 fix NoisyTCP?

No. CVE-2026-98432 was a use-after-free of IPv4 request options fixed on 5 October. NoisyTCP sits earlier in the receive path, in the socket lookup, so it needs its own fix.

Buy me A Coffee!

Support The CyberSec Guru’s Mission

🔐 Fuel the cybersecurity crusade by buying me a coffee! Your contribution powers free tutorials, hands-on labs, and security resources.

Why your support matters:
  • Writeup Access: Get complete writeup access within 12 hours
  • Zero paywalls: Keep the main content 100% free for learners worldwide

Perks for one-time supporters:
☕️ $5: Shoutout in Buy Me a Coffee
🛡️ $8: Fast-track Access to Live Webinars
💻 $10: Vote on future tutorial topics + exclusive AMA access

“Your coffee keeps the servers running and the knowledge flowing in our fight against cybercrime.”☕ Support My Work

Buy Me a Coffee Button

If you like this post, then please share it:

Exploits

Discover more from The CyberSec Guru

Subscribe to get the latest posts sent to your email!

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.