Critical

CA-26-051: Public PoC Available for Critical NGINX HTTP/2 RCE (CVE-2026-123007)

By Adversary Tactics and Intelligence Team

Estimated Reading Time: 7 minutes

NGINX | HTTP/2 | Remote Code Execution | Public PoC | CVE-2026-123007

Source Material: F5 K000163926; NGINX Security Advisories; Rapid7 Technical Analysis and PoC | Technology: NGINX Open Source and NGINX Plus | Targeting: Opportunistic – Internet-facing and internal NGINX services with HTTP/2 enabled

Executive Summary

CVE-2026-123007 is an HTTP/2 flow-control integer underflow that can produce heap memory corruption in vulnerable NGINX Open Source and NGINX Plus deployments. An unauthenticated remote attacker may crash an NGINX worker, disclose memory, corrupt the worker process, or execute code with the worker’s privileges. Public proof-of-concept code is now available and security researchers have reported reliable exploitation under concurrent traffic against public cloud endpoints, demonstrating that attackers can refine the technique beyond the initial PoC.

Organizations should inventory NGINX instances, identify HTTP/2 listeners, and apply vendor or distribution fixes immediately, prioritizing Internet-facing systems. Upgrade upstream NGINX Open Source to 1.30.7 or 1.31.9 and NGINX Plus to 37.0.8.1 or 37.3.0.1. If patching cannot be completed immediately, disable HTTP/2 on affected listeners, validate the configuration, reload NGINX, and confirm old worker processes have exited.

At publication, reputable reporting had not identified exploitation in the wild. The public PoC and the long affected version range justify urgent action, focused hunting, and monitoring for NGINX worker crashes, sustained high-volume HTTP/2 sessions, and unexpected child processes or outbound connections from NGINX.

Threat Overview and Strategic Impact

CVE-2026-123007 affects the NGINX HTTP/2 implementation. The flaw is caused by incorrect connection send-window accounting. Under attacker-controlled HTTP/2 flow-control conditions, queued response credit can push an internal counter above the protocol maximum. A later unsigned subtraction underflows, allowing the counter to reach a value that is interpreted as a negative response length. In the TLS send path, signed and unsigned conversions can produce an out-of-bounds memory copy and enable memory disclosure, heap corruption, worker crashes, and code execution.

Any affected NGINX deployment accepting HTTP/2 traffic over TLS is exposed, including servers hosting only static content, as no backend application is required. NGINX Open Source versions 1.9.5 through 1.30.6 and 1.31.0 through 1.31.8 are affected, with upstream fixes available in stable 1.30.7 and mainline 1.31.9. F5’s advisory identifies affected NGINX Plus branches 37.0.0 – 37.0.7.1 (fixed in 37.0.8.1), 37.1.0 – 37.2.0.1 (fixed in 37.3.0.1), and R33–R36 (no backported fix; upgrade to a fixed 37.x release or disable HTTP/2). Linux distributions and products that embed NGINX may backport the fix or use different versioning, so customers should validate the full package build against the relevant supplier advisory. Exposure is highest when NGINX sits directly on the Internet or behind a Layer 4 load balancer (such as AWS NLB); Layer 7 proxies and CDNs that terminate HTTP/2 and rebuild upstream frames reduce exploitability.

The published RCE PoC targets a specific Linux/amd64 Docker environment and requires about 128 GB of HTTP/2 traffic (~60 GB for a worker crash). Its reliability depends on bandwidth, connection lifetime, proxy behavior, heap state, concurrent clients, and a specific x86-64 glibc memcpy implementation. However, additional security researchers independently analyzed the underlying flow-control flaw and validated an exploit path under concurrent traffic across AWS, GCP, Azure, and public IP targets.

Successful exploitation grants the privileges of the NGINX worker, not the master process or root by itself. From that foothold, an attacker could access sensitive data handled by the worker, alter served content, disrupt co-hosted applications, or attempt local privilege escalation (researchers demonstrated container escape to host root by chaining worker RCE with a Linux kernel SCTP vulnerability where SCTP was reachable). 

Security Hardening and Recommendations

  • Patch and restart NGINX. Upgrade upstream NGINX Open Source to 1.30.7 or 1.31.9, or NGINX Plus to 37.0.8.1 or 37.3.0.1 (also resolving co-disclosed HTTP/2 use-after-free CVE-2026-123633). Perform a full service restart or a USR2 binary upgrade—a standard nginx -s reload only reloads configuration and will not replace the running binary in memory—and verify that all old worker processes have exited. For OS packages, containers, ingress controllers, appliances, OpenResty, or other embedded distributions, confirm whether a backport is present.
  • Inventory HTTP/2 exposure. Identify every NGINX listener that negotiates HTTP/2, including internal services, alternate ports, direct origin IPs, containers, and instances behind load balancers. Do not rely solely on public banners or nginx -v; run nginx -V to confirm ngx_http_v2_module is compiled, inspect nginx -T for http2 on; or listen … http2, and test external endpoints with openssl s_client -connect <host>:443 -alpn h2.
  • Apply temporary mitigation when patching is delayed. Disable HTTP/2 in every affected server block (set http2 off; on NGINX 1.25.1+ or remove the http2 parameter from listen directives on earlier versions; for community kubernetes/ingress-nginx, set use-http2: “false” in the controller ConfigMap). Test application compatibility—especially gRPC and HTTP/2-dependent services—reload NGINX, and verify that h2 is no longer negotiated.
  • Reduce exposure. Run workers with least privilege, restrict host and container capabilities (including blocking unnecessary protocols such as SCTP), limit access to secrets and writable paths, segment exposed hosts, and restrict outbound network access. Use WAFs and Layer 7 reverse proxies as defense-in-depth alongside patching or disabling HTTP/2.

