CVE-2026-123007: Critical NGINX2Root HTTP/2 Flaw Enables Remote Code Execution

CVE-2026-123007: Critical NGINX2Root HTTP/2 Flaw Enables Remote Code Execution

SOC Prime Team
SOC Prime Team linkedin icon Follow

F5 has released emergency security updates addressing CVE-2026-123007, a critical memory-corruption vulnerability in NGINX that can allow an unauthenticated remote attacker to execute code on vulnerable web servers. Dubbed NGINX2Root, the flaw resides in NGINX’s HTTP/2 flow-control implementation and has been present in the codebase for more than a decade.

The vulnerability carries a CVSS v4 score of 9.2. An attacker who can reach an HTTP/2-enabled NGINX listener can manipulate flow-control state until an invalid response length causes out-of-bounds memory access. Depending on the target environment, exploitation can crash an NGINX worker, disclose memory, corrupt process memory, or enable arbitrary code execution with the privileges of the worker process.

NGINX Open Source releases from 1.9.5 through 1.31.8 are vulnerable. F5 released fixed versions 1.30.7 for the stable branch and 1.31.9 for mainline on November 18, 2026. NGINX Plus is also affected across multiple 37.x and older supported branches.

The flaw is particularly concerning because authentication is not required. Xint researchers demonstrated remote command execution through a reachable HTTP/2 service, while Rapid7 independently developed an unauthenticated RCE exploit against NGINX 1.31.8. However, obtaining root privileges on the underlying operating system requires a separate privilege-escalation vulnerability or another post-exploitation technique.

Organizations can strengthen their defenses against emerging vulnerability exploitation with SOC Prime’s AI-Native Detection Intelligence Platform, enabling security teams to operationalize threat intelligence and accelerate threat hunting and detection engineering across SIEM, EDR, XDR, and Data Lake environments.

Security teams can also use Prime Architect to transform emerging vulnerability intelligence into detection logic, generate hunting queries, refine existing rules, and adapt behavioral detections to their organization’s telemetry.

Contact Sales

Detect CVE-2026-123007 by combining HTTP/2 network telemetry with NGINX worker behavior, crash events, and host-level process activity. Suspicious HTTP/2 traffic followed by worker segmentation faults, abnormal child processes, shell execution, or unexpected outbound connections from NGINX should receive immediate investigation.

CVE-2026-123007 analysis

CVE-2026-123007 affects NGINX deployments using HTTP/2. The vulnerability originates in the way NGINX manages HTTP/2 flow-control windows, which determine how much DATA a server can transmit to a client across individual streams and the overall connection.

HTTP/2 clients can increase available flow-control credit using WINDOW_UPDATE frames. NGINX maintains separate counters for individual streams and the connection itself. The protocol limits these flow-control windows to 2^31-1 bytes, but the vulnerable implementation can be manipulated into exceeding the permitted connection-window threshold.

Rapid7’s analysis describes a multi-stage condition in which an attacker keeps response data queued, manipulates stream and connection credits, and forces selected streams to close. Cleanup of those streams can restore reserved credit to the connection counter, pushing it above the HTTP/2 maximum. A subsequent unsigned subtraction can then underflow, allowing additional WINDOW_UPDATE frames to drive the counter to an invalid value.

Eventually, NGINX interprets the excessive unsigned connection window as a negative signed response length. During buffered output processing, that value can be converted into an extremely large unsigned length passed to memory-copy operations, resulting in out-of-bounds reads and writes in the NGINX worker’s heap.

The immediate result is often a worker segmentation fault. Under favorable memory-layout conditions, however, researchers demonstrated that the corruption can be converted into controlled memory disclosure and modification. This can ultimately provide arbitrary code execution within the NGINX worker process.

F5 notes that code execution is possible when Address Space Layout Randomization (ASLR) is disabled or when an attacker can bypass it. Wiz researchers reported successfully defeating ASLR in laboratory testing, while Xint demonstrated remote exploitation against publicly reachable servers.

