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

CVSS 4.0 Base Score
9.2 Critical

Remote unauthenticated code execution across 5 CVEs

Minimum Attack Ingress
128 GB / >300 Mbps

Payload delivery threshold before HTTP/2 timeout

Vulnerable Code Base
Sept 2015 – Nov 2026

NGINX 1.9.5 through 1.31.8 / NGINX Plus R34–R36

Executive Takeaway ·Upgrading to NGINX 1.31.9/1.30.7 is mandatory, but disabling HTTP/2 on public listeners and blacklisting the kernel SCTP module eliminates remote exploita…

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.

CVE-2026-123007 Remote Compromise and Host Escape Sequence

Execution chain from unauthenticated HTTP/2 ingress to host-level root control

01 · Step 01
HTTP/2 Control Frame Flooding

Attacker streams 128 GB of malformed frames over 300+ Mbps link to corrupt heap memory.

02 · Step 02
ASLR Bypass & Worker Hijack

Payload exploits glibc AVX-512 memcpy routines to execute shellcode under the unprivileged nginx user.

03 · Step 03
Kernel SCTP Exploitation

Compromised worker process triggers an unpatched Linux kernel SCTP driver bug inside the container.

04 · Step 04
Full Host Root Escape

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 nginx or www-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.
Immediate Threat Vector Mitigation Framework

Addressing worker corruption and host-level container breakout paths

01 · Ingress Vulnerability
HTTP/2 Worker Code Execution

Heap corruption via CVE-2026-123007 permits ASLR defeat on x86-64 AVX-512 systems.

02 · Interim Protocol Defense
Disable HTTP/2 Transport Directives

Strip http2 parameters from active listeners or inject http2 off in server configurations.

03 · Host Containment Defense
Blacklist Linux Kernel SCTP Module

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 IdentifierPrimary ComponentArchitecture PreconditionOperational Blast RadiusImmediate Mitigation Action
CVE-2026-123007HTTP/2 Core Parserlisten ... http2; or http2 on;Unauthenticated RCE as workerUpgrade to 1.31.9/1.30.7 or disable HTTP/2
CVE-2026-123633HTTP/2 Frame HandlerActive HTTP/2 stream negotiationWorker memory corruption / crashUpgrade to 1.31.9/1.30.7 or disable HTTP/2
CVE-2026-123634Internal DNS ResolverSSI, mirror, or variable proxy targetsCode execution via spoofed responsesRemove dynamic upstream names; disable mirror
CVE-2026-113425Mail Proxy Modulemail { ... } block compiled & activeRCE via protocol negotiation bufferRestrict mail proxy port listeners to internal VPC
CVE-2026-121810HTTP/3 QUIC Stacklisten ... quic; or http3 on;Worker corruption via UDP payloadRemove 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.

Attack Ingress Requirement vs Nominal Production Session

Network and data payload divergence during CVE-2026-123007 exploitation

Standard API Session Rapid7 Exploit Trace
Total Data Ingress Volume 2.8M-fold surge
Standard API Session 45 KB
Rapid7 Exploit Trace 128 GB
Minimum Network Throughput 250x line saturation
Standard API Session 1.2 Mbit/s
Rapid7 Exploit Trace 300 Mbit/s

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, or curl), generating core dumps, or exiting via SIGSEGV and SIGBUS signals.
  • 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.
Telemetry Thresholds for Threat Hunting
Ingress Saturation
>300 Mbps

Sustained single-stream bandwidth on an active HTTP/2 session.

Access Log Footprint
0 Requests

Zero standard HTTP logs recorded during control-frame heap corruption.

Worker Exit Signature
SIGSEGV

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.

Remediation Decision Tree for CVE-2026-123007
Can binaries and container bases be upgraded to 1.31.9/1.30.7 within 4 hours?
Yes (Automated CI/CD Available)
Binary Upgrade & Process Refresh

Deploy patched runtime images. Execute a full daemon restart or binary swap to clear old worker memory.

→ Production Tier 1
No (Distribution Patch Lag)
Protocol Hardening & Module Blacklist

Set http2 off in server blocks. Write sctp blacklist to host modprobe.d to stop kernel escapes.

→ Production Tier 2

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.

Related Benchmark Reports

View All in Category →
Weekly Briefing

Weekly Tech & Business Data Briefing

Verified software analysis, practical gotchas, and essential supply-chain updates delivered weekly.

Unsubscribe with 1 click anytime. Zero spam.

* We may earn an affiliate commission from links in this report, at no extra cost to you and with zero impact on our benchmark data.