On November 18, 2026, two links reached the Hacker News front page within the same hour. The first was a Wiz Research write-up titled "Pre-auth RCE in Nginx HTTP/2 handling." The second was a page called NGINX2Root with a tagline that needs no translation: from nginx visitor to root of the server host. By the time the thread passed three hundred points, one sentence from the Wiz post had become the real story. Wiz Research, Ikotas Labs, Metnir, Rapid7, and Xint had independently uncovered the same vulnerability class. Five teams, one bug, no coordination.
Here is the part that should make every operator uneasy. The fix was already public. It landed in the nginx repository on November 11 as an unassuming commit and shipped the same day in mainline 1.31.9 and stable 1.30.7, a full week before anyone said the letters RCE out loud. On disclosure day, the only new commit on master was a version bump to 1.31.10 at 16:40 UTC. The patch hid in plain sight for seven days, and anyone diffing releases for n-days had a running start.
This is an anatomy of that bug: what HTTP/2 flow control is supposed to enforce, the exact counter nginx forgot to subtract, the four-line patch that closes the hole, and the operational traps that will leave hosts vulnerable long after they believe they are patched.
Two headlines, one bug
The public record pieces together cleanly. Wiz Research published the long-form analysis of a pre-authentication remote code execution flaw in nginx's HTTP/2 request handling. Xint, one of the five credited discoverers, published NGINX2Root, which claims a full chain from an unauthenticated HTTP/2 connection to code execution on the server host, and lists five assigned CVEs: CVE-2026-123007, CVE-2026-123634, CVE-2026-123633, CVE-2026-121810, and CVE-2026-113425.
The nginx side of the story is a single commit, e27f5fa84f, dated November 11 and credited as reported by Xint.io. Its message does not mention RCE at all. It describes a flow-control accounting error that leads to memory corruption and a possible segmentation fault. That gap between the dry commit message and the loud disclosure is normal security practice: fix first, ship the fix in routine releases, then disclose once the patched versions exist.
What is less normal is the collision. Five independent reports of the same bug class in the same week suggests either the bug was more visible than anyone assumed, or the tooling for finding such bugs has gotten dramatically better. The Hacker News thread speculated loudly about AI-assisted vulnerability discovery, but that remains speculation. What is verifiable is the code.
HTTP/2 flow control in sixty seconds
HTTP/1.1 has no flow control worth the name: one request, one response, one connection mostly idle. HTTP/2 multiplexes dozens of streams over a single TCP connection, and that creates an immediate problem. A fast server can bury a slow client. The protocol's answer, from RFC 7540, is credit-based flow control.
Every HTTP/2 connection carries a connection-level flow-control window, and every stream inside it carries a stream-level window. Sending DATA frames spends window. The receiver grants more credit by sending WINDOW_UPDATE frames, each carrying an increment that the sender adds to its available window. The window is a 31-bit unsigned integer, so the protocol ceiling is 2,147,483,647 bytes, one byte short of 2 GiB. A receiver may never grant credit that pushes the sender's window past that ceiling, and a sender that receives such credit is required to treat it as a connection error of type FLOW_CONTROL_ERROR.
nginx enforces the ceiling in its HTTP/2 module with a constant and a check:
#define NGX_HTTP_V2_MAX_WINDOW ((1U << 31) - 1) /* validating an incoming WINDOW_UPDATE increment */ if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) { return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR); } The check reads correctly. The increment is rejected if accepting it would push the connection's send window past the protocol maximum. The bug is that the arithmetic is missing one term.
The accounting hole
When nginx generates a response frame but cannot flush it to the socket immediately, it queues the frame on the connection and decrements the connection send window right away. Those bytes are spent from nginx's perspective, even though the client has not seen them yet. The commit message explains the failure precisely:
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.
Read that as an attack recipe. Open a stream and make nginx queue response frames, which charges the connection window. Then, as the client, send a WINDOW_UPDATE that legitimately raises the connection window, since the queued bytes are not counted as outstanding credit in the validation check. Finally, reset the stream. nginx refunds the unsent payload back into the connection window, and the refund stacks on top of credit the client already granted. Repeat, and the connection send window climbs past the 2 GiB ceiling that the protocol says can never be crossed.
The consequences live in ngx_http_v2_send_chain(), where buffer size control depends on the window being honest. Once it is not, the commit says, the result is broken buffer size control followed by memory corruption and a possible segmentation fault. None of this requires authentication. The attacker needs only a TCP connection, a completed HTTP/2 preface, and the freedom to send WINDOW_UPDATE and RST_STREAM frames, all of which are unauthenticated by design.
A detail worth noting for anyone reading the source: the stream-level send_window is a signed ssize_t, deliberately allowed to go negative, while the connection-level send_window is a size_t. Signedness choices around these counters are exactly where underflow and overflow bugs breed.
The patch is one comparison and one counter
The fix introduces a single new counter on the HTTP/2 connection object and subtracts it in exactly one validation. Frames that are queued still belong to the flow-control window from the client's point of view, so the validation must treat them as spent:
struct ngx_http_v2_connection_s { ... size_t send_window; + size_t send_queued; size_t recv_window; ... }; - if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) { + if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued) { ngx_log_error(NGX_LOG_INFO, h2c->connection->log, 0, "client violated connection flow control: " "received WINDOW_UPDATE frame " - "with window increment %uz not allowed for window %uz", - window, h2c->send_window); + "with window increment %uz not allowed for window %uz", + window, h2c->send_window + h2c->send_queued); return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR); } The counter is maintained at the three places where the lifecycle of a queued frame changes. When a frame is queued in ngx_http_v2_send_chain(), the connection books those bytes as queued. When the frame is finally written out, the queued total drops by the frame length. And when a stream is torn down with frames still pending, the cleanup path subtracts the refunded window from the queued total so the refund cannot be counted twice:
/* frame queued in ngx_http_v2_send_chain() */ h2c->send_window -= frame_size; h2c->send_queued += frame_size; /* frame actually sent, ngx_http_v2_data_frame_handler() */ h2c->send_queued -= frame->length; /* stream terminated with pending frames, ngx_http_v2_filter_cleanup() */ h2c->send_window += window; h2c->send_queued -= window; The whole fix is a struct field plus three accounting lines and one changed comparison. Bugs with this ratio of damage to patch size are the ones that keep security teams employed.
From corrupt memory to a root shell
The nginx commit conservatively stops at memory corruption and a possible segmentation fault. The researchers go further. Wiz characterizes the issue as pre-authentication remote code execution in HTTP/2 handling, and Xint's NGINX2Root page claims the chain runs from an unauthenticated visitor to root on the server host, with the five CVEs listed above covering the individual weaknesses in the chain.
I have not reproduced the exploit, and neither the commit nor the public thread proves the full RCE chain end to end, so treat the escalation claims as the researchers' demonstrated results rather than something this article can independently confirm. What the public record does establish is the corruption primitive, in nginx's own words, plus the fact that five organizations considered it serious enough to coordinate disclosure.
Even the conservative reading is bad. A pre-auth, remotely triggerable segmentation fault in the worker that holds every connection is a denial-of-service condition for anything behind that nginx instance. nginx fronts a large share of the public internet as a web server, reverse proxy, and TLS terminator, so the blast radius is measured in a noticeable fraction of all websites.
The operator playbook
The fixed versions are already out: mainline 1.31.9 and stable 1.30.7, both released on November 11. nginx's numbering makes the branch easy to read: an odd minor version is mainline, an even minor version is stable. Check what you run, then check what your package manager actually gives you:
# installed version nginx -v # which branch line you track: 1.31.x is mainline, 1.30.x is stable # fixed means 1.31.9+ on mainline or 1.30.7+ on stable # after upgrading the package, a reload is NOT enough sudo systemctl restart nginx # confirm the running master started after the package install sudo systemctl show nginx --property=ExecMainStartTimestamp Two traps deserve emphasis. First, the reload trap: nginx -s reload sends HUP to the running master, which re-reads configuration and forks fresh workers from the already-running master image. It does not load the new binary you just installed. Hosts can sit patched on disk and vulnerable in memory for weeks, which is exactly the failure mode one operator in the Hacker News thread warned about. Restart the service, then verify the master's start timestamp.
Second, distribution lag. At the time of disclosure, commenters tracking the Ubuntu and Debian nginx packages reported both were still unpatched, while F5 had published advisory K000164058 for its commercially supported builds. If your distribution has not shipped the fix, the documented stopgap is to disable HTTP/2 until the package lands:
# stopgap: remove the HTTP/2 code path until your distro ships the fix server { listen 443 ssl; # no http2 parameter # on nginx 1.25.1+, also delete any: http2 on; } That costs you multiplexing and header compression, and it takes the vulnerable parser off the wire. For most sites it is a survivable performance regression; a pre-auth memory corruption bug is not.
Why HTTP/2 keeps hurting nginx
The thread reaction was blunt: it seems like it is always HTTP/2 with nginx, except when it is regex. That is sentiment, but the structural reason behind it is real. HTTP/2 turns a connection into a long-lived state machine where a handful of shared counters are mutated by asynchronous events from three directions: client frames arriving, upstream responses being generated, and streams being torn down. Flow control is the worst of these counters because it is both security-critical arithmetic and entirely attacker-influenced. The client chooses when to send WINDOW_UPDATE, when to reset, and how much payload to leave queued.
HTTP/1.1 in nginx rarely produces this class of bug because there is almost no shared per-connection arithmetic to corrupt. That does not make HTTP/2 a mistake; the performance case for multiplexing is real, and the same RFC that defined the 31-bit ceiling also told implementers exactly what to enforce. The lesson is narrower and colder: any place where your code refunds, grants, or otherwise re-credits a resource is a place where the accounting has to be airtight, because the attacker controls the interleaving.
The window to act is measured in days. The fix has been sitting in the public repository since November 11, which means every n-day differ has had a week of head start, and the patched releases predate the disclosure. If you run nginx with HTTP/2 enabled, the order of operations is unglamorous and non-negotiable: install 1.30.7 or 1.31.9 or newer, restart the master process rather than reloading it, verify the running binary actually changed, and only then consider yourself patched.
Originally published on Dispatch.

