Skip to main content
●SecurityNovember 19, 20267 min read

NGINX HTTP/2 Flaws (nginx2root): Check Your Version and Understand the Bug

NGINX 1.30.7 and 1.31.9 fix critical HTTP/2 flaws, one dating back to 2015. How to check your servers, what to patch, and how an unsigned counter wrapped.

ShareXLinkedIn
NGINX HTTP/2 Flaws (nginx2root): Check Your Version and Understand the Bug
Contents · 10 sections
  1. What was disclosed
  2. Are you affected?
  3. How to check your servers
  4. How to fix it
  5. How a counter that "can't" go above a limit did
  6. FAQ
  7. Is a static site really at risk?
  8. My site sits behind a CDN. Do I still need to patch?
  9. Does turning off HTTP/2 break my site?
  10. Is reloading NGINX enough after the upgrade?

Short answer: On 18 November 2026, F5 released NGINX 1.30.7 (stable) and 1.31.9 (mainline) to fix a batch of memory-safety bugs that researchers call "nginx2root". The two most widely exposed, CVE-2026-123007 and CVE-2026-123633, affect servers with HTTP/2 switched on (the second also needs NGINX to be proxying to a backend) and can let an unauthenticated attacker run code on the server. Check which NGINX version every server, container and ingress controller runs, upgrade, and restart. If you can't upgrade today, turning HTTP/2 off blocks those two bugs, but not the rest of the batch.

What was disclosed

NGINX's own security advisories page lists ten issues fixed in mainline 1.31.9; nine of them also apply to the stable branch and are fixed in 1.30.7. According to Sophos's summary of the F5 advisories, F5 rates five of them 8.1 (High) under CVSS 3.1 and 9.2 (Critical) under CVSS 4.0, and proof-of-concept exploit code for CVE-2026-123007 is public.

The Wiz Research write-up says several teams found the two HTTP/2 bugs independently: Wiz, Ikotas Labs, Metnir, Rapid7 and Xint. Wiz showed code execution on an NGINX server that was serving only ordinary static files, with no backend application and no third-party modules. That matters, because many people assume a "plain" static site has nothing to exploit.

There are limits worth knowing. Rapid7's analysis says its proof of concept needs about 128 GB of HTTP/2 traffic: roughly two minutes on a 10 Gbit/s link and seventeen minutes on 1 Gbit/s. Below about 300 Mbit/s the attack runs past NGINX's default one-hour connection lifetime. Code runs with the permissions of the NGINX worker process, and Rapid7 says it has not shown execution as root. Bitsight reports that Xint, which named the batch, chained the NGINX bugs with a separate Linux kernel SCTP flaw to get root on the host, and that no kernel patch was available when it published. None of that is a reason to wait. Public exploit code tends to improve, and the fix is a routine upgrade.

Are you affected?

The bugs need different configurations. This summary follows the NGINX advisories page and the Wiz and Sophos write-ups:

CVE What it is Needs Vulnerable versions
CVE-2026-123007 Memory corruption in HTTP/2 flow control HTTP/2 enabled, including plain static sites 1.9.5 to 1.31.8
CVE-2026-123633 Use-after-free in HTTP/2 HTTP/2, proxying to a backend, worker running low on connections 1.19.7 to 1.31.8
CVE-2026-121810 Use-after-free in HTTP/3 HTTP/3 (QUIC), proxying to a backend 1.25.0 to 1.31.8
CVE-2026-123634 Use-after-free in the resolver proxy_pass built from variables, plus a mirror or SSI subrequest to the same name 0.6.18 to 1.31.8
CVE-2026-113425 Use-after-free in the mail proxy NGINX used as a mail proxy 0.5.33 to 1.31.8

The fixed releases are 1.30.7 and 1.31.9 for all five. Version 1.9.5, where the flow-control bug starts, was the first NGINX release with HTTP/2 support, as Bitsight notes, so any HTTP/2 server from the last decade that hasn't been updated this week is in scope.

Are you affected by nginx2root? Check the NGINX version, then whether HTTP/2 is on; versions 1.30.7 and 1.31.9 are fixed; if you can't upgrade, turn HTTP/2 off temporarily

How to check your servers

1. Find every NGINX. Look beyond the obvious web servers. Reverse proxies, load balancers, Docker images, Kubernetes ingress controllers and products that bundle NGINX, such as OpenResty, all count. Sophos advises starting with internet-facing systems and with instances where NGINX itself accepts HTTP/2 or HTTP/3 from clients.

2. Read the version. On a host, run:

Snippet
nginx -v

It prints a line such as nginx version: nginx/1.30.7. For a container image, run the same command inside it, for example docker run --rm <image> nginx -v.

3. Don't trust the version number alone on Linux distributions. Distributions often backport security fixes without changing the upstream version, so an older-looking number can still be patched. Check your distribution's security tracker for the CVE numbers above.

4. Check whether HTTP/2 is on. Search your configuration for http2:

Snippet
grep -Rn "http2" /etc/nginx/

A listen 443 ssl http2; line or an http2 on; directive means HTTP/2 is enabled for that server block.

5. Check embedded copies separately. The vendor of each product has to ship its own update. One example from Anyscale's bulletin: the Kubernetes community archived the ingress-nginx project, its final controller image bundles NGINX 1.27.1, which is vulnerable, and that project won't release a fix. If you run it, you need a patched fork from your vendor or a different ingress controller.

How to fix it

