Get DeafLetter
A weekly selection of signals, vulnerabilities and guides. Critical alerts remain optional.
You can unsubscribe at any time. Privacy policy.
On November 17, 2026, Rapid7 published its full analysis of CVE-2026-123007, a critical vulnerability in NGINX's HTTP/2 module that enables unauthenticated remote code execution. Researcher Stephen Fewer developed a working proof-of-concept: the exploit requires approximately 128 GB of HTTP/2 traffic, but completes in roughly two minutes on a 10 Gbit/s link. The question is no longer whether it is theoretically possible, but who has the bandwidth to attempt it.
- CVE-2026-123007 is an integer underflow in the NGINX HTTP/2 flow-control counter, rated CVSS 4.0 9.2 (CRITICAL) per the official CVE record.
- Rapid7 demonstrated unauthenticated RCE on nginx 1.31.8 in a Docker linux/amd64 environment, with the exploit dependent on specific glibc
memcpyimplementations using AVX-512 extensions. - The attack requires transferring nearly 128 GB of HTTP/2 data; on 1 Gbit/s links it takes about 17 minutes, on 10 Gbit/s about 2 minutes.
- The
ngx_http_v2_moduleis not compiled by default, but HTTP/2 is enabled in many modern TLS configurations exposed directly to the Internet.
The Mechanism: When Flow Control Becomes a Weapon
The vulnerability lies in the management of the HTTP/2 module's send_window field. According to Rapid7's analysis, this unsigned counter (size_t) can be manipulated to exceed the protocol limit of 2,147,483,647 bytes (231-1) through a coordinated sequence of WINDOW_UPDATE frames, frame cancellation, and SETTINGS_INITIAL_WINDOW_SIZE updates.
Once the unsigned value is reinterpreted as signed (off_t), the resulting negative value generates an invalid buffer size for the subsequent memcpy operation. The resulting memory corruption enables, under the demonstrated conditions, code execution in the context of the nginx worker. The source specifies that the demonstrated exploit relies on a particular memcpy implementation in glibc x86-64 that uses EVEX/YMM instructions, selected at runtime when the CPU features avx512f and avx512vl are present.
This architectural constraint does not make the vulnerability less real, but it does bound its surface: the exploit has been validated on x86-64 with specific software conditions, and no alternative strategies for other platforms are documented.
ASLR as an Obstacle, Not a Barrier
The official CVE record distinguishes two possible outcomes. With ASLR (Address Space Layout Randomization) enabled, the typical exploit crashes the nginx worker. To achieve code execution, ASLR must be disabled or bypassed. This distinction matters for operators: repeated worker crashes may be the first indicator of attempts, but it does not rule out that advanced actors can overcome address randomization.
The protocol reality is that the vulnerability hits the data plane, not the control plane: the attack travels over normal HTTP/2 streams and requires no access to administrative interfaces or internal configurations.
The Speed Paradox: Theoretical Slowness, Practical Speed
The aspect that distinguishes this vulnerability from other RCEs is the required network profile. Approximately 128 GB of HTTP/2 traffic represents an apparently insurmountable barrier for most attackers. However, Rapid7's estimates show how this barrier shrinks drastically with available bandwidth: on 10 Gbit/s the operation takes roughly two minutes, on 1 Gbit/s roughly seventeen.
This profile inverts the usual security paradigm of "obscurity through complexity." Infrastructure with high connectivity — data centers, CDNs, cloud providers, servers colocated in facilities with direct peering — become theoretically more exposed precisely because of, or due to, their transfer capacity. The implicit protection of slowness does not exist where speed is the normal mode of operation.
The source also notes that an HTTP/2 proxy that modifies frames likely prevents the exploit, but this observation is not backed by empirical testing: it cannot be asserted as an absolute protection.
What to Do Now
Operators running NGINX with the HTTP/2 module must verify three concrete elements. First: confirm whether ngx_http_v2_module is compiled and active, checking the output of nginx -V for the --with-http_v2_module flag and http2 directives in virtual server configurations. Second: assess whether the server is directly exposed to the Internet without intermediaries that modify HTTP/2 frames, since network topology influences attack feasibility. Third: verify whether the runtime environment presents the specific conditions that make the demonstrated exploit applicable, particularly x86-64 architecture with CPUs exposing the avx512f and avx512vl features.
The source does not specify which versions have been patched: operators must consult official F5 advisories to identify available patches for NGINX Plus and NGINX Open Source. Patching priority should be higher for systems directly exposed on high-capacity networks, where the risk profile concentrates temporally.
Why It Matters
The severity of CVE-2026-123007 lies not in its ease of exploitation — which is limited and measurable — but in what it reveals about the attack surface of complex binary protocols. HTTP/2 is a protocol many organizations have enabled for performance gains, often without a full assessment of the server-side parsing implementation. The integer underflow in a flow-control counter is a bug class that standard testing may miss: it requires understanding the interactions between multiple protocol states and type conversions in the underlying code.
For organizations running NGINX with HTTP/2, risk assessment must weigh three simultaneous factors: whether the module is compiled and active, whether the server is directly exposed to the Internet without intermediaries that modify HTTP/2 frames, and whether the operational environment presents the specific software and hardware conditions that make the demonstrated exploit applicable. The source does not specify which versions have been patched, nor does it provide an estimate of the real-world attack surface on the Internet.
"Rapid7 has developed a proof-of-concept to demonstrate leveraging CVE-2026-123007 for unauthenticated RCE against a vulnerable linux/amd64 Docker image running nginx version 1.31.8" — Rapid7
The coordinated nature of the disclosure — between Rapid7 and F5, with acknowledgment also to Tomer Schwartz of Wiz Research, Xint.io, and Ikotas Labs — suggests a shared assessment of the problem's gravity. No infrastructure overlaps link the activity to in-the-wild exploits: at present it is not possible to confirm or rule out that the technique has already been employed outside research environments.
For the industry, the case raises a broader question: unsigned counters in flow-control protocols represent an attack surface class that warrants specific attention. The implicit conversion between signed and unsigned types, combined with the assumption that protocol values always remain within declared limits, can generate critical vulnerabilities that standard bounds checks do not catch.
Who Is Actually at Risk
The necessary condition is that NGINX is compiled with --with-http_v2_module and that the http2 directive is active on the listening port. Per the nginx.org reference documentation, the module is not included in the default build: it requires an explicit option at compile time. However, binary distributions and official Docker images may include it, and many modern TLS configurations enable it to serve HTTP/2 over HTTPS connections.
The absence of an estimate for the number of exposed systems in the dossier makes it impossible to quantify the global attack surface. What is documented is that the exploit was demonstrated on a specific version in a controlled environment, with measured network and hardware conditions.
Sources
Get DeafLetter
A weekly selection of signals, vulnerabilities and guides. Critical alerts remain optional.
You can unsubscribe at any time. Privacy policy.