Dissecting CVE-2026-123007: How Unauthenticated HTTP/2 Ingress Triggers Worker Code Execution in NGINX
A technical autopsy of the decade-old nginx2root vulnerability, detailing AVX-512 glibc heap exploitation, container escapes via kernel SCTP bugs, and immediate protocol mitigation steps.
Published: 2026.11.19
Remote unauthenticated code execution across 5 CVEs
Payload delivery threshold before HTTP/2 timeout
NGINX 1.9.5 through 1.31.8 / NGINX Plus R34–R36
A critical decade-old vulnerability in NGINX’s HTTP/2 implementation allows unauthenticated remote attackers to execute arbitrary code within worker processes. Tracked as CVE-2026-123007 and informally designated “nginx2root,” the flaw traces back to commit branches introduced in NGINX 1.9.5 on September 22, 2015.
The vendor, F5, alongside independent researchers at Wiz and Xint, confirmed that attackers can achieve memory corruption and bypass Address Space Layout Randomization (ASLR) on modern 64-bit systems. Once an attacker gains worker-level execution, local container isolation can be compromised. In validated test harnesses, researchers chained this initial foothold with a secondary Linux kernel Stream Control Transmission Protocol (SCTP) defect to escape Docker runtime boundaries and capture root access on the underlying host.
Execution chain from unauthenticated HTTP/2 ingress to host-level root control
Attacker streams 128 GB of malformed frames over 300+ Mbps link to corrupt heap memory.
Payload exploits glibc AVX-512 memcpy routines to execute shellcode under the unprivileged nginx user.
Compromised worker process triggers an unpatched Linux kernel SCTP driver bug inside the container.
Kernel ring-0 corruption breaks container boundaries, yielding root privilege on the host node.
Memory Corruption Mechanics and Exploitation Constraints
CVE-2026-123007 resides directly inside the state machine parsing HTTP/2 stream frames. When HTTP/2 handling is active on a listener directive, inbound frames are processed prior to standard HTTP request dispatching. Because invalid or malformed frame streams alter internal stream state tracking buffers, sustained memory corruption can occur within the heap allocated to the handling worker process.
The practical exploitability of this memory corruption depends heavily on host CPU extensions and the underlying system C library. Rapid7’s independent technical analysis revealed that successful exploitation relies on specific memory copy behavior inside glibc. On x86-64 hardware featuring the avx512f and avx512vl instruction sets, glibc deploys vector-optimized memcpy paths that can be predictably manipulated to bypass ASLR.
Network transport conditions impose strict mechanical limits on attackers attempting to exploit this vulnerability remotely:
- Ingress Volume Requirement: The attack pipeline must pump approximately 128 GB of crafted HTTP/2 control frames directly into a single open connection.
- Bandwidth Floor: NGINX enforces a default connection inactivity and lifespan ceiling of one hour. To deliver 128 GB before the session drops, the attacking ingress pipeline must maintain a sustained throughput above 300 Mbit/s.
- Execution Ceiling: Successful exploitation grants the execution privileges of the active worker process, which runs under an unprivileged system account (typically
nginxorwww-data). - Secondary Escalation Dependency: Gaining host root requires a distinct privilege escalation vector. In research environments across AWS, GCP, and Azure, researchers weaponized an unresolved Linux kernel vulnerability in the SCTP transport module (
sctp.ko) to breach Docker boundaries and secure root-level execution.
Addressing worker corruption and host-level container breakout paths
Heap corruption via CVE-2026-123007 permits ASLR defeat on x86-64 AVX-512 systems.
Strip http2 parameters from active listeners or inject http2 off in server configurations.
Prevent container breakouts by writing install sctp /bin/false into /etc/modprobe.d/.
Comparative Exposure Matrix and Mitigation Profile
F5 fixed CVE-2026-123007 alongside four additional severe security flaws in simultaneous maintenance updates. All five vulnerabilities hold a CVSS 4.0 score of 9.2 due to potential code execution outcomes under specific build profiles.
The vendor addressed these vulnerabilities in open-source NGINX versions 1.31.9 (Mainline) and 1.30.7 (Stable). Commercial NGINX Plus installations require upgrading to release 37.3.0.1 or 37.0.8.1. The table below details the scope, architectural vectors, and remediation profiles across all affected components.
| Vulnerability Identifier | Primary Component | Architecture Precondition | Operational Blast Radius | Immediate Mitigation Action |
|---|---|---|---|---|
| CVE-2026-123007 | HTTP/2 Core Parser | listen ... http2; or http2 on; | Unauthenticated RCE as worker | Upgrade to 1.31.9/1.30.7 or disable HTTP/2 |
| CVE-2026-123633 | HTTP/2 Frame Handler | Active HTTP/2 stream negotiation | Worker memory corruption / crash | Upgrade to 1.31.9/1.30.7 or disable HTTP/2 |
| CVE-2026-123634 | Internal DNS Resolver | SSI, mirror, or variable proxy targets | Code execution via spoofed responses | Remove dynamic upstream names; disable mirror |
| CVE-2026-113425 | Mail Proxy Module | mail { ... } block compiled & active | RCE via protocol negotiation buffer | Restrict mail proxy port listeners to internal VPC |
| CVE-2026-121810 | HTTP/3 QUIC Stack | listen ... quic; or http3 on; | Worker corruption via UDP payload | Remove quic directives; block UDP 443 ingress |
Official Docker Hub base images for NGINX (nginx:1.31.9 and nginx:1.30.7, including Alpine variants) were published immediately. However, enterprise Linux distributions lag behind. Canonical’s Ubuntu status tracker confirms all distributions from 16.04 through 26.10 remain vulnerable upstream. Similarly, Debian’s security tracking designates bookworm, trixie, forky, and sid as unpatched.
Network and data payload divergence during CVE-2026-123007 exploitation
Runtime Detection Gaps and Kernel Defense Playbook
A standard monitoring baseline will not detect active exploitation attempts using default HTTP request metrics. Because the exploit occurs during HTTP/2 control frame processing before a logical request finishes parsing, zero records are generated in conventional access.log files. Systems under active exploitation show completely empty request logs despite receiving dozens of gigabytes of traffic over port 443.
Security operations centers and platform teams must deploy detection alerts at the transport layer and process supervisor tier to catch anomalous activity:
- Asymmetric Connection Accounting: Monitor network boundary firewalls for single TCP connections sustaining greater than 300 Mbit/s over port 443 that yield negligible HTTP layer-7 requests.
- Worker Process Anomalies: Alert on any NGINX worker process spawning child processes (such as
/bin/sh,/bin/bash, orcurl), generating core dumps, or exiting viaSIGSEGVandSIGBUSsignals. - Outbound Tunneling: Flag unexpected outbound socket initiation from edge reverse proxies, specifically atypical external DNS resolutions or outbound SSH and reverse-shell connections originating from unprivileged service accounts.
Sustained single-stream bandwidth on an active HTTP/2 session.
Zero standard HTTP logs recorded during control-frame heap corruption.
Repeated abnormal restarts indicate unstable memory corruption attempts.
If enterprise systems run edge NGINX instances inside Docker, Kubernetes, or LXC containers, security teams must block the host kernel container escape path immediately. If your infrastructure does not rely on SCTP, disable the underlying kernel driver across all container hosts:
# Append blacklist directive to prevent dynamic kernel loading
echo "install sctp /bin/false" | sudo tee /etc/modprobe.d/disable-sctp.conf
# Confirm the module cannot be initialized by unprivileged namespaces
sudo modprobe --dry-run sctp
Note that writing to /etc/modprobe.d/ prevents subsequent attempts to load the module, but does not unload an active driver already running in host memory. Verify active kernel modules via lsmod | grep sctp. If the driver is loaded and unused, manually remove it using rmmod sctp.
Production Triage and Protocol Disablement Protocol
Engineering teams that cannot roll out updated base images or recompiled binaries immediately must implement transport protocol workarounds across their edge clusters.
Prioritize public-facing ingress nodes directly accessible from the internet. NGINX servers behind Content Delivery Networks (CDNs) or Layer-7 cloud load balancers present a narrower attack surface if the intermediate provider terminates HTTP/2 and forwards traffic to the origin over HTTP/1.1. Confirm origin configuration directly:
# Direct TLS handshake audit bypassing proxy/CDN layers
openssl s_client -connect origin.internal.net:443 -alpn h2 </dev/null 2>/dev/null | grep -i "ALPN protocol"
If the handshake output returns ALPN protocol: h2, the origin actively accepts HTTP/2 traffic and remains vulnerable to direct exploitation.
Deploy patched runtime images. Execute a full daemon restart or binary swap to clear old worker memory.
Set http2 off in server blocks. Write sctp blacklist to host modprobe.d to stop kernel escapes.
Protocol Disablement Configuration
For NGINX versions 1.25.1 and newer, set the explicit directive inside all active server configuration blocks:
server {
listen 443 ssl;
server_name api.enterprise.internal;
# Explicitly turn off HTTP/2 processing
http2 off;
ssl_certificate /etc/ssl/certs/bundle.crt;
ssl_certificate_key /etc/ssl/private/server.key;
# ...
}
For legacy deployments running versions 1.9.5 through 1.25.0, strip the http2 parameter directly from every listen directive:
# Change from: listen 443 ssl http2;
# Change to:
listen 443 ssl;
A simple configuration reload (nginx -s reload) is insufficient to clear running exploits. A reload leaves old worker processes alive while existing connections complete, keeping vulnerable code paths active in memory. Production engineering teams must perform a live executable replacement (kill -USR2 <master-pid>) or a complete daemon restart (systemctl restart nginx) to verify that all active workers are running safe code.