Laboratório diferencial conteinerizado e PoC HTTP/2 em stdlib para CVE-2026-119618, uma corrida no alocador do mod_http2 que causa corrupção de heap no Apache httpd 2.4.55-2.4.70, com evidências de ASan/TSan.
mod_http2 do Apache httpd em assign_headers()| CVE | CVE-2026-119618 |
| Componente | Apache HTTP Server, módulo mod_http2 (mod_h2 autônomo) |
| Afetado | httpd 2.4.55 – 2.4.70 · mod_h2 2.0.8 – 2.0.42 |
| Corrigido em | httpd 2.4.71 · mod_h2 2.0.43 |
| CWE | CWE-362 — Execução Concorrente Usando Recurso Compartilhado com Sincronização Imprópria |
| Impacto | Corrupção de heap em um processo filho do httpd; potencial execução remota de código |
| Vetor | Rede, não autenticado, HTTP/2 (h2c em texto claro ou h2 via TLS) |
| Gatilho | Uma requisição HTTP/2 sem corpo contendo Content-Type e sem Content-Length, com a tabela de cabeçalhos da requisição preenchida até a capacidade |
| Commit de correção | 824beab9b9424d6cfb29595248fdbf6c3dddeab1 (cherry-pick do trunk 5ed39287660daacd1233cb9bbc984b25fa9a4fe3) |
| PR upstream | apache/httpd#975 → apache/httpd#977, mesclado em 2026-11-09 |
| Crédito | OSS Scanner da Anthropic (ANT-2026-MAPKT6MZ); Anthony Weems e Simon Scannell, Google Cloud Vulnerability Research |
| Aviso | https://httpd.apache.org/security/vulnerabilities_24.html |
| Solução alternativa | remover h2 e h2c da diretiva Protocols |
| Repositório | https://github.com/googlesky/CVE-2026-119618 |
O mod_http2 concede a cada stream HTTP/2 um pool próprio, e esse pool
herda o alocador da conexão que possui a sessão. O
alocador não possui mutex: apr_allocator_create() não cria um, portanto
allocator_lock() é uma operação nula para toda a conexão. O processamento
de requisições é deliberadamente movido para threads de trabalho com um alocador
privado (c2_transit_create()) justamente para que uma thread de trabalho nunca toque no
alocador da conexão. assign_headers() quebra essa invariante: para uma
requisição sem corpo que contém Content-Type e nenhum Content-Length, a
thread de trabalho grava o Content-Length: 0 sintetizado na tabela de
stream compartilhada em vez do r->headers_in privado da requisição. Quando a tabela
está cheia, essa gravação aloca um novo nó de 8 KB a partir do alocador
livre de bloqueios da conexão enquanto a thread da conexão está alocando ou
liberando na mesma lista livre. Duas threads podem retirar o mesmo nó, e a
dupla propriedade resultante corrompe o heap do processo filho do httpd.
Este repositório contém um laboratório diferencial conteinerizado que reproduz a corrupção no httpd 2.4.70, comprova a corrida com ThreadSanitizer, mostra o httpd 2.4.71 limpo sob o mesmo tráfego, exercita todas as formas de requisição irmãs, verifica a solução alternativa publicada e registra uma varredura de 0-day na linha corrigida.
modules/http2/h2_request.c, Apache httpd 2.4.70, assign_headers().
Os números de linha são do tarball de lançamento 2.4.70.
320: static void assign_headers(request_rec *r, const h2_request *req,
321: int no_body, int is_connect)
322: {
323: const char *cl;
324:
325: r->headers_in = apr_table_clone(r->pool, req->headers);
...
341: /* Unless we open a byte stream via CONNECT, apply content-length guards. */
342: if (!is_connect) {
343: cl = apr_table_get(req->headers, "Content-Length");
344: if (no_body) {
345: if (!cl && apr_table_get(req->headers, "Content-Type")) {
346: /* If we have a content-type, but already seen eos, no more
347: * data will come. Signal a zero content length explicitly.
348: */
349: apr_table_setn(req->headers, "Content-Length", "0");
350: }
351: }
A correção na versão 2.4.71 altera uma linha:
- apr_table_setn(req->headers, "Content-Length", "0");
+ apr_table_setn(r->headers_in, "Content-Length", "0");
r->headers_in é o clone criado na linha 325 em r->pool, o pool de requisições pertencente à thread de trabalho. req->headers é a tabela do stream, alocada a partir do pool do stream e acessível pela thread de conexão.
h2_session_open_stream() (h2_session.c:117) cria o pool por stream como filho do pool da sessão e o marca:
apr_pool_create(&stream_pool, session->pool);
apr_pool_tag(stream_pool, "h2_stream");
stream = h2_stream_create(stream_id, stream_pool, session, ...);
O pool de sessões é um descendente do pool de conexões que o MPM
cria em child_main() (server/mpm/prefork/prefork.c:423). O alocador desse pool
vem de apr_allocator_create(), e nenhum mutex é jamais definido
nele:
/* memory/unix/apr_pools.c:164 */
static APR_INLINE void allocator_lock(apr_allocator_t *allocator)
{
#if APR_HAS_THREADS
if (allocator->mutex) /* NULL for the MPM allocator */
apr_thread_mutex_lock(allocator->mutex);
#endif
}
O processamento de requisições, por outro lado, é explicitamente projetado para evitar
esse alocador. c2_transit_create() (h2_mplx.c:210) dá a cada worker
um alocador privado:
/* We create a pool with its own allocator to be used for
* processing a request. This is the only way to have the processing
* independent of its parent pool in the sense that it can work in
* another thread.
*/
rv = apr_allocator_create(&allocator);
O request_rec do worker é criado em c2->pool, um descendente do
pool de trânsito, portanto toda alocação que o worker normalmente faz é privada.
A escrita vulnerável é a exceção: ela aloca do pool de stream,
cujo alocador é o da conexão.
apr_table_setn() em uma chave ausente recai para apr_table_add(),
que chama table_push() → apr_array_push_noclear()
(tables/apr_tables.c:126):
if (arr->nelts == arr->nalloc) {
int new_size = arr->nalloc <= 0 ? 1 : 2 * arr->nalloc;
apr_table_entry_t *new_elts = apr_palloc(arr->pool, elt_size * new_size);
...
}
A tabela é criada por h2_request_create() como
apr_table_make(pool, 10), então nalloc começa em 10 e dobra: 10, 20,
40, 80, 160. Pseudo-cabeçalhos não são armazenados na tabela — eles se tornam
req->method, req->scheme, req->authority e req->path.
h2_request_end_headers() (h2_request.c:212) adiciona exatamente uma entrada Host.
Uma requisição com 79 cabeçalhos regulares portanto contém 79 entradas, Host
totaliza 80, e nelts == nalloc == 80 quando assign_headers() é executado. O
apr_table_setn() vulnerável expande o array para 160 entradas:
160 * sizeof(apr_table_entry_t) = 160 * 24 = 3840 bytes
allocator_align() (apr_pools.c:268) arredonda isso para MIN_ALLOC
(8192), então a escrita solicita um novo nó de 8 KB ao alocador do pool de
stream sempre que o nó ativo do pool tiver menos de 3840 bytes restantes.
Essa é a alocação que sofre a condição de corrida.
allocator_alloc() (apr_pools.c:289) percorre a lista de nós livres
(allocator->free[index], allocator->max_index) e retira um nó;
allocator_free() (apr_pools.c:426) devolve um nó e reescreve
max_index. Sem mutex, essas são sequências de leitura-modificação-escrita
não sincronizadas sobre o mesmo apr_allocator_t — um objeto de heap de
200 bytes alocado por apr_allocator_create() em child_main(). Duas threads
podem retirar o mesmo nó, após o que dois pools diferentes distribuem memória
sobreposta.
O ThreadSanitizer captura exatamente isso na 2.4.70
(evidence/tsan-vulnerable.txt):