18 November 2026

nginx2root: What to Do Right Now

nginx2root: What to Do Right Now
8 min. readBy Borg

When a high-severity flaw lands in software that runs almost everywhere, engineering teams end up chasing ghost configurations or breaking production with unvetted workarounds. This guide documents what primary sources verify as of today, separates confirmed facts from speculation, and lays out the inventory and remediation steps your infrastructure team should run now.

Status as of 18 November 2026 (and what may change)

nginx2root is the name Xint gave to five vulnerabilities in nginx, each of which can let an unauthenticated attacker run code on the server under the right configuration. Xint also found a separate bug in the Linux kernel that, combined with any of the five, turns that foothold into full control of the machine. That includes the host underneath a Docker container.

The nginx half is fixed. The nginx team released versions 1.31.9 (mainline) and 1.30.7 (stable) today. The kernel half is not. There is no kernel patch yet, and Xint is withholding the details until there is one.

This article is intentionally dated. Distribution packages, managed platforms and vendor advisories will keep updating over the coming days. Treat early third-party analysis, including this post, as provisional. Re-check nginx.org and your distribution's security tracker before you sign off on a fix.

What is confirmed: the nginx advisories, the Xint disclosure, Rapid7's independent find

During an active disclosure, it matters to separate verified facts from chatter. As of today, the following are backed by primary or named sources.

First, nginx.org lists all five vulnerabilities in its security advisories and says they are fixed in 1.31.9 and 1.30.7. The most serious one, CVE-2026-123007, sits in nginx's HTTP/2 support. It affects every release from 1.9.5, when HTTP/2 arrived in 2015, through 1.31.8. The other four only matter if you use specific features: HTTP/3, the DNS resolver with dynamic proxying, or nginx as a mail proxy.

Second, Xint published a full writeup. It shows a working attack against servers on AWS, GCP and Azure over the public internet, and a chain from nginx to root on the host.

Third, Rapid7 found the same HTTP/2 bug on its own and reported it to F5 (the company behind nginx) a few days ago. Rapid7 scores it CVSS v4 9.2, critical. The nginx changelog also credits one of the five, a separate HTTP/2 bug, to a researcher at Vexera AI rather than Xint. When several teams find the same bugs in the same weeks, it's safest to assume others have found them too.

Everything else is still developing. A 9.2 score demands immediate priority, but it doesn't mean your setup is exploitable without context.

What is not confirmed: exploitation, the kernel bug, backports, practical exploitability

Several important questions don't have verified answers yet. Keep them separate from the confirmed facts.

First, there are no confirmed reports of attacks in the wild as of this afternoon. Expect that to change now that the fix is public and can be compared against the old code.

Second, the kernel bug has no CVE number listed in Xint's writeup, no patch, and few public details. Xint says it has been in the kernel since 2018. It sits in SCTP, a networking feature most web servers never use but that many Linux distributions load automatically when asked.

Third, distribution backport status is still moving. Ubuntu, Debian, Red Hat and others often patch their own nginx packages without changing the version number nginx reports. That means nginx -v alone can't tell you whether you're safe. Check your distribution's security tracker for the exact patched package. The same goes for Kubernetes ingress controllers built on nginx, so watch their advisories too. F5 says older NGINX Plus releases R34 to R36 have no fix.

Fourth, how hard this is to exploit in practice is debated. Rapid7's working attack had to send roughly 128 GB of traffic to a single server. That takes minutes on a fast connection and becomes impractical on slow ones. Rapid7 also found it likely fails when a CDN or proxy sits in front of nginx. Xint's attack worked over public IPs on all three major clouds. Treat a CDN as something that may slow an attacker down, not as a fix.

Finally, Xint's headline figure, that 98.9% of internet-facing nginx servers showing a version number fall in the affected range, is based on version strings from Shodan. It doesn't account for backported fixes or for servers with HTTP/2 turned off, so it overstates real exposure.

Inventory: find nginx in hosts, containers, base images, ingress, CI, vendors and managed platforms