Detection Strategy

Use a multi-signal detection strategy because the released exploit manipulates HTTP/2 frames below the detail normally preserved in standard NGINX access logs. Correlate load balancer, firewall, network-flow, host, container, systemd, coredump, EDR, and NGINX error telemetry.

Prioritize long-lived, high-throughput HTTP/2 sessions to NGINX, especially a single source or small source set transferring unusually large inbound volumes (tens of gigabytes, such as the ~60 GB crash and ~128 GB RCE thresholds observed in public testing), opening many streams, or generating a mismatch between network bytes and logged request sizes. Tune volume thresholds to normal service baselines rather than relying on a fixed byte count.

On the workload, investigate repeated NGINX worker segmentation faults, abnormal exits, core dumps, rapid worker respawns, or unexplained spikes in 5xx responses. High-confidence post-exploitation signals include nginx worker processes spawning sh, bash, dash, python, perl, curl, wget, nc, socat, or other unusual children; unexpected file writes to temporary, web-root, startup, cron, or SSH locations; and new outbound connections from an NGINX worker or container. Correlate network anomalies with process or crash evidence to reduce false positives. Absence of these signals does not prove non-exploitation where HTTP/2 frame visibility or endpoint telemetry is limited.

How Deepwatch Protects Our Customers

Deepwatch SOC analysts monitor available SIEM, EDR, cloud, container, load balancer, firewall, and NGINX telemetry for behaviors associated with exploitation and post-exploitation. Our experts correlate unusual high-volume HTTP/2 activity with NGINX worker crashes, suspicious process lineage, file creation, and outbound connections rather than rely on a single network signature.

When relevant telemetry is available, analysts monitor for nginx spawning shells or transfer utilities, investigate worker segmentation faults and restarts, and review suspicious egress. Detection is a compensating control, not a replacement for remediation. Coverage depends on log quality, endpoint visibility, and whether traffic terminates or is transformed upstream. Customers should patch or disable HTTP/2, confirm the running build, and retain relevant network and host telemetry.

Relevant Detections

Please visit the Guardian Platform to access the relevant detections for this activity and ask NEXA Detection Advisor for a breakdown of which detections are enabled in your environment.

Threat Hunting Leads

  • Inventory NGINX versions, package builds, container images, and every listener that negotiates HTTP/2
  • Search network-flow and load-balancer telemetry for long-lived, unusually high-volume HTTP/2 sessions to NGINX, including single-source transfers approaching the scale of the published PoC
  • Correlate large inbound byte counts or many HTTP/2 streams with gaps in NGINX request logging, spikes in 5xx responses, and worker restarts
  • Hunt systemd, kernel, coredump, and NGINX error logs for worker segmentation faults, abnormal exits, or rapid respawning
  • Review EDR process trees for nginx spawning shells, interpreters, curl, wget, nc, socat, or other unusual utilities
  • Review file writes and executions by the NGINX service account, plus new outbound connections or cloud metadata access from NGINX hosts and containers

Technical Artifacts 

Please visit the Guardian Platform to access available technical artifacts for this report.

Threat Object Mapping

Intrusion Set:

  • Unattributed. No confirmed in-the-wild exploitation was identified at publication.

Attack Pattern (MITRE ATT&CK/MITRE ATLAS):

TacticTechniqueTechnique IDAssociated Threat Activity
Initial AccessExploit Public-Facing ApplicationT1190A remote unauthenticated client targets an Internet-facing NGINX HTTP/2 listener to obtain worker-context code execution. This maps the disclosed exploit path, not confirmed in-the-wild activity.
ExecutionCommand and Scripting Interpreter: Unix ShellT1059.004The public PoC redirects an NGINX cleanup callback to execute an attacker-selected command. This is demonstrated PoC behavior, not observed intrusion activity.

Vulnerabilities:

  • CVE-2026-123007 – NGINX HTTP/2 flow-control integer underflow and heap memory corruption

Malware/Tool:

  • Public PoC repository for CVE-2026-123007 – trigger and environment-specific RCE demonstration

Additional Sources

↑

Share

LinkedIn Twitter Facebook