NGINX2Root (CVE-2026-123007): Patch nginx Before HTTP/2 Hands Out Root

NGINX2Root is five nginx flaws, led by an HTTP/2 bug present since 2015, that can chain to root through an unpatched Linux kernel issue. How to check your servers, patch to 1.30.7 or 1.31.9, and contain it if you can't patch yet.

TL;DR: NGINX2Root is five memory-safety bugs in nginx, fixed on 18 November 2026 in nginx 1.30.7 (stable) and 1.31.9 (mainline). The worst one, CVE-2026-123007, sits in the HTTP/2 code that has shipped since 2015. Public exploit code exists, and a separate, still-unpatched Linux kernel bug turns the nginx foothold into root. Patch and restart nginx today; if you can’t, turn off HTTP/2 and block the SCTP kernel module.

If you run a website, there’s a good chance nginx is in front of it, either directly, inside a Docker image, behind a Kubernetes ingress or bundled in a control panel. That’s what makes this one worth dropping other work for. Here’s what NGINX2Root is, how to tell whether your servers are exposed, and the exact steps to fix or contain it.

What NGINX2Root is

NGINX2Root (also written nginx2root) is the name the research team at Xint gave to five nginx vulnerabilities disclosed together on 18 November 2026. F5, which maintains nginx, shipped fixes the same day, coordinated with AWS, Azure and Google Cloud. Wiz Research, Rapid7, Ikotas Labs and Metnir reported some of the same issues independently.

Each bug can lead to code execution as the nginx worker process, but only when the matching feature is turned on. F5 scores all five at 9.2 on CVSS v4.0. The headline flaw is in HTTP/2, which most modern sites enable by default.

CVEWhere the bug isYou’re exposed if…HTTP/2 off helps?
CVE-2026-123007HTTP/2 flow controlHTTP/2 is enabled and reachable (since 1.9.5, 2015)Yes
CVE-2026-123633HTTP/2 with upstreamsHTTP/2 clients and requests proxied to a backend (since 1.19.7)Yes
CVE-2026-123634DNS resolverresolver is set and proxy_pass uses a variable, e.g. proxy_pass http://$host;No
CVE-2026-121810HTTP/3 (QUIC)HTTP/3 is enabled with requests forwarded to an upstreamNo
CVE-2026-113425Mail proxynginx runs as a mail proxy with proxy on and auth_httpNo

How a web request ends in root

On a well-configured server, nginx workers run as an unprivileged user such as www-data, so code execution in a worker is bad but contained. NGINX2Root gets its name from the second step: the researchers chained the nginx bugs with a use-after-free in the Linux kernel’s SCTP code (present since Linux 4.15, 2018) to become root on the host. They report this working from nginx inside a Docker container too.

  • Step 1: an attacker opens a long-lived HTTP/2 connection and sends a stream of crafted control frames for several minutes, corrupting memory in the worker.
  • Step 2: with code running as the worker, the attacker triggers the SCTP kernel bug to escalate to root.

That kernel bug has no CVE and no patch yet, and a fully updated kernel is still vulnerable. Patching nginx removes the way in; it doesn’t remove the way up. That’s why the SCTP blocklist below is worth doing even after you patch.

Is anyone exploiting it?

As of 18 November there was no public confirmation of attacks in the wild, but working exploit code is public. Xint says its own exploit works against servers on public IPs at AWS, Google Cloud and Azure, and it is holding back the final steps. The public exploit has limits: it needs a direct connection to nginx, runs for minutes on one connection, depends on a specific glibc memory-copy routine on 64-bit x86, and needs ASLR bypassed. None of that should make you comfortable; a capable attacker works around exactly these limits.

Step 1: check whether you’re exposed

Start with the version, but don’t stop there. Ubuntu, Debian and others backport fixes without changing the version number, so compare the full package version against your distro’s advisory.

# nginx version and build options
nginx -v
nginx -V 2>&1 | tr ' ' '\n' | grep -E 'http_v2|http_v3|mail'

# exact package version (Debian/Ubuntu, then RHEL/Rocky/Alma)
dpkg -l nginx* 2>/dev/null | grep '^ii'
rpm -q nginx 2>/dev/null

Then check whether the vulnerable features are actually switched on in your loaded config:

# HTTP/2 (CVE-2026-123007, CVE-2026-123633)
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE 'listen\s.*http2|^\s*http2\s+on'

# resolver + variable proxy_pass (CVE-2026-123634)
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE '^\s*resolver\s|proxy_pass\s+\S*\$'

# HTTP/3 / QUIC (CVE-2026-121810)
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE 'listen\s.*quic|^\s*http3\s+on'

