I put nginx in front of nearly everything I deploy, so a pre-authentication RCE in its HTTP/2 module is my problem whether or not I have time for it this week. On 18 November the project shipped 1.30.7 on the stable branch and 1.31.9 on mainline, with ten security fixes in the changelog. Five came from Xint, which disclosed them the same day under the name nginx2root, alongside a sixth bug in the Linux kernel’s SCTP code that turns an nginx worker compromise into root on the host.
The one that decides your evening is CVE-2026-123007, a flow-control accounting error in ngx_http_v2_module. Every official release from 1.9.5, the September 2015 version that first shipped HTTP/2, through 1.31.8 carries it. Xint says the vulnerable code was still in master on 10 November. Wiz, Rapid7, Metnir and Ikotas Labs found the same bug on their own.
🧯 What Actually Shipped
HTTP/2 gives a server a byte credit to spend on response data: one window per stream, one for the whole connection. The client tops both up with WINDOW_UPDATE frames, and the protocol caps them at 2^31-1. nginx debits the connection credit when it queues a DATA frame rather than when those bytes leave, which is correct, and it refunds the credit if the request dies while the frame is still queued.
The refund is where it breaks. That addition never checks the ceiling. A client that stops reading, raises the connection window to exactly the max, and then uses a SETTINGS frame to terminate streams without terminating the connection can push the counter past the limit. The next WINDOW_UPDATE underflows it, nginx treats the huge unsigned value as a negative response length, and the TLS output path hands a byte count near 2^64 to memcpy. Rapid7 walks the four stages with the actual source, which also explains why this survived a decade: it needs four specific frames in one order.
The other four need narrower configurations: a use-after-free when HTTP/2 traffic is proxied to an upstream and the worker is short on worker_connections (CVE-2026-123633); a resolver use-after-free reached when a request-derived proxy_pass destination resolves concurrently in a subrequest (CVE-2026-123634); the same class over HTTP/3 (CVE-2026-121810); and the mail proxy’s auth_http path, which goes back to 0.5.33 (CVE-2026-113425). No exploitation in the wild had been reported as of 18 November, and none of the five are in CISA’s KEV catalog.
🧮 The Number Everyone Read
F5 scores all five flaws with a single CVSS 3.1 vector: AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H. That one H on attack complexity is doing an enormous amount of work, and it is justified by saying code execution requires ASLR to be disabled or bypassed.
Which is true, and which also describes a condition the exploit produces for itself. Wiz got code execution against stock 1.31.7 and 1.31.8 builds after bypassing ASLR. Rapid7’s out-of-bounds read hands over the pointers ASLR exists to hide. Xint documented a heap and image pointer disclosure for the same bug. Three teams that were not coordinating ended up in the same place, so I read AC:H as a measure of how much work the attacker does, not how well the victim is protected.
Wiz and Rapid7 both score CVE-2026-123007 at 9.2 Critical under CVSS 4.0. nginx’s own advisory page calls it “major” and files CVE-2026-123633, the HTTP/2 use-after-free, as “medium”, even though Wiz and Xint each report working code execution against it. I don’t think that is bad faith. Advisory severity has always been a vendor’s judgment about default configurations, and “medium” is defensible for a bug that needs connection exhaustion plus a proxy target. The trouble is that the number is what lands in the ticket, and it was set by the party with the least interest in raising it.
📦 Two Checks That Lie to You
The first is nginx -v. On Debian and Ubuntu a security fix does not move the version string. Debian 12 ships 1.22.1 and Ubuntu 24.04 ships 1.24.0, and a backport bumps only the package revision. A patched box and a vulnerable box both print the same version.
I checked the trackers the morning after the release. Debian has bookworm at 1.22.1-9+deb12u10 and trixie at 1.26.3-3+deb13u10, both marked vulnerable, security pockets included. forky sits at 1.30.6-3, also vulnerable. Only sid, at 1.30.6-4, is fixed. Ubuntu lists resolute, noble, jammy, focal, bionic and xenial all as vulnerable. Ubuntu 14.04 was never affected: its 1.4.6 has SPDY, not HTTP/2. So for the packages most servers actually run, the answer a full day after the fix was no, and the version string would not have told you either way.
The official Docker images moved faster: 1.31.9 and 1.30.7 tags went up, Alpine included. But a container started last week is still running the old image, and restarting it reuses the same layers.
The second check that lies is nginx -s reload. It re-reads configuration and starts new workers. It does not replace the executable. The master stays on the old binary, and established connections can remain on old workers until they drain. Upgrade the package, reload, and you have patched a file while the vulnerable code keeps answering traffic. You need a full restart or the live binary upgrade (USR2, then WINCH on the old master once the new workers are up), and then you should confirm what is actually mapped:
PID=$(pgrep -o -x nginx); sudo readlink -f /proc/$PID/exe
If that path points at a build older than 18 November, you are not patched, whatever nginx -v printed. In containers, rebuild and redeploy, because a restart pulls the same layer back.
Then there is everything that embeds nginx and never says so. Precursor’s tracker reports that the community ingress-nginx controller is unmaintained and will not get a fix, and that F5’s own controller still shipped 1.31.8 in version 5.8.0. Flawfence, which could not verify those, notes that Metnir reproduced the bug in OpenResty and crashed shipped Kong and Apache APISIX builds. Neither nginx -v nor a distro advisory helps there. You find out which nginx is inside the thing.
🚪 Disabling HTTP/2 Closes Two Doors Out of Five
The stopgap everyone is repeating, myself included, is to turn HTTP/2 off until you can upgrade. That blocks CVE-2026-123007 and CVE-2026-123633. It does nothing for the other three, which go through the resolver, HTTP/3, and the mail proxy. CIRCL’s response guidance says the same thing plainly.
Two consequences follow. “HTTP/2 off” is not the same sentence as “mitigated,” and a ticket claiming the second while performing the first is wrong in a way that survives review. And it breaks gRPC behind nginx, so the teams with the most reason to run HTTP/2 cannot use the stopgap and have to patch instead.
There is also the kernel half, which has no CVE as of 18 November and no patch. Xint used it to go from the worker account to root, and says the chain escaped a Docker container. Where SCTP is not needed, blocking the module from loading with install sctp /bin/false in a file under /etc/modprobe.d/ removes the second stage, though it will not unload a module already in use or affect an SCTP compiled into the kernel.
⏳ What Buys You Time
The honest counterweight is that this is not a worm. Rapid7 needed roughly 128 GB over a single connection: two minutes on a 10 Gbit/s link, seventeen at 1 Gbit/s, and probably not workable below about 300 Mbit/s because nginx’s default one hour connection lifetime closes first. It depends on a glibc memcpy path selected only on x86-64 CPUs with avx512f and avx512vl. Connections that pass through a proxy will likely break the frame sequence.
That is a real barrier to mass scanning. It is not a per-victim barrier, though. Two minutes of a 10 Gbit/s link is affordable for anyone who wants your specific server, and the only thing standing in the way is not being worth the effort, which is not a control you can test.
Detection is thin for the same reason. HTTP/2 control frames do not show up in access logs as requests, so a clean log proves nothing. CIRCL’s list is the useful one: workers that start programs they should not, workers that die or leave core dumps, long-lived HTTP/2 connections pulling large volumes while logging almost nothing, and outbound connections from a worker that has no business making them. None of those is proof on its own.
🧠 Final Thoughts
The bug is genuinely interesting. What I will remember is the arithmetic around it: a same-day fix, a public proof of concept, and a vendor advisory telling you to upgrade, restart properly, and not trust a reload. Every instruction there is correct. Every one of them also assumes you can already answer “which of my machines has this,” which is the question this ecosystem answers worst. Version strings lie on the two biggest distributions. Embedded copies hide behind product version numbers. And the severity score that decides your patch queue was set by weighing how hard the attack is rather than how exposed you happen to be.
If you are on distro packages, nginx -v tells you nothing today. Compare the full package version against your vendor’s advisory, or check /proc/PID/exe against a build date. If you run nginx from a container, a chart, or an appliance, go find out which nginx is inside it, and expect to be surprised.
Thanks for reading.