TL;DR
If you run NGINX with HTTP/2 turned on, patch today. On November 18, 2026, F5 shipped fixes for two critical bugs, CVE-2026-123633 and CVE-2026-123007, that let an attacker with no credentials run code on your web server. Both score 9.2 on CVSS 4.0.
- Who is affected: NGINX Open Source from 1.9.5 up to 1.30.6 (stable) and 1.31.8 (mainline), plus NGINX Plus 37.x before the fixed builds, when HTTP/2 is enabled on a listener.
- What fixes it: NGINX Open Source 1.30.7 or 1.31.9, NGINX Plus 37.0.8.1 or 37.3.0.1.
- Can’t patch yet? Turn HTTP/2 off. Both bugs live only in the HTTP/2 code path.
The worst part: one of these bugs is reachable on a server that does nothing but serve static files over HTTPS. No backend, no plugins, no vulnerable application code needed.
Why an NGINX bug is never “just one server”
NGINX is the front door. It terminates TLS, routes requests to the right app, balances load, and often sits in front of a dozen services at once. Wiz estimates it powers more than 225 million websites.
That position is exactly what makes these flaws dangerous. Your application can be perfectly written and still get owned, because the attacker never reaches it. They take over the process that receives the traffic. From there they can read secrets, change what your sites serve, pivot to the backends, or just knock everything offline.
The two bugs, explained
Both are memory-safety bugs in how NGINX handles HTTP/2. Both let an unauthenticated attacker go from a crafted connection to code running in the NGINX worker process. Researchers also showed that each one can leak memory first, so ASLR does not save you.
| CVE-2026-123633 | CVE-2026-123007 | |
|---|---|---|
| Bug class | Use-after-free | Integer underflow → out-of-bounds copy |
| Where | HTTP/2 connection lifecycle | HTTP/2 flow control (send_window) |
| Introduced in | 1.19.7 (about six years ago) | 1.9.5 (2015, the first HTTP/2 release) |
| Typical exposure | NGINX as a reverse proxy, when connection slots run low | Any HTTP/2 over TLS listener, even static files only |
| CVSS 4.0 | 9.2 | 9.2 |
CVE-2026-123633: a busy connection that NGINX thinks is idle
NGINX keeps a list of idle connections it is allowed to close when it needs room for new ones. An HTTP/2 connection with no active requests lands on that list.
The trick is to send a request’s HEADERS frame in two pieces. After the first piece, the connection looks idle and gets marked as reclaimable. When the second piece arrives, NGINX starts processing the request but forgets to take the connection off the list.
Now the request gets proxied upstream. Opening that upstream connection needs a free slot. If slots are scarce, NGINX reclaims an “idle” connection, and it can pick the very one serving this request. Under the right conditions the cleanup frees that connection’s memory, then the request carries on using it. That is a textbook use-after-free, and with careful heap shaping it becomes code execution.
CVE-2026-123007: a refund that breaks the math
HTTP/2 flow control caps how much data a server may send before the client says it is ready for more. NGINX tracks that allowance in a counter.
When a stream is cancelled while some of its data is still queued, NGINX gives the unused allowance back to the counter. It never checks whether that refund pushes the counter past the protocol maximum. If the client raised the allowance in the meantime, it does.
Once the counter is over the limit, a later bounds check subtracts it from the maximum. The result should be negative, but the variable is unsigned, so it wraps to a huge number and the check passes. An attacker keeps feeding WINDOW_UPDATE frames, the oversized value turns negative when converted for the send logic, and the TLS write path ends up copying memory from places it never should. That gives memory disclosure, heap corruption and, eventually, code execution.
Wiz confirmed the full chain on official 1.31.7 and 1.31.8 builds, over HTTP/2 with TLS on 64-bit Linux, against a server serving plain static content.
Am I affected?
You are exposed if two things are true: your NGINX version is in the affected range, and at least one listener accepts HTTP/2. HTTP/2 is off by default in NGINX, so exposure always comes from your own configuration.
| Product | Affected | Fixed (covers both CVEs) |
|---|---|---|
| NGINX Open Source stable | 1.9.5 – 1.30.6 | 1.30.7 |
| NGINX Open Source mainline | 1.31.0 – 1.31.8 | 1.31.9 |
| NGINX Plus 37.0 (LTS) | 37.0.0 – 37.0.7.1 | 37.0.8.1 |
| NGINX Plus 37.1 / 37.2 | 37.1.0 – 37.2.0.1 | 37.3.0.1 |
| NGINX Plus R34 – R36 | Affected | No fix listed |
One trap with NGINX Plus: F5 lists 37.0.7.1 and 37.2.0.1 as fixing CVE-2026-123633 only. Go straight to 37.0.8.1 or 37.3.0.1 to close both.
Another trap with distro packages: Debian, Ubuntu, RHEL and Amazon Linux usually backport security fixes into their own version numbers. A Debian package still reporting 1.22.x can be patched. Check your distribution’s security tracker for these CVE IDs rather than comparing upstream version numbers.
Quick checks
Check the version:
nginx -v
Check whether HTTP/2 is enabled anywhere in the loaded config:
nginx -T 2>/dev/null | grep -nE 'http2'
Any listen ... http2 parameter or http2 on; directive means that listener is in scope.
Across a fleet managed with FleetDM / osquery, this lists every package-managed NGINX and its version:
SELECT name, version, 'deb' AS pkg_type
FROM deb_packages WHERE name LIKE 'nginx%'
UNION ALL
SELECT name, version, 'rpm' AS pkg_type
FROM rpm_packages WHERE name LIKE 'nginx%';
Don’t forget NGINX you didn’t install with a package manager: containers, custom builds, appliances and products that embed NGINX.
What to do now
- Inventory. Find every NGINX instance and note its version and whether HTTP/2 is on.
- Prioritize what’s reachable. Internet-facing listeners first, then internal ones. A CDN or WAF that terminates HTTP/2 in front of NGINX may blunt some of the attack, but that depends on the product, so don’t count on it.
- Patch. Upgrade to 1.30.7 / 1.31.9 (Open Source) or 37.0.8.1 / 37.3.0.1 (Plus), or apply your distro’s security update.
- Restart cleanly. After the upgrade, make sure the old worker processes are gone, not just the master reloaded.
Can’t patch today? Turn HTTP/2 off
Both bugs need HTTP/2, so disabling it removes the attack surface. On NGINX 1.25.1 and later:
server {
listen 443 ssl; # remove "http2" from listen
http2 off;
# ...
}
On older versions, just remove http2 from every listen line. Then run nginx -t, reload, and confirm old workers have exited. Clients fall back to HTTP/1.1 automatically. Turn HTTP/2 back on once you’re patched.
What to watch for
There are no confirmed indicators of compromise yet, but these are worth alerting on:
- NGINX workers crashing or restarting unexpectedly (segfaults in the error log or kernel log).
- Shells or other commands spawned by NGINX worker processes.
- Long-lived HTTP/2 connections pushing large volumes of WINDOW_UPDATE frames or data, a pattern CVE-2026-123007 needs.
The urgency is real. Rapid7 has already published a working exploit for CVE-2026-123007, and history shows mass exploitation tends to start with packaged products that share an identical build and config.
The bigger picture: old bugs, new tools
One of these bugs sat in NGINX for over a decade, the other for about six years. Then five teams (Wiz Research, Ikotas Labs, Metnir, Rapid7 and Xint) found them independently within weeks of each other. Wiz says it used AI tooling both to find the bugs and to validate that they were exploitable.
That pattern matches what we saw with PHP2Shell last month. Memory-safety bugs that depend on subtle interactions across code paths used to be protected by sheer difficulty. That protection is fading, for defenders and attackers alike.
The practical takeaway for ops teams: the gap between disclosure and exploitation is shrinking. The real measure is how fast you can find every instance, patch it or switch off the vulnerable feature, and confirm it’s done.
Credits and sources
The vulnerabilities were discovered and reported to F5 by Wiz Research, Ikotas Labs, Metnir, Rapid7 and Xint. Credit for the research belongs to them; this post summarizes their findings for operators.