This article was first published on the Rokkhe blog on Hashnode. It was drafted with AI assistance and reviewed and edited by the Rokkhe team; all facts were checked against the linked public sources as of 20 Nov 2026.
What is known about nginx2root (CVE-2026-123007 and four related nginx bugs) as of 20 Nov 2026, from 40+ public sources. By the Rokkhe research team.
On 18 November 2026, nginx.org released nginx 1.31.9 (mainline) and 1.30.7 (stable) with fixes for ten security bugs (nginx news, nginx advisories). Five of them are memory corruption bugs that an unauthenticated attacker can use to crash an nginx worker and, in researchers' tests, run code on the server. Xint, one of the teams that found them, calls the set nginx2root (Xint). The one that matters for most people is CVE-2026-123007, a flaw in HTTP/2 flow control that has been in every nginx release since HTTP/2 support arrived in 1.9.5 in 2015 (Xint, Rapid7).
If you run nginx with HTTP/2 turned on, this post is for you. We read the nginx changelog and fix commits, the researcher write-ups, the F5, distribution and government advisories, the security vendor analyses, the news and the discussion, and put it in one place. Every claim links to where it came from. Where sources disagree, we say so. The short version: find every nginx you run, including the ones inside containers, ingress controllers and appliances, update it, restart it, and turn HTTP/2 off on any listener you cannot patch today.
Credit first. Xint researchers found all five memory bugs: one researcher found CVE-2026-123007 by hand and an automated Xint scan found the other four (Xint, Cloudflare). The two HTTP/2 bugs were also found independently by Wiz Research, Rapid7 (Stephen Fewer), Ikotas Labs, Metnir and Palo Alto Networks Unit 42 (Wiz, Rapid7, Cloudflare). The other five fixes in the release credit Marc Luchian and Liviu-Alexandru Bud, CERT.PL, ruokeqx, Vivek Parikh of BreachX Zero Day Labs and Maxim Dounin (nginx CHANGES). Thanks also to the nginx and F5 teams for shipping fixes for all of it in one release.
Each bug is a separate way in. They do not need to be chained, and each one needs a different feature turned on (Xint, Cloudflare).
| CVE | What it is | What has to be turned on | Affected open source versions |
|---|---|---|---|
| CVE-2026-123007 | HTTP/2 flow-control memory corruption | HTTP/2 on a listener. Works even when nginx only serves static files | 1.9.5 to 1.31.8 |
| CVE-2026-123633 | HTTP/2 use-after-free | HTTP/2, proxying to a backend, and a worker running low on worker_connections |
1.19.7 to 1.31.8 |
| CVE-2026-121810 | HTTP/3 use-after-free | HTTP/3 (QUIC), proxying to a backend | 1.25.0 to 1.31.8 |
| CVE-2026-123634 | Resolver use-after-free | resolver , aproxy_pass built from request data, and a subrequest such asmirror or SSI |
0.6.18 to 1.31.8 |
| CVE-2026-113425 | Mail proxy use-after-free | a mail block withproxy on andauth_http . No valid login needed |
0.5.33 to 1.31.8 |
Sources: nginx advisories, CERT-EU, JFrog, Red Hat.
F5 rates all five 9.2 (Critical) under CVSS 4.0 and 8.1 (High) under CVSS 3.1, and says code execution needs ASLR to be off or bypassed (NVD, Censys). Xint reports code execution as the nginx worker for each of the five, including leaking addresses to get past ASLR (Xint, Hadrian).
HTTP/2 lets a client tell the server how much response data it may send before waiting. nginx keeps a running counter of that allowance for each connection, and the protocol caps it at 2^31 minus 1 bytes (Rapid7).
When a client cancels a stream that still has data queued, nginx gives the unsent allowance back to the counter. That refund had no upper-bound check. A client can grant the same amount once with a WINDOW_UPDATE frame and then get it refunded a second time by cancelling, which pushes the counter past the cap (Xint). From there, the check on later WINDOW_UPDATE frames wraps around, the oversized counter turns into a negative length when nginx prepares data to send, and the TLS layer copies memory out of bounds. That can leak memory and corrupt the heap (JFrog, Rapid7).
The fix is small: nginx now tracks data already queued for sending and counts it when it validates a WINDOW_UPDATE, so the counter can no longer pass the cap (commit b89c410, JFrog). Cloudflare built 1.31.8 and 1.31.9 with AddressSanitizer and saw four of the five bugs fault on 1.31.8 and run clean on 1.31.9 (Cloudflare).
Harder than "send one request", easier than you would like.
memcpy. StepSecurity reports that the exploit's instructions say earlier tests failed on servers already handling heavy traffic, and notes the bug itself does not need AVX-512: it crashed a worker on a CPU without it (
Xint also found a use-after-free in the Linux kernel's SCTP code, present since Linux 4.15 (2018). Code already running as the nginx worker can use it to become root on the host, and Xint did this from nginx inside a Docker container (Xint, LWN). Many distributions load the SCTP module automatically the first time a program opens an SCTP socket, so hosts that never use SCTP can still be exposed. In Sysdig's lab, one SCTP socket opened from the worker was enough to load it (Sysdig). As of 18 to 19 Nov there was no CVE and no kernel fix, and Xint is holding back details until there is one (Cloudflare, Sysdig).
Not that anyone has confirmed, as of 20 Nov.
Five teams found the same HTTP/2 bugs independently, several with AI-assisted code analysis (JFrog, Wiz). Plan as if someone who does not publish found them too.
Work through these on every host and container that runs nginx. The nginx commands below were tested on Debian 13 with nginx 1.26.3.
1. Find every nginx. That includes distribution packages, nginx.org packages, official and third-party container images, Kubernetes ingress controllers, OpenResty, NGINX Plus, and appliances that ship nginx inside (Cloudflare, JFrog). OpenResty 1.31.8.1 is built on nginx 1.31.8 and is affected until it ships a new build (OpenResty issue #1165).
pgrep -a nginx
kubectl get pods -A -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{.spec.containers[*].image}{"\n"}{end}' | grep -iE 'nginx|openresty|ingress'
2. Check the version and the full package version.
nginx -v
dpkg-query -W -f='${Package} ${Version}\n' 'nginx*'
rpm -q nginx
apk info -v nginx
docker exec <container> nginx -v
kubectl exec -n <ns> <pod> -- nginx -v
Upstream 1.31.9 and later, or 1.30.7 and later, are fixed. Distributions backport the fix without changing what nginx -v prints, so compare the full package version with the table below (Xint, Cloudflare). For example, Debian 13 still reports nginx/1.26.3 after the fix; the fixed package is 1.26.3-3+deb13u11 (Debian).
3. Check which modules are compiled in.
nginx -V 2>&1 | tr ' ' '\n' | grep -E '^--with-(http_v2_module|http_v3_module|mail|stream)'
No --with-http_v2_module means the HTTP/2 code is not in the binary and CVE-2026-123007 and CVE-2026-123633 do not apply (Xint). On Debian and Ubuntu, mail and stream are often dynamic modules (--with-mail=dynamic), so also check what is loaded:
ls /etc/nginx/modules-enabled/ 2>/dev/null
4. Check the running config for each risky feature. nginx -T prints the full config nginx would load. The sed strips comments.
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE '\bhttp2\s+on\b|\blisten\s[^;]*\bhttp2\b'
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE '\b(proxy|fastcgi|uwsgi|scgi|grpc|memcached)_pass\s'
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE '\bhttp3\s+on\b|\blisten\s[^;]*\bquic\b'
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE '\bresolver\s|\bproxy_pass\s+[^;]*\$|\bmirror\s|\bssi\s+on\b'
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE '^\s*mail\s*\{|\bauth_http\s'
nginx -T reads the config on disk. If someone changed it without re, the running config may differ (Xint).
5. Check whether HTTP/2 is reachable from outside. Run this from a machine outside your network, against the nginx server itself and not only your CDN hostname (Xint):
openssl s_client -connect HOST:443 -servername HOST -alpn h2 </dev/null 2>&1 | grep -E 'ALPN protocol|No ALPN negotiated'
ALPN protocol: h2 means HTTP/2 is reachable. An unpatched build plus that result is the case to fix first.
Status as of 20 Nov 2026. Distribution packages move fast this week, so re-check your vendor's page before you act on this table.
| Platform | Fixed version | Source |
|---|---|---|
| nginx open source | 1.31.9 (mainline), 1.30.7 (stable). Older branches get no fix | nginx advisories ,Censys tracker |
| NGINX Plus | 37.3.0.1 or 37.0.8.1. R34 to R36 have no fixed build, so move to 37.x | Rapid7 ,Cloudflare |
| F5 NGINX Ingress Controller | NVD lists versions before 5.8.0, and before 2026-lts-r11 on the LTS track, as affected. Confirm the fixed build in F5's advisory | NVD |
| F5 NGINX Gateway Fabric | NVD lists 2.x before 2.9.0, and 1.5.0 to 1.6.2, as affected. Confirm the fixed build in F5's advisory | NVD |
| Official Docker images | nginx:1.31.9 ,nginx:1.30.7 and their-alpine ,-trixie ,-slim and-perl variants, pushed 18 to 19 Nov (UTC) |
Docker Hub |
| Ubuntu 26.10 / 26.04 / 24.04 / 22.04 | 1.30.4-7ubuntu1.2 / 1.28.3-2ubuntu1.13 / 1.24.0-2ubuntu7.20 / 1.18.0-6ubuntu14.23. 20.04, 18.04 and 16.04 through Ubuntu Pro | Ubuntu ,USN-9159-1 |
| Debian 13 trixie / 12 bookworm | 1.26.3-3+deb13u11 (DSA-6642-1) / 1.22.1-9+deb12u11 (DLA-4918-1). sid fixed in 1.30.6-4; forky still vulnerable | Debian |
| RHEL | RHEL 9 nginx:1.24 module fixed in RHSA-2026:100746 (20 Nov). Red Hat lists RHEL 8, 9 and 10 as affected, so check each stream | RHSA-2026:100746 ,RHSB-2026-019 |
| Amazon Linux 2023 / Amazon Linux 2 (nginx1 extra) | 1.30.7-1.amzn2023.0.1 (ALAS2023-2026-3494) / 1.30.7-1.amzn2.0.1 (ALAS2NGINX1-2026-018) | ALAS ,ZEST |
| Alpine 3.24 / 3.23 / 3.22 | 1.30.7-r0 / 1.28.3-r8 / 1.28.3-r8 | Alpine secdb |
| Arch | nginx 1.30.7-1, nginx-mainline 1.31.9-1 | Hadrian |
| kubernetes/ingress-nginx (community) | No upstream fix. The project was archived on 24 Mar 2026 | ingress-nginx ,JFrog |
Two gaps worth knowing about:
dnf upgrade --security can skip it (
sudo apt update && sudo apt install --only-upgrade nginx nginx-common nginx-core
sudo dnf upgrade nginx
sudo apk update && sudo apk upgrade nginx
docker pull nginx:1.30.7 # or nginx:1.31.9
Package names vary by distribution and by how nginx was installed, so adjust the list to what step 2 showed.
Then restart, do not just reload. A reload does not replace the running binary (Cloudflare, Xint). Afterwards, confirm that no old workers are left:
sudo systemctl restart nginx
ps -eo pid,lstart,args | grep '[n]ginx'
Every nginx process should show a start time after the upgrade. Then repeat step 2 to confirm the new package version is what is running.
These block the known attack paths. None of them replaces the patch (Xint, CERT-EU).
http2 off; in each affected server block and remove http2 from listen lines. On older versions, change listen 443 ssl http2; to listen 443 ssl;. Check every server block that shares the same address and port. Clients fall back to HTTP/1.1, but native gRPC and anything else that needs HTTP/2 will break (quic listeners, set http3 off;, and replace any Alt-Svc header advertising HTTP/3 with Alt-Svc 'clear' (proxy_pass at a fixed upstream group instead of a name built from the request. Do not rely on mirror_request_body on alone: it stopped Xint's tested exploit, but SSI and other subrequests can still reach the bug (install sctp /bin/false to a file in /etc/modprobe.d/. It does not unload a module that is already loaded ( lsmod | grep sctp), does not help where SCTP is built into the kernel, and breaks workloads that use SCTP, such as telecom signalling and some Kubernetes network plugins (
After a reload, old workers keep serving existing HTTP/2 and mail connections with the old config until they close (nginx: worker process is shutting down in ps). Restart if they linger (Xint).
There are no confirmed indicators of compromise yet, and none of these signals proves an attack on its own (JFrog, CERT-EU).
/bin/sh or anything else. Xint calls this the clearest sign of a successful attack, and suggests an auditd rule on execve for the worker's UID (worker process <pid> exited on signal 11 in the error log, especially on servers that accept HTTP/2 or HTTP/3 and proxy upstream. A use-after-free does not always crash (
sudo grep -Ei 'worker process.*exited|signal 11|segfault' /var/log/nginx/error.log
ss -tinp byte counts with a log format that records $connection and $request_length. client violated connection flow control: received WINDOW_UPDATE frame with window increment ... not allowed for window ... at info level, below nginx's default error level (could not cancel <name> resolving at alert level on unpatched versions, and worker crashes in a mail proxy using auth_http with connections reset during login (
Patching does not undo a past compromise. If an exposed, unpatched server shows any of the signals above, investigate before you close the ticket.
The release also fixes five lower-impact bugs. They are worth the same upgrade (nginx CHANGES, Wiz, NVD):
try_files and alias in certain configurations (0.9.6 to 1.31.8).ssl_preread could read malformed ClientHello messages differently from other TLS stacks, which might bypass restrictions (1.15.2 to 1.31.8).
nginx's advisory list grew from 2 entries in 2025 to 36 so far in 2026 (Cloudflare, Xint). If you pin nginx and patch it twice a year, that schedule no longer fits.
We did not find these bugs. Xint, Wiz, Rapid7 and the other teams did the hard work. What we can do is help you get through the week.
Exposure review. We go through your hosts, container images, ingress controllers and configs with you, and map each nginx to its real package version, its compiled modules and the features each of the five bugs needs.
Testing what you own. For systems you own and authorise us to test, Rokkhe's AI agents check which listeners accept HTTP/2 and HTTP/3 from the internet, whether origins behind a CDN can be reached directly, and whether the fix or the stopgap is live on the running process. We will not run public exploit chains against your production systems.
Watching while you patch. Our SOC can watch for the signals above in your logs while fixed packages roll out.
If you run nginx in production and want a second pair of eyes on your exposure this week, book an evaluation at rokkhe.com. Patching Java this week too? See our write-up on Java4Shell (CVE-2026-114938).
Project sources
Researcher write-ups
Vulnerability records and government advisories
Distributions and images
Security vendor analysis
News and discussion
Rokkhe SAS is based in Strasbourg, France. This post reflects public sources as of 20 Nov 2026 (Asia/Dhaka) and will be updated as vendors ship fixes or exploitation is reported.
Disclosure: this post was drafted with AI assistance and reviewed and edited by the Rokkhe team. Every claim was checked against the linked public sources as of 20 Nov 2026.