Execution initially occurs with the privileges assigned to the NGINX worker, rather than automatically providing root access. Xint separately identified a Linux kernel SCTP vulnerability that could be chained after NGINX compromise to escalate privileges and, in its demonstration, escape a Docker container and obtain root access to the underlying host. That kernel issue is separate from the NGINX vulnerability itself.

The CVE-2026-123007 PoC situation substantially increases the urgency of remediation. Rapid7 publicly released exploit code demonstrating unauthenticated RCE against NGINX 1.31.8 running in a Linux x86-64 Docker environment. Xint published demonstrations but intentionally omitted the final exploitation steps from its research.

The currently public RCE technique is not equally reliable against every vulnerable server. Rapid7’s implementation requires approximately 128 GB of HTTP/2 traffic and depends on a specific x86-64 glibc memory-copy implementation selected on systems exposing AVX-512 features. In Rapid7’s test environment, exploitation took approximately two and a half minutes.

Bandwidth and connection lifetime therefore affect practicality. Rapid7 estimates that transmitting the required traffic takes roughly two minutes over a 10 Gbit/s connection and around 17 minutes over 1 Gbit/s. Slower links can collide with NGINX’s default one-hour connection lifetime, while HTTP/2-terminating proxies may alter the frame sequence enough to prevent the demonstrated exploitation method from succeeding.

These constraints should not be interpreted as making the vulnerability low risk. Multiple research teams independently achieved code execution, and alternative exploitation techniques could emerge now that the vulnerability and its underlying memory-corruption primitive are public.

The flaw dates back to NGINX 1.9.5, released on September 22, 2015, when HTTP/2 support first appeared. As a result, more than ten years of releases contain the vulnerable code. Xint reports discovering the issue on October 11, 2026 and submitting it to F5 through HackerOne on October 16. Coordinated public disclosure and patched NGINX releases followed on November 18.

For CVE-2026-123007 detection, security teams should correlate abnormal HTTP/2 activity with NGINX error logs, service restarts, operating-system crash telemetry, and endpoint behavior. Repeated worker segmentation faults or unexplained NGINX worker exits occurring alongside unusual HTTP/2 connections should be treated as potential exploitation attempts.

Post-exploitation monitoring is equally important. Defenders should investigate any NGINX worker process spawning shells or utilities such as sh, bash, curl, wget, Python interpreters, or other unexpected binaries. New outbound connections, file creation in unusual locations, privilege-escalation activity, or container escape behavior after suspicious HTTP/2 traffic should substantially increase alert severity.

Traditional CVE-2026-123007 IOCs such as fixed malicious domains, hashes, or attacker IP addresses are currently limited because exploitation is protocol-driven and does not require a predefined payload infrastructure. Organizations should prioritize behavioral indicators and HTTP/2 exploitation patterns rather than relying solely on blocklists.

As of November 19, 2026, neither F5 nor the reviewed security researchers have reported confirmed real-world exploitation, and the vulnerability has not been added to CISA’s Known Exploited Vulnerabilities catalog. Nevertheless, the availability of public exploit code significantly increases the likelihood of scanning and exploitation attempts against exposed systems.

Security teams looking for additional details for CVE-2026-123007 should review both F5’s security guidance and their operating-system or NGINX package vendor advisories because downstream distributions may backport fixes without matching upstream NGINX version numbers exactly.

CVE-2026-123007 Mitigation

The primary CVE-2026-123007 mitigation is to upgrade vulnerable NGINX installations immediately. The official NGINX security advisory lists the following Open Source ranges:

ProductVulnerable versionsFixed version
NGINX Open Source mainline1.31.0–1.31.81.31.9
NGINX Open Source stable/older1.9.5–1.30.61.30.7
NGINX Plus37.1.0–37.2.0.137.3.0.1
NGINX Plus7.0.0–37.0.7.137.0.8.1
NGINX PlusR34–R36No fixed build listed in the reviewed advisory

