NoisyTCP: Linux Kernel Pre-Auth Remote DoS (CVE-2026-99288)
A race in Linux TCP socket lookup lets a remote attacker panic kernels from 4.4 onward; fixed in 6.12.117, 6.18.63 and 7.3.4.
TL;DR
- A race in the Linux kernel's lockless TCP established-socket lookup lets a remote attacker panic the host. Hyunwoo Kim published the technical report on November 15, 2026.
- The flaw was introduced in Linux 4.4 in October 2015 and affects kernels before 6.12.117, 6.18.63 and 7.3.4. Nginx, Apache and SSH listeners with default configuration are enough.
- Red Hat rates it Important with a draft CVSS v3.1 7.5, Canonical rates it Medium, and the CVE record carries no score. No exploitation is known, and it is not in CISA KEV as of November 16, 2026.
- Upgrade to 6.12.117, 6.18.63, 7.3.4 or 7.4-rc2, or to a distribution kernel that carries commit 4e2b3ef19e0e. Workarounds are in "How do I fix it?".
Am I affected?
All of these must hold for a host to be exposed:
- The running kernel does not contain commit 4e2b3ef19e0e. On November 16, 2026, that included every release in the 6.6, 6.1, 5.15, 5.10 and 4.19 longterm branches.
- A TCP listener accepts packets from an untrusted network. The report names Nginx, Apache and SSH with default configuration, and any socket that calls
listen()is enough. - The receive path can run in two or more contexts at once. That means two or more receive (RX) queues on the interface, or receive packet steering (RPS) distributing packets across CPUs.
- The attacker can send TCP packets that reach the host's network stack. A proxy that terminates TCP in front of the server reduces the set of directly reachable listeners but does not remove the backend listener's exposure.
A quiet server with one RX queue and RPS disabled does not meet the race condition. A busy server with several queues, or a virtual machine whose vCPUs can preempt each other, does.
| Branch | Affected versions | Fixed version |
|---|---|---|
| 6.12.y | 6.12.116 and earlier | 6.12.117 |
| 6.18.y | 6.18.62 and earlier | 6.18.63 |
| 7.3.y | 7.3.3 and earlier | 7.3.4 |
| 7.4 | 7.4-rc1 | 7.4-rc2 |
| 6.6.y | Every release in the branch | No fixed release on 2026-11-16 |
| 6.1.y | Every release in the branch | No fixed release on 2026-11-16 |
| 5.15.y | Every release in the branch | No fixed release on 2026-11-16 |
| 5.10.y | Every release in the branch | No fixed release on 2026-11-16 |
| 4.19.y | Every release in the branch | No fixed release on 2026-11-16 |
The CVE record lists 6.12.117, 6.18.63, 7.3.4 and 7.4-rc2 as the fixed releases. The branch tips for 6.6.y, 6.1.y, 5.15.y, 5.10.y and 4.19.y did not contain the check when this post was written. Distribution kernels must be checked against their vendor's changelog, because many distributions carry their own backports.
Check the running kernel:
uname -r
For a kernel you build yourself, search the source tree for the fix:
git -C /path/to/linux log --oneline --all --grep="reject unhashed sockets during established lookups"
Check whether the interface can run the race. A single RX queue with every rps_cpus value at zero blocks it:
ethtool -l eth0
for f in /sys/class/net/eth0/queues/rx-*/rps_cpus; do echo "$f: $(cat "$f")"; done
Check the SYN-cookie setting, which one workaround changes:
sysctl net.ipv4.tcp_syncookies
How do I fix it?
Install a kernel that contains commit 4e2b3ef19e0e, then reboot. The fixed upstream releases are 6.12.117, 6.18.63, 7.3.4 and 7.4-rc2.
The package commands below only fix the host once your vendor ships a kernel that carries the fix. On November 16, 2026, the 6.6, 6.1, 5.15, 5.10 and 4.19 longterm branches that most LTS distributions follow had no fixed release. Check your vendor's advisory first (see "Is my distribution kernel fixed?"), and use the workarounds below until it ships.
- On Debian or Ubuntu, update the kernel package and reboot:
sudo apt update
sudo apt install --only-upgrade linux-image-generic
sudo reboot
- On Fedora, RHEL or a derivative, update the kernel package and reboot:
sudo dnf update kernel
sudo reboot
- If you build an upstream stable kernel, check out a fixed tag and build it:
git fetch --tags
git checkout v6.12.117
make olddefconfig
make -j"$(nproc)"
sudo make modules_install
sudo make install
sudo reboot
After the reboot, run uname -r. On an upstream build, confirm that the running kernel is the fixed release for its branch or a later one. On a distribution kernel, the version alone does not prove the fix; confirm that the vendor's changelog names CVE-2026-99288 or commit 4e2b3ef19e0e.
If you cannot upgrade yet, the report gives two workarounds. Each removes one precondition the race needs: disabling SYN cookies cuts the path that rebuilds a request socket from a cookie, and a single RX queue with RPS off removes the second receive context.
- Disable SYN cookies. This blocks the path that reconstructs a request socket through a SYN cookie:
sudo sysctl -w net.ipv4.tcp_syncookies=0
To persist it:
echo 'net.ipv4.tcp_syncookies=0' | sudo tee /etc/sysctl.d/99-noisytcp.conf
sudo sysctl --system
The setting is per network namespace. Apply it inside every container that uses its own network namespace. Disabling SYN cookies lowers the host's protection against SYN floods.
- Serialize packet processing to one RX queue and disable RPS:
sudo ethtool -L eth0 combined 1
for f in /sys/class/net/eth0/queues/rx-*/rps_cpus; do echo 0 | sudo tee "$f"; done
sudo sysctl -w net.core.rps_sock_flow_entries=0
This reduces throughput and removes the parallelism the server was tuned for. It blocks both trigger flows in the report because they require two receive contexts.
Neither workaround repairs the lookup. They only make the race unavailable. A host that needs the throughput should take the kernel fix.
What is the root cause?
The kernel looks up established TCP sockets without a lock, and it relies on SLAB_TYPESAFE_BY_RCU so an RCU reader can keep using an address that another CPU has freed. The reader must therefore revalidate everything it reads after it takes a reference.
This is __inet_lookup_established() in net/ipv4/inet_hashtables.c at 6.12.116:
begin:
sk_nulls_for_each_rcu(sk, node, &head->chain) {
if (sk->sk_hash != hash)
continue;
if (likely(inet_match(net, sk, acookie, ports, dif, sdif))) {
if (unlikely(!refcount_inc_not_zero(&sk->sk_refcnt)))
goto out;
if (unlikely(!inet_match(net, sk, acookie,
ports, dif, sdif))) {
sock_gen_put(sk);
goto begin;
}
goto found;
}
}
The lookup takes a reference and repeats the tuple check. It does not check whether the object at that address is still in the hash table. If the address was reused for a socket with the same tuple, the second inet_match() succeeds and the lookup returns the new object.
The new object can be a request socket created by tcp_get_cookie_sock(). That request socket is not inserted into the established hash, and its rsk_listener field is NULL. tcp_v4_rcv() then reads sk_state through that NULL listener. On the tested kernel the read faulted at address 0x12 and produced a kernel panic in interrupt context.
The report describes a second path through a full child-socket reuse. That path can produce a use-after-free, but it needs a nested race and the report does not demonstrate code execution from it.
How is it exploited?
An attacker makes one receive context free a request socket while another context still holds its address. The kernel then reallocates a SYN-cookie request with the same tuple at the same address.
- The attacker opens a TCP connection attempt to a listening port. The traffic is ordinary TCP, so no credential or application input is needed.
- The attacker uses IPv4 fragments and regular TCP packets so that the receive hash sends the work to different RX contexts. This requires two or more RX queues, or RPS.
- One context frees an existing request socket. Another context reallocates a SYN-cookie request socket with the same tuple at the same slab address.
- A stale lookup still holds the old address. It acquires a reference on the new object and repeats the tuple check, which passes because the tuple is the same.
- The lookup returns the new request socket, which is unhashed and has a
NULLlistener. tcp_v4_rcv()readssk_statethrough theNULLlistener and the kernel panics.
The timing is the hard part. The report measured about 5 seconds to 2 minutes against Nginx, Apache and SSH on QEMU/KVM virtual machines. It measured about 14 hours against Nginx on a quiet bare-metal server with 8 RX queues, using a proof of concept tuned for that host.
The public repository contains the report, not exploit code. No public exploit code is linked in the CVE record or the report.
How does the attack flow?
The attacker spreads one TCP conversation across two receive contexts. One context frees a request socket while the other still uses its address, and the stale lookup returns an unhashed socket with no listener.
TCP packets"] --> B["Fragments and regular packets
reach different RX queues"] B --> C["Stale ehash lookup holds
an old request-socket address"] C --> D["Other RX context frees it
and reallocates a SYN-cookie request"] D --> E["Lookup takes a reference
and passes the tuple recheck"] E --> F["New socket is unhashed
with a NULL listener"] F --> G["tcp_v4_rcv reads sk_state
through NULL"] G --> H["Kernel panic,
host goes down"]
What can an attacker do?
An attacker can crash a remote Linux host without authentication, and a listener inside a container takes the whole host down with it.
The conditions are part of the impact:
- The attacker must be able to send TCP packets to a listening port. A host behind a proxy can still be reached through the proxy if the proxy forwards connections.
- The receive path must use at least two contexts. That means two or more RX queues, or RPS enabled.
- The race must land inside a narrow window. The report needed seconds to minutes on a virtual machine and about 14 hours on a quiet bare-metal host.
- The attacker needs no account, no user interaction and no application-specific input.
The demonstrated impact is availability. The report shows a kernel panic and a second path that can produce a use-after-free, but it does not show code execution, data theft or privilege escalation. A crash in the network stack is still a full host outage, and a container escape is not required to cause it.
Why does the fix work?
The fix rejects a socket whose hash node is no longer linked after the lookup takes its reference, so the reallocated, unhashed request socket cannot be returned.
This is the change in net/ipv4/inet_hashtables.c:
- if (unlikely(!inet_match(net, sk, acookie,
- ports, dif, sdif))) {
+ if (unlikely(hlist_nulls_unhashed_lockless(&sk->sk_nulls_node) ||
+ !inet_match(net, sk, acookie, ports, dif,
+ sdif))) {
sock_gen_put(sk);
goto begin;
}
The IPv6 lookup in net/ipv6/inet6_hashtables.c gets the same check. If the node is unhashed, or the tuple no longer matches, the lookup drops the reference and restarts from the beginning of the chain.
The patch also repairs reference counting in the SYN-cookie, Fast Open and request-migration paths. When those paths fail after setting a nonzero refcount, they now release the references with reqsk_put() instead of freeing the request directly:
bh_unlock_sock(child);
sock_put(child);
+ reqsk_put(req);
+ return NULL;
}
__reqsk_free(req);
Together, the checks make the stale lookup restart instead of returning an object that another context has reused. They cover the IPv4 and IPv6 lookups and the three request-socket paths that can publish a reference to an unhashed request.
The fix does not make the race window smaller. It makes the lookup reject the reused object, which is the condition the race depended on. The report says the patch is the priority and that the two workarounds are temporary.
How do I check if I was compromised?
No indicators of compromise are published. A successful trigger leaves a kernel panic, so the useful check is the kernel log from the time of an unexpected reboot.
- Search the kernel log for the crash signature:
sudo dmesg | grep -E "tcp_v4_rcv|NULL pointer dereference|Kernel panic"
- Search the persistent journal if the host rebooted before you read
dmesg:
sudo journalctl -k | grep -E "tcp_v4_rcv|NULL pointer dereference|Kernel panic"
- Look for
BUG: kernel NULL pointer dereference, address: 0000000000000012,RIP: 0010:tcp_v4_rcv, andKernel panic - not syncing: Fatal exception in interrupt. The address and instruction pointer are from the report's crash and can differ on another kernel. - Check whether the host had the vulnerable shape at the time: two or more RX queues, or RPS enabled.
A panic is evidence that the bug was triggered, not evidence that data was taken. The demonstrated impact is a crash. An attempt that lost the race leaves no trace, and the harder use-after-free path may not leave the same signature. With no published indicators, absence of a crash is not proof that the host was not targeted.
Timeline
- 2026-10-29: Hyunwoo Kim sends the fix patch to the kernel networking maintainers.
- 2026-11-03: The fix is merged into mainline as commit 4e2b3ef19e0e.
- 2026-11-10: The Linux CNA publishes CVE-2026-99288.
- 2026-11-15: The linux-distros embargo ends and the NoisyTCP report is published.
FAQ
Does an attacker need a valid account?
No. The trigger is a sequence of TCP packets against a listening socket. The report describes it as pre-authentication, and the kernel reaches the vulnerable lookup before any application authentication.
Is every Linux server exposed?
No. The host must have the vulnerable kernel and a receive path with two or more contexts. A server with a single RX queue and RPS disabled does not meet the race condition. A virtual machine is easier to race than a quiet bare-metal host because its vCPUs can preempt each other.
Is this remote code execution?
No code execution is demonstrated. The report shows a remote kernel panic through the request-socket reuse path. It describes a second path that can produce a use-after-free, but says that path needs a nested race and is generally hard to trigger.
Why does Red Hat score it 7.5 while the report calls it pre-authentication?
Red Hat's draft CVSS v3.1 vector is CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, which uses high attack complexity and low privileges. The report and the CVE description call the trigger pre-authentication because no account is needed. The CVE record carries no score, Canonical rates it Medium, and the disagreement is about the race's complexity and preconditions, not about the impact of a successful trigger.
Is my distribution kernel fixed?
Only if the vendor's kernel changelog names CVE-2026-99288 or commit 4e2b3ef19e0e. The upstream 6.6, 6.1, 5.15, 5.10 and 4.19 branches did not contain the check on November 16, 2026. A distribution that follows one of those branches needs its own backport. Check the vendor's advisory before assuming that a kernel version from the table's left column is safe.
Do the workarounds really stop the attack?
The report says both do. Disabling SYN cookies blocks the path that reconstructs a request socket. Reducing the interface to one RX queue and disabling RPS removes the second receive context. Both cost something: SYN-flood protection or throughput. Neither replaces the kernel fix.
Find exposed Linux hosts with Ostorlab
Ostorlab's attack surface discovery inventories the internet-facing hosts and services in your estate, so you can see which Linux servers answer on TCP before you plan the kernel upgrade. Inventory your exposed attack surface with Ostorlab.
References
- Linux CVE record for CVE-2026-99288, https://www.cve.org/CVERecord?id=CVE-2026-99288 (checked November 16, 2026)
- NoisyTCP report on oss-security, https://www.openwall.com/lists/oss-security/2026/11/15/2 (checked November 16, 2026)
- NoisyTCP report repository, https://github.com/V4bel/NoisyTCP (checked November 16, 2026)
- Fix commit 4e2b3ef19e0e, https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/commit/?id=4e2b3ef19e0e04adca38442f07dd6bc93c712bf1 (checked November 16, 2026)
- 6.12.117 backport d69100340b4c, https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/commit/?id=d69100340b4cae08d40f898f1b601032403f6be6 (checked November 16, 2026)
- 6.18.63 backport 8e5172cbd227, https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/commit/?id=8e5172cbd227fae32f3313cba1f3e1b9edb5c4fd (checked November 16, 2026)
- 7.3.4 backport eb8a2d156f2c, https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/commit/?id=eb8a2d156f2c1d862fffdfd1b3432bfbcd939879 (checked November 16, 2026)
- Vulnerable lookup at 6.12.116, https://github.com/gregkh/linux/blob/v6.12.116/net/ipv4/inet_hashtables.c (checked November 16, 2026)
- Fixed lookup at 6.12.117, https://github.com/gregkh/linux/blob/v6.12.117/net/ipv4/inet_hashtables.c (checked November 16, 2026)
- Red Hat CVE page, https://access.redhat.com/security/cve/CVE-2026-99288 (checked November 16, 2026)
- Ubuntu CVE page, https://ubuntu.com/security/CVE-2026-99288 (checked November 16, 2026)
- CISA Known Exploited Vulnerabilities catalog, https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json (checked November 16, 2026)