Upgrade to NGINX 1.30.7 or 1.31.9 (or your distribution's patched package, or the fixed NGINX Plus build), then restart NGINX so the patched binary is actually running. Sophos's advisory puts it plainly: update and restart.

If you can't upgrade straight away, Wiz recommends turning HTTP/2 off as a stopgap. On NGINX 1.25.1 or later, set http2 off; in the affected server blocks and remove the http2 parameter from any listen lines. Test your application, reload NGINX and confirm the old worker processes have exited. Browsers will fall back to HTTP/1.1. Sophos notes that turning off HTTP/2 blocks only CVE-2026-123007 and CVE-2026-123633, and turning off HTTP/3 only CVE-2026-121810. The resolver and mail-proxy bugs still need the upgrade.

Wiz also suggests looking for unexpected NGINX worker crashes or commands started by NGINX processes. Those are general warning signs, not confirmed indicators of these bugs.

If you only visit websites, there's nothing for you to patch. These bugs are in servers, and site owners have to update them.

How a counter that "can't" go above a limit did

The flow-control bug is a good lesson in how unsigned arithmetic fails quietly.

HTTP/2 lets a client limit how much data a server sends before the client is ready for more. That allowance is called a flow-control window, and RFC 9113, the HTTP/2 standard, caps it: "A sender MUST NOT allow a flow-control window to exceed 2^31-1 octets." That's 2,147,483,647 bytes, or 0x7FFFFFFF in hex.

According to Wiz and Rapid7, NGINX keeps the connection's remaining allowance in h2c->send_window, an unsigned 64-bit counter, which can hold values far above the protocol cap. Three steps go wrong:

  1. A refund without a cap check. When NGINX queues response data, it subtracts the size from the counter. If the client cancels that stream before the data is sent, NGINX adds the unused amount back. That refund doesn't check the 2^31−1 maximum, so if the client has already raised the window in the meantime, the counter ends up above the limit.
  2. A bounds check that wraps. When the client later asks for a bigger window, NGINX checks if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window). With the counter already above the maximum, that subtraction would be negative, but unsigned integers can't be negative. The result wraps around to a huge positive number, and the check passes.
  3. A cast that turns huge into negative. The oversized value later becomes a signed 64-bit length (off_t) in the send path. In two's complement, a value with the top bit set reads as negative, and a negative length ends up driving an out-of-bounds memory copy.
How the NGINX HTTP/2 window counter wrapped: a refund pushes the counter past 2^31−1, an unsigned subtraction wraps to 0xFFFFFFFFFFFFFC18, and reading those bits as signed gives −1000

Here's the arithmetic with illustrative numbers (not the exploit's real values). Say a refund leaves the counter 1,000 bytes over the cap, at 2,147,484,647. The check computes 2,147,483,647 − 2,147,484,647. In ordinary maths that's −1,000. In 64-bit unsigned arithmetic it wraps to 18,446,744,073,709,550,616, which is 0xFFFFFFFFFFFFFC18, so no window increase looks too big. Read those same 64 bits as a signed number and you get −1,000 again. The bits never changed; only the type used to read them did.

The defensive patterns are old but easy to forget: enforce a protocol limit at every place that writes the counter, not just where the client changes it; compare before you subtract (if (send_window > MAX || window > MAX - send_window)); and treat any cast from unsigned to signed as a place to check the range.

If you want to see these numbers for yourself, BitLens, our free Chrome extension, converts between decimal, hexadecimal, binary and octal as you type and includes two's complement calculations, so you can paste 0x7FFFFFFF or a value from a crash log and look at its bits. The conversions run locally in your browser. For the background, see our guides to two's complement and negative numbers in binary and binary, hex and octal.

FAQ

Is a static site really at risk?

Yes, if NGINX serves it over HTTP/2 and hasn't been updated. Wiz demonstrated code execution on a server that served only static files, with no backend and no third-party modules.

My site sits behind a CDN. Do I still need to patch?

Yes. A CDN in front of your site doesn't patch the NGINX behind it, your origin server may still be reachable directly, and Sophos is clear that updating NGINX is the only fix for these vulnerabilities.

Does turning off HTTP/2 break my site?

Usually not. Browsers fall back to HTTP/1.1, which can be a little slower on pages with many files. Treat it as temporary and turn HTTP/2 back on after you upgrade.

Is reloading NGINX enough after the upgrade?

Restart it. A reload only re-reads the configuration: the new workers come from the master process that is already running, so they still run the old binary. After restarting, check that the NGINX master process started after the upgrade, for example with ps -o lstart,cmd -C nginx.

For a browser-side reminder of the same habit, our post on checking your extension versions after the uBlock Origin fix walks through it for extensions.

Filed undernginxhttp/2nginx2rootcve-2026-123007web server securityinteger underflowtwo's complementbitlens

ShareXLinkedIn

● Related entries

  1. 01

    Signal Is Blocking Screenshots to Keep AI Agents Out of Your Chats

    Signal is blocking screenshots and on-device AI assistants from reading your chats. What it covers on iPhone, Android, Windows and Mac, and what to do if you need a screenshot.

    SecurityNovember 22, 2026
  2. 02

    Ghostscript Upload2Shell Flaw (CVE-2026-125396): How to Check Your Server

    A Ghostscript flaw lets a fake JPG or PDF run commands on servers that make previews. Who is affected, how to check your version, and what to update now.

    SecurityNovember 22, 2026
  3. 03

    Fake Claude Downloads on claude.ai: How to Check an Installer Before You Run It

    Attackers put fake Claude download pages on claude.ai itself. Why a real domain isn't proof, and five checks to run before you install any app.

    SecurityNovember 21, 2026

Enjoyed this?
Get the next one by email.

Release notes and essays, a few times a month at most. Or follow along with the RSS feed.