Disclosed: November 18, 2026 | Severity: Critical, CVSS 4.0 9.2 (F5) | Fixed in: nginx 1.30.7 (stable), 1.31.9 (mainline), NGINX Plus 37.0.8.1 / 37.3.0.1
Executive Summary
F5 just shipped fixes for a nginx HTTP/2 RCE pair: CVE-2026-123007, an integer underflow in HTTP/2 flow control, and CVE-2026-123633, a use-after-free in HTTP/2 connection handling. Both are unauthenticated, both need HTTP/2 enabled, and both got a CVSS 4.0 score of 9.2. The first one has been in the code since HTTP/2 landed in nginx 1.9.5 back in 2015, and Rapid7 has already published a working proof of concept for it.
I kept both CVEs in one post on purpose. They live in the same module, they are fixed by the same release, and the same stopgap (turning HTTP/2 off) covers both. Splitting them would mean running the same checks twice. Where they differ is who is exposed, so each one gets its own section below.
Objective: find every nginx that is in scope, put a stopgap in place where you cannot patch tonight, then patch and prove the patch is actually running.
Target audience: Linux and web admins, platform and Kubernetes teams running ingress or API gateways, and security engineers who have to answer “are we exposed?” before the morning standup.
| CVE-2026-123007 | CVE-2026-123633 | |
|---|---|---|
| Bug class | Integer underflow in HTTP/2 send window (CWE-191) | Use-after-free on an HTTP/2 connection (nickname: Drainbreak) |
| nginx OSS affected | 1.9.5 through 1.31.8 | 1.19.7 through 1.31.8 |
| In scope when | HTTP/2 is enabled, even serving static files | HTTP/2 to clients + proxy_pass to a backend + worker low on worker_connections |
| NGINX Plus fixed | 37.0.8.1, 37.3.0.1 | 37.0.7.1, 37.2.0.1 |
| Public PoC | Yes (Rapid7) | None public at time of writing |
| Disabling HTTP/2 helps | Yes | Yes |
Prerequisites and Architecture
- Shell access with sudo on each nginx host, or kubectl access to the cluster running an nginx-based ingress.
- Comfort reading
nginx -Toutput and editingserverblocks. - A box outside your network (or at least outside the load balancer) with
opensslandcurlto test what clients actually negotiate. - A maintenance window that allows a full restart of nginx, not just a reload.

