News / Security / nginx2root vulnerability: is your nginx server…
Security · Vulnerability

nginx2root vulnerability: is your nginx server exposed?

nginx2root lets attackers run code on nginx servers with HTTP/2 on, and a public exploit is out. How to check yours and what to do before your distro patches.

opnF.shNov 19, 20268 min readnginx2rootnginx vulnerabilitycve-2026-123007
On this page 5 sections ▾

WHAT TO DO

  • Fixed nginx builds are out from nginx.org, Arch and Docker Hub (by exact tag), but Ubuntu, Debian and RHEL hadn't shipped packages on November 18, so most servers either switch to nginx.org's packages or turn HTTP/2 off.
  • Kubernetes clusters on the community ingress-nginx controller will never get a patched image: the project is retired, so the way out is switching HTTP/2 off now and moving to another controller.
New to this?Ping explains the hardest part in plain words.
CVE-2026-123007
"nginx2root" · nginx and NGINX Plus (HTTP/2 module)
CRITICAL9.2
Affected
nginx 1.9.5 to 1.31.8 with HTTP/2 enabled
Fixed in
nginx 1.30.7 and 1.31.9; NGINX Plus 37.0.8.1 and 37.3.0.1
Disclosed
Nov 18, 2026
Exploited
No known exploitation; public proof of concept
Workaround
Turn HTTP/2 off on every listener

Every nginx release since 2015 that has HTTP/2 switched on is open to the nginx2root vulnerability, a flaw that lets anyone on the internet run code on the server without logging in. A working exploit landed on GitHub the same day it was disclosed. And if your nginx came from Ubuntu, Debian or RHEL, running your usual updates won't fix it yet, so it's worth ten minutes today to find out where you stand.

Quick facts

Xint counted 2 new vulnerabilities on nginx's advisory list in all of 2025, and 26 by November 17 this year, before nginx2root was added.

Rapid7's public exploit needs about 128 GB of HTTP/2 traffic over a single connection, roughly 17 minutes on a 1 Gbit/s link.

Xint's chain reached root even from inside a Docker container, through a Linux kernel bug from 2018 that has no patch or CVE number yet.

#How nginx2root works

HTTP/2 lets both sides of a connection say how much data the other may send before it has to wait, a running count called the flow-control window. A client can send updates that push nginx's count past what its math expects, and a later copy then writes outside the memory it was given. The same bad copy also leaks 64 bytes of nginx's internal memory addresses back to the attacker inside the TLS response. Those addresses are exactly what ASLR, the defense that shuffles memory locations, is meant to hide, so the attacker knows where to aim and overwrites a cleanup function pointer to run their own commands.

ELI5: explain it simply
Ping explainsNo experience needed.
THE WORDS
Flow-control window
The amount of data one side of a connection is allowed to send before waiting for the other side to say go.
ASLR
A defense that puts a program's code and data at random memory addresses each time it starts, so attackers can't guess them.
Function pointer
A saved memory address that tells a program which code to run later.
THE IDEA

Imagine a coat check that tracks how many coats you're allowed to hand over. Trick its counter, and it hangs your coat on a hook outside its own rack. While doing that, it also reads out the rack's floor plan, so next time you know exactly which hook holds the manager's keys.

That code runs as the nginx worker user, not root. Xint's jump to root comes from a separate bug in the Linux kernel's SCTP networking code, present since Linux 4.15 in 2018. The SCTP module ships installed on many distributions and loads by itself the first time any program opens an SCTP socket, so a worker that's been taken over can pull it in. No kernel patch existed at disclosure.

#A public exploit, with real limits

Rapid7's Stephen Fewer published both a crash trigger and a full code-execution chain on GitHub, but it isn't point-and-shoot. Pushing 128 GB through one connection takes about 2 minutes at 10 Gbit/s, and below roughly 300 Mbit/s it would likely run into nginx's default one-hour connection limit. It also depends on a memory-copy routine that glibc only picks on AVX-512 CPUs, and HTTP/2 traffic that passes through a proxy probably won't carry the frames it needs.

Those limits apply to this one exploit, not the bug: Xint and Wiz have their own working exploits that they're keeping private. No attacks had been reported and nothing was on CISA's Known Exploited Vulnerabilities list as of November 18. Precursor Security also warns that fake nginx2root exploits are circulating, and that Rapid7's repository is the only genuine public one it knows of.

Get opnF in your inbox

Tech news for IT professionals that actually teaches you something.

Our promise to you: we'll be conscious about email quality/frequency, and your address will never be shared/sold.

#Is your nginx server exposed to nginx2root?

nginx2root is really five nginx bugs, and only some of them care about HTTP/2. Here's what each one needs, and whether switching HTTP/2 off blocks it:

SystemStatus
CVE-2026-123007: HTTP/2 on, any setup (since 1.9.5)HTTP/2 off blocks it
CVE-2026-123633: HTTP/2 plus proxying to a backend (since 1.19.7)HTTP/2 off blocks it
CVE-2026-121810: HTTP/3 plus proxying to a backend (since 1.25.0)Needs the patch
CVE-2026-123634: resolver and request-built proxy_pass, with mirror or possibly SSI (since 1.13.4)Needs the patch
CVE-2026-113425: mail proxy with auth_http (since 0.5.15)Needs the patch

To see which of those apply to you, check the version, then search the full running config for the features in the table. These commands follow Xint's and Cycode's guidance; nginx isn't installed on our test machine, so we haven't run them here:

