
PoC: vazamento da janela de envio de conexão HTTP/2 no nginx 1.31.8 (CVE-2026-123007)
Prova de conceito para um vazamento da janela de envio HTTP/2 no nível de conexão no
nginx 1.31.8: a limpeza de streams devolve apenas os frames DATA que ainda estão
desbloqueados, portanto os bytes debitados da janela de conexão antes de o socket bloquear
nunca são devolvidos. A conexão perde permanentemente janela utilizável e um
WINDOW_UPDATE posterior, perfeitamente legítimo, é rejeitado com FLOW_CTRL_ERROR.
A PoC é um laboratório Docker autocontido em 127.0.0.1 — sem host externo, sem
dependências de build além de Docker e Python 3 (o h2 é vendorizado).
Use a imagem oficial, fixada na versão vulnerável. O bug está no
binário, então nada precisa ser compilado — apenas a configuração e os assets do laboratório são montados
somente leitura sobre a imagem padrão 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
Fixe a tag. nginx:alpine flutua e já passou para 1.31.9, que está
corrigida — a execução então falha no estágio 5. O Dockerfile incluído faz a mesma
montagem como um build único, se você preferir docker build / docker run.
O script não faz nenhuma chamada docker. Você inicia o contêiner, o script
apenas se comunica via HTTP com ele. Todos os 8 estágios devem passar. Uma falha deixa o contêiner
intacto para inspeção. O último estágio é um controle: a mesma carga com e
sem resets, provando que o vazamento está no caminho de limpeza e não na carga
em si.
poc/_vendor embutida (sem pip install)Verificado contra nginx:alpine = 1.31.8 em 2026-11-19. Toda execução termina
com 11 [PASS] e 0 [FAIL] contra um contêiner recém-iniciado. Builds mais recentes ou
corrigidos devem falhar nos estágios 5 e/ou 6 — esse é o sinal.
Apenas o laboratório acima é testado. Outras implantações, branches mais antigas e proxies reversos na frente do nginx não são testados.
ngx_http_v2_filter_module.c subtrai o payload de cada frame DATA da
janela de conexão quando o frame é enfileirado:
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() deveria devolver esse payload quando um
stream morre, mas ele percorre a fila de saída com
if (frame->stream == stream && !frame->blocked) {
*fn = frame->next;
window += frame->length;
portanto, os frames que já foram contabilizados e depois bloqueados no socket são
ignorados. Seus bytes permanecem subtraídos de h2c->send_window para sempre. Esse
campo é um size_t simples, então o dano só se manifesta como uma janela de conexão
que não consegue mais atingir o MAX. Apenas a janela por stream é assinada
(ssize_t), porque uma alteração de SETTINGS_INITIAL_WINDOW_SIZE pode torná-la
negativa.
O caminho de WINDOW_UPDATE no nível de conexão apenas compara o novo incremento
com 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;
Uma janela desviada, portanto, torna MAX - h2c->send_window maior do que
deveria ser, de modo que o servidor aceita incrementos que uma compilação correta rejeitaria.
A própria janela nunca pode exceder 2^31-1 (que é exatamente o que a verificação
impõe), o que significa que a conexão perde permanentemente janela utilizável:
o par continua tendo os bytes a que tem direito recusados.
Estágio 5 — overflow. O cliente anuncia INITIAL_WINDOW_SIZE = 2^31-1,
abre 1000 streams atrás de um buffer de socket de 1 KiB para que os frames HEADERS não possam
sair, drena e, em seguida, envia dois incrementos de tamanho total. O segundo só é
legal por causa do desvio:
[PASS] server rejected the WINDOW_UPDATE (1 log line(s))
increment 2147418112 not allowed for window 2081882111
Estágio 6 — vazamento após a limpeza. 400 streams, todos menos o último RST depois. Os bytes dos quadros DATA bloqueados não são retornados, então a janela permanece abaixo de MAX e o incremento final é rejeitado:
[PASS] window leaked after stream reset - increment rejected
increment 2147418112 not allowed for window 2147401727
2147483647 - 2147401727 = 81920 — exatamente cinco frames DATA de 16 KiB cujo
payload ainda está ausente da janela após 399 streams terem sido limpos.
O servidor permanece saudável e ainda negocia HTTP/2 em seguida.
Estágio 7 — o controle. A mesma carga de 400 streams duas vezes, uma com os resets e outra sem. Ambas as execuções vazam, mas a execução com reset termina mais alta: a limpeza de fato devolve algo, apenas pula os frames bloqueados.
with resets -> window 1921441791
without resets -> window 1898053631
[PASS] cleanup gives back only unblocked frames - window stays short
O Estágio 6, portanto, não é apenas "alguma carga aconteceu": a janela está muito abaixo de MAX em ambos os braços, e a ordenação corresponde ao filtro !frame->blocked no código-fonte. poc/window_growth.py repete o ciclo várias vezes se você quiser observar a janela afundar sob churn sustentado.
| caminho | função |
|---|---|
defex_ngnix.sh | driver de 8 estágios somente HTTP, com cores |
Dockerfile | nginx:alpine (1.31.8) + configuração e assets do laboratório |
conf/nginx.conf | TLS + http2 on, buffer de saída de 4 KiB, log info em lab.log, log exposto em /__lab.log |
conf/big.bin | payload de 4 MiB |
poc/flow_control.py | estágio 5, overflow de janela |
poc/blocked_frames.py | estágio 6, vazamento após limpeza de stream |
poc/leak_control.py | estágio 7, controle com/sem reset |
poc/window_growth.py | opcional, ciclos repetidos de churn |
poc/_vendor | h2 / hpack / hyperframe, sem necessidade de pip |
data/ | diretório do host, monte-o via bind em /opt/lab/data ao iniciar o contêiner |
Tudo o que você escrever no shell vai para /opt/lab/data, que você monta via bind a partir de data/. O contêiner é seu para recriar, então esse diretório é o único lugar onde o trabalho sobrevive a um reinício.
error_log aponta para um arquivo real, não para /dev/stderr: um log com symlink não pode ser truncado e tail/grep bloqueariam no pipe para sempre. Ele é publicado em /__lab.log para que o script possa lê-lo sem docker exec; cada estágio memoriza o deslocamento em bytes e só examina as linhas produzidas após esse ponto.