Skip to content

Image: rapid7.com · rights & removal

Executive Summary

A critical integer underflow vulnerability, CVE-2026-123007, exists in nginx affecting HTTP/2 flow-control mechanisms, which can lead to unauthenticated Remote Code Execution (RCE). The vulnerability arises from an error in how nginx handles the calculation and enforcement of HTTP/2 send window credits for both the connection and individual streams. Exploitation requires a specific sequence of actions involving manipulating flow-control frames and WINDOWUPDATE frames to cause an integer underflow, which is then leveraged by unsafe memory copy operations within the application. The exploit chain involves artificially inflating network traffic to reach 64-bit counter boundaries, leading to an invalid length being passed to memory functions, resulting in out-of-bounds reads/writes in worker memory. While large amounts of network traffic are required for a practical exploit against internet services, the mechanism relies on specific compiler and CPU features (x86-64 glibc implementation with AVX512f/avx512vl) to achieve arbitrary code execution by overwriting heap objects or function pointers within the nginx process.

Facts Only

* CVE ID: CVE-2026-123007 affects nginx HTTP/2 flow-control memory corruption permitting worker-context RCE.
* The vulnerability allows unauthenticated Remote Code Execution (RCE) against affected servers under certain conditions.
* Exploitation requires approximately 128 GB of HTTP/2 data transfer.
* The vulnerability targets a Linux/amd64 Docker image running nginx version 1.31.8 with HTTP/2 enabled and TLS enabled.
* The vulnerability exploits how nginx manages HTTP/2 flow-control credit tracked in connection and stream counters, separate from TCP windows.
* Exploitation involves manipulating WINDOWUPDATE frames and SETTINGS frames to induce an integer underflow on the connection counter.
* This underflow leads to the relaxation of constraints, causing an excessive value that is interpreted as a negative response length during memory copying via memcpy operations.
* The exploitation depends on a specific x86-64 glibc EVEX/YMM memcpy implementation based on AVX512f and AVX512vl CPU features.
* The exploit involves queuing DATA frames, sending WINDOWUPDATEs to inflate counters near the 64-bit maximum, and leveraging subsequent memory operations where the resulting invalid length is passed to `memcpy`.
* Remediation includes updating nginx versions to 1.31.9 or higher for Open Source distributions.

Full Take

The existence of this vulnerability highlights a critical mismatch between protocol specification (RFC 9113) and implementation safety, specifically concerning unchecked unsigned arithmetic in context-sensitive memory operations. The core pattern observed is that complexity—tracking multiple concurrent flow states across network frames and operating system memory structures—introduces subtle boundary conditions where standard constraints are violated under specific, high-load sequences. The fact that the exploit requires a highly specific, performance-dependent interaction with low-level CPU instruction sets (like EVEX/YMM) suggests that security boundaries are often enforced by architectural assumptions rather than strict protocol adherence alone. The vulnerability path demonstrates an evolution: control flow manipulation via network signaling leads to integer arithmetic failure, which in turn causes memory corruption when interacting with optimized library implementations. This flow confirms that successful exploitation does not depend on a single flaw but on the convergence of application logic error, protocol state management weakness, and specific compiler/hardware implementation choices. The enormous data requirements noted for practical exploitation suggest that while theoretically possible, real-world abuse remains heavily constrained by physical network limitations and infrastructure architecture, forcing an analysis away from pure theoretical possibility toward system-level resource exhaustion versus functional risk.
Bridge Questions: If the memory copy routines were hardened against negative lengths regardless of the underlying memory layout (as suggested by Addendum A), would this specific sequence of flow control manipulation still be viable, or would a different method for exploiting signed/unsigned integer interactions emerge? What is the systemic cost to security engineering when performance optimizations in low-level libraries create vectors that bypass high-level protocol invariants?

From the original · Rapid7 Blog

Overview Today, both Rapid7 and F5 are disclosing CVE-2026-123007, a critical integer underflow vulnerability affecting nginx HTTP/2, which can allow for unauthenticated remote code execution (RCE) against affected servers under certain conditions.
Read the full story at rapid7.com

Sentinel unavailable

The automated check of the source article's wording did not complete, so no result is shown.

This looks only at the wording of the original source article, not at this page's AI-written sections. A small local AI model made this estimate. It has not been checked against known human and machine texts, so treat it as provisional. It cannot show who wrote an article.

CVE-2026-123007: Critical NGINX HTTP/2 Integer Underflow Leads to RCE (FIXED) | Huntaegis