Quick Answer: This NGINX HTTP/2 vulnerability pair, CVE-2026-123633 and CVE-2026-123007, allows unauthenticated remote code execution on affected servers and carries a CVSS 4.0 score of 9.2. Upgrade to NGINX 1.30.7 (stable) or 1.31.9 (mainline). If you can't upgrade yet, set
http2 offand remove the http2 parameter from your listen directives.
If your NGINX server accepts HTTPS traffic, it's probably the first thing an attacker touches. On November 18, 2026, F5 published fixes for two critical flaws that five independent research teams found, including Wiz Research. An unauthenticated attacker can run code on the server itself. The bug lives in NGINX, not your application, so clean application code doesn't protect you.
What the NGINX HTTP/2 Flaws Actually Do
Both bugs are memory-safety problems in how NGINX handles HTTP/2 traffic. They're different failures with the same outcome.
CVE-2026-123633 is a use-after-free. A connection's memory is released while a request still needs it. The freed memory gets reused for other data, and the request code keeps following its old pointers. CVE-2026-123007 is an integer underflow in the send_window flow-control counter. Incorrect accounting leads to an invalid memory copy.
Here's the part that surprised me. Address space layout randomization (ASLR) is supposed to make memory corruption hard to exploit. Wiz reports that ASLR doesn't help here, because attackers can use either bug to read memory before they execute code. Don't count on OS-level hardening to save you.
Why a Reverse Proxy Turns One Bug Into Many Outages
NGINX is the world's most widely used open-source web server, and it powers more than 225 million websites. It usually sits in front of your applications as a reverse proxy, accepting requests and forwarding them to the right backend. That makes it a shared entry point.
When one NGINX box serves five applications, a single compromise exposes all five. Wiz's testing of CVE-2026-123007 showed code execution on a server serving ordinary static files, with no backend application and no third-party modules. If you assumed a "static-only" box was low risk, that assumption doesn't hold for this bug.
Who Is Actually Exposed
Both vulnerabilities need HTTP/2 enabled. Beyond that, the conditions differ, and the table below is the fastest way to triage your fleet.
| CVE | Bug | Extra condition | First affected OSS version | Fixed OSS builds |
|---|---|---|---|---|
| CVE-2026-123633 | HTTP/2 connection use-after-free | Reverse-proxy processing when connection slots run low | 1.19.7 | 1.30.7 stable; 1.31.9 mainline |
| CVE-2026-123007 | HTTP/2 send_window integer underflow | Also affects direct serving; demonstrated over HTTPS on 64-bit systems | 1.9.5 (2015) | 1.30.7 stable; 1.31.9 mainline |
Note the timeline in the second row. The integer underflow dates to 2015, so almost any server you've run for a decade is in scope if it ever had HTTP/2 turned on. Check older hosts first.
How the Use-After-Free Gets Triggered
Here's where the exploit chain gets interesting. The bug is a race between connection cleanup and an active request.
Wiz describes the sequence this way:
- The attacker sends part of a HEADERS frame, so NGINX marks the connection as reusable while it waits for the rest.
- When the frame completes, NGINX creates a request stream but never removes the connection from the reusable list.
- Opening an upstream connection can exhaust free connection slots, prompting NGINX to close reusable connections.
- NGINX tries to send a GOAWAY frame first. If frame allocation fails, the error path frees the connection's memory while the request still uses it.
Each step looks harmless on its own, which is why this class of bug survived code review for years. Connection-state bugs like this are easy to miss because no single code path is wrong.
The Fastest Mitigation: Turn Off HTTP/2 First
You have two moves, and their order matters. The first is the fix. The second is the stopgap you use while the fix is rolled out.
Here's a practical sequence for the stopgap:
- Inventory every NGINX instance and note which server blocks or
listendirectives enable HTTP/2. - Set
http2 off;in affected server blocks on NGINX 1.25.1 or later. On older builds, remove thehttp2parameter fromlistendirectives. - Test application compatibility, then reload NGINX and confirm the old worker processes have exited.
- Upgrade to 1.30.7 (stable) or 1.31.9 (mainline), then re-enable HTTP/2.
The trade-off is real. HTTP/2 multiplexing reduces connection overhead for clients that make many requests, so clients may see slower page loads while it's off. That's usually a better outcome than remote code execution on your edge. Still, measure the impact on your busiest services before you flip the switch.
Most people stop after step 2. Don't. A disabled HTTP/2 listener is not a patched server, and you still owe the upgrade.
Detection: Useful Signals, Not Proof
Wiz's guidance on detection is deliberately modest. Investigate unexpected NGINX worker crashes, and investigate commands launched by NGINX processes. These are general warning signs, not confirmed indicators of either vulnerability.
That means a clean log doesn't clear you. If you were running a vulnerable version with HTTP/2 on, treat the host as in scope and review it, even if you see nothing obvious. Check for unusual child processes spawned by workers, unexpected outbound connections, and worker restarts that don't line up with your deploys.
Why AI Changed the Patch Clock
This is the part most advisories skip. Wiz reports that it used its own AI-driven code-scanning harness to find both bugs, and that its researchers used large language models to validate their impact. Wiz also notes that PHP2Shell and Java4Shell share the same pattern: memory-safety flaws that once took serious expertise to find.
The argument is that tracing subtle interactions across code paths used to be a practical barrier, and AI is lowering it. I'd take that claim seriously but not as settled fact. The historical evidence is that these bugs were hiding for a long time, with the integer underflow in place since 2015 and the use-after-free present for nearly six years.
The operational lesson holds regardless of how much AI changes discovery. Shorter gaps between disclosure and exploitation mean your patch pipeline is the bottleneck. Turning a published fix into production protection still takes manual work, from validating builds to coordinating rollouts with service owners. Start that work now, before someone else's proof-of-concept gets public.
Frequently Asked Questions
What is the NGINX HTTP/2 vulnerability?
The NGINX HTTP/2 vulnerability refers to CVE-2026-123633 and CVE-2026-123007, two critical flaws that allow unauthenticated remote code execution on affected NGINX servers with HTTP/2 enabled. Both were rated CVSS 4.0 9.2. The bugs are in NGINX itself, so exposure exists even when the applications behind it are secure.
How do I disable HTTP/2 in NGINX without upgrading?
Set http2 off; in each affected server block on NGINX 1.25.1 or later. On older versions, remove the http2 parameter from listen directives. Then test your applications, reload NGINX, and confirm old workers have exited. Re-enable HTTP/2 only after you've upgraded.
Why doesn't ASLR stop these NGINX attacks?
ASLR randomizes memory locations, which normally makes exploitation harder. Wiz reports that attackers can use either bug to read memory before executing code, so the randomized layout can be discovered first. Treat ASLR as one layer of defense, not a fix for these flaws.
Am I affected if I only serve static files?
Possibly, yes. Wiz demonstrated CVE-2026-123007 on NGINX serving ordinary static files over HTTPS on 64-bit systems, with no backend application or third-party modules. Check whether HTTP/2 is enabled on that server, and if it is, treat it as exposed until you've upgraded.
Pass This to Whoever Owns Your Edge
The single most useful action is to find out which NGINX hosts have HTTP/2 enabled and which version they run. Patch to 1.30.7 stable or 1.31.9 mainline, and use http2 off as a temporary bridge if you can't upgrade today. This NGINX HTTP/2 vulnerability is a reminder that your front door is code too, and it needs the same patch discipline as everything behind it.
This week, run nginx -V on every edge host and record the version and HTTP/2 status. Pass this article to whoever manages your load balancer config, and ask them to confirm the answer before the end of the day.