Critical NGINX HTTP/2 Integer Underflow Vulnerability (CVE-2026-123007) Allows Remote Code Execution
A critical integer underflow vulnerability in NGINX's HTTP/2 implementation, tracked as CVE-2026-123007, has been disclosed, potentially allowing unauthenticated remote code execution.

Security researchers from Rapid7 and F5 have jointly disclosed CVE-2026-123007, a critical vulnerability affecting the HTTP/2 implementation in NGINX. This flaw, categorized under CWE-191 (Integer Underflow), carries a CVSSv4 score of 9.2, indicating a critical severity that could lead to unauthenticated remote code execution (RCE) under specific conditions.
The vulnerability arises from NGINX's miscalculation of the amount of response data an HTTP/2 client is permitted to receive. A remote, unauthenticated attacker can exploit this by manipulating flow-control credits. By cancelling queued response data and then triggering NGINX to use an invalid length when copying subsequent response data, the attacker can induce memory corruption. This corruption can result in data disclosure, service interruption, and, critically, the execution of code with the privileges of the NGINX worker process.
Rapid7 has developed a proof-of-concept (PoC) demonstrating RCE against NGINX version 1.31.8 running within a Docker container. The PoC requires approximately 128 GB of HTTP/2 data to be transmitted, making exploitation challenging over limited bandwidth connections. Practical exploitation is constrained by available network bandwidth and connection timeouts. For instance, on a 10 Gbit/s network, the data transmission takes about two minutes, while on a 1 Gbit/s network, it extends to seventeen minutes. NGINX's default one-hour connection lifetime means networks slower than approximately 300 Mbit/s would prevent successful exploitation. Additionally, if NGINX is used behind a proxy, the precise HTTP/2 frames required for exploitation might not be retransmitted correctly.
The specific RCE exploitation strategy demonstrated by Rapid7 relies on a particular x86-64 glibc memcpy implementation that is selected at runtime based on CPU features like AVX512F and AVX512VL. While alternative exploitation methods might exist, none are currently known. The vulnerability was discovered by Stephen Fewer, a Senior Principal Security Researcher at Rapid7.
Technically, the vulnerability lies in how NGINX manages HTTP/2 flow-control credits. NGINX uses separate counters for connection-level and stream-level credits. The connection-level credit, stored as an unsigned size_t, can exceed the HTTP/2 protocol limit of 2^31-1 bytes (MAX). The stream-level credit, however, is stored as a signed ssize_t, allowing it to become negative temporarily. The vulnerability is triggered when the output filter attempts to treat an excessive connection credit as a signed 64-bit off_t length, leading to memory corruption.
Exploitation involves several stages: the client slows its reading of server output to keep DATA frames queued, increases the connection credit to MAX and stream credits just below MAX, and then uses a SETTINGS frame to increase SETTINGS_INITIAL_WINDOW_SIZE. This latter action can cause NGINX to close streams while leaving the connection usable, and request cleanup then restores the reserved credit above MAX, setting the stage for memory corruption.
NGINX has released fixes for this vulnerability. Users are strongly advised to update to patched versions of NGINX to mitigate the risk of RCE. The disclosure highlights the ongoing security challenges associated with complex network protocols like HTTP/2 and the importance of rigorous memory safety checks in high-performance web server software.