- Version banners do not prove a distribution backport is installed or that workers were restarted.
- The checker launches the host’s nginx binary on loopback and stops at the flow-control accounting oracle, before the crash and RCE stages.
- A negative probe only becomes
PATCHEDwhen every running binary also has supported fixed provenance. - Test the checker against known-vulnerable and fixed controls before trusting it on a fleet.
Last updated: 19th November 2026
On 19th November, a day after nginx shipped 1.30.7 and 1.31.9, I was checking CVE-2026-123007 across our nginx estate.
Finding packages to update was easy enough. Proving that the update changed the behaviour of the binary on each box was the bit I did not have.
Rapid7’s proof of concept answered whether the vulnerability was exploitable, but its simple trigger deliberately continues into a worker-crash stage after demonstrating the accounting bug. I was not going to point that at the fleet and hope for the best.
I started with a package and process audit.
It checked the vendor revision, found the executable behind every running nginx process, flagged old (deleted) binaries, and validated the configuration on disk for HTTP/2.
That is useful evidence, especially when distributions backport fixes without changing the upstream version.
It still did not show that the patched binary rejected the broken accounting sequence.
Why an nginx version check is not enough
The test needed to answer all of these:
- Is the executable behind the live nginx processes affected?
- Are the live workers actually using that executable?
- Does the validated configuration on disk enable HTTP/2?
- Did the active check reach the interesting code path, or did it quietly fail before doing anything?
- Can it do all of that without reloading nginx, touching a public listener, or crashing a worker?
That last one rules out using the complete exploit chain. The useful boundary is earlier, at nginx’s HTTP/2 flow-control accounting bug.
How the safe nginx2root checker works
The checker records the production nginx PIDs first, then resolves /proc/<pid>/exe for each process.
If those links point at more than one executable, or at an old (deleted) file after an upgrade, it refuses to run the active stage.
It launches that path with a minimal temporary configuration, a nobody worker, and a random port bound only to 127.0.0.1.
There is no production reload, no public endpoint, and no attempt to reproduce a CDN or TLS path.
The small fixture lets the control requests consume exactly one normal HTTP/2 connection window, while the sparse 8 MiB file supplies queued response DATA for the accounting check. The probe first receives exactly 65,535 ordinary HTTP/2 response bytes. That is the positive control: if the temporary listener is dead, the fixture is wrong, or the protocol exchange never worked, the check fails instead of calling the host patched.
It then:
- Refills the connection window.
- Opens the large response so nginx has DATA queued.
- Cancels the stream that owns those queued bytes.
- Sends the limited window updates that expose the incorrect accounting.
- Sends a PING on the same connection.
If nginx accepts the over-credit and still acknowledges the PING, the accounting bug is present.
That PING acknowledgement is the positive vulnerability signal. Patched nginx rejects the earlier update and closes the connection while the temporary process stays alive.
The checker stops at that point. It never continues into the amplification, memory-corruption, disclosure or command-execution stages from the full research exploit.
Finally, it terminates only its temporary nginx process, removes the fixture, and checks that the original production PID set has not changed.
How do I read the result?
An active negative result can mean patched, but it can also mean the test took a different path, the package behaves differently on that platform, or some prerequisite was missing.
So NO_OVER_CREDIT_OBSERVED is only one piece of evidence.
The final result is PATCHED only when the active sequence is rejected and every running executable maps to a supported fixed vendor build.
The outcomes are deliberately awkward:
| Result | Meaning |
|---|---|
PATCHED | The active sequence was rejected and every running binary has supported fixed provenance. |
VULNERABLE | The installed binary accepted over-credit; configuration on disk also enables HTTP/2 when that can be read. |
INCONCLUSIVE | The evidence is incomplete or contradictory, so the checker refuses to produce a green result. |
I would much rather have an annoying inconclusive result than a false green one.
Run a vulnerable and fixed control first
I calibrated the sequence against stock upstream containers in the same run.
| Control | Ordinary response | Accounting result |
|---|---|---|
| nginx 1.31.8 | 65,535 bytes | Accepted over-credit and acknowledged PING. |
| nginx 1.31.9 | 65,535 bytes | Rejected the four-MiB precursor. |
Those become VULNERABLE and NO_OVER_CREDIT_OBSERVED respectively in the machine-readable result.
That gives the negative test its positive control. If both controls return the same answer, the calibration has failed.
Fleet validation then turned up the untidy bit.
Two hosts had byte-identical /usr/sbin/nginx files at Ubuntu Noble’s fixed 1.24.0-2ubuntu7.20 revision (SHA-256 1a2d979e8b1b7682e3dd056e174854047d406228d25ebe9e973c92cb8a212a61).
One rejected the probe and the other accepted it.
The hosts also ran different kernels, although that is correlation rather than an explanation, and I have not proved what caused the difference.
So the checker treats that exact revision as inconclusive. I would rather document the contradiction than make the package label or one negative run win because it is convenient.
The first fleet pass also produced positive accounting results on several deployments that needed updates. The operational results remain private; I am not publishing client names, addresses or a map of the affected estate.
Which versions are affected?
| Build | Status |
|---|---|
| Upstream nginx 1.9.5–1.30.6 | Affected; update to 1.30.7+ on the stable branch or 1.31.9+ on mainline. |
| Upstream nginx 1.31.0–1.31.8 | Affected; update to 1.31.9 or later. |
| Distribution package | Check the full vendor revision, not only nginx -v. |
Ubuntu’s backported revisions are listed in USN-9159-1.
How to check CVE-2026-123007 on a Linux host
The checker is in SamJUK/nginx2root-check. On a Linux nginx host:
git clone https://github.com/SamJUK/nginx2root-check.git
cd nginx2root-check
sudo ./nginx2root-check \
--acknowledge-owned-system I-AM-AUTHORIZED
The supported command only launches the one executable resolved from the live nginx processes and binds its test listener to loopback. There is no remote-target option.
Bonus Tip: How to check at scale?
The repository has a complete example, but the important assertion is short enough to keep beside the runbook:
# tasks/health-checks/nginx2root-e2e.yaml
- name: Exercise the local nginx binary
ansible.builtin.command:
argv:
- python3
- /tmp/nginx2root-check/nginx2root-check
- --acknowledge-owned-system
- I-AM-AUTHORIZED
- --json
register: nginx2root_command
changed_when: false
failed_when: false
- name: Require a patched result
ansible.builtin.assert:
that:
- (nginx2root_command.stdout | from_json).outcome == 'PATCHED'
The full usage notes include JSON output, exit codes and the Ansible workflow.
What the nginx2root checker does not prove
This is a bounded diagnostic, not an exploitability guarantee.
It proves behaviour of the installed binary through a controlled cleartext HTTP/2 fixture, then combines that with process, package-file and configuration-on-disk evidence. It does not reproduce the path through a public TLS listener, CDN, WAF, proxy or load balancer.
The checker runs a package-verified nginx with -T as its stripped-down test account; unreadable configuration is inconclusive rather than a reason to retry as root.
nginx -T reads configuration from disk, so it cannot prove that existing workers have reloaded a recent HTTP/2 change.
For that reason, configured-off HTTP/2 remains inconclusive rather than being presented as a proven mitigation.
It also does not replace the vendor update. If the result is vulnerable or inconclusive, patch the supported package, restart every worker, and run the check again.
The protocol sequence is adapted from Censys Research’s Apache-2.0 accounting test, with the full exploit stages deliberately left out. Rapid7’s technical analysis covers the complete chain.
My question here is smaller: did the patch change the accounting behaviour of nginx on this box, and do the live processes match the package I think I updated?