A critical nginx HTTP/2 vulnerability, tracked as CVE-2026-123007, lets a remote attacker run code on a web server without logging in. The flaw was disclosed on November 18, 2026, together with fixes from F5, which maintains nginx. It’s an integer underflow, and it works only under specific conditions.
Those conditions are demanding. Still, any team that runs nginx with HTTP/2 switched on should check its version and apply the vendor patch.
How the nginx HTTP/2 vulnerability works
HTTP/2 splits traffic into numbered streams, and the client controls how much response data the server may send. The client hands nginx “flow-control credit” in bytes. nginx tracks that credit with one counter per stream and one for the whole connection, and it can send data only when both allow it.
The connection counter is stored as an unsigned 64-bit value. The protocol caps it at 2,147,483,647 bytes, so nginx has to enforce that limit in its own logic. The stream counter is signed, which lets it go negative after a client shrinks the initial window size.
The bug sits in what happens when a client cancels streams whose response data is still queued. Cancelling hands credit back to the connection counter, and it can push the total past the protocol maximum. The next window-update check then performs an unsigned subtraction that wraps around. From there, a series of accepted window updates can drive the counter into the upper half of its range.
nginx later reads that oversized number as a negative response length. It builds an invalid buffer, and buffered TLS output passes a gigantic byte count to the memory-copy routine. The result is out-of-bounds reads and writes.
What an attacker can do
The memory corruption can leak data, interrupt service or run code with the permissions of the nginx worker process. Remote code execution was demonstrated against a Docker image running nginx 1.31.8 on linux/amd64, with HTTP/2 and TLS enabled. The attacker needs no credentials.
The worker process usually runs with limited rights, so an attacker would still need further steps to take over a whole machine. Even so, code execution on a front-door web server is a serious foothold.
Why most servers are harder to hit than the headline suggests
The published exploit has real practical limits:
- It needs roughly 128 GB of HTTP/2 data sent to the target.
- On a 10 Gbit/s link that takes about two minutes. On 1 Gbit/s it takes seventeen minutes.
- nginx closes connections after one hour by default, so a link slower than about 300 Mbit/s can’t finish in time.
- If the HTTP/2 connection passes through a proxy, the exact frames the attacker crafts will likely not arrive intact.
- The method relies on a particular glibc memory-copy routine, chosen at runtime on CPUs with the avx512f and avx512vl features.
The demonstration ran in two and a half minutes, shown at 8x speed in the video. The researchers add that other exploitation strategies might work, though none are known today.
Who found it and how it was disclosed
Stephen Fewer, a senior principal security researcher, discovered the flaw. His team first contacted F5 on November 11, 2026. F5 confirmed receipt the next day, validated the bug on November 16 and set the public disclosure date for November 18.
That is a seven-day path from first contact to disclosure, short by the standards of vendor coordination.
What to do now
Patching is the cleanest answer. F5 has published fixes, and its advisory carries the latest remediation guidance. Administrators should check which nginx builds they run and whether HTTP/2 is enabled on public-facing listeners.
Vulnerability scanners are catching up as well. The Rapid7 Exposure Command, InsightVM and Nexpose products gained an unauthenticated check for this flaw in the November 19 content release.
Defenders who can’t patch right away have partial relief from the exploit’s constraints. A reverse proxy in front of nginx that terminates HTTP/2 itself can break the attack sequence. Bandwidth limits and connection timeouts also work against it. None of that replaces an update.
What to watch next
The exploit is tied to one memory-copy path, but the underlying counter error is general. Expect other researchers to test whether different builds and CPU feature sets give attackers a faster route, and expect scanning for unpatched servers to pick up now that the details are public.
Source: Rapid7