Two Critical NGINX HTTP/2 RCEs: When Your Front Door Becomes the Breach
CVE-2026-123633 and CVE-2026-123007 let unauthenticated attackers execute code on NGINX with HTTP/2 enabled — including servers that only serve static files. Here is how the bugs work and how to close them.
Two memory-safety flaws in NGINX allow an unauthenticated attacker to run code on the server that terminates your TLS and routes traffic to everything behind it. Both are rated Critical at CVSS 4.0 9.2, both require HTTP/2, and one of them has been sitting in the codebase since 2015. If NGINX is the front door to your production estate, this is the week to read your configs.
What was disclosed
On 18 November 2026, F5 shipped a coordinated security release for two critical remote code execution vulnerabilities in NGINX, tracked as CVE-2026-123633 and CVE-2026-123007. The findings were reported independently by Wiz Research alongside Ikotas Labs, Metnir, Rapid7 and Xint — a convergence of separate teams landing on the same bugs, which is itself a signal worth paying attention to.
The flaws live in NGINX itself, not in the applications it fronts. That distinction matters enormously. NGINX is commonly deployed as a reverse proxy: it accepts the incoming request, decides where it should go based on configuration, forwards it to an application server, and returns the response. When the proxy is compromised, the security posture of the code behind it is irrelevant. A perfectly hardened application can be exposed by a bug in the thing standing in front of it.
NGINX powers more than 225 million websites and is the default front door for a huge share of modern web architectures. A single deployment frequently serves several applications, which means one vulnerable instance can put multiple services at risk simultaneously.
| Tracking ID | The bug | Attacker outcome |
|---|---|---|
| CVE-2026-123633 | HTTP/2 connection use-after-free | Unauthenticated code execution |
| CVE-2026-123007 | HTTP/2 send_window integer underflow | Unauthenticated code execution |
How the two bugs work
Both vulnerabilities are memory-safety issues in NGINX's HTTP/2 handling, and both share the same prerequisite: HTTP/2 must be enabled on the affected server. Beyond that, their conditions differ in ways that change who is exposed.
CVE-2026-123633: use-after-free on connection teardown
In the use-after-free flaw, a connection's memory is freed while a request still holds a reference to it. The dangling pointer then gets used, and an attacker who can shape the heap around that window can turn the corruption into control of execution. This one affects reverse-proxy processing when available connection slots run low — a state that is entirely normal under load, and one an attacker can deliberately induce by exhausting the connection pool.
Wiz reported this to F5 on 21 October 2026 with a confirmed remote code execution chain including an ASLR bypass, plus a proposed fix. F5 confirmed the same vulnerability had already been reported by another research team. A patch was supplied for review on 10 November.
CVE-2026-123007: integer underflow in flow control
The second flaw is an integer underflow in HTTP/2 flow-control accounting. HTTP/2 uses a send_window to track how much data a peer is permitted to receive; incorrect accounting around that counter leads to an invalid memory copy. Wiz reported it on 16 November, F5 confirmed the match the next day, and it landed in the 18 November release.
This is the more alarming of the two from an exposure standpoint. Wiz demonstrated code execution on NGINX serving ordinary static files over HTTPS on 64-bit systems — no backend application, no third-party modules, nothing but a web server handing out files. If you assumed a static-only NGINX box was not a meaningful target, that assumption no longer holds.
Caution: Typical memory-safety mitigations do not save you here. Because either flaw can be used to obtain memory read access before code execution, ASLR does not reliably prevent exploitation. Do not treat a hardened allocator or PIE build as compensating control.
Why this one is different
The integer underflow dates back to NGINX 1.9.5, released in 2015. That is more than a decade of the flaw sitting quietly in code that terminates TLS for a substantial fraction of the internet. The use-after-free had been present for nearly six years. Neither was found by the armies of human reviewers who have read that codebase.
They were found by AI. Wiz used its Atlas harness, the system behind its AI code scanning product, to discover both vulnerabilities, and validated impact with large language models. This is the third data point in a pattern: the PHP2Shell vulnerabilities reported the previous month, Java4Shell disclosed the day before, and now NGINX. Multiple independent teams converging on the same long-dormant memory-safety bugs is not coincidence — it is a change in the economics of vulnerability discovery.
For years, the practical barrier to finding these bugs was complexity itself: tracing subtle interactions between memory operations across multiple code paths required rare skill and enormous time. That barrier is dissolving. Attackers get the same leverage, and the window between disclosure and exploitation compresses accordingly. Complexity is no longer a defence.
From a penetration-testing perspective, this shifts the calculus in a subtle way. Historically, an assessment of a web estate would focus effort on application logic, authentication, and injection — the places where custom code goes wrong. When the shared infrastructure underneath is itself vulnerable to pre-auth RCE, the highest-value finding on the engagement may be a version string in a response header, not a flaw in anyone's business logic.
Who is actually exposed
Exposure comes down to two questions: is HTTP/2 enabled, and which NGINX build is running? The second question is harder than it sounds, because NGINX ships in many forms — distribution packages, official repositories, container base images, vendor appliances, and the commercial NGINX Plus line — and patch lag varies wildly between them.
- Reverse proxies with HTTP/2 enabled are exposed to both CVEs, with CVE-2026-123633 reachable under connection-slot pressure.
- Static file servers with HTTP/2 enabled are exposed to CVE-2026-123007, as demonstrated in testing.
- Servers with HTTP/2 disabled are not reachable through either flaw, which is why disabling it is the recommended stopgap.
The uncomfortable part is the inventory problem. Many organisations do not have an accurate answer to "which of our NGINX instances are running HTTP/2?" The protocol is often enabled implicitly by a listen 443 ssl http2; directive added years ago by someone who has since left, or inherited from a base image nobody audits. Finding those instances is the real work, and it is the step that determines whether the patch actually reduces risk.
Note: A single NGINX deployment often fronts several applications. Patching one instance may close the exposure for a dozen services at once — and conversely, one forgotten instance can leave all of them reachable.
Remediation that actually lands
The primary fix is straightforward in principle: update affected NGINX deployments to the latest release, which bundles multiple security fixes including these two. The difficulty is operational, not technical. Turning a published patch into protection in production still requires validating the update against your configuration, coordinating rollout with service owners, and confirming the change reached every instance.
If upgrading cannot happen immediately, temporarily disable HTTP/2. That closes both attack paths at the cost of performance on connections that benefited from multiplexing. It is a legitimate trade for internet-facing proxies while you test the patch.
A practical sequence:
- Inventory every NGINX instance, including container images, sidecars, ingress controllers and vendor appliances.
- Determine which have HTTP/2 enabled, and prioritise those reachable from untrusted networks.
- Patch to the latest release; where that is impossible, disable HTTP/2 on the
listendirectives. - Rebuild and redeploy container base images rather than patching running containers in place.
- Verify after rollout — do not assume the change propagated.
Verification is worth doing properly. You can confirm whether a given endpoint negotiates HTTP/2 with a simple protocol check:
curl -sI --http2 https://target.example.com | head -n 1A response beginning with HTTP/2 confirms the protocol is live on that listener. To disable it, remove the http2 parameter from the relevant server blocks:
# Before
listen 443 ssl http2;
# After
listen 443 ssl;Reload rather than restart where you can, and check the error log afterwards for configuration warnings you may have introduced.
Detection is the other half. Because these are memory-corruption bugs, successful exploitation may leave little in the access log that looks obviously malicious — the requests are valid HTTP/2 frames. Focus monitoring on anomalies around connection churn and exhaustion, unexpected worker process crashes, and unusual child process behaviour on proxy hosts. If you have the telemetry, alert on NGINX worker restarts that correlate with spikes in new connections from a single source.
The takeaway for defenders
Two things are true at once here. The immediate one is that a critical, unauthenticated, pre-auth RCE sits in the most widely deployed web server on the internet, and the fix is a version bump that many organisations will take weeks to fully land. The strategic one is that the discovery pipeline has changed permanently. Flaws that survived a decade of human review are now being surfaced in months, by multiple teams at once, and the same capability is available to people who want to exploit them.
The organisations that come out of this cycle intact will be the ones who can answer, quickly and accurately, what is running in their estate, which of it is internet-facing, and how fast they can push a change to it. That capability is worth more than any single patch. The NGINX bugs will be fixed; the next set of decade-old memory-safety flaws is already being found.