Yesterday we released a checker for Java4Shell. The same day, nginx disclosed two HTTP/2 RCEs, and they come with the same headache: the version string won’t tell you if you’re exposed, and the public PoC is a full exploit.
nginx 1.31.9 and 1.30.7, released November 18, fix two unauthenticated RCEs in the HTTP/2 code: CVE-2026-123007 (an integer underflow in flow control) and CVE-2026-123633 (a use-after-free in connection reuse). Both score 9.2 under CVSS 4.0. No exploitation in the wild has been reported so far.
If you run 1.9.5 through 1.31.8 with HTTP/2 on, upgrade and restart. A reload keeps the old binary running.
The harder part is knowing which servers that applies to, and confirming the fix landed. So, as with java4shell-check, we built nginx-h2-probe, a free, open-source (MIT) checker that tests how the running code behaves without exploiting it. To run it with an agent, paste this:
Check our environment for CVE-2026-123007 and CVE-2026-123633 using
https://github.com/MazeResearch/nginx-h2-probe. Clone it and follow
AGENTS.md. Only test hosts I confirm are in scope, and ask before
touching anything else. Run the passive check first, then the active
check on HTTP/2 origins, and the local check on any nginx host it has
shell access to. Give me a Markdown report grouped by verdict.
Are you exposed?
You’re exposed to CVE-2026-123007 when all three conditions are true:
- An affected nginx version, anything from 1.9.5 to 1.31.8 except 1.30.7 and later on the stable branch. On distro packages, check the changelog rather than the version number, because distros usually backport the fix and keep the old version.
- HTTP/2 turned on in a server block, with the HTTP/2 module compiled in. Since 1.25.1 this is set per virtual host (
http2 on;), so check every server block: if any hostname on a listener has it on, an attacker can send that hostname and reach the bug. - HTTP/2 that reaches nginx directly, rather than ending at a CDN or load balancer in front of it. A load balancer that passes TCP straight through still counts as direct, and so does any path that skips the CDN to reach the origin.
No backend is needed. Wiz reached it on servers that only serve static files. CVE-2026-123633 adds a fourth condition: nginx reverse-proxies to an upstream (proxy_pass and friends), and the affected range starts at 1.19.7.
The same release fixed three more nginx bugs (resolver with mirror, HTTP/3, mail proxy). Turning HTTP/2 off does nothing for those, and our tool doesn’t check them. Xint also chained the nginx bugs with an unpatched Linux SCTP bug to get host root; that needs a kernel fix of its own.
Why version checks can mislead here
The usual remote check is to read the Server header and compare it to the affected range. For these bugs, that comparison can be wrong in both directions.
Distros often backport fixes without changing the version string. On Ubuntu 22.04, for example, nginx reports nginx/1.18.0 whether or not the fix is installed, so a version-based scanner may flag it either way. Xint found 98.9% of version-identifiable nginx hosts on Shodan inside the affected range. That figure counts banners, so it doesn’t tell you how many of those hosts are exploitable. Banner checks are likely least reliable in the first days after disclosure, while distro fixes are still rolling out and you’re deciding what to patch first.
Banners can also miss things. server_tokens off hides the version entirely, and forks and appliances (OpenResty, Kong, Tengine, Angie, ingress-nginx) report their own version strings. Since HTTP/2 can be enabled per virtual host, a scan by IP may only reach the default server.
The public PoC isn’t a substitute. Rapid7’s is a working exploit that moves around 128 GB of traffic, and we wouldn’t point it at production.
How the check works
The fix tells you what to test. For CVE-2026-123007 it changed one bounds check in ngx_http_v2_state_window_update():
- if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window)
+ if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window - h2c->send_queued)
Fixed nginx counts DATA that’s queued but not yet sent when it enforces HTTP/2’s 2^31−1 window limit. Vulnerable nginx ignores it. That difference shows up on the wire, so we stage a situation where the two must disagree:
- Ask for one of nginx’s built-in error pages and measure its size. The tool tries a GET for a random path first, then TRACE, which nginx answers itself even when everything else is proxied to a backend.
- Fill the server’s send buffers with PING replies, so the next response gets queued but can’t go out.
- Request the page again, then send a legal WINDOW_UPDATE sized to land between what each version allows. Fixed nginx rejects it with FLOW_CONTROL_ERROR. Vulnerable nginx accepts it.
- Cancel the stream and send a second update. Vulnerable nginx accepts this only if its connection window has gone past the protocol maximum. That’s the bug’s precondition, reproduced on purpose.
Why it’s safe to point at production:
- The window stays near 2^31. The memory corruption needs it near 2^63, about four billion times higher.
- It only sends standard frames: HEADERS, PING, WINDOW_UPDATE and RST_STREAM.
- A fixed server sees a normal protocol error on one connection, the same as from any misbehaving client.
- Before giving a verdict, it checks that the error page came from nginx itself and not a backend, and that the target rejects an over-limit update on a clean connection the way nginx does. Anything ambiguous comes back INCONCLUSIVE with a note explaining why.
Check it
The tool is plain Python 3.8+ with no dependencies. Clone the repo and run the single file, copy that one file onto a host, or run the Docker image.
Triage
The passive check is instant and sends no test traffic. What it tells you reliably is whether HTTP/2 is negotiated: if it isn’t for that hostname, neither bug is reachable there. It also reports the banner version, but treat that as a hint for the reasons above. The active check gives the verdict.
git clone https://github.com/MazeResearch/nginx-h2-probe
cd nginx-h2-probe
python3 nginx-h2-probe.py check origin.example.com --passive
Verify
The active check usually takes 2 to 8 minutes and 10 to 60 MB of traffic per endpoint. Expect http2 flood detected and flow-control errors in the target’s error log while it runs; that’s the probe. Pass --sni for each virtual host you care about:
python3 nginx-h2-probe.py check 127.0.0.1 --sni shop.example.com
It exits with 1 if the endpoint is vulnerable, 0 if it’s patched or HTTP/2 is off, 2 if it can’t tell, and 3 if it couldn’t connect. For scripts, --json gives you the full result, and it separates “patched” from “HTTP/2 not enabled”.
On the host
python3 nginx-h2-probe.py local checks the running binary’s version, whether the HTTP/2 module is compiled in, which listeners enable HTTP/2 or HTTP/3, and whether the config reverse-proxies (the CVE-2026-123633 condition), then gives a verdict and exit code. On NGINX Plus it won’t judge by version, because Plus builds don’t follow the open-source version numbers; the remote check works there.
At scale
Sweep with --passive or your existing scanner, then run the active check on every host that negotiates HTTP/2, whatever its banner says. For teams without Python on the scanning host, serve wraps the probe in a small HTTP service:
python3 nginx-h2-probe.py serve --listen 10.0.0.5 --token "$TOKEN"
curl "http://10.0.0.5:8080/probe?token=$TOKEN&target=origin.example.com"
With an agent
The prompt at the top has the agent ask what’s in scope, then run the passive, active and local checks where each one applies. It merges the results into one report.
Both targets below report nginx/1.31.8. The second was built from 1.31.8 source with the official fix applied, which is what a distro backport looks like from the outside:
target: 10.0.4.17:443
Server banner : nginx/1.31.8
CVE-2026-123007 behavior : VULNERABLE (flow-control validation matches unfixed 1.9.5-1.31.8 code)
send_window exceeded 2^31-1: YES -- CVE precondition reproduced (bounded, safe)
RESULT: VULNERABLE to CVE-2026-123007 on this endpoint.
target: 10.0.4.18:443
Server banner : nginx/1.31.8
CVE-2026-123007 behavior : PATCHED / RFC-correct (connection terminated with FLOW_CONTROL_ERROR; matches 1.30.7/1.31.9+)
RESULT: NOT VULNERABLE to CVE-2026-123007 on this endpoint
Where checks go wrong
We hit all of these while building the tool.
Reload isn’t enough. Upgrading the package replaces the binary on disk, but nginx -s reload keeps the old master, and workers holding HTTP/2 connections can linger. Restart, then check again.
If a CDN terminates HTTP/2, you’re testing the CDN. Point the probe at the origin from a host that reaches it directly. That usually isn’t your laptop: Docker Desktop and other NAT setups absorb the backpressure the test needs, so you’ll get INCONCLUSIVE. Use a Linux box or docker run --network host.
A 404 isn’t always nginx talking. Behind a catch-all proxy_pass, the error page comes from your app, and an early build of the tool read that as “not vulnerable” on a vulnerable server. It now only trusts nginx’s own built-in pages and falls back to TRACE when it can’t get one.
Version ranges trip people up too. 1.30.7 is fixed but sits inside “1.9.5 to 1.31.8”, because nginx has separate stable and mainline branches. Our first version flagged it.
Fix it, then prove it
Upgrade to nginx 1.30.7 or 1.31.9 and restart. NGINX Plus has its own fixed builds: 37.0.8.1 or 37.3.0.1 for CVE-2026-123007, and 37.0.7.1 or 37.2.0.1 for CVE-2026-123633. On distro packages, go by your distro’s advisory, not nginx -v. OpenResty, Kong, Tengine, Angie and ingress-nginx ship their own fixes, and container images pinned to old digests need rebuilding too.
Then run the active check again. A 0 means the code serving traffic is fixed, so it also catches a wrong binary or old workers that never went away.
If you can’t patch yet, turn HTTP/2 off and restart: http2 off; and drop http2 from listen on 1.25.1 and later, or just drop it from listen on older versions. gRPC will break, and it does nothing for the other three bugs.
Access logs won’t show HTTP/2 control frames, so watch for long-lived HTTP/2 connections pulling in lots of data (Rapid7’s exploit sends about 128 GB), workers dying on signal 11, and processes started by the nginx worker user (an auditd execve rule catches those). If you don’t use SCTP, block it with install sctp /bin/false in /etc/modprobe.d/. Quiet logs still don’t mean you’re safe.
What the tool can and can’t tell you
The tool answers one question: does the code answering HTTP/2 at this address behave like unfixed nginx? A VULNERABLE result means it reproduced the bug’s precondition on that endpoint. We validated it against the official 1.31.8, 1.31.9 and 1.30.7 images, a 1.31.8 source build with the official patch, and a vulnerable 1.31.8 behind a catch-all proxy to a slow backend. One setup can still fool it: nginx proxying to another nginx that serves built-in error pages quickly, with TRACE proxied too. There, use local, or point --path at something the front nginx answers itself.
It doesn’t probe CVE-2026-123633, because triggering it means exhausting the server’s connection slots, which is the attack itself. If an endpoint is vulnerable to 123007 and reverse-proxies, treat 123633 as present too. It also doesn’t cover the three sibling bugs, the SCTP kernel bug, or anything behind an HTTP/2-terminating proxy you don’t control.
It also can’t tell you which of your services take HTTP/2 straight from the internet, or what an nginx worker on them could reach. Maze works on that part: for each finding, we trace whether attacker input reaches the vulnerable code in your environment, then check the conditions on the service that runs it. The tool is MIT-licensed, and issues and PRs are welcome.
References
- nginx-h2-probe (Maze, MIT)
- NGINX HTTP/2 vulnerabilities: CVE-2026-123633 and CVE-2026-123007 (Wiz Research)
- CVE-2026-123007: critical nginx HTTP/2 integer underflow leads to RCE (Rapid7)
- NGINX2Root: remote code execution to host root (Xint) and nginx2root.com
- nginx security advisories and F5 K000163926 / K000163928




