On November 18, 2026, nginx shipped 1.31.9 (mainline) and 1.30.7 (stable) with ten CVEs fixed in one release. Four of them are rated major on nginx.org, and the two HTTP/2 bugs in the middle of it — CVE-2026-123007 and CVE-2026-123633 — carry a CVSS 4.0 score of 9.2 in F5’s own CVE records. A Wiz blog post went up the same day; a Hacker News submission reached 1,103 points and 494 comments.
The interesting part is not the severity. It is how small the fix is, and how much of the published narrative does not survive contact with the commit log.
This article does three things. It reads the actual patches (six added lines for one bug, two for the other). It reproduces the broken state on instrumented builds of 1.31.8 and 1.31.9 over cleartext HTTP/2, with a hand-written frame client and no exploit. And it documents one behaviour of the fixed binary that no advisory, vendor blog, or CVE record mentions: an 8,192-byte counter residue that makes 1.31.9 stricter than the protocol requires.
What actually shipped
| Item | Value |
|---|---|
| Releases | nginx 1.31.9 (mainline) and 1.30.7 (stable), both tagged 2026-11-18 |
| GitHub release timestamps | 1.31.9 at 15:54 UTC, 1.30.7 at 15:56 UTC |
| CVEs fixed in 1.31.9 | 10 |
| nginx.org severity labels | 4 × major, 4 × medium, 2 × minor |
| F5 CVE score (CVE-2026-123007) | CVSS 4.0 9.2 critical; CVSS 3.1 8.1 high; CWE-191 + CWE-787 |
| F5 CVE score (CVE-2026-123633) | CVSS 4.0 9.2 critical; CVSS 3.1 8.1 high; CWE-416 |
| Total diff, 1.31.8 → 1.31.9 | 37 files, 743 insertions, 128 deletions |
| Hacker News | 1,103 points, 494 comments, submitted 15:19 UTC — 35 minutes before the GitHub release |
| Repository | 32,162 stars, 942 watchers, 8,406 forks, BSD-2-Clause |
Ten CVEs in one release is not normal for nginx. Scanning the advisory index by fixed version, 1.31.9 is the largest single batch in the 1.31 line; the previous high was 1.31.0 with six. The 1.31.7 release on October 14 carried five.
The HN submission at 15:19 UTC is worth noting on its own: the blog post and the CVE records were public roughly half an hour before the fixed tarballs appeared on GitHub. Anyone who read the thread first and patched second had a 35-minute window in which the only available advice was “turn HTTP/2 off”.
The fix, in the order it was written
Two commits carry the two critical bugs. Both were written by Roman Arutyunyan.
CVE-2026-123007 — six lines, three files
Commit e27f5fa8, HTTP/2: account for queued frames when validating WINDOW_UPDATE, 3 files, +6/−2:
- if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
+ if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued) {
h2c->send_window -= frame_size;
+ h2c->send_queued += frame_size;
h2c->send_window += window;
+ h2c->send_queued -= window;
Three more edits complete it: a new size_t send_queued field in ngx_http_v2_connection_t, a send_queued -= frame->length in the data-frame handler, and a guard around the refund loop so that only data frames are refunded:
- window += frame->length;
+ if (frame->handler == ngx_http_v2_data_frame_handler) {
+ window += frame->length;
+ }
The commit message states the failure mode without hedging:
When a stream is terminated, its unsent payload length is refunded back to the connection flow control. Previously, this could increase the flow control beyond NGX_HTTP_V2_MAX_WINDOW, if it was increased by the client after the stream frames were queued and before the stream was terminated. This eventually resulted in broken buffer size control in ngx_http_v2_send_chain() followed by memory corruption and a possible segmentation fault.
And it credits one reporter: Reported by Xint.io.
CVE-2026-123633 — two lines, one file
Commit 2df48a50, HTTP/2: reset reusable connection status on stream creation, 1 file, +2:
h2c->processing++;
+ ngx_reusable_connection(h2c->connection, 0);
The commit message contains the shortest reproduction in the whole disclosure, and it is not in any vendor blog:
Having an HTTP/2 connection with streams registered as reusable became possible after 76672e650. A connection with no streams and a partial frame read from client was registered as reusable to avoid DoS attacks. So if a client sends only the first HEADERS frame byte, the connection becomes reusable. Later, when the remaining HEADERS bytes are received and a new stream is created, the reusable status is not reset until the connection becomes idle.
76672e65 is dated 2021-02-11, HTTP/2: reuse of connections with incomplete frames, by Maxim Dounin, “Prodded by Taewoo Kim.” That is 5 years and 9 months between the commit that created the precondition and the commit that removed it.
This one credits a different reporter: Reported by Albert @ Vexera AI.
What the changelog credits, and what the blogs claim
| Source | CVE-2026-123007 | CVE-2026-123633 |
|---|---|---|
CHANGES in the release | “Thanks to Xint.io.” | “Thanks to Albert of Vexera AI.” |
| Git commit trailer | “Reported by Xint.io.” | “Reported by Albert @ Vexera AI.” |
| Wiz blog | Wiz Research, with Ikotas Labs, Metnir, Rapid7 and Xint listed as independent finders | Wiz says it reported on Oct 21; “F5 confirms that another research team had previously reported the same vulnerability” |
| Xint blog | Xint, part of a five-CVE set called nginx2root | Xint does not claim CVE-2026-123633 at all |
Wiz’s own timeline explains the discrepancy it does not resolve: Wiz reported the use-after-free on October 21, and F5 replied that someone else had reported it first. The upstream project credited Vexera AI. Five teams are named in one blog, one team is named in the other, and the code says two names in total.
None of this changes what a reader should do — patch. It does change what “we found it” means in a disclosure where a fully automated scan found four of the five bugs, as Xint states plainly: “a fully automated Xint scan found the other four without human guidance.”
The lab: two builds, one client, no exploit
To check the patches rather than the prose, I built both versions from the official tarballs on Debian 13 with gcc:
./configure --prefix=... --without-http_rewrite_module \
--without-http_gzip_module --with-http_v2_module --with-cc-opt="-O1 -g"
Three ngx_log_error(NGX_LOG_ERR, ...) lines prefixed INSTR were added to ngx_http_v2.c and ngx_http_v2_filter_module.c: one after h2c->processing++ reporting h2c->connection->reusable, one after every accepted connection-level WINDOW_UPDATE reporting h2c->send_window, and one at the end of ngx_http_v2_filter_cleanup() reporting the refund and the resulting window.
The client is ~200 lines of Python that writes raw frames to a socket: preface, SETTINGS, HEADERS, WINDOW_UPDATE, RST_STREAM. No TLS, no ALPN, no library. nginx accepts this because listen 8081 http2; enables cleartext HTTP/2 (h2c) — the same code path for frame parsing, flow control and the output queue, with a different transport underneath.
What this setup can prove: that the protocol state the patches exist to prevent is reachable, exactly which counter values change, and whether a patched build still accepts the same bytes.
What it cannot prove: remote code execution. Both Wiz and Xint place the final out-of-bounds copy in ngx_ssl_send_chain(), the TLS send path. A cleartext listener does not go through it. I did not build nginx against OpenSSL here, so the lab stops at the invariant, not at the copy.
Experiment A: 28 bytes flip a flag that should never be set
The claim in commit 2df48a50 is testable in one shot. Send exactly one byte of a HEADERS frame — the first byte of the 9-byte frame header — wait 0.6 s, then send the remaining 27 bytes.
RESULT test=reusable sent=1+27 bytes
| Build | create_stream sees connection->reusable |
|---|---|
| 1.31.8 | 1 |
| 1.31.9 | 0 |
That is the entire precondition for CVE-2026-123633, reproduced in 28 bytes and a pause. The connection has no streams, so nginx marks it reusable to avoid a slow-client DoS; the rest of the HEADERS frame then creates a stream, and on 1.31.8 the connection stays on the drain list while it is processing that stream. Everything after that — the upstream connection, ngx_drain_connections(), the failed GOAWAY, the freed pool — is reachable from this state and requires no new protocol trick.
I did not take it further. Draining requires worker_connections pressure plus a proxy_pass upstream; that is a configuration the reader can reason about from the commit message, and it would have produced a crash rather than a measurement.
Experiment B: three frames past the maximum
The flow-control bug is arithmetic, so it can be measured rather than argued. The vulnerable sequence is:
- Top the connection window up to exactly
NGX_HTTP_V2_MAX_WINDOW(2,147,483,647) while no stream exists — nothing can consume the credit behind your back. - Request a large file. nginx queues DATA frames and subtracts their payload from
h2c->send_window. - Send a small WINDOW_UPDATE. It is legal, because the check compares the increment against
MAX_WINDOW - send_window, and the queued frames already reducedsend_window. - Reset the stream.
ngx_http_v2_filter_cleanup()refunds the queued payload on top of the window you just raised.
Running this against a 64 MiB static file, with the client never reading so the socket buffers stay saturated, on 1.31.8:
step1 base_send_window=1071161343
step2 topped_to=2147483647 (target 2147483647)
step3 final_send_window=2147487743 max=2147483647 delta=4096
step4 probe_alive=True send_window_after_probe=4294971390
The worker log, in order:
INSTR window_update_accepted: inc=1073741824 send_window=1073807359
INSTR cleanup_refund: sid=1 refund=40960 send_window=1071161343 max=2147483647
INSTR window_update_accepted: inc=1076322304 send_window=2147483647
INSTR window_update_accepted: inc=4096 send_window=2147422207
INSTR cleanup_refund: sid=3 refund=65536 send_window=2147487743 max=2147483647
INSTR window_update_accepted: inc=2147483647 send_window=4294971390
Read the last three lines together. send_window is 2,147,487,743 — 4,096 bytes above the protocol maximum. The next WINDOW_UPDATE asks for another 2,147,483,647, which is the largest increment a frame can carry, and 1.31.8 accepts it, taking the counter to 4,294,971,390. That is 2³² plus 4,094. The bounds check is not weakened; it is dead, because MAX_WINDOW - send_window underflowed into a huge unsigned value.
The overshoot is exactly the size of the increment I sent in step 3. That is the shape of the bug: the refund returns credit that was already returned by the client’s WINDOW_UPDATE, and nothing compares the result to the maximum.
Xint’s writeup describes the same four counter values with the same labels (Wmax, Wmax − Q, Wmax, Wmax + Q) and one technique I did not need: a burst of PING frames first, because nginx queues control-frame responses ahead of pending DATA and the ACKs fill the TLS/TCP buffers before the DATA is queued. That is how they make Q large. My Q was 65,536 bytes, which is enough to cross the maximum and not enough to reach an interesting heap layout.
The same script against 1.31.9
step1 base_send_window=1071161343
step2 topped_to=1073807359 (target 2147483647)
FAIL top-up did not land on MAX
INSTR cleanup_refund: sid=1 refund=40960 send_window=1071161343 send_queued=8192 max=2147483647
[info] client violated connection flow control: received WINDOW_UPDATE frame
with window increment 1076322304 not allowed for window 1071169535
The step that 1.31.8 accepted is refused, and the connection is closed with FLOW_CTRL_ERROR. 1071169535 is 1071161343 + 8192: the new check subtracts send_queued as well, so the client’s credit is measured against the frames it has not received yet. That is the fix, and it works.
It also leaves a residue.
The undocumented part: send_queued does not return to zero
Look at the number again. After the stream is reset and its queued frames are discarded, send_queued reads 8,192, not 0. The refund subtracted 40,960 from a counter that had been charged 49,152.
That is not a rounding artifact; it is structural. The cleanup loop removes and refunds frames matching frame->stream == stream && !frame->blocked. Blocked frames are skipped and left in the queue, and when they are eventually discarded they are not subtracted from send_queued. The patched counter can therefore only go down via paths that never see those bytes.
Consequence, measured: in 1.31.9 the connection’s usable window is permanently 8,192 bytes smaller than the client believes. In my run the difference was enough to turn a top-up that 1.31.8 accepts into a FLOW_CTRL_ERROR disconnect. A client that tracks the connection window strictly against the protocol maximum — which is exactly what a well-behaved client library does after receiving the server’s SETTINGS — can be disconnected for sending a frame that the specification permits.
How much this matters in production is a separate question, and I will not overstate it. An 8 KiB shortfall accumulates per reset stream on a given connection; a connection with many cancelled streams can lose more. Most real clients never push the window to the exact maximum, which is why this has not produced a wave of bug reports in the first twelve hours. But it is a behaviour change with no release note, no mention in either vendor writeup, and no test: the commit adds a counter and never asserts that the counter returns to its starting value.
The claim is easy to check and I would rather state its limits: measured here on two resets in one connection, in one build, with -O1 -g, over h2c. A build with different buffer sizes may leave a different residue.
Where the two published analyses disagree
Beyond the credit question, the sources do not line up on several numbers a patch team might act on.
| Claim | Wiz | Xint | nginx.org advisory |
|---|---|---|---|
| CVE-2026-123634 first affected | 0.6.18 | 1.13.4 | 0.6.18 |
| CVE-2026-113425 first affected | 0.5.33 | 0.5.15 | 0.5.33 |
| CVE-2026-123633 severity | Critical, CVSS 4.0 9.2 | “critical”, no score | medium |
| CVE-2026-123634 severity | Critical, 9.2 | no score | medium |
| CVEs in the release | 10 | 5 nginx + 1 kernel | 10 |
| Stable-branch fix | 1.30.7 | not mentioned | 1.30.7 |
| Exposure | “>225 million websites” | 56.7 M Shodan hosts, 11.94 M versioned (21.1%), 98.9% in range | — |
The most consequential row is the third. nginx.org labels the HTTP/2 use-after-free Severity: medium while F5’s CVE record for the same identifier says 9.2 critical / CWE-416. Both are official. An operations team that triages from the advisory index and an operations team that triages from the CVE feed will order their work differently on the same day.
The exposure numbers need the same care that Xint applies to them in the following sentence: “These numbers are based on reported version strings and don’t confirm that a server is vulnerable.” 98.9% of versioned hosts fall in the affected range, but the range starts at 1.9.5, which is eleven years of releases. The fraction that also has HTTP/2 enabled and is internet-reachable is not published by anyone.
What a team should actually verify
The published advice is “upgrade to 1.31.9” and “or disable HTTP/2”. Both are correct. Neither is sufficient as a check, because none of these five documents tells you what your host is running.
1. Version strings do not prove patch status. Ubuntu 22.04 shipped 1.18.0; after USN-8955-1 the package is 1.18.0-6ubuntu14.22 while nginx -v still prints 1.18.0. Compare the full package version, not the upstream version.
2. http2 on; in a config file does not prove HTTP/2 is reachable. Check ALPN against the public port:
openssl s_client -connect host:443 -alpn h2 </dev/null 2>/dev/null | grep "ALPN protocol"
A 200 over HTTPS proves nothing either way: a browser falls back to HTTP/1.1 silently.
3. A reload does not replace the binary. nginx -s reload keeps the old workers alive until they drain. Xint makes the point explicitly — restart or do a live binary upgrade, then confirm the old workers exited.
4. Per-CVE configuration checks — the ones that actually decide whether you are exposed:
| CVE | Needs | Blocked by disabling HTTP/2? |
|---|---|---|
| CVE-2026-123007 | HTTP/2 enabled, any content (static files included) | Yes |
| CVE-2026-123633 | HTTP/2 + proxy_pass to an upstream + connection-slot pressure | Yes |
| CVE-2026-123634 | resolver + request-derived proxy_pass + a subrequest (mirror with mirror_request_body off, or SSI) | No |
| CVE-2026-121810 | HTTP/3 + upstream | No |
| CVE-2026-113425 | mail proxy with proxy on and auth_http | No |
The “No” column is the part most summaries leave out. Disabling HTTP/2 buys you two of five, and the resolver bug is reachable from plain HTTP on port 8080 — Xint’s own validation table lists that as the entry point.
5. Read the commit, not the summary, for your own build. If you vendor nginx or maintain a fork, git log --oneline release-1.31.8..release-1.31.9 -- src/http/v2/ returns five commits. Apply the ones you need; the rest of the 743-line diff is unrelated hardening.
FAQ
Is my nginx vulnerable if it is behind a CDN? Probably less exposed, not safe. Wiz notes that CDNs and WAFs terminating HTTP/2 “may mitigate parts of the exploit by not reflecting the exact payload back to the underlying NGINX server,” and adds that this “depends on implementation.” If the CDN forwards h2 to your origin, the origin still parses the frames.
Does this affect HTTP/1.1 only servers? No. Neither critical bug is reachable without HTTP/2 framing. But the release fixes eight other CVEs, and CVE-2026-118899 (infinite loop while reading a request body over TLS 1.3) needs no HTTP/2 at all.
Why is the fix so small if the bug is a decade old? Because the bug is not in a feature; it is in an accounting rule. Six lines add a counter and subtract it in three places. Finding it required understanding that the refund and the client’s WINDOW_UPDATE can both return the same credit — which is a reasoning problem, not a code-volume problem. Xint attributes four of its five findings to an automated scan.
Can I detect exploitation from logs?
Only weakly. Wiz suggests watching for long-lived HTTP/2 connections that send large amounts of data, which is also what a busy upload looks like. Xint’s section 3.2 suggests comparing $request_length sums per connection against bytes_received from ss: a client whose byte count grows while its logged request lengths do not is sending frames, not requests. Xint also warns these are general indicators, not signatures.
Does the patch have side effects I should test for?
One measured here: after a stream reset, the new send_queued counter in 1.31.9 does not return to zero (8,192 bytes in my run), so the connection window is permanently smaller than the client’s model of it, and a strict client can be disconnected with FLOW_CTRL_ERROR. Test your HTTP/2 clients against 1.31.9 with cancellation-heavy traffic — gRPC deadlines, video seeking, anything that sends RST_STREAM.
Is 1.30.7 equivalent to 1.31.9?
For nine of the ten CVEs, yes: the advisory lists both releases. CVE-2026-120993 (NULL pointer dereference with PROXY protocol v2) says Not vulnerable: 1.31.9+ only, because it was introduced in 1.31.4 and never reached the stable branch.
The pattern worth remembering
A nine-point-something RCE in the world’s most deployed web server was fixed with eight lines across two commits, one of which is a single call that resets a boolean. Nothing about that is unusual for memory-safety work — the same was true of last week’s Java4Shell analysis, where the fix was four lines and the trigger needed a fresh JIT compile.
What is unusual is the size of the gap between the code and the story. Four teams, two blogs, and a coordinated disclosure produced two different first-affected versions for the same CVE, two different severity scales for the same identifier, and two different accounts of who found what. The code, meanwhile, is unambiguous: send_queued exists, ngx_reusable_connection(h2c->connection, 0) is called, and the counter it introduces does not always return to zero.
If you run nginx with HTTP/2, upgrade and restart. Then, before you close the ticket, run the two experiments above against your own build — the 28-byte one takes a second and tells you whether the binary you deployed is the one you think it is.
The instrumentation patch, the frame client, and the full log for both builds are reproducible from the steps in this article; the only local changes are three ngx_log_error calls and a --with-http_v2_module configure line. For a comparison of how a similarly small fix behaved under measurement on a different stack, the Java4Shell audit covers the same method applied to a JIT intrinsic.