On November 18, F5 shipped fixes for two critical NGINX bugs that researchers are calling NGINX2Root: CVE-2026-123007 and CVE-2026-123633, both rated 9.2 under CVSS 4.0, both reachable without authentication, and both in the HTTP/2 code that sits in front of a huge share of the web's Django, Rails, Node and PHP apps.

The first instinct on every team is to SSH in and type nginx -v. I want to argue that this is close to useless as a patch check, and that the scary headline numbers built on version strings are misleading in both directions. Here is why, and the three checks I would run instead. I tested every command below in a lab on Debian 13 against two builds of its nginx package, the vulnerable one and the fixed one, so the output you see is real.

TL;DR

  • Fixed upstream in NGINX 1.30.7 (stable) and 1.31.9 (mainline). Every 1.9.5–1.31.8 release is in range for CVE-2026-123007.
  • Both bugs need HTTP/2 enabled on a listener the attacker can reach. CVE-2026-123633 additionally needs NGINX to be proxying to a backend, which is exactly what sits in front of most app servers.
  • Distro packages backport the fix without changing the version number. On Debian 13, the vulnerable and fixed builds both print nginx/1.26.3.
  • Check the package version or changelog, check what your config actually enables, and probe the port from outside with ALPN using a name you did not configure.
  • If you cannot patch today, http2 off; closes both NGINX2Root bugs, at the cost of HTTP/2 (and native gRPC).

What was disclosed

Wiz Research, Ikotas Labs, Metnir, Rapid7 and Xint found the bugs independently and reported them to F5. The summary, from the official nginx security advisories and Wiz's write-up:

CVE Bug Affected NGINX OSS Extra condition
CVE-2026-123007 Memory corruption in HTTP/2 flow control (send_window underflow) 1.9.5–1.31.8 HTTP/2 enabled; Wiz showed RCE on a server serving only static files
CVE-2026-123633 Use-after-free in HTTP/2 1.19.7–1.31.8 HTTP/2 enabled and NGINX proxying; triggered when free connection slots run low

The same release fixes eight more issues, including use-after-free bugs in HTTP/3 proxying (CVE-2026-121810), the DNS resolver (CVE-2026-123634) and the mail proxy (CVE-2026-113425), plus an infinite loop when reading request bodies over TLS 1.3 (CVE-2026-118899). NGINX Plus users need 37.0.8.1 or 37.3.0.1.

Two details made this more than a routine patch day. Wiz says it built working remote code execution for both bugs and is not publishing the exploits. And Xint, according to BleepingComputer's report, chained the flow-control bug with a separate Linux kernel SCTP flaw to escape an NGINX Docker container and get root on the host. "It's in a container" is not the safety net people assume.

The numbers are misleading in both directions

Xint reported that 98.9% of NGINX hosts that disclose a recognisable version were running a release in the affected range. Censys estimated about 8.8 million services potentially exposed to CVE-2026-123007 as of November 19, based on version and HTTP/2 support. Those figures went straight into headlines.

Security researcher Florian Roth pushed back on X: the flaws need non-default configuration (HTTP/2 has to be switched on in NGINX), and exposure claims based only on version numbers are misleading because they ignore configuration and distro backports. His own sample of a few hundred HTTPS endpoints found roughly two thirds supported HTTP/2.

Both camps are right about something. The headline overstates exposure, because a large share of those "vulnerable versions" are distro builds with the fix backported. But the reassurance can understate it for app teams specifically: the textbook Django or Rails deployment puts NGINX in front as a TLS-terminating reverse proxy, HTTP/2 is one of the first things people enable for performance, and proxying is the extra condition CVE-2026-123633 needs. If that describes your stack, you are in the group the bugs were made for.

So the honest answer to "are we affected?" is not a version number. It is three questions: is the code fixed, is HTTP/2 enabled, and is it reachable.

Check 1: the package, not the binary

Here is the problem with nginx -v in one screen. I downloaded both nginx builds from the Debian 13 archive, the original 1.26.3-3+deb13u7 and the security update 1.26.3-3+deb13u11, extracted them side by side and asked each for its version:

$ ./root_u7/usr/sbin/nginx -v nginx version: nginx/1.26.3 $ ./root_u11/usr/sbin/nginx -v nginx version: nginx/1.26.3 

Identical. 1.26.3 is squarely inside 1.9.5–1.31.8, so a scanner that trusts the banner flags both, and a human who compares against "fixed in 1.30.7" concludes both need an upgrade that the distro will never ship. The difference only shows up in the package metadata:

# Debian / Ubuntu: full package version dpkg-query -W -f='${Version}\n' nginx # Did the security fix land? The Debian changelog names the CVEs. zgrep -c 'CVE-2026-123007' /usr/share/doc/nginx/changelog.Debian.gz zgrep -c 'CVE-2026-123633' /usr/share/doc/nginx/changelog.Debian.gz 

On the two builds, the changelog grep returned 0 0 for deb13u7 and 1 1 for deb13u11, whose changelog reads "Backport security fixes from upstream 1.30.7" followed by one patch per CVE. That is the check I trust.

Fixed package versions published by the distros at the time of writing:

Distro Fixed nginx package
Debian 13 (trixie) 1.26.3-3+deb13u11 (DSA-6642-1)
Debian 12 (bookworm) 1.22.1-9+deb12u11 (DLA-4918-1)
Ubuntu 26.04 LTS 1.28.3-2ubuntu1.13 (USN-9159-1)
Ubuntu 24.04 LTS 1.24.0-2ubuntu7.20
Ubuntu 22.04 LTS 1.18.0-6ubuntu14.23
Ubuntu 20.04 and older Ubuntu Pro (ESM) only

Compare with dpkg --compare-versions "$(dpkg-query -W -f='${Version}' nginx)" ge 1.24.0-2ubuntu7.20 && echo patched (swap in your release's version). On RPM-based systems, rpm -q --changelog nginx | grep CVE-2026-123007 does the same job; check your vendor's tracker, because not every enterprise distro had a fixed build on day one. If you run the nginx.org packages or build from source, you are looking for 1.30.7 or 1.31.9 or later, and here nginx -v is accurate.

Containers deserve their own line. The official Docker image has nginx:1.30.7 and nginx:1.31.9 tags. A floating tag such as nginx:stable only protects you after you pull and rebuild; an image built last month is still last month's NGINX, however patched the host is.

One more trap: after upgrading, restart or reload and confirm the old worker processes have exited. Wiz calls this out explicitly. Workers still serving long-lived connections keep running the old code until they finish.

Check 2: what your config actually enables

The second question is whether HTTP/2, HTTP/3 or proxying are on. nginx -T prints the full merged configuration, including every included file, which is far more reliable than grepping /etc/nginx by hand. I wrote a short script that reads it and reports exposure per listen address:

"""Read `nginx -T` output on stdin and flag addresses exposed to NGINX2Root.""" import re, sys def audit(text): servers, cur, depth, srv_depth = [], None, 0, None for raw in text.splitlines(): line = raw.split("#", 1)[0].strip() if not line: continue if re.match(r"server\s*\{", line) and cur is None: cur = {"listen": [], "names": [], "http2": False, "quic": False, "proxy": False} srv_depth = depth depth += line.count("{") - line.count("}") if cur is None: continue if line.startswith("listen "): cur["listen"].append(line[7:].rstrip(";")) cur["http2"] |= " http2" in line cur["quic"] |= " quic" in line elif re.match(r"http2\s+on\s*;", line): cur["http2"] = True elif line.startswith("server_name "): cur["names"] += line[12:].rstrip(";").split() elif re.search(r"\b(proxy_pass|grpc_pass)\s", line): cur["proxy"] = True if depth <= srv_depth: servers.append(cur) cur = None return servers if __name__ == "__main__": ports = {} for s in audit(sys.stdin.read()): name = s["names"][0] if s["names"] else "_" for l in s["listen"]: p = ports.setdefault(l.split()[0], {"h2": [], "quic": False, "proxy": False, "names": []}) p["names"].append(name) p["proxy"] |= s["proxy"] p["quic"] |= s["quic"] if s["http2"]: p["h2"].append(name) # An attacker picks the SNI name, so one HTTP/2 block makes the whole address reachable over h2. for addr, p in sorted(ports.items()): risks = [] if p["h2"]: risks.append(f"CVE-2026-123007 via SNI {', '.join(p['h2'])}") if p["proxy"]: risks.append("CVE-2026-123633 (proxying on this address)") if p["quic"] and p["proxy"]: risks.append("CVE-2026-121810 (HTTP/3 + proxying)") print(f"{addr:8} servers={','.join(p['names'])}") print(f" {'; '.join(risks) or 'no HTTP/2 or HTTP/3 exposure'}") 

It is deliberately simple. It does not understand if blocks, maps or Lua, and it errs on the side of reporting. Run it as sudo nginx -T 2>/dev/null | python3 h2_audit.py.

My lab config had a Django app with http2 on; and an admin site on the same port 8443 without it, both proxying to an upstream, plus a static-only site on 8444:

8443 servers=app.example.test,admin.example.test CVE-2026-123007 via SNI app.example.test; CVE-2026-123633 (proxying on this address) 8444 servers=static.example.test no HTTP/2 or HTTP/3 exposure 

Why report per address instead of per site? Because of what the next check showed.

Check 3: probe from outside, with a name you didn't configure

Config tells you intent; the wire tells you what an attacker gets. HTTP/2 over TLS is negotiated with ALPN, so you can ask the server directly, no HTTP/2 client library needed:

import socket, ssl, sys def negotiated_alpn(host, port=443, sni=None): ctx = ssl.create_default_context() ctx.check_hostname = False # we only care about the protocol ctx.verify_mode = ssl.CERT_NONE # self-signed staging certs are fine here ctx.set_alpn_protocols(["h2", "http/1.1"]) with socket.create_connection((host, port), timeout=5) as raw: with ctx.wrap_socket(raw, server_hostname=sni or host) as tls: return tls.selected_alpn_protocol() if __name__ == "__main__": host, port = sys.argv[1], int(sys.argv[2]) if len(sys.argv) > 2 else 443 sni = sys.argv[3] if len(sys.argv) > 3 else None proto = negotiated_alpn(host, port, sni) print(f"{host}:{port} -> {proto or 'no ALPN (HTTP/1.1 only)'}") 

Against the lab server, with three different SNI names on the same port:

$ python3 alpn_probe.py 127.0.0.1 8443 app.example.test 127.0.0.1:8443 -> h2 $ python3 alpn_probe.py 127.0.0.1 8443 admin.example.test 127.0.0.1:8443 -> http/1.1 $ python3 alpn_probe.py 127.0.0.1 8443 nobody.example.test 127.0.0.1:8443 -> h2 

The admin site, probed by its own name, looks safe. But a made-up name falls through to the default server (here the first one, the app), and that speaks HTTP/2. An attacker does not have to use your hostnames. If you only probe the names in your inventory, you can miss the one block on a shared IP and port that still offers h2. Probe every address with an unknown name too. The openssl one-liner works as well: openssl s_client -connect host:443 -servername whatever -alpn h2 </dev/null 2>&1 | grep -E 'ALPN protocol|No ALPN'.

If you can't patch today: turn HTTP/2 off everywhere on that address

The mitigation from Wiz and F5 covers both NGINX2Root bugs (not the HTTP/3, resolver or mail ones):

server { listen 443 ssl; # remove "http2" from listen lines on older versions http2 off; # NGINX 1.25.1+, in EVERY server block on this address ... } 

Then sudo nginx -t && sudo nginx -s reload, and probe again. In the lab, after switching the app block to http2 off; and reloading, all three names on 8443 negotiated http/1.1, the audit script reported no exposure on either port, and openssl s_client printed No ALPN negotiated.

The trade-offs are real but usually small for app backends: browsers fall back to HTTP/1.1 transparently, but native gRPC through NGINX stops working, and pages with many small assets may load a little slower. For most Django and Rails sites, a few days on HTTP/1.1 is a far better deal than an unauthenticated RCE window on the one process that sees every request.

Also watch for unexpected NGINX worker crashes or child processes spawned by NGINX. Wiz lists these as general warning signs, not confirmed indicators.

What I'd take from this beyond the patch

The bugs are in NGINX, not in your code, so a perfectly written Django app behind an unpatched proxy is still exposed. Wiz noted that one bug had been in the code since 2015 and the other for nearly six years, and that AI-assisted analysis helped find them. Whether or not you buy the broader "AI is finding old memory bugs faster" argument, the practical consequence is the same: the gap between disclosure and exploitation is shrinking, so the useful skill is answering "are we exposed?" in minutes, accurately, not reading the version banner and guessing.

Keep the package-level check and the ALPN probe in your runbook. They will be just as useful for the next NGINX advisory as for this one.

Where do you land: are you turning HTTP/2 off until every box is patched, or patching in place and accepting a few hours of exposure? And has anyone else been burned by a scanner trusting nginx -v on a backported distro build?