Threat Intel · 20 Nov 2026

NGINX2Root (CVE-2026-123007 and four more): nginx RCE with a kernel route to root

Five memory-safety flaws in nginx, led by an HTTP/2 bug present since 2015, can give an attacker code execution in the nginx worker. Public exploit code chains it with an unpatched Linux SCTP bug to reach root. Upgrade to 1.30.7 or 1.31.9, restart, and block the SCTP module.

← Threat Intel / Vulnerability

At a glance

ItemDetail
NameNGINX2Root (five CVEs disclosed together by Xint)
Headline CVECVE-2026-123007, HTTP/2 flow control, in nginx since 1.9.5
Other CVEsCVE-2026-123633 (HTTP/2 + upstreams) · CVE-2026-123634 (resolver with variable proxy_pass) · CVE-2026-121810 (HTTP/3) · CVE-2026-113425 (mail proxy)
ImpactCode execution as the nginx worker user; root on the host when chained with the SCTP kernel bug
SeverityCVSS v4.0 9.2 for all five (F5)
Fixed inNGINX Open Source 1.30.7 (stable), 1.31.9 (mainline) · NGINX Plus 37.0.8.1 / 37.3.0.1
Not fixedBranches before 1.30 · community ingress-nginx (archived) · the Linux SCTP use-after-free (no CVE, no patch)
Disclosed18 November 2026

What is wrong

Each of the five bugs corrupts memory inside an nginx worker, but only when a particular feature is in use. The one that matters most is in the HTTP/2 implementation, which nearly every modern site turns on. An attacker holds one HTTP/2 connection open and feeds it crafted control frames for several minutes until the worker's memory is in a state they can use.

A worker normally runs as an unprivileged account, which would limit the damage. The researchers closed that gap with a use-after-free in the kernel's SCTP protocol code (present since Linux 4.15). From code execution in the worker, loading SCTP and triggering that bug gives root, and they report it works from inside a Docker container as well. A fully patched kernel is still affected today.

Who is exposed

FeatureCVETypical sign in the config
HTTP/2CVE-2026-123007listen 443 ssl http2; or http2 on;
HTTP/2 to a proxied backendCVE-2026-123633HTTP/2 enabled plus proxy_pass
Runtime DNS resolutionCVE-2026-123634resolver set and proxy_pass http://$variable
HTTP/3 / QUICCVE-2026-121810listen 443 quic; or http3 on;
Mail proxyCVE-2026-113425a mail { } block with auth_http

Look beyond standalone web servers: Docker images built FROM nginx, Kubernetes ingress controllers, hosting control panels and appliances that bundle their own nginx all count.

Is it exploited?

As of 20 November we have seen no confirmed in-the-wild attacks. The public exploit is not point-and-click: it needs a direct connection to nginx (not just to a CDN in front of it), a specific 64-bit x86 glibc routine and an ASLR bypass. Xint says its full exploit works against hosts at the big three cloud providers and is holding back the last steps. Expect that gap to close.

How to check

All commands below only read state.

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

# distro package version (backports keep the upstream number)
dpkg -l 'nginx*' 2>/dev/null | grep '^ii'
rpm -q nginx 2>/dev/null

# which risky features are active in the loaded config
sudo nginx -T 2>/dev/null | sed 's/#.*//' | grep -nE 'http2|quic|http3|^\s*resolver\s|proxy_pass\s+\S*\$|auth_http'

# can the internet negotiate HTTP/2 with this host?
openssl s_client -connect www.example.com:443 -servername www.example.com -alpn h2 </dev/null 2>&1 | grep 'ALPN protocol'

If a CDN or load balancer sits in front, run the last test against the origin as well.

How to fix

  1. Upgrade to 1.30.7 or 1.31.9 from nginx.org, or to your distribution's fixed package once it ships. On 18 November Debian and Ubuntu had not yet published fixed builds.
  2. Restart nginx (sudo nginx -t && sudo systemctl restart nginx). A reload keeps the old binary in memory.
  3. Pull and redeploy containers; rebuild any image that starts from an nginx base.
  4. NGINX Plus: move to 37.0.8.1 or 37.3.0.1.
  5. Community ingress-nginx will not be fixed. Plan a move to a maintained controller (for example F5 NGINX Ingress Controller 5.8.0 or NGINX Gateway Fabric 2.9.0).

If you can't patch yet

  • HTTP/2: set http2 off; (1.25.1+) or remove http2 from the listen line. Check gRPC services first, as they need HTTP/2.
  • Resolver: replace proxy_pass http://$host style targets with a fixed upstream block.
  • HTTP/3: remove quic listeners and set http3 off;.
  • Mail proxy: bind it to localhost or restrict it to trusted IPs at the firewall.
  • Kernel step: on hosts that don't use SCTP (almost all web servers), stop the module from loading. Do this on the container host, not inside the container.
echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/disable-sctp.conf
lsmod | grep -w sctp                                   # loaded right now?
grep CONFIG_IP_SCTP= /boot/config-$(uname -r)          # =y means built in

Keep the SCTP block in place even after patching nginx, until the kernel is fixed.

Detection ideas

Microsoft Defender for Endpoint on Linux: an nginx worker should never start a shell or load kernel modules.

DeviceProcessEvents
| where Timestamp > ago(14d)
| where InitiatingProcessFileName == "nginx"
| where FileName in~ ("sh", "bash", "dash", "python3", "perl", "curl", "wget", "modprobe", "insmod")
| project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine, InitiatingProcessCommandLine

Microsoft Sentinel with Syslog from your web servers: bursts of crashed workers can mean someone is trying.

Syslog
| where TimeGenerated > ago(7d)
| where ProcessName == "nginx" or SyslogMessage has "nginx"
| where SyslogMessage has_any ("exited on signal 11", "exited on signal 6", "worker process")
| summarize Crashes = count() by Computer, bin(TimeGenerated, 15m)
| where Crashes > 5

Checklist

  • Find every nginx: servers, images, ingress controllers, panels, appliances
  • Record version and which features (HTTP/2, HTTP/3, resolver, mail) are on
  • Upgrade to 1.30.7 / 1.31.9 (or the fixed distro package) and restart
  • Disable the affected feature where you can't patch, with an end date
  • Block the SCTP module on every Linux host that doesn't need it
  • Redeploy containers; retire community ingress-nginx
  • Alert on nginx spawning shells and on worker crash bursts

How Kage can help

  • Exposure check: we find every nginx in your estate, including container images, ingress controllers and appliances, and confirm which risky features are switched on.
  • Detection: our Sentinel MDR service deploys hunting rules for nginx worker crashes and suspicious child processes.
  • Compromise assessment: if an unpatched server was exposed, our incident response team reviews it for follow-on activity.

References

Facts as of 20 November 2026. Distribution packages and the kernel fix were still pending; we will update this page when they land.