A Flow-Control Refund in NGINX HTTP/2 Becomes a Remote Code Execution Path

"F5 shipped 1.30.7 and 1.31.9 on 18 November 2026 with fixes for two critical HTTP/2 memory-safety flaws in NGINX. The send_window refund behind CVE-2026-123007 explains why a server that on

"Netics card on the NGINX HTTP/2 flow-control flaw and the releases that fix it."
"Netics editorial visual on CVE-2026-123007 and the HTTP/2 release that carries both fixes."

TL;DR

  • NGINX is an open-source web server and reverse proxy that accepts incoming client requests, passes them to the applications behind it, and can also serve files directly and balance load across several servers.
  • F5 published NGINX 1.30.7 and 1.31.9 on 18 November 2026 with fixes for CVE-2026-123007, an integer underflow in HTTP/2 flow control, and CVE-2026-123633, a use-after-free in HTTP/2 proxy processing.
  • Both flaws carry a CVSS 4.0 score of 9.2 and both require HTTP/2 on the affected server; CVE-2026-123007 reaches back to NGINX 1.9.5, released in 2015.
  • The defect is arithmetic: a cancelled stream returns its unsent allowance to the connection window without checking the protocol maximum, and the bounds check that follows subtracts from an unsigned value and wraps.
  • Rapid7 built a working exploit against 1.31.8 that sends approximately 128 GB of HTTP/2 data, which is about two minutes on a 10 Gbit/s link and seventeen minutes on 1 Gbit/s.
  • A server serving ordinary static files is reachable through the TLS path, so the exposure question lands on the web tier itself.
  • The remediation is a package upgrade to 1.30.7 or 1.31.9; where that has to wait, setting http2 off and removing http2 from listen closes the path until the new build runs.
Wiz Research card announcing two critical NGINX HTTP/2 RCE flaws, wiz.io/blog/nginx-http2-rce-vulnerabilities
The card Wiz Research published with its 18 November 2026 analysis of CVE-2026-123633 and CVE-2026-123007. Source: wiz.io/blog/nginx-http2-rce-vulnerabilities, retrieved 19 November 2026.

Wiz Research and Rapid7 disclosed the two HTTP/2 flaws on 18 November 2026 in coordination with F5, the company behind NGINX. The nginx.org advisory list records CVE-2026-123007 as a memory-corruption issue of major severity and CVE-2026-123633 as a use-after-free, with 1.30.7 and 1.31.9 as the not-vulnerable releases. Wiz puts the reach of the software at more than 225 million websites, which is the reason a one-line counter bug deserves a careful read.

What F5 shipped on 18 November 2026

The release covers ten CVEs, and the two HTTP/2 flaws are the top of the table by score. CVE-2026-123007 is described as memory corruption in HTTP/2 flow control, exploitable in default configurations with HTTP/2 enabled, CVSS 9.2, affecting 1.9.5 through 1.31.8. CVE-2026-123633 is a use-after-free in HTTP/2 that needs HTTP/2 acting as a proxy server, CVSS 9.2, affecting 1.19.7 through 1.31.8. The same release also carries a use-after-free in HTTP/3, a use-after-free in the DNS resolver and a NULL pointer dereference under the PROXY protocol, which tells you how much the HTTP stack moved in one maintenance window.

Wiz diagram of NGINX as a reverse proxy in front of app servers, wiz.io/blog/nginx-http2-rce-vulnerabilities
Wiz's diagram of the position NGINX occupies: one process accepting client connections and routing them to application servers or serving content itself. Source: wiz.io/blog/nginx-http2-rce-vulnerabilities, retrieved 19 November 2026.

On the OSS side the fixed releases are 1.30.7 on the stable branch and 1.31.9 on mainline. NGINX Plus customers need 37.0.8.1 or 37.3.0.1 for CVE-2026-123007 and 37.0.7.1 or 37.2.0.1 for CVE-2026-123633.

The refund that pushes a window past its maximum

HTTP/2 lets several requests, called streams, share one TCP connection, and flow control caps how much response data a server may have in flight. NGINX tracks the remaining allowance per connection in a counter named h2c->send_window. When it queues response data it subtracts that data's size from the counter before sending.

Cancel a stream while its data still sits in the queue and ngx_http_v2_filter_cleanup() removes the unsent data and credits the allowance back with h2c->send_window += window. That refund never checks the protocol maximum. If the client raised the allowance with WINDOW_UPDATE records while the data was waiting, the refund pushes the counter above the ceiling, and every later assumption in the HTTP/2 code now rests on a value the protocol says cannot exist.

Everything downstream is ordinary code operating on a corrupted precondition. The window grows because a subtraction was meant to bound it, and the send path converts the counter into a length. This is the class of bug that survives review for a decade: each individual line reads correctly, and the invariant that makes them correct is held somewhere else.

The bounds check that stops bounding

The check lives in ngx_http_v2_state_window_update(), which compares an incoming increase against the room left under the maximum with if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window). With the counter already above the maximum, that subtraction runs on unsigned integers, cannot go negative, and wraps to a very large positive number. The check then reports plenty of room and permits further increases.

Wiz diagram of what a compromised NGINX server exposes behind it, wiz.io/blog/nginx-http2-rce-vulnerabilities
Wiz's illustration of why the web tier matters: one NGINX process often fronts several applications, so a single compromised server exposes everything it routes. Source: wiz.io/blog/nginx-http2-rce-vulnerabilities, retrieved 19 November 2026.

