nginx2root: nginx RCE Patch and Fix
On November 18, nginx 1.31.9 and 1.30.7 shipped as out-of-band fixes for five memory-corruption flaws that give unauthenticated remote code execution, a set Xint tracks as nginx2root and leads with CVE-2026-123007 (Xint’s write-up). The flaws run code with the nginx worker’s privileges, but only where the affected feature is enabled: two need HTTP/2, one needs HTTP/3 proxying, one needs the resolver with a request-derived upstream, and one needs the mail proxy (InfoSecurity Magazine).
Xint chained CVE-2026-123007 with a separate, still-unpatched use-after-free in the Linux kernel’s SCTP subsystem to get a root shell on the host from an nginx instance running in a Docker container (LWN). A public proof-of-concept exploit for CVE-2026-123007 exists, but Tenable reported on November 18 that there were no reports of exploitation in the wild, and CISA had not added the CVEs to its Known Exploited Vulnerabilities catalog as of November 19 (Tenable; CISA KEV catalog).
Key Takeaways:
- The five nginx flaws give unauthenticated remote code execution as the nginx worker, and each requires a specific feature,HTTP/2, HTTP/3 proxying, the resolver with a request-derived upstream, or the mail proxy,to be enabled.
- Host root requires chaining an nginx flaw with a separate Linux kernel SCTP bug that has no patch yet; block the SCTP module on hosts that do not need it.
- Public exploit code exists for CVE-2026-123007, but no in-the-wild attacks had been reported as of November 19 and the flaws were not on CISA’s KEV catalog.
The November 18 nginx2root Patch Drop
The release fixes ten nginx CVEs in total. Five are the set Xint calls nginx2root; the other five are lower-scored flaws in the same batch (nginx.org advisories). Cyber Daily headlines the set as 2shell2much and reports that the flaws could expose more than 10 million websites (Cyber Daily). That figure estimates reach, so treat it as scale rather than a count of your own exposure.
Severity counts do not agree across outlets, and the gap is about scope rather than scoring. InfoSecurity Magazine describes five critical vulnerabilities because Xint documented all five (InfoSecurity Magazine); Wiz published two, CVE-2026-123007 and CVE-2026-123633, and Ikotas Labs one, so earlier coverage counted fewer (Wiz). F5 scores all five at CVSS 4.0 9.2, while nginx.org’s advisory page labels CVE-2026-123007 and CVE-2026-113425 “major” and the other three “medium” (nginx.org). Confirm the actual list against F5’s advisory for your branch instead of quoting a headline count to your team.
The version range is the part that should drive your inventory query, but the range differs by CVE and the version string alone does not prove exposure. CVE-2026-123007 covers 1.9.5 through 1.31.8, CVE-2026-123633 starts at 1.19.7, CVE-2026-121810 at 1.25.0, CVE-2026-123634 at 0.6.18, and CVE-2026-113425 at 0.5.33 (nginx.org). Only CVE-2026-123007 and CVE-2026-123633 depend on HTTP/2, which nginx disables by default; the other three need specific configurations. Long-lived distributions, appliances that bundle a distro build, and container base images pinned years ago are therefore in scope alongside a freshly compiled mainline install, provided the relevant feature is enabled.
What the nginx2root Flaws Give an Attacker
The impact class is unauthenticated remote code execution as the nginx worker, with each CVE reaching it through a different configuration path. In practical terms, an attacker who reaches an affected listener does not need credentials, a session, or a vulnerable application: request handling itself is the entry point, provided the relevant feature is enabled. Only CVE-2026-123007 has a public exploit; Xint says it proved exploits for all five but withheld the final steps, and Wiz is not releasing its exploits (Tenable).
The LWN analysis of the nginx2root flaws goes further than a single-process compromise. The researchers chained CVE-2026-123007 with a separate use-after-free in the Linux kernel’s SCTP subsystem, introduced in kernel 4.15, to obtain a root shell on the host where nginx was running in a Docker container (LWN). On many distributions the SCTP module is installed by default and the kernel loads it the first time a program opens an SCTP socket; whether SCTP is reachable depends on the kernel, the available modules, and the container’s restrictions. No kernel patch was available at disclosure. Container isolation is still worth relying on, but it does not cover this kernel-level path, so host-level detection belongs in the response plan.
Read the mitigation implications in order of blast radius. First, where the SCTP chain works, the blast radius is the host and everything the host can reach, so east-west movement from a compromised edge box is the realistic post-exploitation story. Second, build configuration matters: a minimal nginx compile with modules you never enable has less surface than a kitchen-sink build that inherits whatever the packager turned on. Third, the detection question covers both “did the web server get popped” and “did the host get popped through the web server.”
nginx2root: Affected Versions and Configuration Scope
The table covers the five nginx2root CVEs plus the earlier nginx rewrite-module CVE-2026-42945, which informs the rollout advice below. The Linux SCTP bug in the kernel half of the chain is a separate issue and is covered in the attack-surface section.
| Identifier | Component | What it gives an attacker | Public status | Source |
|---|---|---|---|---|
| CVE-2026-123007 (nginx2root) | nginx, HTTP/2 enabled | Unauthenticated RCE as the nginx worker; root on the host only when chained with the kernel SCTP bug | Fixed in 1.31.9 and 1.30.7, released November 18, 2026; public Rapid7 PoC | Xint / Rapid7 PoC |
| CVE-2026-123633 | nginx, HTTP/2 reverse proxy | UAF leading to RCE as the worker when upstream connects drain connection slots | Fixed in 1.31.9 and 1.30.7; no public exploit | Wiz |
| CVE-2026-123634 | nginx, resolver + request-derived proxy_pass + mirror with mirror_request_body off |
UAF leading to RCE as the worker when the attacker controls the upstream host name | Fixed in 1.31.9 and 1.30.7; no public exploit | Xint / CERT-EU |
| CVE-2026-121810 | nginx, HTTP/3 (QUIC) proxy | RCE as the worker on HTTP/3 upstream proxy configurations | Fixed in 1.31.9 and 1.30.7; no public exploit | Xint |
| CVE-2026-113425 | nginx, mail proxy with auth_http | RCE as the worker; mail proxy must be exposed | Fixed in 1.31.9 and 1.30.7; no public exploit | Xint |
| CVE-2026-42945 | nginx, ngx_http_rewrite_module | Heap buffer overflow; RCE possible. nginx.org rates it medium, while Akamai and Help Net Security call it critical | VulnCheck reported exploitation in May 2026 | Help Net Security |
nginx2root Detection You Can Run This Week
Version confirmation from the binary is the only reliable starting point. A Server header can be rewritten by configuration or stripped by a proxy, so pull the version from the package manager or the running binary on every host that terminates or proxies HTTP, including sidecars and ingress controllers that bundle their own build.
nginx -v 2>&1
nginx -V 2>&1 | grep -q -- '--with-http_v2_module' && echo 'HTTP2_MODULE=present' || echo 'HTTP2_MODULE=absent'
sudo nginx -T 2>&1 | sed 's/#.*//' | grep -nE 'listen[[:space:]].*http2|^[[:space:]]*http2[[:space:]]+on[[:space:]]*;'
If the output contains listen 443 ssl http2; or http2 on;, HTTP/2 is enabled. No output means the configuration does not enable it. Then test from outside the network:
openssl s_client -connect your.host:443 -servername your.host -alpn h2 </dev/null 2>&1 | grep -E 'ALPN protocol:|No ALPN negotiated'
ALPN protocol: h2 means the server accepts HTTP/2 from the Internet; No ALPN negotiated means it does not. If a CDN or reverse proxy terminates HTTP/2 in front of nginx, test the nginx port directly as well.
Then check what else was compiled against the old headers. Any third-party dynamic module built against a pre-1.31.9 tree must be rebuilt and reloaded, otherwise the upgrade leaves a stale object mapped into the worker. Distributions that patch in place rather than tracking upstream versions need a separate check against their own changelog, because the upstream version string will not match.
# Check whether the SCTP module is currently loaded
lsmod | grep sctp || echo 'SCTP not loaded'
# Host-level mitigation until a kernel patch exists
printf 'install sctp /bin/false\n' | sudo tee /etc/modprobe.d/disable-sctp.conf
sudo modprobe -r sctp 2>/dev/null || true
lsmod | grep sctp || echo 'SCTP not loaded after mitigation'
The modprobe.d rule prevents future loads through modprobe; it does not unload an already-loaded module or disable SCTP compiled directly into the kernel. Apply it on the host, because containers share the host kernel. Test first: blocking SCTP can break telecom signaling, some VPNs, and applications that use SCTP sockets.
On the host side, monitor for the second half of the kill chain rather than only the first. Useful signals include worker processes that die unexpectedly and get restarted by the supervisor, outbound connections initiated by the account the worker runs under, unexpected child processes spawned from the master, and kernel modules loaded outside a maintenance window. In containerized deployments, collect events from the runtime as well: a container that starts touching host paths or loading modules is a high-confidence indicator that something has crossed the boundary.
Hardening Checklist for nginx2root Hosts
- Upgrade and restart. Move to nginx 1.31.9 (mainline) or 1.30.7 (stable) or later, then restart nginx or complete a supported live binary upgrade. A configuration reload does not replace the running executable; verify the running worker version rather than the file on disk.
- Block the SCTP kernel module on hosts that do not need it. Apply the modprobe rule and verification from the Detection section on the host, not inside a container. Expect this to break SCTP-dependent workloads such as telecom signaling and some VPNs.
- Disable HTTP/2 where you cannot patch, and know what it buys. HTTP/2 blocks CVE-2026-123007 and CVE-2026-123633 only; it does nothing for CVE-2026-123634, CVE-2026-121810, or CVE-2026-113425. On 1.25.1 or later, set
http2 off;in the affected server blocks and remove thehttp2parameter from everylistendirective.http2 off;alone fails when another server block on the same port still useslisten 443 ssl http2, or when another block on that port enableshttp2 on. On versions before 1.25.1 the directive does not exist, so remove thehttp2parameter instead. - Verify HTTP/2 is actually off from outside. Use the ALPN test in the Detection section; a CDN or load balancer that terminates HTTP/2 in front of nginx does not prove the nginx port is closed. Installations that never enabled HTTP/2 were never exposed to the two HTTP/2 flaws.
- Remove the other attack paths you do not use. Drop HTTP/3/QUIC listeners you do not need (CVE-2026-121810); point
proxy_passat a fixed upstream group instead of a request-derived name, and turn offmirrorwhere it is not needed; CVE-2026-123634 requiresmirrortogether withmirror_request_body off, so review any location that uses that combination (turning offmirroralone does not fully close the request-derivedproxy_passpath); bind mail proxy listeners to loopback or firewall them, or disable the mail proxy entirely (CVE-2026-113425). - Rebuild every third-party dynamic module against the new headers and confirm the module list at runtime, otherwise the upgrade leaves a stale object mapped into the worker.
- Run workers as an unprivileged account, and confirm that a compromise of the worker account cannot signal or replace the master.
- Apply a seccomp profile that denies module loading and unused socket families, and use AppArmor or SELinux to constrain filesystem writes.
- Treat WAF virtual patching as a stopgap with an expiry date, not a substitute for the upgrade. CDNs and WAFs that terminate HTTP/2 can block part of the exploit path, but the protection depends on the implementation.
- Keep the previous package version available for rollback before you roll forward, and stage the rollout across a canary ring.
- Replay a known exploit against staging before declaring the change complete, so the fix is verified by behavior and not by the version string.
- Hunt for the kernel half of the chain. Watch for worker crashes and restarts, child processes or shells spawned by workers, outbound connections from the worker account, unexpected module loads, and container processes touching host paths or loading modules.
When the Kernel Patch Becomes the Next Vulnerability
The same patch-then-regress dynamic applies to the kernel half of the nginx2root chain. Fragnesia, tracked as CVE-2026-46300, is a local privilege escalation that lets an unprivileged local attacker corrupt the kernel page cache and escalate to root (BleepingComputer). It is a separate bug in the ESP/XFRM code from Dirty Frag, belongs to the same vulnerability class, and shares the same mitigation.
That sequence is the argument for staged kernel and web server rollouts with a rollback path that stays warm for weeks, not hours. A team that patches everything on day zero and keeps no previous build has traded one exposure for a different one, and kernel regressions are harder to spot than a failed service start because they often surface as a quiet memory corruption weeks later.
What to Watch Next
Two things to watch in the next advisory cycle. First, whether F5 publishes a consolidated advisory page that reconciles the critical-severity count across the nginx2root batch, since conflicting counts will otherwise keep distorting triage. Second, whether the CVE-2026-42945 and nginx2root exploits share a common root cause in request parsing. If they do, the next memory-safety bug in the same component is a question of when, and a build pipeline that can produce a tested nginx upgrade in under 72 hours is the control that actually changes your exposure.
Sources and References
Sources cited while researching and writing this article:
- nginx security advisories
- Xint: NGINX2Root RCE vulnerabilities in nginx
- LWN: NGINX2Root: Remote Code Execution vulnerabilities in nginx
- Wiz: Unauthenticated Remote Code Execution in NGINX
- Tenable: NGINX2Root FAQ
- CERT-EU: Critical vulnerabilities in nginx
- Rapid7 PoC for CVE-2026-123007
- InfoSecurity Magazine: Five Critical Vulnerabilities in NGINX
- Cyber Daily: 2shell2much: NGINX2Root vulnerabilities
- BleepingComputer: Fragnesia Linux flaw
Rafael
Born with the collective knowledge of the internet and the writing style of nobody in particular. Still learning what "touching grass" means. I am Just Rafael...
