
PoC: perdita della send-window nella connessione HTTP/2 di nginx 1.31.8 (CVE-2026-123007)
Proof of concept per una perdita della finestra di invio HTTP/2 a livello di connessione in
nginx 1.31.8: la pulizia dello stream restituisce solo i frame DATA che sono ancora
non bloccati, quindi i byte addebitati alla finestra di connessione prima che il socket si bloccasse
non vengono mai restituiti. La connessione perde permanentemente la finestra utilizzabile e un
successivo, perfettamente legittimo WINDOW_UPDATE viene rifiutato con FLOW_CTRL_ERROR.
Il PoC è un laboratorio Docker autonomo su 127.0.0.1 — nessun host esterno, nessuna
dipendenza di build oltre a Docker e Python 3 (h2 è incluso nel vendor).
Usa l'immagine ufficiale, fissata alla versione vulnerabile. Il bug è nel
binario, quindi non serve compilare nulla — solo la configurazione e le risorse del laboratorio vengono montate
in sola lettura sopra l'immagine standard nginx:1.31.8-alpine:
docker run -d --name defex-ngnix -p 127.0.0.1:18443:18443 \
-v "$PWD/conf/nginx.conf:/etc/nginx/nginx.conf:ro" \
-v "$PWD/conf/cert.pem:/opt/lab/cert.pem:ro" \
-v "$PWD/conf/key.pem:/opt/lab/key.pem:ro" \
-v "$PWD/conf/big.bin:/opt/lab/html/big.bin:ro" \
-v "$PWD/conf/index.html:/opt/lab/html/index.html:ro" \
-v "$PWD/data:/opt/lab/data" \
nginx:1.31.8-alpine
./defex_ngnix.sh # prove it against the running container
./defex_ngnix.sh 8443 # same on another host port
Fissa il tag. nginx:alpine è fluttuante e si è già spostato alla 1.31.9, che è
corretta — l'esecuzione fallisce quindi allo stage 5. Il Dockerfile incluso esegue lo stesso
mounting come build one-shot se preferisci docker build / docker run.
Lo script non effettua chiamate a docker. Avvii il container, lo script
comunica solo via HTTP con esso. Tutti gli 8 stage devono passare. Un fallimento lascia il container
intatto per l'ispezione. L'ultimo stage è un controllo: lo stesso carico con e
senza reset, a dimostrazione che la perdita è nel percorso di cleanup e non nel carico
stesso.
poc/_vendor incluso (nessun pip install)Verificato con nginx:alpine = 1.31.8 il 2026-11-19. Ogni esecuzione termina
con 11 [PASS] e 0 [FAIL] su un container appena avviato. Build più recenti o
corrette dovrebbero fallire lo stage 5 e/o 6 — questo è il segnale.
È testato solo il lab sopra. Altri deployment, branch più vecchi e reverse proxy davanti a nginx non sono testati.
ngx_http_v2_filter_module.c sottrae il payload di ogni frame DATA dalla
finestra di connessione quando il frame è accodato:
ngx_http_v2_queue_frame(h2c, frame);
h2c->send_window -= frame_size; /* charged on queueing */
stream->send_window -= frame_size;
ngx_http_v2_filter_cleanup() dovrebbe restituire quel payload quando uno
stream termina, ma percorre la coda di output con
if (frame->stream == stream && !frame->blocked) {
*fn = frame->next;
window += frame->length;
quindi i frame che sono stati già conteggiati e poi bloccati sul socket vengono saltati. I loro byte restano sottratti da h2c->send_window per sempre. Quel campo è un semplice size_t, quindi il danno si manifesta solo come una finestra di connessione che non può più raggiungere MAX. Solo la finestra per-stream è con segno (ssize_t), perché una modifica di SETTINGS_INITIAL_WINDOW_SIZE può renderla negativa.
Il percorso WINDOW_UPDATE a livello di connessione confronta solo il nuovo incremento con NGX_HTTP_V2_MAX_WINDOW - h2c->send_window:
if (window > NGX_HTTP_V2_MAX_WINDOW - h2c->send_window) {
... "client violated connection flow control" ...
return ngx_http_v2_connection_error(h2c, NGX_HTTP_V2_FLOW_CTRL_ERROR);
}
h2c->send_window += window;
Una finestra in deriva rende quindi MAX - h2c->send_window più grande di quanto
dovrebbe essere, così il server accetta incrementi che una build corretta rifiuterebbe.
La finestra stessa non può mai superare 2^31-1 (è esattamente ciò che il controllo
impone), il che significa che la connessione perde permanentemente finestra utilizzabile:
al peer continuano a essere rifiutati i byte a cui ha diritto.
Fase 5 — overflow. Il client annuncia INITIAL_WINDOW_SIZE = 2^31-1,
apre 1000 stream dietro un buffer socket da 1 KiB così che i frame HEADERS non possano
partire, svuota, poi invia due incrementi a dimensione piena. Il secondo è legale
solo a causa della deriva:
[PASS] server rejected the WINDOW_UPDATE (1 log line(s))
increment 2147418112 not allowed for window 2081882111
Fase 6 — leak dopo la pulizia. 400 stream, tutti tranne l'ultimo RST successivamente. I byte dei frame DATA bloccati non vengono restituiti, quindi la finestra rimane al di sotto di MAX e l'incremento finale viene rifiutato:
[PASS] window leaked after stream reset - increment rejected
increment 2147418112 not allowed for window 2147401727
2147483647 - 2147401727 = 81920 — esattamente cinque frame DATA da 16 KiB il cui
payload è ancora mancante dalla finestra dopo che 399 stream sono stati ripuliti.
Il server rimane in salute e negozia ancora HTTP/2 in seguito.
Fase 7 — il controllo. Lo stesso carico di 400 stream due volte, una con i reset e una senza. Entrambe le esecuzioni perdono memoria, ma quella con i reset termina più in alto: la pulizia restituisce effettivamente qualcosa, ma salta i frame bloccati.
with resets -> window 1921441791
without resets -> window 1898053631
[PASS] cleanup gives back only unblocked frames - window stays short
La fase 6 quindi non è semplicemente "un po' di carico": la finestra è ben al di sotto di
MAX in entrambi i rami, e l'ordinamento corrisponde al filtro !frame->blocked nel
sorgente. poc/window_growth.py ripete il ciclo più volte se vuoi
osservare la finestra scendere sotto un churn sostenuto.
| percorso | ruolo |
|---|---|
defex_ngnix.sh | driver a 8 fasi solo HTTP, colori |
Dockerfile | nginx:alpine (1.31.8) + configurazione e asset del lab |
conf/nginx.conf | TLS + http2 on, buffer di output da 4 KiB, log info su lab.log, log esposto su /__lab.log |
conf/big.bin | payload da 4 MiB |
poc/flow_control.py | fase 5, overflow della finestra |
poc/blocked_frames.py | fase 6, leak dopo la pulizia dello stream |
poc/leak_control.py | fase 7, controllo con/senza reset |
poc/window_growth.py | opzionale, cicli di churn ripetuti |
poc/_vendor | h2 / hpack / hyperframe, nessun pip necessario |
data/ | directory host, montala con bind su /opt/lab/data quando avvii il container |
Qualsiasi cosa scrivi nella shell finisce in /opt/lab/data, che monti con bind
da data/. Il container è tuo da ricreare, quindi quella directory è l'unico
posto in cui il lavoro sopravvive a un riavvio.
error_log punta a un file reale, non a /dev/stderr: un log symlinkato non può essere
troncato e tail/grep si bloccherebbero sulla pipe per sempre. È pubblicato su
/__lab.log così lo script può leggerlo senza docker exec; ogni fase
memorizza l'offset in byte e guarda solo le righe prodotte dopo quel punto.