DEV Community

Cover image for CVE-2026-123007: the NGINX HTTP/2 bug, who is affected and the fix

CVE-2026-123007: the NGINX HTTP/2 bug, who is affected and the fix

NGINX shipped fixes on November 18 for two bugs in its HTTP/2 code that researchers say can run code on the server with no password. The one that matters most for the largest number of servers is CVE-2026-123007, a flow-control counter that goes past its maximum. This article covers what the bug is, who found it and who says what, what the public write-ups say it takes to exploit, which servers it can reach, and what to change tonight. It accompanies today's Daily Diff episode.

TL;DR

  • Two NGINX bugs, CVE-2026-123007 and CVE-2026-123633, both need HTTP/2 enabled. F5 scores both 9.2 out of 10 (CVSS 4.0); nginx.org's own list calls them "major" and "medium".
  • Fixed builds: NGINX 1.30.7 (stable) and 1.31.9 (mainline).
  • Wiz says it ran code on an NGINX server serving ordinary static files over HTTPS, with no backend application and no third-party module.
  • Rapid7's exploit needs about 128 GB of HTTP/2 traffic over one connection, so a link slower than about 300 Mbit/s runs into NGINX's default one-hour connection limit. That is one team's exploit; Rapid7 says other routes may exist.
  • http2 off; blocks these two bugs. It does not block the three other bugs Xint reported in the same release, so patch and restart.
  • No source I found says these bugs are exploited in the wild; CISA's known-exploited catalog did not list them on November 19.

What is CVE-2026-123007 in NGINX?

HTTP/2 lets many requests, called streams, share one connection. Flow control stops a server from sending more than the client is ready to receive: the client grants credit, and the server tracks how much it may still send in a counter. In NGINX that connection-level counter is h2c->send_window.

When NGINX queues response data, it subtracts that size from the counter. If the client cancels a stream while its data is still queued, NGINX removes the unsent data and returns the credit. The maintainers' commit message says the refund could push the flow control beyond NGX_HTTP_V2_MAX_WINDOW if the client had raised the allowance after the frames were queued and before the stream ended.

Wiz's write-up goes one step further. The check that validates the next increase subtracts the current counter from the maximum:

if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window)
Enter fullscreen mode Exit fullscreen mode

