ServicesBlogPricingContactContact Now
Cyber Security4 min read

NGINX HTTP/2 Flaw: 10-Year-Old Bug Allows RCE

NGINX HTTP/2 Flaw: 10-Year-Old Bug Allows RCE

Introduction

Security teams running NGINX have a new patch to schedule this week. A flaw in the web server's HTTP/2 support allows an unauthenticated attacker to execute code on affected systems, and it has been sitting in the open-source codebase for roughly a decade. The issue is tracked as CVE-2026-123007 and has been given the nickname nginx2root. F5, the company that maintains NGINX, shipped fixes in versions 1.31.9 and 1.30.7 today.

The headline facts are the ones that matter for triage: no authentication required, remote reachability, and code execution. For anyone terminating TLS or serving high-volume traffic through NGINX, that combination puts this near the top of the queue.

Why a ten-year-old bug is only surfacing now

According to the published details, the vulnerable code has been present since NGINX 1.9.5, which shipped on 22 September 2015. That predates the point at which HTTP/2 became a routine part of production configurations, and it means every release between that version and today's fixed builds carries the same defect.

HTTP/2 is not switched on by default in NGINX; it is enabled deliberately, usually at the TLS termination layer where multiplexing and header compression pay off. That opt-in nature is cold comfort. A decade of tutorials, default templates, Helm charts and cloud load-balancer configurations have made HTTP/2 a near-reflex addition to the listen directive, which means the population of exposed servers is likely far larger than the number of administrators who consciously chose it.

The full technical root cause has not been detailed in the material available at the time of writing, and it is not yet public how reliable exploitation is or what conditions an attacker needs beyond HTTP/2 being enabled. The nickname implies the worst case reaches root-level compromise, but the privilege level an attacker actually obtains is not confirmed in the available information.

Who is affected

  • Any NGINX open-source deployment with HTTP/2 enabled, on versions from 1.9.5 up to but not including 1.31.9 and 1.30.7.
  • Reverse proxies, API gateways and TLS terminators — the tiers where HTTP/2 is most commonly turned on and where a compromise gives an attacker a view of traffic to everything behind them.
  • Container images and vendor appliances that bundle NGINX. Patching the host does nothing for a base image that was built two years ago.
  • Managed and embedded deployments where the operator does not control the NGINX build directly.

The source material does not indicate whether exploitation in the wild has been observed. Absence of reporting is not evidence of absence, particularly for a bug that requires no credentials.

What defenders should do now

Upgrade. Version 1.31.9 is the mainline fix and 1.30.7 covers the stable branch; both were released today. Prioritise internet-facing endpoints that speak HTTP/2 over TLS, then work inward.

  • Inventory before you patch. Run nginx -v on every host, but do not stop there. Check container registries, sidecar proxies, ingress controllers and appliance firmware. The version string in a running pod is often months behind the one in your build pipeline.
  • Rebuild, do not hot-patch. If NGINX is baked into an image, the fix belongs in the Dockerfile and the registry, not in a running container that the next deployment will overwrite.
  • Disable HTTP/2 if you cannot patch immediately. Falling back to HTTP/1.1 removes the attack surface at a real performance cost. Treat it as a stopgap with a deadline, not a permanent posture.
  • Do not rely on signature-based filtering alone. Protocol-level parsing flaws are a poor fit for request-signature WAF rules; a rule that blocks one malformed frame sequence may miss the next.
  • Watch for follow-up detail. Exploit specifics, proof-of-concept code and revised severity scoring typically appear in the days after a patch ships. Re-triage when they do.

Grivyonx Expert Analysis

The most uncomfortable lesson here is not about HTTP/2 — it is about the age of the code path. A defect introduced in 2015 survived a decade of releases, audits and production traffic, which tells you that protocol implementations at the edge get far less adversarial scrutiny than the application code sitting behind them. Most organisations can name the frameworks inside their services; far fewer can name the exact patch level of the proxy in front of them. That asymmetry is what turns a single CVE into a fleet-wide emergency. The teams that come out of this cleanly will be the ones whose asset inventory already knew which hosts had HTTP/2 enabled before the advisory landed.

Conclusion

CVE-2026-123007 is a reminder that the boring infrastructure layer is where the sharpest risk usually sits. Unauthenticated remote code execution in a component that terminates TLS for everything else is about as bad as vulnerability triage gets, and the fix is available now in 1.31.9 and 1.30.7. Patch the internet-facing tier first, confirm your container images were rebuilt rather than restarted, and keep a list of every place HTTP/2 is switched on. Teams that would rather spend engineering time on detection than on version archaeology can lean on Grivyonx's AI automation and DevSecOps services to keep infrastructure dependencies visible and current.

  • #NGINX
  • #HTTP/2
  • #CVE-2026-123007
  • #nginx2root
  • #remote code execution
  • #F5
  • #vulnerability management
  • #server security
Gourav Rajput

Gourav Rajput

Founder of Grivyonx Technologies