Chat with AI Agent, powered by Text

Nginx2root: Patch NGINX and Limit the Blast Radius

Nginx2root: Patch NGINX and Limit the Blast Radius
Written by
Cesar Saavedra
Cesar Saavedra
-
Sr. Director Technical Product Marketing
,
Published on
November 19, 2026

NGINX2Root is a set of five memory-safety vulnerabilities in nginx that let an attacker with no credentials run code on your web servers, reverse proxies, and ingress controllers. The researchers who found them also chained the worst one with a Linux kernel bug to get root on the host, including from inside a Docker container. The fixes shipped on November 18, 2026, in nginx 1.31.9 and 1.30.7.

This article explains what the five CVEs are, how to check whether your servers are exposed and whether anyone has tried to exploit them, and how RapidFort helps you find every affected nginx build, move to fixed images, and limit what an attacker can do with code execution while you patch.

What are the NGINX2Root vulnerabilities?

The Xint research team found all five flaws and reported them to F5 in October 2026, as described in the Xint NGINX2Root disclosure. Each one is an independent path to remote code execution in a different nginx configuration, so check your configuration against all five.

The two most severe are in the HTTP/2 code. CVE-2026-123007 is an integer overflow in HTTP/2 flow-control accounting that leads to an out-of-bounds heap copy. It has been in nginx since HTTP/2 support arrived in version 1.9.5 in September 2015, so every official release through 1.31.8 contains it. CVE-2026-123633 is a use-after-free, while running low on worker_connections, that occurs when nginx proxies HTTP/2 requests to an upstream server, which describes most production reverse proxy deployments. Both carry a CVSS 4.0 score of 9.2.

The five CVEs

CVEAffected configurationFirst affected releaseBlocked by disabling HTTP/2?
CVE-2026-123007HTTP/2 enabled1.9.5Yes
CVE-2026-123633HTTP/2 with requests proxied to an upstream server1.19.7Yes
CVE-2026-123634DNS resolver with a request-derived proxy_pass target and mirror subrequests0.6.18No
CVE-2026-121810HTTP/3 (QUIC) with requests proxied to an upstream server1.25.0No
CVE-2026-113425Mail proxy with proxy on and auth_http; no valid credentials needed0.5.15No

In every case, the attacker’s code runs with the privileges of the nginx worker process, usually an unprivileged account such as nginx or www-data. Although Xint and a second research team built working exploits and have not released them, a third research team has publicly released a working PoC exploit. As of November 18, 2026, no exploitation in the wild had been reported. Xint demonstrated CVE-2026-123007 against servers on AWS, Google Cloud, and Azure over their public IP addresses.

Fixed versions and what to change before you can patch

Upgrade to nginx 1.31.9 (mainline) or 1.30.7 (stable). NGINX Plus customers need 37.0.8.1 or 37.3.0.1 for CVE-2026-123007, and 37.0.7.1 or 37.2.0.1 for CVE-2026-123633, as listed in F5 advisory K000164058. After you install the fix, restart nginx or run a live binary upgrade. A configuration reload leaves the old executable running.

Distribution packages complicate the version check. Ubuntu, Debian, and other distributions backport security fixes without changing the version that nginx -v reports, so compare the full package version against your distribution’s advisory.

Until you can upgrade, turn off HTTP/2 on internet-facing listeners. On nginx 1.25.1 and later, set http2 off; in each affected server block and remove the http2 parameter from its listen directives:

server {
    listen 443 ssl;
    http2 off;
    # ...
}

On older versions, remove http2 from listen 443 ssl http2;. This blocks the two HTTP/2 CVEs and breaks native gRPC clients. It doesn’t block the other three. For those, turn off HTTP/3, point proxy_pass at fixed upstream groups wherever you use mirror, and bind mail proxy listeners to loopback or restrict them to trusted addresses.

How NGINX2Root shows up in your environment

nginx is usually the first component that untrusted traffic reaches, and it often holds TLS private keys and has network routes to internal services. That makes an nginx worker a useful foothold even before an attacker escalates privileges.

Check whether a server is exposed

A server is exposed to CVE-2026-123007 when it runs an unpatched build, includes the HTTP/2 module, and has HTTP/2 enabled on a reachable port. These checks cover each condition:

# Version (compare distribution packages against the vendor advisory)
nginx -v 2>&1

# Was the binary built with the HTTP/2 module?
nginx -V 2>&1 | grep -o -- '--with-http_v2_module'

# Is HTTP/2 enabled in the configuration?
sudo nginx -T 2>&1 | grep -nE 'listen .*http2|^\s*http2\s+on;'

# Does the server negotiate HTTP/2 from outside your network?
openssl s_client -connect example.com:443 -servername example.com \
  -alpn h2 </dev/null 2>&1 | grep 'ALPN protocol'