| Component | Lab value | Role |
|---|---|---|
| Client / attacker | 198.18.50.10 | Opens a long-lived HTTP/2 over TLS connection |
| Optional front end | CDN, WAF, FortiWeb, load balancer | If it terminates HTTP/2, attacker frames may never reach nginx |
| nginx edge | 198.18.10.20:443 (web01) | listen 443 ssl with HTTP/2 enabled |
| Backend upstream | 10.0.20.15:8080 | Reached by proxy_pass, needed for CVE-2026-123633 |
CVE-2026-123007: the 11-year-old flow-control bug
When a client cancels a stream, nginx refunds the unused send allowance back to the connection window without checking the HTTP/2 maximum. Push that counter past the limit, and the later WINDOW_UPDATE bounds check, done with unsigned math, wraps around and lets the window keep growing. Eventually the oversized value is treated as a negative length on the output path and you get an out-of-bounds memory copy. Wiz walks through the exact functions involved in their write-up.
- Reach: Wiz demonstrated it over HTTPS on 64-bit systems serving static files only, no backend and no third-party modules. If HTTP/2 is on, you are in scope.
- Impact: code execution as the nginx worker. Xint chained it with an unpatched Linux kernel SCTP flaw to get root on the host, including from nginx inside a Docker container (Qualys summary).
- PoC: Rapid7 published a full unauthenticated RCE exploit. Per Rapid7, it needs about 128 GB of HTTP/2 traffic (roughly 2 minutes at 10 Gbit/s, 17 minutes at 1 Gbit/s), x86-64 glibc with AVX-512, and an ASLR bypass.
- Status: no in-the-wild exploitation and not in CISA KEV as of November 18, per Tenable.
CVE-2026-123633: Drainbreak, the reverse-proxy use-after-free
This one needs a specific shape. An HTTP/2 connection waiting on a partial HEADERS frame goes onto nginx’s reusable-connection list, and it is not taken off when the request stream gets created. When the worker runs short of free connection slots, nginx drains reusable connections, picks this one, and on an error path frees memory the in-flight request is still using.
- In scope when: HTTP/2 to clients, requests passed to a backend with
proxy_pass, and a worker running low onworker_connections. A pure static site is not the target here; a reverse proxy, API gateway, or ingress is. - Downstream blast radius: Metnir reproduced it in OpenResty and crashed the shipped binaries of Kong, Apache APISIX, NGINX Gateway Fabric, and community ingress-nginx, all of which enable HTTP/2 by default (CSO Online).
- Exploit time: Metnir’s exploit took about 10 minutes with ASLR on, almost all of it spent defeating ASLR.
- Status: no public PoC and no known exploitation at time of writing.
Step-by-Step: Check, Mitigate, Patch nginx HTTP/2 RCE
Step 1: Inventory the version and the build
Goal: know which hosts run an affected build with the HTTP/2 module compiled in.
Action: run on every nginx host. nginx -v alone is not enough, because distros backport fixes without bumping the version, so check the package changelog too.
nginx -v
nginx -V 2>&1 | grep -o -- '--with-http_v2_module'
# Debian / Ubuntu: count changelog hits for the fixes
apt changelog nginx 2>/dev/null | grep -cE 'CVE-2026-(123007|123633)'
# RHEL / Rocky / Alma
rpm -q --changelog nginx | grep -E 'CVE-2026-(123007|123633)'
Verification: a version in 1.9.5 to 1.30.6 or 1.31.0 to 1.31.8, the module flag printed, and zero changelog hits means the host is unpatched.
Step 2: Confirm HTTP/2 is enabled in the loaded config
Goal: separate “module compiled in” from “actually listening with HTTP/2”.
Action: dump the full running config and grep both syntaxes, the old listen ... http2 parameter and the newer http2 on; directive.
sudo nginx -T 2>&1 | sed 's/#.*//' | grep -nE 'listen[[:space:]].*http2|^[[:space:]]*http2[[:space:]]+on[[:space:]]*;'
# For CVE-2026-123633 scoping: is this box a reverse proxy, and how many slots?
sudo nginx -T 2>&1 | grep -nE 'proxy_pass|worker_connections'
Verification: any match on the first command puts the host in scope for CVE-2026-123007. Matches for both http2 and proxy_pass add CVE-2026-123633.
Step 3: Test what clients actually negotiate
Goal: see the server the way an attacker does. A CDN or load balancer can hide HTTP/2 on the nginx port, so test the nginx port directly too.
openssl s_client -connect <HOST>:443 -servername <HOST> -alpn h2 </dev/null 2>&1 | grep -E 'ALPN protocol:|No ALPN negotiated'
curl -skI --http2 https://<HOST>/ | head -1
Verification: ALPN protocol: h2 and HTTP/2 200 mean HTTP/2 is live. No ALPN negotiated and HTTP/1.1 200 mean it is off.
Step 4: Patch, then restart (not reload)
Goal: run nginx 1.30.7 or 1.31.9 (or NGINX Plus 37.0.8.1 / 37.3.0.1). NGINX Plus R33 to R36 get no fix, so those move to 37.x.
Action: as of disclosure day, distro packages (Ubuntu, Debian, RHEL, Amazon Linux, Alpine) and the official nginx:stable and nginx:mainline Docker images were still pending, per ComputingForGeeks. Until your distro ships, the nginx.org repo is the fastest path. Example on Rocky / RHEL with the nginx.org nginx-stable repo configured:
sudo dnf remove nginx nginx-core
sudo dnf install nginx-1.30.7
sudo nginx -t
sudo systemctl restart nginx
nginx -v
Verification: nginx version: nginx/1.30.7, and no workers left from the old binary:
ps -o pid,lstart,cmd -C nginx
Every worker should show a start time after your restart. Then rebuild container images, Helm charts, golden AMIs, and autoscaling templates so the old build does not come back on the next scale-out.
Step 5: Stopgap if you cannot patch tonight: turn HTTP/2 off
Goal: close both CVEs until the patched build is in. This does nothing for the other three NGINX2Root CVEs (resolver, HTTP/3, mail proxy), so it is a bridge, not a fix.
Action, nginx 1.25.1 and newer: remove http2 from every listen line AND set http2 off; in each server block.
server {
listen 443 ssl; # was: listen 443 ssl http2;
http2 off;
server_name www.example.com;
...
}
# main context: cap how long old workers keep draining HTTP/2 clients
worker_shutdown_timeout 30s;
Action, builds older than 1.25.1 (Ubuntu 24.04, 22.04, Debian 12): only remove http2 from the listen lines. Do not add http2 off;, those versions do not know the directive and nginx -t fails.
sudo nginx -t && sudo systemctl reload nginx
Action, ingress-nginx on Kubernetes: flip the ConfigMap option. The project is no longer maintained, so plan the migration while you are in there.
kubectl -n ingress-nginx patch configmap ingress-nginx-controller --type merge -p '{"data":{"use-http2":"false"}}'
Verification: rerun Step 3 from outside. You want No ALPN negotiated. Browsers fall back to HTTP/1.1 fine, but native gRPC breaks, so warn those app owners first.
Step 6: Where a Fortinet front end fits
Goal: buy time at the perimeter, without pretending it replaces the patch.
Wiz notes that a CDN or WAF terminating HTTP/2 in front of nginx may partly mitigate exploitation, and Rapid7 notes that proxied HTTP/2 connections will likely not relay the attacker’s frames in a way the known exploit needs. A FortiWeb in reverse-proxy mode, or any front end that terminates the client’s HTTP/2 session and opens its own connection to nginx, fits that description. Two cautions:
- Validate it. Run the Step 3 ALPN test against the nginx origin IP from a host that bypasses the front end, and lock the origin down so only the front end can reach port 443.
- Check the FortiGuard Encyclopedia for IPS and virtual patch coverage for these CVE IDs before claiming it in a change ticket. I could not confirm a published signature at the time of writing.
Verification and Validation
| Test | Command | Expected after the fix |
|---|---|---|
| Version | nginx -v | nginx/1.30.7 or nginx/1.31.9 |
| Distro backport | apt changelog nginx | grep -cE ‘CVE-2026-(123007|123633)’ | 2 or more hits |
| Workers on new binary | ps -o pid,lstart,cmd -C nginx | All start times after the restart |
| Stopgap holding | openssl s_client … -alpn h2 | No ALPN negotiated |
| Config valid | sudo nginx -t | syntax is ok / test is successful |
$ nginx -v
nginx version: nginx/1.30.7
$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
Troubleshooting and Gotchas
1. http2 off; is set but ALPN still says h2
ComputingForGeeks found that http2 off; is ignored when any listen line for that address still carries the http2 parameter. One forgotten vhost on the same IP and port keeps HTTP/2 alive for all of them.
sudo nginx -T 2>&1 | grep -nE 'listen[[:space:]].*http2'
Fix: this must return nothing. Strip http2 from every remaining listen line, then nginx -t and reload.
2. Patched package installed, but still vulnerable
A reload keeps the old master process and the old binary in memory, and draining workers can keep serving HTTP/2 for a long time.
ps -o pid,lstart,cmd -C nginx | grep 'shutting down'
Fix: sudo systemctl restart nginx after any package change, and set worker_shutdown_timeout 30s; so stragglers do not hang around for an hour.
3. nginx -v says vulnerable, scanner says patched (or the reverse)
Distros backport security fixes into older version numbers. Ubuntu 22.04 ships 1.18.0, which is below the CVE-2026-123633 range but still inside CVE-2026-123007. Trust the package changelog and the vendor tracker over the version string, and test the origin port directly if a CDN or load balancer sits in front.
Sources
- Wiz Research: Unauthenticated RCE in NGINX, CVE-2026-123633 and CVE-2026-123007
- Rapid7: CVE-2026-123007 Critical NGINX HTTP/2 Integer Underflow Leads to RCE
- Qualys: NGINX2Root, five nginx flaws led by CVE-2026-123007
- Tenable: NGINX2Root FAQ, five critical NGINX vulnerabilities
- CSO Online: AI unearths internet breaker flaws in Nginx web server
- ComputingForGeeks: nginx CVE-2026-123007, check, disable HTTP/2, patch
No fluff. Just the config that works.