check nginx and its config
student@opnf:~$ nginx -v
# distro builds: compare the full package version with your distro's advisory
student@opnf:~$ sudo nginx -T | grep -nE 'http2|http3|quic|resolver|mirror|ssi|auth_http'
# a listen ... http2 line or http2 on; means HTTP/2 is on and CVE-2026-123007 applies
# resolver plus mirror or ssi lines: CVE-2026-123634 may apply
student@opnf:~$ lsmod | grep sctp
# no output: the SCTP module isn't loaded right now

Don't judge by the version number alone. nginx only fixes its stable and mainline branches, so 1.29 and older get no official fix, and that covers the default packages on Ubuntu 24.04, Ubuntu 22.04 and Debian 12. Distro fixes arrive as new package revisions rather than as 1.30.7, so a patched Ubuntu 24.04 server will still print 1.24.0. Here's where things stood on the afternoon of November 18:

SystemStatus
nginx.org packages (Debian, Ubuntu, RHEL, SLES, Amazon Linux 2023, Alpine)Fixed: 1.30.7-1 and 1.31.9-1
Alpine 3.24 and edgeMostly fixed: 1.30.7-r0 covers 9 of the release's 10 CVEs
Arch LinuxFixed
Ubuntu (all supported releases)No fix yet
DebianNo fix yet
RHEL 8, 9 and 10No fix yet
Fedora 43 to 45No fix yet
Amazon Linux AL2023 and AL2Fix pending
Alpine 3.22 and 3.23No fix yet

If you're exposed

Patch where you can, close the HTTP/2 door where you can't yet, and cut off the route to root:

  1. Patch, then restart rather than reloadInstall a fixed build from nginx.org's repository or apply your distro's update when it ships. For Docker, pull the fixed image by its exact tag, such as nginx:1.31.9-alpine: Precursor Security found nginx:alpine still pointing to a vulnerable 1.31.8 image hours after the fix, so check nginx -v inside the container. Then restart nginx (sudo systemctl restart nginx): a reload doesn't replace the running binary, and old workers keep serving existing connections. The restart briefly drops every client.
  2. No patch yet? Switch HTTP/2 offOn nginx 1.25.1 and later, add http2 off; to each affected server block. On older versions, which includes Ubuntu 22.04's 1.18.0, remove http2 from the listen lines instead. Check it with sudo nginx -t, then apply it with sudo systemctl reload nginx: a reload is fine for a config change. Browsers fall back to HTTP/1.1, and this covers only the two HTTP/2 bugs.
  3. Block the SCTP moduleOn hosts that don't use SCTP, put install sctp /bin/false in a .conf file under /etc/modprobe.d/. That stops the module loading, which cuts off Xint's path to root, but it won't unload a module that's already loaded or switch off SCTP built into the kernel, so check lsmod too.

Signs someone already tried

There are no published indicators of compromise yet, and your access log won't help much: ordinary access logs don't record HTTP/2 control frames, so a clean one proves nothing. These are the signs Precursor Security says to look for instead:

  • Repeated nginx worker crashes in the error log, since failed attempts tend to crash workers.
  • nginx worker processes starting a shell or opening new outbound connections.
  • Long-lived HTTP/2 connections that send unusually large amounts of data.

If you can't tell whether a server is affected, treat any internet-facing nginx with HTTP/2 on as exposed until you've patched it or switched HTTP/2 off.

#Kubernetes: the ingress controller that won't be fixed

The community ingress-nginx controller bundles its own nginx and serves HTTP/2 by default, so a cluster that kept the defaults is exposed. The project is retired, with its last release in March 2026, and no fixed image is coming. Updating nginx on the nodes changes nothing, because the controller never uses it.

The nginx inside the controller is 1.27.1, and with no new image coming, the setting that matters most is HTTP/2. Check the controller's ConfigMap for use-http2: "false". If the setting isn't there, HTTP/2 is on. Set it, then plan the move to a maintained controller. F5's own NGINX Ingress Controller is a different product, fixed in 5.8.0, though its 2026-lts-r11 release is not.

#AI found four of the five

A Xint researcher found the main HTTP/2 bug while preparing for the ZeroDay Cloud 2026 competition. A few days later, a fully automated Xint scan found the other four with no human guidance.

Xint wasn't the only one to find the HTTP/2 bug. Wiz and Rapid7 each reported it to F5 on their own, and the CVE was assigned to Rapid7's report. On disclosure day, Ikotas Labs announced it under a second name, NGINX2Shell, saying it found the bug with OpenAI. That's the same story as PHP2Shell last month and Java4Shell the day before: old bugs in software everyone runs, found with AI help in hours or days.

Knowing what a web server has switched on, reading its config and restarting it cleanly is core DevOps work. If that's new to you, the DevOps Pro ProCourse teaches Linux server administration in a simulated terminal in your browser, and Level 1 is free.

Does turning off HTTP/2 fix nginx2root?
Only partly. It blocks the two HTTP/2 bugs, including the worst one, but the HTTP/3, resolver and mail proxy flaws still need the patched release.
Is NGINX Plus affected?
Yes. 37.x is fixed in 37.0.8.1 and 37.3.0.1, but F5 lists no fix at all for R34 to R36, so those customers have to move to 37.x or turn HTTP/2 off on internet-facing listeners.
Is nginx2root being exploited?
Not that anyone had reported by November 18, and it wasn't on CISA's KEV list. With a working exploit public on GitHub, that's a reason to patch fast rather than a reason to wait.

What this means for you

Check every nginx you run, including inside containers and Kubernetes ingress, for HTTP/2. Patch from nginx.org or your distro and restart, switch HTTP/2 off anywhere you can't patch today, and block the SCTP module on hosts that don't need it.

Get opnF in your inbox

Tech news for IT professionals that actually teaches you something.

Our promise to you: we'll be conscious about email quality/frequency, and your address will never be shared/sold.