NGINX HTTP/2 RCE (CVE-2026-123007): Pre-Auth Code Execution via Flow-Control Underflow

On 18 November 2026, F5 and the NGINX project coordinated the release that fixes CVE-2026-123007, an integer underflow in NGINX's HTTP/2 flow-control accounting that three research teams, Xint.io, Wiz Research and Rapid7, independently demonstrated as unauthenticated remote code execution against stock NGINX builds. The vulnerable code has shipped in every NGINX release with HTTP/2 support since 1.9.5 in September 2015. Rapid7 published a complete working exploit on disclosure day. If you run NGINX with HTTP/2 anywhere internet-facing, this is an upgrade-and-restart event.
To be clear about provenance: IKZERO did not discover this vulnerability. This is our technical read of the coordinated disclosures and our independent verification of the public PoC against the official patch and the pinned NGINX build, written for teams who ship NGINX to production.
The bug in one paragraph
When an HTTP/2 stream is canceled, NGINX refunds its queued-but-unsent response bytes to the connection send window without re-checking the RFC ceiling of 2^31-1. A client can engineer this state with protocol-valid frames: queue two responses under a zeroed connection window, re-open the window, then force NGINX to cancel both streams, and the refund pushes the connection window above the maximum. The WINDOW_UPDATE bounds check then computes the remaining headroom as MAX_WINDOW - send_window in unsigned arithmetic; with the window above the maximum the subtraction underflows to a near-2^64 value, the guard accepts any increment, and the 64-bit counter becomes fully attacker-steerable. Walking it past 2^63 makes NGINX reinterpret the window as a negative signed offset in its output filter, which rebuilds a frame size as a near-2^64 unsigned length and copies response data through an inverted buffer over adjacent heap memory. That is the out-of-bounds write and, with tuning, an out-of-bounds read that discloses memory.
How the exploit reaches code execution
Rapid7's public chain (github.com/sfewer-r7/CVE-2026-123007) runs in five stages: (1) the accounting corruption described above, confirmed by an oracle that proves the server still serves normal responses on the corrupted connection; (2) a 15 GiB carrier plus 8,589,934,593 WINDOW_UPDATE frames that carry the counter past its signed midpoint to a tuned distance of negative 14,392; (3) a bounded wrapping copy that emits 14,393 bytes of adjacent heap, from which the exploit derives the holder allocation, the libc base and the NGINX PIE base with no hardcoded addresses; (4) a forged ngx_http_request_t that turns NGINX's own output path into an arbitrary-read primitive and resolves system() from the live process's ELF metadata; (5) heap reclaim via attacker-sized HPACK values that installs system(command) behind NGINX's own pool-cleanup machinery. The command executes with worker-process privileges. The reference run transfers 119 GiB in about three minutes on a lab network. The full technical breakdown, including our line-by-line audit, is in the Ikzero research blog.
Verification notes
IKZERO pulled the exact image digest Rapid7 validated against (linux/amd64, nginx 1.31.8), confirmed the server binary and libc SHA-256 hashes match the exploit's calibration profiles byte-for-byte, verified the fix commit against the vulnerable source, built the PoC's native helper from source under -Werror, and ran the repository's component suite, and all 36 of 36 tests pass. We also proved the patched 1.31.9 build rejects the exploit's trigger sequence with a flow-control GOAWAY. The full RCE could not be re-executed on our Apple Silicon verification host because the calibrated exploitation path depends on an AVX-512-selected glibc copy routine that Rosetta emulation does not expose; the definitive reproductions remain Rapid7's, Wiz's and Xint's on native x86-64 hardware. Our verification confirmed the environment, the code and the mechanism. The RCE claim itself is demonstrated by the three original teams.
Am I affected?
You are affected if the running NGINX has HTTP/2 enabled and falls in one of these ranges: OSS 1.9.5 to 1.31.8 (CVE-2026-123007) or 1.19.7 to 1.31.8 (CVE-2026-123633), or NGINX Plus R33 and earlier and 37.x pre-point-releases. Version strings lie: Ubuntu 22.04 ships "1.18.0", Debian 12 ships "1.22.1"; distro backports fix the code without changing nginx -v, so compare full package versions against distro advisories. A sibling use-after-free, CVE-2026-123633, needs HTTP/2 plus reverse proxying plus worker-connection exhaustion; the same release also fixes RCE-path bugs in the resolver, HTTP/3 and mail proxy handlers that disabling HTTP/2 does not cover.
What to do
Upgrade to NGINX 1.31.9 (mainline) or 1.30.7 (stable); NGINX Plus customers move to 37.0.8.1/37.3.0.1 or 37.0.7.1/37.2.0.1. Rapid7 notes R34 to R36 have no listed fix. Restart the service rather than reloading: a reload leaves old workers serving existing connections on the vulnerable binary. If you cannot patch, disable HTTP/2 (http2 off; plus removal of any listen ... http2 parameter), verify with openssl s_client -connect HOST:443 -alpn h2, and confirm old worker PIDs exited. Detection guidance: watch for long-lived HTTP/2 connections whose received bytes dwarf their sent bytes (the WINDOW_UPDATE flood), any execve by the NGINX worker UID (audit rule -S execve,execveat -F euid=<worker-uid>), and repeated worker signal-11 exits.
How Ikzero can help
Our penetration testing team can validate exposure across your estate, our DevSecOps practice can drive patch-and-restart rollout with verification, and our SOC service can deploy the flow-asymmetry and worker-exec detections described above.