The inflated counter reaches ngx_http_v2_send_chain(), where it is converted to the signed type off_t to compute how much data to send. A large enough value turns negative, that negative length describes a response buffer whose end pointer sits before its start pointer, and the TLS send path in ngx_ssl_send_chain() converts the impossible length into an out-of-bounds copy. Wiz reports memory disclosure, heap corruption and unauthenticated code execution from there, confirmed with an ASLR bypass on official 1.31.7 and 1.31.8 builds.

How much traffic an exploit needs in practice

Rapid7's write-up is the more useful document for anyone deciding how fast to patch, because it publishes the cost of the attack. Its proof of concept against a linux/amd64 container running 1.31.8 sends approximately 128 GB of HTTP/2 data. That is about two minutes on a 10 Gbit/s link, seventeen minutes on 1 Gbit/s, and beyond the reach of anything slower than roughly 300 Mbit/s because NGINX closes a connection after one hour by default.

Netics metric grid: CVSS 4.0 score 9.2, first affected version 1.9.5, 128 GB of traffic in the Rapid7 proof, fixed stable release 1.30.7
Netics visual, 19 November 2026: the four numbers that frame a patching decision, taken from the Wiz advisory tables and Rapid7's exploitation notes.

Two further constraints narrow the practical surface. A proxied HTTP/2 connection is unlikely to relay the attacker's frames intact, and the exploitation strategy Rapid7 built depends on one x86-64 glibc memcpy variant chosen at runtime from the CPU's AVX-512 features. Wiz adds the network-side version of the same point: a CDN or WAF that terminates HTTP/2 may not reflect the exact payload back to the origin.

The flaw remains exploitable in practice. Network proximity substantially reduces the high cost of exploitation over the open internet, a profile that matters most to hosted services, shared proxies and systems near an existing attacker foothold.

Two model-assisted discoveries in one release

Wiz states that its researchers used Wiz Atlas, the harness behind its AI code-scanning product, to find both flaws, and used Gemini 4 Carbon and ChatGPT 5.6 Sol to validate that each one allows code execution. The same post places the finding beside PHP2Shell and Java4Shell, disclosed in the preceding weeks, and draws the conclusion directly: the flaws were already there, and AI helped find them.

Wiz blog page for the NGINX HTTP/2 research with its CVE summary, wiz.io/blog/nginx-http2-rce-vulnerabilities
The Wiz post as published on 18 November 2026, with the executive summary and severity ratings at the top. Source: wiz.io/blog/nginx-http2-rce-vulnerabilities, captured 19 November 2026.

A careful reading limits that conclusion to vulnerability discovery. Five teams arrived at these two bugs independently, which says the barrier was the cost of discovery. That cost has fallen fast. The exploitation cost remains high: 128 GB of traffic, a specific libc path, heap grooming and version-specific offsets require substantial work, and Wiz declined to release its exploits.

The operational consequence sits in the middle. A decade-old memory bug in a web tier that most organisations treat as furniture is now findable by scanning harnesses pointed at source code, which means the queue of patches arriving each month gets longer at the same time as each individual patch gets more urgent.

The patch order for a live server

Start with an inventory that names the version and whether HTTP/2 is enabled on each listener. nginx -V reports the build and the modules compiled in, and a configuration search for http2 in listen directives and http2 on finds the listeners that expose the flaw.

Netics checklist of the four operator steps for the NGINX HTTP/2 fix: upgrade and restart workers, confirm old workers exited, disable HTTP/2 temporarily, re-enable after the upgrade
Netics visual, 19 November 2026: the sequence that takes a live fleet from 1.31.x to a fixed build without leaving workers on the old binary.

Then upgrade to 1.30.7 or 1.31.9 and restart the master process, because a binary upgrade alone leaves the running workers on the old code. Where a distribution package lags, and where an NGINX Plus contract needs its own release, the temporary mitigation is to set http2 off in the affected server blocks on 1.25.1 and later, remove the http2 parameter from listen directives, reload, and confirm that the old workers exited. HTTP/2 comes back after the upgrade, and the mitigation stays until then.

A crash loop is visible long before anyone reads an advisory. Workers restart, 5xx rates climb, established connection counts drop, and a team that already runs infrastructure monitoring with plain-language alerts has the timeline of what happened first; a team that does not starts from an empty log at the worst possible moment.

nginx.org advisory list with CVE-2026-123007 fixed in 1.31.9 and 1.30.7, nginx.org/en/security_advisories.html
The authoritative list of advisories from nginx.org, where CVE-2026-123007 appears with its vulnerable range 1.9.5 to 1.31.8. Source: nginx.org/en/security_advisories.html, captured 19 November 2026.

What the advisory leaves to you

Three questions stay open. The first is which listeners actually carry HTTP/2, since a server block that never negotiated the protocol does not take this path and a scan that flags the package alone overstates the estate. The second is whether anything in front of NGINX terminates HTTP/2, because that changes the reachable set and deserves confirmation from the proxy's own configuration. The third is whether the connection lifetime and rate limits in front of a deployment make a 128 GB transfer feasible, which is a calculation each operator can run with its own numbers.

The patch answers the vulnerability. Those three answers decide how much of the estate was ever at risk, and none of them appears in a CVE record.

Sources

Source: "Unauthenticated Remote Code Execution in NGINX: CVE-2026-123633 and CVE-2026-123007" — wiz.io/blog, 2026-11-18, https://www.wiz.io/blog/nginx-http2-rce-vulnerabilities, with Rapid7's disclosure post at https://www.rapid7.com/blog/post/ve-cve-2026-123007-critical-nginx-http-2-integer-underflow-leads-to-rce-fixed/ and the nginx.org advisory list at https://nginx.org/en/security_advisories.html; all fetched and saved on 2026-11-19 under sources/2026-11-20/nginx-http2-flow-control-memory-corruption-cve-2026-123007/.