Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
defex-ngnix — PoC: vazamento da janela de envio de conexão HTTP/2 no nginx 1.31.8 (CVE-2026-123007) | Kitploit
Ferramentas/GitHubGitHub/defexnn/defex-ngnix
Scanners de Vulnerabilidades WebAnálise de VulnerabilidadesExploraçãoFuzzingSegurança de RedeLabs e Prática
GitHubdefexnn/defex-ngnix

defex-ngnix

PoC: vazamento da janela de envio de conexão HTTP/2 no nginx 1.31.8 (CVE-2026-123007)

Ver Repositório
1há 2 diasAinda não revisado

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    627
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    416
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer é uma plataforma de código aberto de Gerenciamento de Acesso Privilegiado (PAM) que fornece às equipes de DevOps e TI acesso seguro e sob demanda a endpoints SSH, RDP, Kubernetes, Banco de Dados e RemoteApp através de um navegador web.

    379
  • 5

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    330
  • 6

    Aliens_eye

    arxhr007/aliens_eye

    Mecanismo OSINT com IA para descobrir e mapear mais de 7.700 identidades em redes sociais na web

    288

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

defex-ngnix

nginx CVE license

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.

Requisitos

  • Docker, para construir e executar a imagem do laboratório
  • Python 3 com a árvore poc/_vendor embutida (sem pip install)
  • nada mais; o TLS é um certificado autoassinado descartável fornecido para o laboratório

Status

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.

O bug

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.

Prova

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.

Layout

caminhofunção
defex_ngnix.shdriver de 8 estágios somente HTTP, com cores
Dockerfilenginx:alpine (1.31.8) + configuração e assets do laboratório
conf/nginx.confTLS + http2 on, buffer de saída de 4 KiB, log info em lab.log, log exposto em /__lab.log
conf/big.binpayload de 4 MiB
poc/flow_control.pyestágio 5, overflow de janela
poc/blocked_frames.pyestágio 6, vazamento após limpeza de stream
poc/leak_control.pyestágio 7, controle com/sem reset
poc/window_growth.pyopcional, ciclos repetidos de churn
poc/_vendorh2 / 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.

Notas

Baixar ferramenta