NGINX2Root is five nginx CVEs plus one Linux kernel bug. Each nginx bug is a use-after-free or out-of-bounds memory access that an attacker can trigger without authentication; which one applies to you depends on whether you use HTTP/2, HTTP/3, a DNS resolver, or the mail proxy. nginx rates CVE-2026-123007 (HTTP/2 flow control) and CVE-2026-113425 (mail proxy) as Major and the other three as Medium. The kernel half, a flaw in the SCTP network protocol present since Linux 4.15, had no patch when the research was published.
This article was created with AI assistance. Facts were checked against the nginx security advisories page, the nginx.org release announcement, and Xint’s NGINX2Root write-up on November 18, 2026. No CVSS scores had been published at the time of writing. Confirm details with your distribution or F5 before acting.
TL;DR: what to do today
- Upgrade nginx to 1.30.7 (stable) or 1.31.9 (mainline), or install your distribution’s package that lists these CVE IDs. Then restart nginx (or do a binary upgrade) and rebuild container images. A
reloadis not enough. - If you cannot patch yet, disable HTTP/2 and HTTP/3 on internet-facing servers and apply the other config workarounds that match your setup.
- Block the SCTP kernel module on hosts that do not need it, which breaks the published path from nginx worker to root.
- Check for signs of compromise since November 18 (worker crashes, shells spawned by the nginx user), and rotate TLS keys and secrets on any host that looks suspicious.
The five NGINX2Root CVEs
Version ranges and severity below are from the official nginx security advisories. All five are fixed in 1.31.9 and 1.30.7.
| CVE and bug | nginx severity | Vulnerable versions | You are exposed if |
|---|---|---|---|
| CVE-2026-123007 Memory corruption in HTTP/2 flow control | Major | 1.9.5–1.31.8 | HTTP/2 is enabled |
| CVE-2026-123633 Use-after-free in HTTP/2 | Medium | 1.19.7–1.31.8 | HTTP/2 is enabled and nginx proxies to an upstream |
| CVE-2026-121810 Use-after-free in HTTP/3 | Medium | 1.25.0–1.31.8 | HTTP/3 (QUIC) is enabled and nginx proxies to an upstream |
| CVE-2026-123634 Use-after-free in the DNS resolver | Medium | 0.6.18–1.31.8 | A resolver is configured, proxy_pass uses a request-derived name such as $host, and mirror (or another subrequest feature such as SSI) is in use |
| CVE-2026-113425 Use-after-free in the mail proxy module | Major | 0.5.33–1.31.8 | A mail block proxies IMAP, POP3, or SMTP with auth_http |
The same release fixes five other CVEs that are not part of the NGINX2Root chain but are worth knowing about: an infinite loop reading request bodies over TLS 1.3 (CVE-2026-118899, Major, 1.13.0–1.31.8), an SNI bypass in stream-module client certificate validation (CVE-2026-120967, Medium), and three Minor issues: a PROXY protocol v2 NULL dereference (CVE-2026-120993, mainline 1.31.4–1.31.8 only), a buffer overflow with alias plus try_files (CVE-2026-125283), and insufficient validation in ssl_preread (CVE-2026-123640). Upgrading covers all ten.
Timeline
| Date (2026) | Event |
|---|---|
| October 11 | Xint finds the vulnerabilities. CVE-2026-123007 came from manual research; the other four from Xint’s automated code scanning |
| October 16 | Reported to F5 through HackerOne |
| October 27 | Reports reach the nginx development team |
| November 10 | Xint finishes validating nginx’s patches |
| November 18 | nginx 1.30.7 and 1.31.9 released; Xint publishes nginx2root.com and its write-up. No exploitation in the wild reported |
How a website visitor becomes root
Xint describes a two-stage chain. Neither stage needs credentials.
- Code execution in an nginx worker. In CVE-2026-123007, when an HTTP/2 stream is cancelled, nginx returns its queued data “credit” to the connection’s send window without checking the upper limit. An attacker can push the window past its 31-bit maximum, after which an unsigned size check wraps around and a negative length reaches
memcpy. That gives out-of-bounds reads, which defeat address randomization, and out-of-bounds writes, which Xint used to overwrite a cleanup function pointer. The other four bugs are use-after-frees in which a connection, request, or session is freed while another code path still holds a pointer to it. - Root via the kernel. nginx workers run as an unprivileged user, so Xint paired them with a use-after-free in the Linux SCTP send path (a send waiting on an association runs after the association moved to another socket). It provides a memory leak and an arbitrary kernel function call. Xint reports that it worked from inside a Docker container and reached the host kernel, which means every other container on that host too.
Xint says it demonstrated the chain on AWS, GCP, Azure, and bare metal, and deliberately withheld the final exploitation steps. The patch diffs are public, though, and reverse proxies are some of the most exposed software on the internet, so expect exploit development to be fast.
Check whether you are exposed
Run these on each nginx host, including container images and ingress controllers:
# 1. Version and compiled-in modules (look for http_v2 / http_v3 / mail)
nginx -v
nginx -V 2>&1 | tr ' ' '\n' | grep -E 'http_v2|http_v3|mail'
# 2. Which risky features does the running config actually use?
nginx -T 2>/dev/null | grep -nE '\bhttp2\b|\bhttp3\b|\bquic\b|\bresolver\b|\bmirror\b|\bauth_http\b|^\s*mail\s*\{'
# 3. Does the server negotiate HTTP/2 from the outside?
openssl s_client -connect example.com:443 -servername example.com -alpn h2 </dev/null 2>/dev/null \
| grep -i 'ALPN protocol'
# 4. Does it advertise HTTP/3?
curl -sI https://example.com | grep -i '^alt-svc'
# 5. Is SCTP loaded or loadable on the host?
lsmod | grep -w sctp; modinfo sctp >/dev/null 2>&1 && echo "sctp module available"
- If a CDN or load balancer sits in front, test the origin directly as well. The CDN may terminate HTTP/2 itself, while the origin still accepts HTTP/2 from anyone who can reach it.
- Distribution packages lie about versions. Debian, Ubuntu, RHEL, and Alpine routinely backport fixes, so
nginx -von Ubuntu 22.04 prints1.18.0whether or not it is patched. Check your distribution’s security tracker for these five CVE IDs and compare the full package version. - Containers and ingress. Official
nginximages, Kubernetes ingress controllers based on nginx, and appliances that embed it all need their own update. Rebuild images; do not assume the host package covers them.
Mitigations if you cannot patch right now
Apply the ones that match the features your config uses:
- Disable HTTP/2 (blocks CVE-2026-123007 and CVE-2026-123633). Browsers and API clients fall back to HTTP/1.1. Services that use
grpc_passneed HTTP/2 on the listener, so patch those first instead.# nginx 1.25.1 and later server { listen 443 ssl; # remove "http2" here if present http2 off; } # nginx 1.9.5 to 1.25.0: change "listen 443 ssl http2;" to listen 443 ssl; - Disable HTTP/3 (blocks CVE-2026-121810). Remove
quiclisteners, sethttp3 off;, and tell clients to forget cached HTTP/3 endpoints withadd_header Alt-Svc clear always;. Optionally block UDP 443 at the firewall. - Pin upstreams (CVE-2026-123634). Replace request-derived targets like
proxy_pass http://$host;with a fixedupstreamblock, and removemirrorwhere you do not need it. Xint found thatmirror_request_body onstopped its exploit, but it does not fix the underlying bug. - Restrict the mail proxy (CVE-2026-113425). Bind IMAP, POP3, and SMTP listeners to loopback or firewall them to known clients.
- Block SCTP on hosts that do not use it, which breaks the published path to root:
This does not unload a module that is already loaded and does nothing if SCTP is built into the kernel.echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/disable-sctp.conf lsmod | grep -w sctp # if listed, it is already loaded; reboot or unload it - Restart, do not reload. After any change, run
nginx -tand restart. A reload leaves old workers serving existing connections, so an attacker holding a long-lived HTTP/2 connection keeps the vulnerable code path. For a zero-downtime alternative, use nginx’s binary upgrade; we walked through it in our October nginx upgrade guide.
Look for signs of exploitation
- Worker crashes. Memory-corruption attempts often fail noisily. Search for
worker process ... exited on signalin the error log and runcoredumpctl list nginx. - Shells or commands spawned by the nginx user. nginx workers never need to run programs. Audit
execveby the worker’s UID (for example withauditctlandausearch); any hit is the clearest signal of compromise. - Odd HTTP/2 connections. Long-lived connections on port 443 that receive far more data than they send (
ss -tinp state established '( sport = :443 )'), many cancelled streams, or unusual flow-control behavior. - Outbound connections from nginx to unfamiliar hosts or DNS servers, which CVE-2026-123633, CVE-2026-121810, and CVE-2026-123634 rely on.
If a host looks compromised, assume root. Rebuild it rather than cleaning it, and rotate what nginx and the host held: TLS private keys, upstream credentials, API keys in config, and session or signing secrets for the applications behind it.
Why this matters for the APIs behind nginx
Most APIs never face the internet directly. nginx terminates TLS, routes requests, and often adds identity: it sets X-Forwarded-For, passes the client certificate, or forwards a user header after auth_request. That makes a compromised nginx worker uniquely dangerous for an API team:
- It sees every request in clear text, including bearer tokens, API keys, session cookies, and request bodies, for every service behind it.
- It can forge any header your backends trust. If a service grants access because a request has
X-User-Id,X-Internal: true, or a source IP from the proxy, the attacker now controls that decision. - It sits on the internal network, so services that skip authentication because they are “only reachable from the proxy” are reachable by the attacker.
The defensive principle is zero trust behind the edge: every API should authenticate and authorize each request itself, validate tokens rather than trusting headers, and treat proxy-supplied identity as a hint, not proof. Emergency mitigations add a second risk: disabling HTTP/2, pinning upstreams, or rewriting proxy_pass under pressure changes routing, and a mistake can expose an internal route or drop an auth_request check without anyone noticing.
How DastPilot helps around NGINX2Root
To be clear about what DAST can and cannot do: DastPilot will not tell you whether your nginx build is vulnerable to CVE-2026-123007. That is a question for your package inventory, the checks above, and your distribution’s advisories. Firing memory-corruption payloads at a production proxy to “test” it is a good way to take your site down.
Where dynamic application security testing helps is making sure the patch and the emergency config changes do not open a different hole. DastPilot scans your APIs through the same nginx your users hit, from your OpenAPI spec or Postman collection, as every role you configure:
- Authentication still enforced after the change: calls every documented operation with no credentials and with expired or tampered tokens, so you know immediately if a rewritten
locationor a droppedauth_requestleft an endpoint open. - Authorization across roles (BOLA and BFLA): replays requests as other users and lower-privileged roles, so a backend that leans on proxy-set identity instead of checking it shows up as a finding before an attacker finds it.
- Security misconfiguration: flags verbose error pages, missing security headers, and unsafe HTTP methods, which commonly reappear when nginx config is edited in a hurry.
- Revoked credentials stay revoked: after you rotate keys and tokens on a suspect host, a re-scan confirms that old tokens are rejected.
- Regression tracking in CI/CD: each scan is compared with the last, so new or reopened findings after an nginx upgrade are obvious. Wire it into your pipeline and every proxy change ships with evidence that your APIs still fail closed.
Patch nginx and block SCTP to close NGINX2Root. Then point DastPilot at the upgraded edge, so you can prove nothing behind it got weaker in the rush.
Frequently asked questions
What is NGINX2Root?
NGINX2Root is the name security firm Xint gave to five nginx memory-safety vulnerabilities (CVE-2026-123007, CVE-2026-123633, CVE-2026-121810, CVE-2026-123634, and CVE-2026-113425) and a Linux kernel SCTP bug. Each nginx bug can give an unauthenticated attacker code execution in an nginx worker process, and the kernel bug escalates that to root on the host. nginx fixed the five CVEs on November 18, 2026.
Which nginx versions fix NGINX2Root?
nginx 1.30.7 (stable) and 1.31.9 (mainline), released November 18, 2026, fix all five CVEs. Distribution packages such as Ubuntu and Debian often backport fixes without changing the version that nginx -v prints, so check your distribution’s security notice for these CVE IDs rather than the version string.
Is my nginx server affected by CVE-2026-123007?
CVE-2026-123007 affects nginx 1.9.5 through 1.31.8 when HTTP/2 is enabled, a common setting on HTTPS servers. nginx rates it Major. The other four bugs need HTTP/2 with upstream proxying, HTTP/3, a DNS resolver with mirrored requests, or the mail proxy with auth_http.
How do I mitigate NGINX2Root without upgrading?
Disable HTTP/2 (http2 off; on nginx 1.25.1 and later, or remove http2 from the listen directive on older versions) to block CVE-2026-123007 and CVE-2026-123633. Remove quic listeners and set http3 off; for CVE-2026-121810. Use fixed upstreams instead of request-derived proxy_pass targets and turn off mirror for CVE-2026-123634. Restrict mail proxy listeners for CVE-2026-113425. Restart nginx afterwards, because a reload leaves old workers serving existing connections.
Is NGINX2Root being exploited in the wild?
As of November 18, 2026 there were no public reports of exploitation in the wild. Xint says it has working exploits that it demonstrated on AWS, GCP, Azure, and bare metal, but it withheld the final steps. Because the patch diff is public, treat internet-facing nginx as urgent.
Can a DAST scanner detect NGINX2Root?
Not safely. These are memory-corruption bugs, so the right check is your nginx build, its configuration, and your distribution’s advisories, and sending exploit traffic can crash production. API DAST tools such as DastPilot help around the patch: they verify that authentication and routing still behave after you upgrade nginx or disable HTTP/2, and that backend APIs do not trust headers a compromised proxy could forge.
Prove your APIs still fail closed after the nginx patch
DastPilot scans every documented endpoint through your upgraded edge, as every role, and flags anything that became reachable without proper authentication or authorization. 30-day free trial, no credit card required.