A patch is useless if you don't know where nginx runs. nginx is easy to miss because it's often there as plumbing, not as the product.

Start with bare metal and virtual machines. Search your fleet for running nginx processes and installed nginx packages, and note the full package version, not just the nginx version.

Next, check your container registries, Dockerfiles and base image references. Teams often update the main web container and forget the sidecars, internal admin panels, static-file servers and reverse proxies built on the public nginx image. Kubernetes clusters deserve their own pass, since the ingress controller in front of everything is often nginx.

Then check CI/CD and preview environments. Many pipelines spin up nginx to serve test builds or preview deployments, and those environments are often reachable from the internet. Then look outward: forgotten staging hosts, old marketing sites and orphaned subdomains are often the nginx installs nobody remembers to patch.

Finally, list the vendors and managed platforms that run nginx for you: load balancers, hosting providers, appliances and SaaS tools you've put in front of your apps. Check their status pages and open support tickets now to ask when they'll ship the fix.

Interim measures and their limits: turning off HTTP/2, blocking SCTP, WAF caveats

The most common stopgap being shared is turning off HTTP/2. Know what it does and what it doesn't.

Turning off HTTP/2 blocks the two HTTP/2 bugs, including the most serious one. It does nothing for the other three, which are in HTTP/3, the DNS resolver and the mail proxy. It will also break anything that depends on HTTP/2, such as gRPC services. If you use those other features, Xint's writeup describes a separate temporary change for each.

For the kernel half, Xint recommends blocking the SCTP module on hosts that don't use it. This stops the kernel from loading it on demand. It doesn't remove a module that is already loaded, so check and reboot where needed.

Web Application Firewalls are unlikely to help here. The main bug is triggered by low-level HTTP/2 control traffic that doesn't show up as normal requests in your logs. If you have internet-facing nginx you can't patch today, the dependable interim measure is network isolation. Put it behind a VPN, an IP allowlist or an access proxy until the patched build is deployed.

Patch day: read the official versions, upgrade, restart, rebuild, verify, and hunt for signs of exploitation

Work through these steps in order:

Read the official advisories: Open nginx.org's security advisories and the 1.31.9 changelog, and note the fixed versions (1.31.9 and 1.30.7). If you use a distribution package, find your distribution's advisory and the exact patched package version.

Pull official packages: Use nginx.org's packages, your distribution's signed updates or the official Docker image. Skip quick-fix builds from unverified sources.

Restart, don't just reload: Reloading nginx's configuration doesn't replace the running program. Restart nginx, or do a proper binary upgrade, so the new code is actually running.

Rebuild and invalidate base image caches: Run clean container builds with --no-cache so they pull the patched nginx instead of reusing a cached layer. Then redeploy.

Verify what is actually running: A green pipeline doesn't prove the rollout worked. Check the version and package on live hosts and running pods, and confirm the old process is gone.

Hunt for signs of exploitation: The clearest warning sign is an nginx worker process starting a shell or another program, since nginx has no normal reason to do that. Also look for nginx workers crashing or leaving core dumps, and for unusually long-lived HTTP/2 connections from one source that send large amounts of data while getting little back. Any of these can have an innocent explanation. Several together deserve a proper investigation, not an assumption.

Old and unsupported nginx: the hardest case

The nginx project only publishes fixes for its current mainline and stable branches. If you run an older branch, an appliance or a product that bundles its own copy of nginx, the fix depends on whoever ships it to you. Some distributions and vendors backport fixes into older packages, so check their advisories before assuming there is none. Where no fix arrives, the realistic options are upgrading to a supported release, putting the service behind a VPN or IP allowlist, or taking it offline. An internet-facing nginx with no fix and HTTP/2 turned on is worth treating as an incident in its own right, not a backlog item.

Conclusion

Upgrading nginx to 1.31.9 or 1.30.7 is today's priority. Find every copy you run, pull verified packages, restart rather than reload, rebuild your containers and confirm the running version on every public host. Block SCTP where you don't need it until a kernel fix ships.

Borg on
Social Media

Borg specializes in securing complex, high-risk digital systems.