nginx2root (CVE-2026-123007) explained, and how to fix it today
nginx2root is a set of five nginx bugs disclosed on 18 November 2026. The worst, CVE-2026-123007, lets anyone who can open an HTTP/2 connection to your server run commands on it, without logging in. An unpatched Linux kernel bug then turns that into root. Every nginx from 1.9.5 to 1.31.8 with HTTP/2 turned on is affected. Upgrade to 1.31.9 or 1.30.7. If your distribution has no fixed package yet, turn off HTTP/2 and block the SCTP kernel module today. We did both on a production server in a few minutes.
nginx2rootin short.
- What: an integer overflow in nginx’s HTTP/2 flow control, CVE-2026-123007, gives an unauthenticated attacker code execution as the nginx worker. Four related bugs hit HTTP/2 upstreams, HTTP/3, the resolver and the mail proxy.
- How bad: CVSS 4.0 score 9.2, CVSS 3.1 score 8.1. Chained with a Linux SCTP bug from 2018, the researchers got root on bare metal, on AWS, GCP and Azure, and on the host of an nginx Docker container.
- Who: any server running nginx 1.9.5 to 1.31.8 with HTTP/2 on, which includes many nginx servers that serve HTTPS.
- Fix: nginx 1.31.9 or 1.30.7, then a restart. Ubuntu and Debian have no fixed package yet, so turn off HTTP/2 and block SCTP until they do.
- Status on 18 November: no attacks reported, no public full exploit, a limited proof of concept published and fake exploit repositories circulating.
Want to know what agents are doing on your site? Book a free 30-minute call with Emre →
What nginx2root is:five bugs and a kernel flaw.
Researchers at Xint reported the bugs to F5, which maintains nginx, on 16 October. F5 released fixes on 18 November, the same day as the disclosure. Some coverage calls the set NGINX2Shell. Each bug needs a particular feature to be turned on:
| CVE | Where | Needs | Since | HTTP/2 off blocks it |
|---|---|---|---|---|
| CVE-2026-123007 | HTTP/2 flow control | HTTP/2 on | 1.9.5 | Yes |
| CVE-2026-123633 | HTTP/2 and an upstream | HTTP/2 plus proxy_pass | 1.19.7 | Yes |
| CVE-2026-121810 | HTTP/3 (QUIC) | HTTP/3 plus proxy_pass | 1.25.0 | No |
| CVE-2026-123634 | Resolver and mirror | resolver, mirror, a variable proxy_pass | 1.13.4 | No |
| CVE-2026-113425 | Mail proxy | mail with auth_http | 0.5.15 | No |
The fixed releases fix five more nginx bugs that are not part of nginx2root, among them an infinite loop when reading a request body over TLS 1.3, CVE-2026-118899. See the nginx.org advisories for the full list.
The exposure numbers come from Xint’s Shodan count on 10 November. Most servers hide their version, so the real share is unknown, but nearly every version string seen is in range.
How the HTTP/2 bugworks.
HTTP/2 lets a client say how much data it is ready to receive, its window. nginx tracks the window it may still send. The bug is in how nginx gives that credit back when a stream is cancelled:
- 01The attacker opens one HTTP/2 connectionand sets the initial window size to 0, so nginx queues its reply instead of sending it.
- 02It keeps the pipe fullwith PING frames, so the queued data stays queued.
- 03It gives the same credit back twiceonce with a WINDOW_UPDATE on the connection and once by cancelling the streams with RST_STREAM.
- 04The send window passes its limitof 2³¹−1 bytes, which nginx never checks on that path, and the size check wraps around.
- 05A copy runs with a huge lengthand writes past a buffer. That leaks an address and overwrites a cleanup pointer, so the worker runs the attacker’s command.
No login, no special URL and no unusual configuration are needed: just HTTP/2 on a listener, which is the default in many setups. The bug has been in nginx since 1.9.5 in 2015, the first release with HTTP/2. The code runs with the worker’s rights, usually www-data or nginx, so it can read everything the worker can: TLS keys, configuration with API keys, and every request that passes through.
From the nginx workerto root.
The second half of the name comes from the kernel. Xint found a use-after-free in Linux’s SCTP send path that has been there since kernel 4.15 in 2018. From inside the nginx worker, it gives an attacker a memory leak and a kernel function call: enough to become root. It worked on bare metal, on cloud hosts and from inside a Docker container running nginx, where it gave root on the host.
No kernel patch existed on 18 November. Most servers never use SCTP, so the fix is to stop the module from loading. It does not unload a module that is already loaded, and it does nothing if SCTP is built into your kernel.
Whois vulnerable.
You are exposed if all three are true:
- Your nginx is between 1.9.5 and 1.31.8, or is a distribution package that has not received the fix.
- HTTP/2 is on. Look for
http2on alistenline orhttp2 on;. - An attacker can reach it. A CDN in front does not count if the origin answers on its own IP.
Patch status on 18 November 2026, 18:00 UTC, from the vendors’ trackers:
| Where your nginx comes from | Version | Status |
|---|---|---|
| nginx.org packages | 1.31.9 and 1.30.7 | Fixed |
| Docker official image | nginx:latest, :mainline, :stable, :alpine | Fixed, pull and recreate |
| NGINX Plus | R37 builds 37.3.0.1 and 37.0.8.1 | Fixed; R34 to R36 get no fix |
| Ubuntu 16.04 to 26.10 | 1.24.0 on 24.04, 1.18.0 on 22.04 | Not fixed yet |
| Debian 12, 13, testing | 1.22.1 on 12, 1.26 on 13 | Not fixed yet |
| RHEL 8, 9, 10 | distribution nginx | Under investigation |
| Amazon Linux | AL2, AL2023 | Fix pending |
| ingress-nginx (community) | retired project | No fix coming |
Distributions backport fixes without changing the version number, so an Ubuntu package will still say 1.24.0 after it is fixed. Watch Ubuntu’s and Debian’s trackers for your release. Products that bundle nginx, such as control panels, proxy managers and appliance images, need their own update. nginx-proxy-manager is tracking it in the open.
Cloudflare says its edge was patched before the disclosure. That protects traffic that goes through Cloudflare. It does not protect an origin server that answers on its own IP.
How to checkyour server.
Run these on the server. Replace example.com and ORIGIN_IP with your site and its server’s address:
# 1. Version and package
nginx -v
dpkg -l nginx | grep ^ii # Debian and Ubuntu
rpm -q nginx # RHEL, Rocky, Amazon Linux
# 2. Which of the five bugs your config can reach
nginx -T 2>/dev/null | grep -nE "listen|http2|http3|quic|resolver|mirror|^\s*mail"
# 3. Does your origin answer HTTP/2 directly, around the CDN?
curl -sk --http2 -o /dev/null -w "%{http_version}\n" \
--resolve example.com:443:ORIGIN_IP https://example.com/
# 4. Can the SCTP module load?
lsmod | grep sctp; modprobe -n -v sctpIf step 3 prints 2, anyone who finds that address can reach the HTTP/2 bug, whatever sits in front. If it prints 1.1, HTTP/2 is off on the origin.
How to fixit today.
- 01UpgradeInstall nginx 1.31.9 or 1.30.7, or your distribution’s fixed package when it ships. Then restart nginx, not just reload it.
- 02If there is no package yet, turn off HTTP/2On 1.25.1 and later, add http2 off; to each server block. On older versions, remove http2 from the listen line.
- 03Turn off what else you don’t needRemove QUIC and HTTP/3 listeners, drop mirror with a variable proxy_pass, and keep mail listeners off the internet.
- 04Block SCTPStop the kernel module from loading, so a compromised worker can’t use the SCTP bug to become root.
- 05Close the originIf a CDN fronts your site, accept ports 80 and 443 only from the CDN’s addresses.
- 06Put HTTP/2 back after the patchOnce a fixed nginx runs, restore the listen line and restart.
The workaround, for servers that cannot be upgraded yet:
# nginx 1.25.1 and later: in every server block that listens on 443
http2 off;
# nginx 1.9.5 to 1.25.0: remove http2 from the listen line
listen 443 ssl; # was: listen 443 ssl http2;
# then test and reload
nginx -t && systemctl reload nginx
# block the SCTP module (does not unload a module that is already loaded)
echo "install sctp /bin/false" > /etc/modprobe.d/nginx2root-sctp.confFor containers and Kubernetes, and after any package upgrade:
# Docker: pull the fixed image and recreate the container (a restart keeps the old image)
docker pull nginx:stable && docker compose up -d --force-recreate
# Kubernetes community ingress-nginx: no fix is coming, turn off HTTP/2 in its ConfigMap
use-http2: "false"
# after a package upgrade, restart (a reload keeps the old binary)
systemctl restart nginxTurning off HTTP/2 is a configuration change, so a reload applies it without dropping connections. Behind a CDN, visitors keep HTTP/2 and HTTP/3 from the CDN and notice nothing. Without one, browsers fall back to HTTP/1.1. If you use gRPC through nginx, that breaks until you upgrade.
How we fixed iton a production server.
We run sites for founders, and one of them sits on a single VPS. On the morning of the disclosure, this is what we found:
- Server
- Ubuntu 24.04 VPS, nginx 1.24.0-2ubuntu7.19, the newest Ubuntu offered
- In front
- Cloudflare, but ports 80 and 443 open to everyone
- Exposed
- CVE-2026-123007 and CVE-2026-123633: HTTP/2 on, proxy_pass to the app
- Root path
- Kernel 6.8 with the sctp module present and loadable
- Not exposed
- No HTTP/3 listener, no resolver with mirror, no mail block
Ubuntu had no fixed package, and unattended upgrades had found nothing newer that morning. The site was behind Cloudflare, but we connected straight to the server’s IP and it answered over HTTP/2. Anyone who found that address could have reached the bug, and the loadable SCTP module left the path to root open. That would have meant the whole server, database included.
The fix took a few minutes. We changed the listen line from listen 443 ssl http2; to listen 443 ssl;, because nginx 1.24 does not have the http2 off; directive. Then we ran nginx -t and reloaded, with a backup of the old file and an automatic restore if the test failed. We blocked the sctp module in /etc/modprobe.d and committed the same change to the site’s repository, so a later deploy would not undo it.
From outside, the server now answers HTTP/1.1 on its own IP, and visitors still get HTTP/2 through Cloudflare. Sign-in and the app work as before. When Ubuntu ships the fix, we upgrade, restart nginx and put http2 back. Limiting the origin to Cloudflare’s ranges is our next step.
Bugs like this now arrivefaster.
One researcher found CVE-2026-123007 while preparing for a hacking contest. The other four were found by an automated scan with no person in the loop. The same week, another team found a remote code execution bug in Java’s Base64 decoder with an AI coding agent in about an hour. Finding bugs in old, widely used code is getting cheap, and so is turning a public bug into a working attack.
Scanners follow quickly. On our own sites, the scanners we track added paths for new LiteLLM, Flowise and Langflow bugs one to three weeks after the advisories. Read how Octopus, Gecko and Tortoise hunt for keys. An HTTP/2 bug is harder to mass-scan than a missing file, because each attempt takes a long connection. But a public proof of concept already exists, and fake ones are spreading malware to people who rush to test their servers. Use the vendor’s fix and the checks above, not code from an unknown repository.
Sourcesand advisories.
Questions.
What is nginx2root?
nginx2root, also written NGINX2Root and sometimes called NGINX2Shell, is a set of five nginx vulnerabilities disclosed by Xint on 18 November 2026. The worst, CVE-2026-123007, is a memory bug in HTTP/2 flow control that lets an unauthenticated attacker run commands as the nginx worker. A separate Linux kernel SCTP bug turns that into root on the host.
Which nginx versions are vulnerable to CVE-2026-123007?
Every nginx from 1.9.5, the first release with HTTP/2, to 1.31.8, with HTTP/2 enabled on a listener. The fixed releases are 1.31.9 (mainline) and 1.30.7 (stable). Distribution packages report older version numbers and get fixes backported, so check your distribution’s advisory, not only nginx -v.
Is my site safe if it is behind Cloudflare?
Only if your origin server cannot be reached directly. Cloudflare says its own edge is patched, but an attacker who knows or finds your origin IP can open HTTP/2 to nginx without going through Cloudflare. Test it by connecting to the origin IP yourself, and limit ports 80 and 443 to Cloudflare’s address ranges.
Does turning off HTTP/2 hurt performance or SEO?
Very little if a CDN sits in front, because visitors still get HTTP/2 or HTTP/3 from the CDN. Without a CDN, browsers fall back to HTTP/1.1, which is somewhat slower on pages with many files. Turn HTTP/2 back on once you run a fixed nginx. It does break native gRPC clients.
Is nginx2root exploited in the wild?
No attacks had been reported as of 18 November 2026, and CISA had not added the CVEs to its Known Exploited Vulnerabilities list. Researchers have working exploits they have not released, a limited proof of concept is public, and fake proof-of-concept repositories carrying malware are circulating. Patch as if exploitation is close.
Is a reload enough after I upgrade nginx?
No. A reload re-reads the configuration but keeps the old binary. After installing a fixed package, restart nginx or do a live binary upgrade. A reload is enough for the configuration-only workaround of turning off HTTP/2.
Is Kubernetes ingress-nginx affected?
Yes. The community ingress-nginx project is retired and will not ship a fix. Set use-http2 to false in its ConfigMap as a stopgap and plan a move to a maintained ingress. F5’s NGINX Ingress Controller 5.8.0 still bundles the vulnerable nginx 1.31.8.
Patch the server.Then see who comes knocking.
Book a free 30-minute call with Emre. We’ll look at what reaches your site, which agents and scanners are behind it, and what to do about them.
Choose a time for your free 30-minute call.

