Two machines. The same unpatched kernel, the same nginx with its default configuration, the same port open to the internet. The same crafted traffic hits both and one ends up with a kernel panic on the console while the other keeps serving pages as if nothing happened. It is not luck and it is not a service-level config detail: the difference is how many receive queues its network card has. And that column is not in almost anybody's inventory.
The flaw is called NoisyTCP and it is CVE-2026-99288. The Linux kernel CVE team published it on 10 November at 18:19 UTC, and Hyunwoo Kim —the researcher who found it— posted the full write-up to the oss-security list on 15 November, once the linux-distros embargo lifted. An unauthenticated attacker, from anywhere on the network, drops the machine by sending crafted TCP packets. Red Hat holds that it allows no data alteration and no code execution. Kim, who found it, is less categorical — and we come back to that below.
The bug, in two paragraphs
Lookups in the established TCP connection table (ehash) are done locklessly, for performance. The socket caches use SLAB_TYPESAFE_BY_RCU, so that memory can be reused before an RCU reader that kept the old address has finished. After a tuple match, __inet_lookup_established() takes a reference and re-checks the tuple. What it never checked is whether the object it is now holding is still hashed.
The proof of concept drives that reuse with a SYN cookie request socket. The new object is unhashed and has a NULL rsk_listener; the lookup returns it and tcp_v4_rcv() reads sk_state through the null pointer. The official record spells it out: CR2: 0000000000000012 — the kernel went to read address 0x12. Kernel panic - not syncing: Fatal exception in interrupt. The commit that opened the hole is 079096f103fa, from October 2015, and everything from the 4.4 line onwards is affected. Eleven years.
The two conditions (and the second one is not software)
What separates this CVE from the others that went past you this month is two things, and they have to hold together:
| Condition | What has to be true | How you check it |
|---|---|---|
| 1 | A kernel without the fix and something listening on TCP that the packets can reach. A stock nginx, Apache or sshd will do. |
uname -r + ss -tlnp |
| 2 | Two or more receive queues, or RPS spreading packets across CPUs. Dropping to a single queue, Kim says, «can block the race». | ethtool -l eth0 |
Any scanner checks condition 1. Nothing checks condition 2, because it is not a package version: it is an adapter setting, it varies with the card model and the CPU count, and it appears in no inventory. Hence the two machines at the top.
And here is the fold, which is what really complicates the answer: the two worlds ship backwards from each other. A modern physical card arrives spreading traffic across several queues —the one Kim used in his bare-metal test had eight. A virtio-net guest does not: in Proxmox VE the Multiqueue option is something its own manual says you «optionally activate», and RPS is off. So the virtual machine that fell in five seconds had one of those two things switched on by hand. The uncomfortable conclusion: condition 2 cannot be inferred from the kind of machine. On bare metal it usually holds and on a guest it usually does not, and both of those sentences carry a «usually». Which is why the answer is ethtool and not a general rule.
Kim's number, which runs against intuition
In his own tests, Kim measured how long it takes to win the race. Against QEMU/KVM virtual machines running default nginx, Apache or SSH: between 5 seconds and 2 minutes, because vCPU scheduling widens the window. Against a quiet bare-metal nginx with 8 receive queues, using a tuned proof of concept: about 14 hours.
Do the division yourself. Fourteen hours is 50,400 seconds: between 420 and 10,080 times faster on the virtual machine than on bare metal. And that inverts the way we normally sort priorities. The machine where a panic takes the most down with it is also the easiest one to knock over. Not because virtualisation is insecure, but for something as dull as this: time-slicing CPU between guests leaves wider windows than a dedicated core does.
The kernel's own crash trace falls through a virtual NIC
We have not seen it in the coverage we have read, and it is right there in the CVE record, and all it takes is reading the whole call trace. The reference panic published by the kernel project itself goes through this:
RIP: 0010:tcp_v4_rcv+0x44e/0x1280
...
__netif_receive_skb_list_core+0x223/0x250
netif_receive_skb_list_internal+0x1d2/0x2c0
? try_fill_recv+0x39/0x7b0
napi_complete_done+0x74/0x170
virtnet_poll+0x445/0x600 <-- virtio-net: a PARAVIRTUALISED network card
__napi_poll+0x27/0x1e0
net_rx_action+0x2fe/0x3b0
virtnet_poll is the receive path of the virtio-net driver, the paravirtualised network card. And it is worth being exact here, because it is easy to overreach: it is not the model Proxmox VE sets by default —its manual says the default model is the emulated Intel E1000— it is the one that same manual recommends "if you aim for maximum performance", because it delivers "up to three times the throughput" of the E1000. In other words, the one that ends up on anything that moves real traffic. The kernel it was reproduced on is in the record too: 7.3.0-00591-g0e135910deec. The panic the project documents was reproduced inside a virtual machine, on a card that does not exist.
Two caveats, because without them this would be an overstatement. One: the trace coming from there does not make bare metal immune; Kim reproduced it on a physical machine too, and it took him fourteen hours instead of five seconds. Two: running virtio-net does not automatically put you in scope, because condition 2 still has to hold, and that is something you check with ethtool, not something you infer from the card model. What the trace says is less comfortable than "virtualisation is insecure": the component you picked because it was fast is the one that shows up in the crash report.
The 7.5 does not come from the kernel, and its own write-up contradicts it
The kernel CNA record carries no CVSS score at all. Not one. The 7.5 your scanner will show comes from Red Hat, with this vector: CVSS:3.1/AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H. And on the same page, their own text speaks of an «unauthenticated» attacker and says the flaw «does not allow data alteration or arbitrary code execution». The vector says PR:L (privileges required) and C:H/I:H (confidentiality and integrity impacted). Both cannot be true at the same time.
Redo the arithmetic with what their own text says —PR:N, C:N/I:N/A:H— and the very same CVSS 3.1 gives you 5.9. This is not an academic quibble: in plenty of companies the threshold for "open an emergency window" sits between those two numbers.
The field we care about is a different one: S:U, scope unchanged. On a standalone server that is right. On a virtualisation host the panic takes down every guest hanging off it, and the same goes for containers because they share the host kernel. We are not going to argue with the standard; we are saying something simpler: the number does not measure blast radius, and blast radius is what decides whether you open a window.
Three ways out, and all three cost something
| Way out | Reboot? | What it costs you |
|---|---|---|
| Your distro's fixed kernel | Yes | The window. And on a host, evacuating or stopping the guests. |
tcp_syncookies=0 |
No | Your SYN flood defence. And it closes only one of the two paths. |
| Single queue + RPS off | No | Network throughput. And on a physical NIC it can briefly drop the link when applied. |
That second row deserves a careful read, because it is where we nearly got it wrong ourselves. Turning off SYN cookies does not close the bug, it closes one path. Kim documents two. The first is the one this post describes —a request socket rebuilt through a SYN cookie— and that is the one the sysctl blocks. The second he calls «Full child socket ABA Race», and describes it like this: «This path can trigger a remote use-after-free, but since complex race scenarios have to succeed in a nested way, it is generally hard to trigger without using special techniques». Nobody has demonstrated it. But that is why «it only stops the box» is better read as Red Hat's position than as a physical limit of the flaw — and why our 5.9 above, resting on a C:N/I:N, is today's arithmetic rather than a permanent truth. We are writing it down so we can come back to it.
Live patches, which would be the elegant way out, were not there. TuxCare —who make them— wrote on 16 November that they had not released one for this CVE on any distribution and had no date to share. So today the real fix is still a reboot.
Even so, notice how unusual this is. Two weeks ago we wrote that XSA-523 had no mitigation, it had a host reboot: either you stopped, or you stayed exposed. Here there is a switch. A partial, badly priced one, but a switch. That turns "I break the change window tonight" into "I wait for the window I already had scheduled", That is six hours of sleep and one less call to management.
Debian has shipped it; Ubuntu, today, has not
Upstream, the fix landed in four branches and only four: 6.12.117, 6.18.63, 7.3.4 and 7.4-rc2. Look at what is not on that list: no 5.10, no 5.15, no 6.1 and no 6.6 — four very much alive longterm lines. Jammy is 5.15. Bookworm is 6.1. That explains what happens downstream far better than how diligent each team is. Debian already has advisories —DSA-6628-1 and DLA-4906-1— with 6.1.192-2 in bookworm, 6.12.117-1 in trixie and 7.3.4-1 in sid. Ubuntu, on the other hand, rates it Medium priority and as of today still lists jammy, noble and resolute as vulnerable, with no kernel released. And RHEL 8, 9 and 10 are listed as affected with no release date in the roundup TuxCare published on 16 November.
If you run hypervisors, that ordering matters more than it looks, and we have been here before: the fixed versions listed in a CVE are almost never the ones your node boots. Keep the rule, which does not expire: the CVE version list talks about upstream branches. What your machine runs is decided by your distribution. If uname -r returns something that is not on that list, you are neither safe nor doomed: you are waiting on a backport, and the job is knowing who you are waiting on.
The two questions to put to each machine
Which kernel it boots and how many queues it has. Those are the two. Everything below is read-only: it changes nothing and needs no window.
# 1. Which kernel this machine ACTUALLY boots
uname -r
# 2. Condition 2: how many receive queues? Look at "Current hardware settings"
ethtool -l eth0
# 3. And RPS spreading across CPUs? Anything other than 0 counts
grep . /sys/class/net/eth0/queues/rx-*/rps_cpus
# 4. What is actually listening, and on which address
ss -tlnp
There is a fifth step you cannot run from the machine: checking from outside which ports actually answer. ss -tlnp tells you what the process listens on —run it with sudo or the process column comes back empty—; it does not tell you what the firewall in front lets through, or what someone published through a NAT three years ago.
The three-column inventory almost nobody keeps
If those four commands cost you a whole afternoon, today's problem is not NoisyTCP. It is that the answer was not written down anywhere. What this CVE asks for is a three-column inventory: which kernel each machine boots, how many queues each outward-facing interface has, and how many guests hang off each host and how long it takes to evacuate them. The first two are maintenance, the boring word. The third decides whether the reboot window is half an hour or an entire Sunday, and that one cannot be improvised: it depends on whether shared storage and live migration were built in from day one, or were not.
What we would not do
Nothing is on fire, but the clock moved on the 16th. As of 17 November no in-the-wild exploitation has been reported and the flaw is not in CISA's KEV catalogue, whose latest published version is 2026.11.13. What there is, since the 16th, are several third-party proofs of concept published on GitHub and already indexed by the exploit search engines, which panic the target kernel. Kim's repository still holds only the analysis: asked about code, he answers "Not yet. and basically, no. So far I have only written a very limited, lab-specific exploit that targets VM servers". It is still not a Friday night. But it is no longer last week.
Do not turn off SYN cookies on an internet-facing machine. You would be trading an attack that requires winning a microsecond race for a SYN flood, which is a twenty-year-old script. That mitigation is for internal machines, and for the stretch between now and your window.
If that interface only listens on the management network, do not rush. But let "it is not exposed" be the output of a scan run from outside, with a date on it, rather than a belief inherited from whoever built the thing.
What we take from this
We say it often because it is the axis of how we design: failure is inevitable, an outage is a design decision. Here the failure has been sitting in the code for eleven years and nobody decided it. What was decided —years ago, the day the thing was built— is whether today you can reboot six hosts without the company noticing, or whether every reboot is a negotiation with management.
And the detail we will keep from this CVE, because it had not occurred to us before reading the trace: the most exposed configuration was not the oldest one, nor the worst maintained. It was the normal one.
Sources (verified at origin): the official CVE record, with the bug description, the panic trace, the introducing commit and the fixed versions — Linux kernel CNA record (published 10 Nov 2026); CVSS score and vector, statement and mitigations — Red Hat; per-release status — Ubuntu Security; fixed versions and advisories — Debian Security Tracker; the author's own advisory, the exploitation conditions, the lab timings and his answer about attack code — Hyunwoo Kim's NoisyTCP repository (@v4bel); live-patch status and the checking commands — TuxCare; coverage and the oss-security posting — BleepingComputer. Default network device model and the VirtIO recommendation — Proxmox VE manual (Network Device). third-party proofs of concept indexed since 16 Nov 2026 — Sploitus exploit search. The 5.9 CVSS recalculation is ours, worked out with the 3.1 formula over the values Red Hat's own text describes.
How many receive queues does the card on each of your internet-facing machines have?
If the answer is "we would have to look", that is the job. We run maintenance on estates where the inventory includes the kernel each machine boots and the reboot window is decided before anyone needs it. If you want someone to go through yours with this list in hand, let's talk.
Talk to everyWAN