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
CVE-2026-119618 — 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. | Kitploit
Ferramentas/GitHubGitHub/googlesky/cve-2026-119618
Scanners de Vulnerabilidades WebSegurança de ContêineresAnálise Dinâmica (Sandboxing)ExploraçãoSegurança WebFuzzingPapers e PesquisaLabs e Prática
GitHub
googlesky/cve-2026-119618

CVE-2026-119618

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.

Ver Repositório
147há 2 diasAinda não revisado

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.

    994
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    656
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    422
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer é uma plataforma de código aberto de Gerenciamento de Acesso Privilegiado (PAM) que fornece às equipes de DevOps e TI acesso seguro e sob demanda a endpoints SSH, RDP, Kubernetes, Banco de Dados e RemoteApp através de um navegador web.

    389
  • 5

    SafeLine

    chaitin/safeline

    WAF auto-hospedado e proxy reverso que filtra tráfego HTTP malicioso, bloqueia injeção SQL, XSS e ataques de bots, com limitação de taxa e criptografia dinâmica de HTML/JS.

    333
  • 6

    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.

    330

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

CVE-2026-119618 — Corrupção de heap no mod_http2 do Apache httpd em assign_headers()

CVECVE-2026-119618
ComponenteApache HTTP Server, módulo mod_http2 (mod_h2 autônomo)
Afetadohttpd 2.4.55 – 2.4.70 · mod_h2 2.0.8 – 2.0.42
Corrigido emhttpd 2.4.71 · mod_h2 2.0.43
CWECWE-362 — Execução Concorrente Usando Recurso Compartilhado com Sincronização Imprópria
ImpactoCorrupção de heap em um processo filho do httpd; potencial execução remota de código
VetorRede, não autenticado, HTTP/2 (h2c em texto claro ou h2 via TLS)
GatilhoUma 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ção824beab9b9424d6cfb29595248fdbf6c3dddeab1 (cherry-pick do trunk 5ed39287660daacd1233cb9bbc984b25fa9a4fe3)
PR upstreamapache/httpd#975 → apache/httpd#977, mesclado em 2026-11-09
CréditoOSS Scanner da Anthropic (ANT-2026-MAPKT6MZ); Anthony Weems e Simon Scannell, Google Cloud Vulnerability Research
Avisohttps://httpd.apache.org/security/vulnerabilities_24.html
Solução alternativaremover h2 e h2c da diretiva Protocols
Repositóriohttps://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.


1. Causa raiz

1.1 O código afetado

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.

1.2 O pool do stream compartilha o alocador sem bloqueio da 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.

1.3 A escrita só aloca quando a tabela de cabeçalhos está cheia

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.

1.4 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):

Baixar ferramenta