(That line is quoted from Wiz's post.) Once the refund has pushed the counter past the maximum, the subtraction happens in unsigned arithmetic, which cannot go negative, so it wraps around to a very large positive value and the check approves more increases. Wiz says the oversized counter is later read as a negative length, which leads to a memory copy outside its buffer in the TLS send path, and that the same out-of-bounds access also discloses memory, which is how it got past ASLR on official 1.31.7 and 1.31.8 builds.

The Wiz post on screen at the refund passage, from our recording of the public page

F5's NVD record is more conditional than the researchers' write-ups: code execution when ASLR is disabled or the attacker can bypass it, and a CVSS vector that rates attack complexity as high. Ubuntu scores the same CVE 8.1 on CVSS 3; different scales and scorers give different headline numbers.

The fix

The fix adds a counter for queued frames and counts them when validating a client's WINDOW_UPDATE. The changed check (from the public commit):

if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued) {
Enter fullscreen mode Exit fullscreen mode

The commit is dated November 11 and says "Reported by Xint.io". The advisory and the releases came out on November 18, a week later. A commenter on Hacker News noticed the gap. The commit message describes flow-control accounting and carries no CVE, and I found no statement that anyone used it.

The second bug, CVE-2026-123633

The second bug is a use-after-free in HTTP/2 connection handling. Wiz explains that a connection with no active request can sit on NGINX's list of connections it may close, and that a request which starts later does not take it off. Under connection-slot pressure NGINX can then close a connection that is still in use, and a failure while sending the GOAWAY frame frees memory the running request still points at. It matters mainly when NGINX runs as a reverse proxy and is low on worker connections. The nginx.org changelog credits "Albert of Vexera AI"; Wiz says it reported the same bug on October 21 and that another team had reported it earlier.

Who found it, and was it really AI?

Wiz says five teams found these bugs independently: Wiz, Rapid7, Xint, Ikotas Labs and Metnir. Each account below is the team's own:

  • Wiz says its AI harness, Atlas, discovered both bugs, and that Gemini 4 Carbon and ChatGPT 5.6 Sol validated the impact.
  • Rapid7 credits a named researcher, Stephen Fewer, for CVE-2026-123007.
  • Xint says one of its researchers found CVE-2026-123007 while preparing for a contest, and that a fully automated scan found four more bugs days later.
  • The nginx.org changelog credits Xint.io for the flow-control bug and Albert of Vexera AI for the use-after-free.

So "AI found it" is Wiz's account for both bugs and Xint's for four others; named human researchers also found the bug this article is about. Wiz argues that AI is removing the barrier complexity used to put around memory-safety bugs, and links this release to PHP2Shell and Java4Shell. That is Wiz's thesis.

How hard is it to exploit CVE-2026-123007?

Wiz did not release its exploits. Xint published demo videos and a technical analysis that deliberately leaves out the final steps, and Rapid7 published a video of its proof of concept. Rapid7's post also lists its limits, which is the most specific public information about what an attacker needs:

  • About 128 GB of HTTP/2 data, most of it control frames, sent over one connection.
  • About 2 minutes over 10 Gbit/s and about 17 minutes over 1 Gbit/s, per Rapid7. NGINX closes connections after an hour by default, so a network slower than roughly 300 Mbit/s cannot finish in time.
  • If the connection is proxied, Rapid7 says the exact frames will likely not be passed along in a way that works. Wiz says a CDN or WAF that terminates HTTP/2 may mitigate parts of the attack, depending on the implementation.
  • Rapid7's exploit depends on a specific glibc memory-copy routine selected on x86-64 CPUs with certain AVX-512 features. Rapid7 says other exploitation strategies may be viable but none is known.

Those limits describe Rapid7's exploit only. Xint's demonstration chains the bug with a Linux kernel flaw to reach root on the host, and Wiz says it confirmed code execution with an ASLR bypass.

Which of my NGINX servers can this reach?

For CVE-2026-123007 you need all of these: a build in the affected range (1.9.5 through 1.31.8, which means every release since HTTP/2 arrived in 2015), the HTTP/2 module compiled in, HTTP/2 switched on for a listener, and a port an attacker can reach. Xint's post gives these checks:

sudo nginx -T 2>&1 | sed 's/#.*//' | grep -nE 'listen[[:space:]].*http2|^[[:space:]]*http2[[:space:]]+on[[:space:]]*;'
Enter fullscreen mode Exit fullscreen mode

(Quoted from Xint's post.) Output means HTTP/2 is enabled in the configuration on disk. Xint also gives an openssl s_client -alpn h2 test to run from outside; if a CDN or reverse proxy sits in front, it only reaches the proxy, so run it against the NGINX host too.

Be careful with the version number, because distributions backport fixes without changing it. Ubuntu 24.04 ships NGINX 1.24.0 and lists the fixed package as 1.24.0-2ubuntu7.20; nginx -v still prints 1.24.0. Compare the full package version with your distribution's advisory. Xint's November 10 Shodan snapshot found that 98.9% of the 11.94 million hosts showing a version were in the affected range, and Xint says those are version strings that confirm no exposure.

What do I change tonight?

  1. Check the package version your distribution reports as well as the number NGINX prints.
  2. Upgrade to NGINX 1.30.7, 1.31.9, or your distribution's fixed package, and restart. Xint notes that a configuration reload does not replace the running executable.
  3. If you cannot upgrade yet, disable HTTP/2: on NGINX 1.25.1 or later set http2 off; in the affected server blocks and remove the http2 parameter from any listen directive; on older versions remove http2 from listen. Reload, and confirm the old workers have exited. Native gRPC needs HTTP/2.
  4. Remember what that does not cover. Xint reported three more bugs in the same release: an HTTP/3 use-after-free, a resolver use-after-free reachable with a request-derived proxy_pass plus mirror, and a mail-proxy use-after-free. Disabling HTTP/2 does not block them, so the patch is still the plan.
  5. Watch for the warning signs Wiz and Xint describe, which are not proof: worker crashes, commands started by NGINX workers, and long-lived connections whose received bytes grow fast while the server sends little.
listen 443 ssl;
http2 off;
Enter fullscreen mode Exit fullscreen mode

Do not run third-party "proof of concept" repositories to test your servers. Several named after the CVE appeared within a day; I opened none of them, and unvetted code with an exploit name is a standard way to get malware.

Also today: Gemini 4 Neon

Google launched Gemini 4 Neon on November 18. Google says it ranks third on the Artificial Analysis Intelligence Index with a 61, costs $3 in and $15 out per million tokens, and that a cyber version scores 90.5% on a vulnerability-finding benchmark at roughly half the cost per challenge, for trusted defenders first. Artificial Analysis's own page agrees on the 61 and calls the model somewhat expensive, notably slow per task and very verbose: about 21.5 minutes and $6.44 per task. Vals ranks Neon second at 70.87%, just behind Claude Fable 5.2. Wiz says it used Gemini 4 Carbon to check its NGINX bugs.

Also today: Anthropic's IPO

Anthropic priced its IPO at $83.00 a share, above the $70 to $78 range it filed on November 10, and sold 980 million shares, up from 825 million planned. The final prospectus, filed on November 19, shows $81.34 billion in total, of which $78.84 billion goes to Anthropic before expenses, $0.55 billion is the underwriting discount, and about $1.95 billion goes to selling stockholders. CNBC calls it the largest offering on record and puts the fully diluted value near $1.5 trillion; shares start trading on Thursday as ANT. The prospectus reports nine-month revenue of $33.2 billion against $2.5 billion a year earlier, an operating loss of $1.26 billion and a net loss of $104.0 billion, $94.3 billion of it a fair-value change on its own convertible notes. This is not investment advice.

Verdict: SHIP IT

My stamp on the NGINX bugs is SHIP IT, and it rates the response. The fix is small, the stopgap is one line, and the one exploit with published limits needs a lot of traffic and a direct path. I would still put the package version in the ticket and patch the other three bugs at the same time.

FAQ

Is CVE-2026-123007 exploited in the wild?
I found no source that says so, and CISA's catalog did not list it on November 19. Xint and Rapid7 published demo videos; Wiz withheld its exploits.

Does setting http2 off; protect me?
It blocks CVE-2026-123007 and CVE-2026-123633. It does not block the HTTP/3, resolver and mail-proxy bugs Xint reported in the same release, so upgrade and restart.

How much traffic does the exploit need?
Rapid7 says its exploit needs about 128 GB of HTTP/2 data over one connection, which NGINX's default one-hour connection limit makes impractical on links slower than about 300 Mbit/s. Rapid7 says other exploitation routes may exist.

Sources


This article expands on an episode of **The Daily Diff, a five-minute daily video on what shipped and what broke in tech.
Watch the episode · Subscribe on YouTube · the written diff lands in your inbox every morning at thedailydiff.dev.

Video transcript and primary sources

Top comments (0)