If the last command prints ALPN protocol: h2, the server accepts HTTP/2. When a CDN or load balancer sits in front of nginx, the external test only reaches that layer, so also run it against the nginx host directly.

Containers add a second inventory problem. Ingress controllers, API gateways, and appliance images bundle their own nginx build, and the image tag doesn’t tell you which nginx version is inside. ingress-nginx/controller, nginx/nginx-ingress, nginx/nginx-gateway-fabric, and harbor/nginx-photon all fall into this group.

What an attack looks like in your logs

Access logs show little. The CVE-2026-123007 exploit sends WINDOW_UPDATE and RST_STREAM control frames, which nginx doesn’t log as requests and TLS encrypts in transit. Look in these places instead:

  • Worker crashes. A failed attempt can crash a worker with a segmentation fault. Search the error log for exited on signal 11 or segfault, and run coredumpctl list nginx.
  • Programs started by the worker. An nginx worker has no reason to run a shell or any other program. An auditd rule on execve for the worker’s user ID records every program it starts from the moment you add the rule.
  • Lopsided HTTP/2 connections. A connection from one address that stays open for minutes and sends far more data than it receives matches the published attack pattern, especially alongside many short TLS connections from the same address.
sudo grep -Ei 'worker process.*exited|signal 11|segfault' /var/log/nginx/error.log
sudo coredumpctl list nginx

# Replace 101 with the user ID of the nginx worker account
sudo auditctl -a always,exit -F arch=b64 -S execve,execveat \
  -F euid=101 -k nginx_worker_exec

A program started by an nginx worker is the strongest signal. The others have innocent explanations on their own, so weigh them together. Clean logs today don’t rule out an earlier compromise.

How a worker compromise reaches the host

Code execution as the nginx worker is the first step. To take over the host, the attacker needs a privilege escalation bug, and Xint found one: a use-after-free in the Linux kernel’s SCTP send path, present since kernel 4.15 in 2018 and unpatched at disclosure. In Xint’s tests, the chain went from an nginx worker inside a Docker container to a root shell on the underlying host.

Many distributions install the SCTP module by default, and the kernel loads it the first time a program opens an SCTP socket. Every container on a host shares its kernel, so a kernel compromise reaches all of them. On hosts that don’t use SCTP, block the module from loading:

echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/disable-sctp.conf
lsmod | grep sctp    # a module that is already loaded stays loaded

This setting stops modprobe from loading the module. It doesn’t unload a module that’s already loaded or disable SCTP compiled into the kernel.

How RapidFort helps you respond to NGINX2Root

Patching nginx closes these five paths. It does nothing about the next nginx bug, and nginx had published 26 security advisories in 2026 before NGINX2Root, compared with two in 2025. RapidFort helps with both halves of the response: finding and replacing vulnerable nginx builds, and shrinking what a compromised worker can reach.

Find every nginx build you run

RapidFort scans container images across your registries, CI/CD pipelines, and Kubernetes clusters at the binary level, as well as hosts and local folders, so it identifies the nginx version compiled into an ingress controller or gateway image even when the tag only describes the controller release. You get one list of affected workloads, including the ones a web server inventory misses.

Move to fixed RapidFort nginx images

RapidFort Images for nginx and nginx-unprivileged at nginx 1.29.5, 1.30.6, 1.31.3, and 1.31.8 were affected and have already been fixed. These images are pin-for-pin replacements in your existing Dockerfiles and Helm charts, so moving to them is a one-line change.

Limit what a compromised worker can do

Every published NGINX2Root exploit ends by starting another program: a shell through execve(), or a command through system() or execv(). RapidFort optimizes images by profiling what a workload uses at runtime and eliminating the packages and binaries it never touches. For an nginx container, that can mean no shell and no package manager, so a payload that calls system(), which runs /bin/sh, fails at that step.

RapidFort Runtime records what each workload executes and generates a Runtime Bill of Materials (RBOM®), so a program started by an nginx worker stands out against the profile of what nginx normally runs.

These controls limit the damage after code execution. They don’t fix the memory corruption. An attacker running code inside the worker can still read what that process holds, including TLS keys, and can still make the system calls that reach a kernel bug such as the SCTP flaw. Patch nginx, run it as a non-root user with a read-only root filesystem and no added capabilities, and block SCTP on hosts that don’t need it.

Schedule time with RapidFort to address NGINX2Root or start for free

If you’re working out which of your images and clusters run an affected nginx build, or how to move to fixed images without disrupting traffic, our team can work through it with you, from inventory to rollout.

Schedule time with RapidFort to review your NGINX2Root exposure

Subscribe to newsletter

Subscribe to receive the latest blog posts to your inbox every week.

By subscribing you agree to with our Privacy Policy.
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
Share on:

Latest posts

Ability to Execute

2026 Gartner® Magic Quadrant™

for Software Supply Chain Security

Get the Report