# mail proxy (CVE-2026-113425)
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE '^\s*mail\s*\{|auth_http'

Finally, test from outside your network whether the internet can negotiate HTTP/2 with the server. If a CDN or load balancer sits in front, also test the nginx origin directly, because the exploit needs to reach nginx itself.

openssl s_client -connect example.com:443 -servername example.com -alpn h2 </dev/null 2>&1 | grep -E 'ALPN protocol|No ALPN'
# "ALPN protocol: h2" = HTTP/2 is reachable

Step 2: patch, then restart (not reload)

The only complete fix is a patched build:

ProductAffectedFixed in
NGINX Open Source, mainline1.31.0 – 1.31.81.31.9
NGINX Open Source, stable1.30.0 – 1.30.61.30.7
NGINX Open Source, older branches1.9.5 – 1.29.xNo fix: move to 1.30.7 / 1.31.9 or a patched distro package
NGINX Plus 37.x37.0.0 – 37.0.8, 37.1.0 – 37.3.037.0.8.1 / 37.3.0.1
# Debian/Ubuntu (nginx.org repo or once your distro ships the fix)
sudo apt update && sudo apt install --only-upgrade nginx
# RHEL/Rocky/Alma
sudo dnf upgrade nginx

# a reload keeps the OLD binary running - restart instead
sudo nginx -t && sudo systemctl restart nginx
nginx -v

A few places that are easy to miss:

  • Distro packages: on 18 November, Ubuntu and Debian still listed their nginx packages as vulnerable with no fixed build. Until they ship, use the official nginx.org repository or the mitigations below.
  • Docker: the official nginx mainline tags now point to 1.31.9, but running containers keep the old build until you pull and redeploy. Rebuild any image that starts FROM nginx.
  • Kubernetes: the community ingress-nginx project was archived in March 2026 and won’t get a fix for CVE-2026-123633. Turn off HTTP/2 there and plan a move to a maintained ingress such as F5 NGINX Ingress Controller 5.8.0 or NGINX Gateway Fabric 2.9.0.
  • Bundled nginx: control panels, appliances and app stacks that ship their own nginx need the vendor’s update.

Step 3: can’t patch today? Contain it

These are stopgaps, not fixes. Give each one an owner and an end date, because the next config deploy can quietly undo it.

HTTP/2 (CVE-2026-123007, CVE-2026-123633). Clients fall back to HTTP/1.1. Test first if you serve gRPC, which needs HTTP/2.

# nginx 1.25.1 and later: in every server block
http2 off;

# older versions: remove "http2" from the listen line
# listen 443 ssl http2;   ->   listen 443 ssl;

Resolver (CVE-2026-123634). Point proxy_pass at a fixed upstream instead of a name built from variables at request time.

upstream app_backend {
    server 10.0.0.10:8080;
}
server {
    location / {
        proxy_pass http://app_backend;   # instead of http://$host
    }
}

HTTP/3 (CVE-2026-121810). Remove the quic listeners and set http3 off;. Mail proxy (CVE-2026-113425). Bind the mail listeners to loopback or restrict them to trusted IPs at the firewall.

The kernel step to root. On hosts that don’t use SCTP (almost every web server), stop the module from loading. This doesn’t unload a module that’s already loaded, and doesn’t help if SCTP is compiled into the kernel, so check both:

# block the module from loading
echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/disable-sctp.conf

# is it loaded right now? (no output = not loaded)
lsmod | grep -w sctp

# is it built in? "=y" means built in, "=m" means a module
grep -E 'CONFIG_IP_SCTP=' /boot/config-$(uname -r)

If sctp is already loaded and nothing on the host uses it, unload it with sudo modprobe -r sctp or reboot after adding the blocklist. On container hosts, apply this on the host, not inside the container.

Checklist

  • ☐ Inventory every nginx: servers, Docker images, Kubernetes ingress, bundled products.
  • ☐ For each one, record the package version and which features are on (HTTP/2, HTTP/3, resolver, mail).
  • ☐ Upgrade to 1.30.7 / 1.31.9 (or the distro’s fixed package) and restart.
  • ☐ Where you can’t, disable the affected feature and set a removal date.
  • ☐ Block the SCTP module on every Linux host that doesn’t need it.
  • ☐ Redeploy containers and rebuild images based on nginx.
  • ☐ Move off community ingress-nginx.
  • ☐ Watch nginx error logs for worker crashes (signal 11, exited on signal): a burst of them can mean someone is trying.

References

Details are current as of 19 November 2026 and will change as distributions ship packages and the kernel fix lands. I’ll update this post when they do.

pir8g33k

Open source, technology and cybersecurity. Practical write-ups by a DevSecOps engineer who would rather automate it twice than click it once.