Pull to refresh
Logo
NGINX patches decade-old HTTP/2 flaws that allow pre-auth code execution

NGINX patches decade-old HTTP/2 flaws that allow pre-auth code execution

Built World

Two critical memory-safety bugs in the web server behind roughly 225 million sites, fixed in F5's November 18 release

Overview

Updated 4 hours ago

F5 released fixes on November 18 for two memory-safety bugs in NGINX, the open-source web server that fronts an estimated 225 million websites. Both let an unauthenticated attacker run code on the server. One of them had been in the code since 2015.

The flaws sit in NGINX's HTTP/2 handling, not in the applications behind it, so a securely coded website can still be exposed. Rapid7 built a working exploit for the flow-control bug, but it needs about 128 gigabytes of traffic to land. Disabling HTTP/2 on exposed listeners blocks both bugs until a patch is applied.

Why it matters

An unpatched NGINX server with HTTP/2 exposed can be taken over without a login, and one server often fronts dozens of sites.

Questions about this story

Free account needed to ask — your question is kept and asked for you right after sign-up. Answers are public.

No questions yet — be the first to ask.

Key Indicators

2
Critical CVEs patched
CVE-2026-123633 and CVE-2026-123007, both memory-safety bugs in HTTP/2 handling.
9.2
Severity score from Wiz
Wiz rates both flaws 9.2 under CVSS 4.0; CERT-EU lists 8.1 for each.
225M
Websites running NGINX
Wiz's figure for the server's installed base, which makes the patch a global one.
128 GB
Traffic needed for Rapid7's exploit
The volume of HTTP/2 data one successful attempt requires, per Rapid7's proof of concept.
5
Vulnerabilities in the November 18 advisory
CERT-EU says all five can lead to code execution as the NGINX worker process.

Voices

Curated perspectives — historical figures and your fellow readers.

Sign up to generate historical perspectives on this story.

Organizations Involved

Timeline

2015 November 2026

6 events Latest: Today
Tap a bar to jump to that date
  1. F5 ships fixes and discloses both bugs

    Today Release

    The coordinated release covers five NGINX vulnerabilities. Wiz and Rapid7 publish technical write-ups, including a working exploit.

  2. F5 confirms the second report

    Remediation

    F5 matches the report to CVE-2026-123007 and folds it into the next day's release.

  3. Wiz reports a second HTTP/2 flaw

    Disclosure

    Wiz discloses the flow-control integer underflow that becomes CVE-2026-123007.

  4. F5 supplies a patch for review

    Remediation

    F5 hands Wiz a fix for CVE-2026-123633 ahead of the planned release.

  5. Wiz reports the use-after-free to F5

    Disclosure

    Wiz sends a confirmed exploit with an ASLR bypass and a proposed fix. F5 says another team had already reported the same bug.

  6. The flow-control bug enters the codebase

    Origin

    NGINX 1.9.5 ships with the integer underflow that becomes CVE-2026-123007, and it survives more than a decade of releases.

Scenarios

1

No public exploitation as patches roll out

Likely Resolves by May 18, 2027

Discussed by: CERT-EU, which noted no in-the-wild exploitation as of the November 18 advisory; Rapid7's own exploit write-up

Rapid7's account sets a high bar for attackers: roughly 128 gigabytes of HTTP/2 traffic per attempt, a connection faster than about 300 megabits per second to finish inside NGINX's one-hour default lifetime, and a specific x86-64 glibc memory-copy path chosen at runtime. A proxy in front of NGINX is likely to break the exact frame sequence the exploit needs. If those constraints hold, these bugs join the long list of critical CVEs that were patched before anyone weaponized them.

2

Targeted attack compromises an unpatched NGINX host

Possible Resolves by Feb 28, 2027

Discussed by: Wiz and Rapid7, both of which stress that the flaws sit in NGINX rather than the application behind it

A single well-resourced attacker with a fast link and a directly reachable server does not need mass scanning. The 128-gigabyte requirement is a bandwidth cost, not a technical barrier, and Rapid7 completed its demo in about two and a half minutes. Organizations that leave HTTP/2 enabled on internet-facing listeners past the patch window carry the risk.

3

Worker-level code execution escalates to host root

Unlikely Resolves by Q2 2027

Discussed by: Xint, which demonstrated the chain in testing; CIRCL, which described the privilege step

Both NGINX bugs grant code execution as the worker process, not root. Xint reported reaching root on the host through a separate Linux kernel flaw in the SCTP networking code, even with NGINX inside a Docker container. That path depends on the kernel version, whether the SCTP module is loaded, and container configuration, so it is a chain an attacker has to assemble rather than a property of the NGINX bugs.

Historical Context

3 moments from history that rhyme with this story — and how they unfolded.

April 2014

Heartbleed (2014)

A missing bounds check in OpenSSL's heartbeat extension let anyone read up to 64 kilobytes of a server's memory with a single request, no credentials needed. The flaw had been in the library since 2012. Researchers at Codenomicon and Google reported it simultaneously.

Then

Major sites patched within days, and several services told users to change passwords.

Now

It pushed companies to fund open-source security audits and made coordinated disclosure the norm for infrastructure code.

Why this matters now

Same shape as the NGINX bugs: a memory-safety error in code nearly everyone depends on, reachable without authentication.

October 2023

HTTP/2 Rapid Reset (2023)

Attackers abused HTTP/2's stream-cancellation mechanism to force servers to churn through requests, producing record-setting distributed denial-of-service attacks. Google, Cloudflare and Amazon Web Services disclosed it after months of quiet mitigation.

Then

Cloud providers patched and added rate limits, but the technique stayed in use.

Now

It established HTTP/2 implementations as a shared attack surface where one protocol bug can hit every vendor at once.

Why this matters now

Both NGINX bugs live in the same HTTP/2 layer, and the protocol's complexity is what produced these memory-safety errors.

December 2021

Log4Shell (2021)

A lookup feature in the Log4j logging library let an attacker run code by getting a single string logged. Public exploits appeared within hours of disclosure, and scanners hit the whole internet.

Then

Mass exploitation began immediately and patching dragged on for years because Log4j was buried inside other dependencies.

Now

It became the reference case for how fast a pre-auth remote code execution in ubiquitous software gets weaponized.

Why this matters now

The contrast matters: Log4Shell needed one crafted string, while the NGINX flow-control exploit needs about 128 gigabytes of traffic.

Sources

(10)