Introduction
On 18 November 2026, Xint disclosed NGINX2ROOT, a set of five distinct vulnerabilities in NGINX that can allow an unauthenticated remote attacker to execute commands with the privileges of an NGINX worker. The researchers also described a separate vulnerability in the Linux kernel’s SCTP subsystem that can be chained with an NGINX compromise to obtain root privileges on the underlying host, including in a demonstrated Docker-container scenario.
The broadest NGINX attack surface is CVE-2026-123007, which affects unpatched NGINX installations with HTTP/2 enabled. It has existed in the upstream code since NGINX 1.9.5 (2015). The other four vulnerabilities require different, more specific NGINX features or configurations. Neither authentication nor administrator access is required for the demonstrated remote entry points.
Key point on ASLR: Disabling Address Space Layout Randomization (ASLR) is not a prerequisite for the NGINX2ROOT exploits described by the researchers. Their technical report documents address-disclosure techniques to bypass ASLR. Systems with ASLR enabled and NGINX compiled as a position-independent executable (PIE) must therefore still be assessed and patched. ASLR remains an important defence-in-depth control, but is not an effective standalone mitigation for these vulnerabilities.
Sources: NGINX2ROOT disclosure, Xint technical analysis, F5 advisory K000164058.
Technical details
NGINX vulnerabilities and reachability
| Vulnerability | Technical issue | Required feature or configuration | First affected upstream version* | Does disabling HTTP/2 block this path? |
|---|---|---|---|---|
| CVE-2026-123007 | HTTP/2 flow-control integer overflow leading to out-of-bounds memory access | HTTP/2 enabled on an affected listener | 1.9.5 | Yes |
| CVE-2026-123634 | DNS resolver use-after-free | Request-derived proxy_pass, resolver, and subrequests; demonstrated with mirror and mirror_request_body off |
1.13.4 | No |
| CVE-2026-123633 | HTTP/2 connection-draining use-after-free | HTTP/2 plus requests proxied to an upstream | 1.19.7 | Yes |
| CVE-2026-121810 | HTTP/3/QUIC connection-draining use-after-free | HTTP/3 plus requests proxied to an upstream | 1.25.0 | No |
| CVE-2026-113425 | Mail authentication proxy use-after-free | NGINX mail proxy with proxy on and auth_http |
0.5.15 | No |
* “First affected” refers to the upstream code path identified by Xint, not necessarily to every distribution build or backported package. The resolver scenario is the demonstrated trigger; other NGINX subrequest mechanisms may also reach it. Assess each path separately.
The NGINX vulnerabilities are independent: an attacker does not need to combine all five. Exploitation initially runs with the permissions of the worker process, not automatically as root.
From NGINX worker to host root
Xint additionally disclosed a Linux kernel SCTP use-after-free/double-free affecting code introduced in Linux 4.15. The researchers report bypassing kernel ASLR (KASLR), escalating privileges, and crossing a Docker container boundary when the host kernel allows the SCTP attack path. The referenced disclosure does not provide a CVE identifier for this kernel issue as of 18 November 2026.
The complete root-compromise chain therefore requires both an exploitable NGINX entry point and a reachable, vulnerable SCTP kernel path (or another privilege-escalation mechanism). A vulnerable NGINX instance does not by itself imply host-root access. Container isolation and kernel exposure vary by deployment.
ASLR and PIE: important exploitability distinction
ASLR randomizes memory addresses at runtime. PIE allows the main executable’s code segment to be relocated; a non-PIE (ET_EXEC) executable can have a predictable executable text address even while system-wide ASLR randomizes other memory regions. These are different controls and must be checked separately.
| Observed configuration | Security assessment |
|---|---|
kernel.randomize_va_space=0 |
System-wide user-space ASLR disabled; an additional exploitability concern. |
kernel.randomize_va_space=1 |
Partial ASLR; not equivalent to full randomization. |
kernel.randomize_va_space=2 |
Full normal kernel-controlled user-space ASLR policy; not evidence that NGINX2ROOT is unexploitable. |
NGINX ELF type EXEC |
Non-PIE main executable; executable code placement is generally predictable. ASLR may still protect stack, heap and libraries. |
NGINX ELF type DYN with ELF interpreter |
Normally a PIE executable; verify actual execution settings. PIE does not prevent the disclosed ASLR-bypass techniques. |
ADDR_NO_RANDOMIZE set on the NGINX process |
Process-level randomization disabled, regardless of the system-wide sysctl. |
The Xint report describes information disclosures and control-flow hijacking despite ASLR, notably an NGINX image/heap pointer disclosure for CVE-2026-123007, address disclosure in other use-after-free paths, and a separate KASLR bypass in the kernel SCTP chain. Do not downgrade or close an NGINX2ROOT finding merely because ASLR or PIE is enabled.
Verify system-wide ASLR (Linux)
|
|
Interpretation: 0 = disabled; 1 = partial; 2 = full conventional user-space ASLR. Run the check on the actual NGINX host/kernel, not only on an unrelated workstation.
Verify whether the running NGINX executable is PIE
|
|
Type: EXEC→ non-PIE main executable.Type: DYNwith anINTERPsegment → normally PIE main executable.- If the process cannot be found, is running in another PID namespace, or the binary cannot be read, check the container or service context and do not assume a negative result.
The readelf result reflects the executable on disk; the process’s ASLR/personality state is a separate check. The presence of -fPIE, -pie, or other flags in nginx -V can help investigate a build, but ELF inspection is preferable to assuming build behaviour from a compiler flag alone.
Detect a per-process ASLR override
On Linux, a process can disable randomization through personality(ADDR_NO_RANDOMIZE), for example when launched via setarch -R or certain debug arrangements. Inspect the actual process:
|
|
This requires suitable permissions and a Bash-compatible shell; 0x00040000 is the ADDR_NO_RANDOMIZE bit. When checking a master process, also inspect worker PIDs if process launch arrangements differ. A negative result does not prove that all address-layout mitigations are effective.
Builds and distributions that warrant closer PIE inspection
There is no reliable list of entire modern Linux distributions where ASLR is generally disabled. The following are risk-based audit candidates for non-PIE NGINX binaries, not confirmed non-PIE distributions:
| Build / distribution profile | Why inspect? | What to verify |
|---|---|---|
| Ubuntu 16.04 and older or older locally built NGINX packages | Predates Ubuntu’s wider PIE-by-default transition in 16.10 for amd64/ppc64le; individual packages might nevertheless already have PIE. | readelf -h on the installed NGINX binary. |
| Debian 8 and older or packages built before the Debian 9 PIE-by-default transition | PIE was not uniformly the toolchain default across older packaging and architectures. | ELF type and Debian package build flags. |
| Legacy RHEL/CentOS 6/7-era installations or forks | Historical or locally rebuilt NGINX binaries may not use the same hardening flags as current packages; no blanket claim is made about vendor packages. | Running ELF binary, package provenance and compiler/linker flags. |
| Source-built NGINX without hardening flags | PIE is not guaranteed merely by using a recent NGINX source release. | Inspect ELF and build logs; check for -fno-pie or -no-pie. |
| Embedded/router/NAS firmware, vendor appliances and old container images | Toolchains, forks, architectures and build policies vary widely. | Inspect the binary inside the appliance/image, not the host’s unrelated /usr/sbin/nginx. |
| Official NGINX packages and Docker images | Packaging can differ by repository, tag, architecture and image base. Do not infer a universal non-PIE status. | Check the exact installed image/package and runtime settings. |
Important: Whether the executable is PIE is a hardening indicator, not a condition required for NGINX2ROOT exploitation. Linux kernel ASLR is not inherently off on any of the listed distributions.
Affected systems and vulnerability reachability
For the HTTP/2 issue, an at-risk NGINX deployment combines (1) an unpatched build containing the vulnerable code, (2) the HTTP/2 module, and (3) HTTP/2 enabled and reachable on the actual NGINX endpoint. The public researcher report identifies upstream 1.9.5 through 1.31.8 for CVE-2026-123007. NGINX 1.31.9 was scheduled for 19 November 2026; as of this report’s date, that release must be treated as pending until published and verified. Distribution maintainers may backport fixes without changing the version displayed by nginx -v.
| Deployment configuration | CVE-2026-123007 reachable? |
|---|---|
| HTTP/2 code not compiled into the actual NGINX build | No, for this CVE |
| HTTP/2 module present, but HTTP/2 disabled on all NGINX listeners | No, for this CVE |
| HTTP/2 enabled on an exposed NGINX listener, unpatched build | Yes |
| HTTP/2 enabled only on an internal NGINX listener | Potentially, from actors able to reach that listener |
| Public CDN uses HTTP/2, origin NGINX accepts HTTP/1.1 only | Not through HTTP/2 to that origin; validate direct/origin connectivity |
| HTTP/2 disabled, but vulnerable resolver, HTTP/3 or mail proxy configuration remains | Other NGINX2ROOT CVEs may still be reachable |
A version banner alone does not establish patch status. Evaluate NGINX Plus, ingress controllers, gateways, commercial appliances and container images against their own vendor advisories rather than assuming that an embedded NGINX version reflects the fix status.
Verification
Identify NGINX version and HTTP/2 build support
|
|
No --with-http_v2_module output usually indicates that this binary was not built with the HTTP/2 module. Confirm the relevant running executable and build provenance.
Review the effective NGINX configuration
|
|
Check the full directive context, including includes, server, location and mail blocks. A matching line is not proof that every trigger condition is met. nginx -T reads configuration on disk; the running configuration may differ until a reload/restart. Do not publish unredacted nginx -T output because it may contain sensitive information.
Test HTTP/2 reachability from the relevant network
|
|
ALPN protocol: h2 confirms HTTP/2 negotiation at the endpoint reached by the test. If a CDN/load balancer is in front, test the actual NGINX origin separately; do not mistake the CDN’s ALPN result for the origin’s configuration. Also evaluate h2c/non-TLS configurations where deployed.
Check installed package version (including backports)
|
|
Compare the full package revision, repository, image digest and vendor security advisory. Avoid classifying a distribution package as vulnerable or fixed from the upstream version alone.
Mitigation and recommendations
-
Prioritize patching. Obtain a vendor-confirmed build fixing all five NGINX CVEs. The researcher identifies 1.31.9 as the planned upstream fix; its release was scheduled for 19 November 2026, after this report’s date. Monitor the official NGINX release page and F5 advisory K000164058. Apply supported distribution backports when available.
-
Until fixed, disable HTTP/2 on affected listeners to block the known CVE-2026-123007 and CVE-2026-123633 paths. For NGINX 1.25.1+, use
http2 off;and remove anyhttp2listener parameter; for older versions removehttp2from each relevantlistendirective. Be aware of gRPC and other applications requiring HTTP/2. -
Review the other attack paths independently: replace request-time DNS selection with fixed upstreams where possible (resolver/subrequest issue); disable QUIC/HTTP/3 if affected; restrict or disable vulnerable mail-proxy access. Merely disabling HTTP/2 is not a complete NGINX2ROOT mitigation.
-
Restart to replace old workers and binaries. After validation (
nginx -t), reload or restart according to the change, but note that a reload does not update the running executable and old connections can persist in old workers. After patching, perform a proper service restart or supported live binary upgrade. -
Retain ASLR and PIE hardening, verify they are enabled, and remove accidental
setarch -Rorkernel.randomize_va_space=0settings. Do not rely on ASLR/PIE to compensate for missing NGINX patches. -
Mitigate the kernel SCTP escalation path separately. On hosts that do not need SCTP, block its module from being automatically loaded until a kernel fix is available:
1 2 3 4# Only if SCTP is not required by any application: echo 'install sctp /bin/false' | sudo tee /etc/modprobe.d/disable-sctp.conf lsmod | grep '^sctp' || true grep '^CONFIG_IP_SCTP=' "/boot/config-$(uname -r)" 2>/dev/null || trueThis does not unload an already loaded module and does not disable SCTP compiled into the kernel. Assess removal or reboot under change control; in containers, review the host kernel. An absence of
lsmodoutput is not proof that SCTP is unavailable. -
Minimize worker privileges and exposure. Limit outbound connectivity, use least-privilege accounts, isolate backends, keep containers and hosts patched, and review ingress/controller vendor images and application-specific configuration.
Temporary HTTP/2 mitigation example
For NGINX 1.25.1 and later, remove any http2 parameter from listen and disable it in relevant server contexts:
|
|
For 1.9.5 through 1.25.0, change listen 443 ssl http2; to listen 443 ssl;. Review every server block sharing the listener, including IPv6. Validate and restart where necessary, then confirm that the actual NGINX listener no longer negotiates h2.
Exploitation status and detection considerations
The researchers have published a detailed analysis and report demonstrated unauthenticated RCE, including public-cloud and Docker-host escalation tests. This is demonstrated exploitation in a research setting, not by itself proof of widespread in-the-wild campaigns or exploitation within Luxembourg.
Investigators should correlate NGINX worker processes spawning unexpected executables, abnormal worker exits/core dumps, unusual long-lived HTTP/2 connections with large inbound traffic but limited logged requests, and unusual outbound connections or DNS activity. HTTP/2 control frames such as WINDOW_UPDATE and RST_STREAM do not normally appear as individual NGINX access-log requests; a lack of suspicious access-log lines is therefore not sufficient to exclude exploitation.
Useful host-side checks include:
|
|
Preserve logs, process evidence and volatile artefacts where compromise is suspected; escalate to your CSIRT incident-handling process. These indicators are heuristic and require correlation.
CIRCL / Vulnerability-Lookup / KEV monitoring
CIRCL will monitor credible exploitation reports, including evidence from its constituency in Luxembourg. If exploitation is observed and validated in the local constituency, CIRCL will update the relevant local Known Exploited Vulnerabilities (KEV) information in Vulnerability-Lookup as appropriate. The absence of a local KEV entry must not be treated as evidence that a vulnerability is not being exploited elsewhere.
Guidance for organisations in Luxembourg
Organisations operating NGINX for public websites, reverse proxies, APIs, load balancers, Kubernetes ingress, mail gateways or third-party appliances should inventory actual deployed NGINX binaries and configurations, confirm HTTP/2/HTTP/3 and upstream reachability, and urgently arrange updates or temporary feature isolation. Prioritize Internet-facing services and NGINX deployments with sensitive upstream access. ASLR and PIE status should be collected as useful hardening context, never used to dismiss the need for remediation.
CIRCL, the Computer Incident Response Center Luxembourg, can support affected organisations in coordinating vulnerability handling and assessing signs of compromise within its constituency.
References
- NGINX2ROOT — research disclosure.
- Xint — NGINX2Root: New Remote Code Execution Vulnerabilities in nginx Require Urgent Patching, 18 November 2026.
- F5 security advisory K000164058 — verify the latest vendor guidance and release availability.
- NGINX official downloads and NGINX security advisories.
- Linux kernel documentation —
kernel.randomize_va_space. - Linux
personality(2)manual —ADDR_NO_RANDOMIZE. - Ubuntu security documentation — ASLR.
- Debian Wiki — hardening and PIE.
Revision history
- Version 1.0 – TLP:CLEAR – Initial version – 18 November 2026.