Organizations should prioritize internet-facing NGINX instances, reverse proxies, API gateways, web applications, Kubernetes ingress infrastructure, and other systems where HTTP/2 is exposed to untrusted clients.

Administrators should also confirm whether HTTP/2 is actually enabled rather than relying only on package inventory. NGINX configurations can enable it through a listen directive containing http2 or, on newer releases, with http2 on;. An HTTP/2-capable listener negotiating the h2 ALPN protocol represents the relevant exposure path.

Where an immediate upgrade is impossible, temporarily disabling HTTP/2 blocks the attack path for this vulnerability. Red Hat recommends removing the http2 parameter from affected listen directives and setting http2 off; on NGINX versions that support that directive.

This workaround should be treated only as an interim measure. F5’s November 18 security release addresses multiple additional NGINX vulnerabilities, several of which do not depend on HTTP/2. Disabling HTTP/2 therefore does not replace installation of the updated packages.

Administrators should also consider the operational impact before disabling HTTP/2. Applications that depend on native HTTP/2 functionality, including certain gRPC deployments, can stop functioning correctly when forced back to HTTP/1.1.

After updating, organizations should ensure that the patched executable is actually running. A full service restart may be necessary rather than relying only on a configuration reload, particularly where older worker processes could remain active.

Internet-facing systems that were vulnerable before remediation should be reviewed retrospectively. Security teams should examine NGINX error logs for worker crashes, operating-system logs for segmentation faults, network telemetry for unusually large or long-lived HTTP/2 sessions, and endpoint telemetry for suspicious execution originating from NGINX workers.

Because public exploit code now exists, patching should be treated as an urgent exposure-reduction measure even though confirmed exploitation in real-world attacks has not yet been reported.

FAQ

What is CVE-2026-123007 and how does it work?

CVE-2026-123007 is a critical memory-corruption vulnerability in NGINX’s HTTP/2 flow-control implementation. A remote unauthenticated attacker can manipulate HTTP/2 window accounting until the connection’s flow-control value exceeds its permitted limit. The resulting integer underflow can cause NGINX to calculate an invalid response length, leading to out-of-bounds heap access. Successful exploitation can crash the worker or, under suitable conditions, enable arbitrary code execution.

When was CVE-2026-123007 first discovered?

Xint reports discovering the vulnerability on October 11, 2026 while conducting security research ahead of ZeroDay Cloud 2026. The researchers submitted the issue through HackerOne on October 16, completed patch validation with the NGINX team on November 10, and publicly disclosed the vulnerability alongside F5’s security updates on November 18, 2026.

What is the impact of CVE-2026-123007 on systems?

Successful exploitation can cause denial of service through NGINX worker crashes, disclose or corrupt process memory, or achieve unauthenticated remote code execution with the privileges of the NGINX worker process. Root access is not an inherent result of the flaw, although researchers demonstrated chaining NGINX compromise with a separate Linux kernel vulnerability to obtain root privileges.

Can CVE-2026-123007 still affect me in 2026?

Yes. Any deployment running a vulnerable NGINX version with HTTP/2 enabled can remain exposed until it is updated or HTTP/2 is disabled. The vulnerable code spans Open Source releases from 1.9.5 through 1.31.8, meaning both older installations and servers running recently released NGINX versions may require remediation.

How can I protect myself from CVE-2026-123007?

Upgrade NGINX Open Source to 1.30.7 or 1.31.9, or install the corresponding fixed NGINX Plus release provided by F5. If immediate patching is impossible, temporarily disable HTTP/2 on vulnerable listeners and restrict unnecessary public exposure. After remediation, restart affected NGINX services and review historical telemetry for worker crashes, suspicious HTTP/2 activity, and unexpected process execution originating from NGINX.

Join SOC Prime's Detection as Code platform to improve visibility into threats most relevant to your business. To help you get started and drive immediate value, book a meeting now with SOC Prime experts.

More CVEs Articles