The fix is the disclosure: what the nginx HTTP/2 commits could have told attackers

Miguel Martinez
The nginx HTTP/2 fix commits named the function, the bug class and the reporter. Anyone watching could read them. Here is how defenders can read them too.

TL;DR: The fix commits for the nginx HTTP/2 bugs named the function, the bug class and the reporter, so anyone reading them knew where to look. Your exposure runs from the moment a fix is public until the patch runs on your servers. Spotting security fixes in commits is easy to automate, so watch the commits of the components you run and of your own code. At Chainloop we do it with AI Code Security Analysis.

On November 18 nginx shipped 1.31.9 and 1.30.7, with fixes for two HTTP/2 remote code execution bugs that Wiz rated critical. CVE-2026-123007 reaches back to nginx 1.9.5 from 2015, so nearly every nginx server with HTTP/2 turned on was exposed.

Less than an hour after the release, one of the top comments on Hacker News said the bug “was apparently fixed in open source repo a week earlier”. The repository activity log says otherwise, because the fixes went public on November 18, 34 minutes before the release. The point still holds. A security fix in a public repository is a disclosure, whatever the advisory says and whenever it is published.

The fix for CVE-2026-123007 adds six lines and removes two. The message explains that a terminated stream could push the flow-control window past its maximum, which “eventually resulted in broken buffer size control in ngx_http_v2_send_chain() followed by memory corruption”, and credits Xint.io, a security firm.

From that message alone you know which function to look at, what kind of bug it is and how to trigger it. With AI agents, one commenter wrote, going from spotting a fix like this to a working exploit now takes “a matter of minutes”.

The window between the fix and your servers

Publishing the fix patched nobody’s servers. Two hours after the release, neither Ubuntu nor Debian had a patched package, so anyone running their distribution’s nginx could read the fix on GitHub while still running the bug.

Other fixes sit in public much longer before they ship. Flood detection for chunked request bodies, a denial-of-service fix credited to an outside reporter, landed on master on November 4, two weeks before it shipped in 1.31.9. Open source projects fix in the open and release on a schedule.

Your exposure starts when the fix becomes public, and it ends when the patch runs on your servers, not when an advisory lands in your inbox.

Attackers might already be watching

Nobody in the thread doubted that someone was watching. “Everybody worth worrying about is monitoring this on every major repo already,” one commenter wrote. Another put it shorter: “fixing open source software is at most an obfuscated announcement.” Private forks and embargoes shorten the window, but the release ships the diff anyway. Assume the people who would attack your nginx already read its commits as they land.

You should watch too

Spotting security fixes in commits is easy to automate today, and defenders can use it as well as attackers can. Researchers have published on it for two years. LLM4VFD tells security fixes from ordinary commits by comparing what a change intends with similar past fixes. CommitShield tracks both the commit that introduced a vulnerability and the one that fixed it, and PatchSeeker maps NVD records back to their fixing commits.

We built AI Code Security Analysis on that research. It walks a repository’s commits and uses a lightweight model pass to pick out the 1 to 2% that fix a security bug. Each fix it confirms goes into a security context with its class, severity, root cause and the exact lines it changed. Scans are incremental, so a new upstream fix shows up on the first scan after it lands. Predicting the next vulnerability from a codebase’s own fix history covers the pipeline in detail.

At Chainloop we watch two kinds of projects with it. The first is the critical components we run, so we can prepare a mitigation or an upgrade as soon as a fix lands upstream. The second is our own code, so we know which mistakes it has made before and keep them from coming back.

For the first kind, we pointed it at the last three months of nginx commits. One of the fixes it confirmed is a PROXY protocol v2 crash that shipped in the same November 18 release. The commit message only says “a segmentation fault might happen”. The security context spells out the rest: an attacker who resumes a TLS session can crash nginx workers remotely, rated High 7.5, along with the rule any later change to that code must keep.

A confirmed fix in Chainloop for the nginx commit 'Core: fixed segfault in PROXY protocol v2 with dynamic certificates', rated High 7.5, memory safety, CWE-476. The impact before the fix is remote denial of service through nginx worker segmentation faults. The root cause section names the flaw, the attacker precondition of TLS session resumption with dynamically loaded certificates, and the sinks X509_get_pubkey and X509_get_signature_nid. The fix is marked fully fixed in src/core/ngx_proxy_protocol.c, followed by the invariant that certificate-dependent PROXY protocol v2 metadata must only be evaluated when SSL_get_certificate() returns a non-NULL certificate.

The PROXY protocol fix from the November 18 nginx release, as Chainloop records it.

You can do the same for the components your production depends on, such as OpenSSL or your ingress controller. A new confirmed fix in one of them is your cue to act before there is a CVE ID to search for. Check whether you run the affected module, apply a mitigation such as turning HTTP/2 off where you can, and plan the upgrade on your own schedule.

A confirmed upstream fix gives you a head start of hours or weeks, and without it, anyone else watching the commits gets that head start instead.

For the second kind, we run the same analysis on the open-source Chainloop repository. It covers 2,736 of its 2,738 commits and has confirmed 99 security fixes, 41 of them in access control, and the median flaw stayed open for 157 days before its fix. Chainloop posts the rule from each past fix on every pull request that touches the same files, so a fixed bug does not come back unnoticed. The fix trend tells us how many security fixes land each quarter, which guides how often we cut releases and publish advisories. Our fixes sit in a public repository too, and every week a fix waits on main for a release is a week of the same exposure nginx had.

The Security Context page for the open-source Chainloop project. Repository coverage is 99.9 percent, 2,736 of 2,738 commits. 99 vulnerabilities introduced, all with a verified origin. Peak open backlog was 48, in the third quarter of 2025. The median exposure window is 157 days. A donut chart splits the 99 confirmed fixes by class: access control 41, information disclosure 15, resource exhaustion 15, logic flaw 11, cryptography 5, injection 3 and 9 in six more classes. A fix trend chart shows flaws fixed and introduced each quarter from 2023 to 2026, with fixes rising to about 23 in a 2026 quarter.

The security context of the open-source Chainloop repository.

Before the next one

Pick the three open-source components your production traffic depends on most, and read their last month of commits. Every security fix you find there that you first heard about from an advisory is one an attacker could have read before you did.

To run that check on every commit, for those components and for your own code, follow the AI Code Security Analysis docs or talk to us.

Security releases like this one keep coming. Four weeks before nginx, PHP shipped fixes for two remote code execution bugs, and patching at this pace wears teams out. There is a silver lining. Nothing tells us these bugs were not already being exploited by the few groups with the skills and the budget to find them on their own. AI puts the same search in many more hands, and every bug it surfaces and gets fixed is one those groups can no longer use without anyone noticing.

Continue Reading

; ---