← Voltar ao Blog

HTTP2Shell: o bug do Brotli não é só do Node.js — e o ataque vem pela resposta, não pela requisição

O nome sugere HTTP/2, mas o HTTP2Shell é a CVE-2026-111497 vista pelo ângulo da biblioteca compartilhada: Express 5, fetch(), Python com Brotli instalado, curl --compressed, Parquet, JPEG XL e uma lista longa de software que embute o mesmo decoder C. Entenda os três vetores de exposição, o ponto cego dos WAFs e como auditar seu ambiente.

G
Gila Security
26 de outubro de 2026
HTTP2Shell: o bug do Brotli não é só do Node.js — e o ataque vem pela resposta, não pela requisição

Quando a CVE-2026-111497 saiu, em 21 de outubro de 2026, a manchete foi “RCE no Node.js”. A Imperva batizou a falha de Node2Shell; dias depois, a Strobes publicou uma análise com outro nome — HTTP2Shell — e outra tese, mais importante para quem defende um ambiente real: o bug não é do Node.js. É do decoder Brotli em C que dezenas de produtos compilam dentro de si. O Node é apenas o porta-voz mais famoso.

O nome “HTTP2Shell” também pode enganar: não há falha no protocolo HTTP/2 (nem em HPACK). O nome existe porque o vetor natural do ataque é HTTP — um corpo comprimido em Brotli trafegando normalmente — e o HTTP/2 é onde Content-Encoding: br é mais comum. A lição da Strobes é a frase que abre o write-up deles: o bug vive na biblioteca compartilhada, não em um runtime.

Se você já leu nossa análise do Node2Shell, o mecanismo interno é o mesmo (um decoder que responde “manda mais dados” a um stream impossível e transborda um buffer de 8 bytes). Este texto cobre o resto: por onde o ataque realmente entra, quem mais está exposto e como auditar.

Resumo executivo

  • A falha: escrita fora dos limites no decoder Brotli em C (versões 1.0.3 a 1.2.0) — CVE-2026-111497, CVSS 9,2/9,8.
  • A tese: qualquer stack que decodifica Brotli está exposto — não só Node.js. Inclui Python (pacotes Brotli e brotlicffi ≤ 1.2.0, carregados automaticamente por clientes HTTP), Bun, e uma lista longa de software que embute cópias do decoder.
  • O detalhe mais perigoso: o vetor mais realista é outbound — sua aplicação buscando uma URL escolhida pelo atacante (webhooks, preview de links, crawlers, descoberta OIDC, agentes de IA). O conteúdo malicioso chega pela resposta, contornando WAFs que só inspecionam requisições.
  • Correções: Node.js 22.23.4 / 24.22.1 / 26.12.1; Bun 1.4.4; Python Brotli 1.2.1 e brotlicffi 1.2.1.0; Brotli nativo 1.2.1 / 1.1.1 / 1.0.10.

Os três vetores de exposição

A pergunta certa não é “eu uso Node.js?”, e sim “o que no meu sistema descomprime Brotli de quem eu não confio?”. Há três famílias de resposta.

1. Corpo de requisição entrando — o caso Express 5

O cenário que a Imperva usou na demonstração de RCE: um servidor que aceita corpo de requisição comprimido. O detalhe que pega muitos de surpresa:

  • Express 5 (5.0.0–5.3.0) com body-parser 2.x descomprime corpos de requisição por padrão (a opção inflate vem true). Uma linha inocente como app.use(express.json()) já coloca o decoder no caminho de dados não confiáveis.
  • Express 4 / body-parser 1.x respondem 415 Unsupported Media Type para Brotli — não expostos por esse caminho.
  • Um servidor Node “puro” (http.createServer) sem middleware não descomprime nada — não exposto.

Mitigação imediata, sem atualizar: express.json({ inflate: false }), ou rejeitar Content-Encoding: br no proxy/WAF antes de chegar na aplicação.

2. Resposta saindo — o ponto cego do WAF

Aqui está o vetor que a maioria dos times esquece. Estes clientes descomprimiam Brotli automaticamente, sem ninguém ter escrito “brotli” em lugar nenhum do código:

  • Node.js: fetch() embutido;
  • Python: urllib3/requests, aiohttp e httpx (com o extra brotli) carregam Brotli/brotlicffi se estiverem instalados — mesmo que seu código nunca importe o pacote;
  • curl com --compressed (via libcurl do sistema).

Os canais de ataque, em ordem de realismo: webhooks que buscam a URL que você cadastrou (o atacante cadastra a dele), preview de links (card de mensagem com thumbnail), crawlers e validadores de URL, descoberta OIDC/OAuth (o .well-known/openid-configuration do provedor malicioso), e agentes de IA que fazem fetch de URLs arbitrárias — o caso demonstrado pela Imperva, com o agente buscando a resposta comprimida maliciosa.

E o ponto cego: o payload chega na resposta de uma conexão que a própria aplicação iniciou. WAF e inspeção de tráfego que olham apenas o inbound não veem nada. A rejeição ingênua também não funciona: tirar br do seu Accept-Encoding não impede um servidor malicioso de enviar Brotli de qualquer forma — quem decide o conteúdo é quem responde.

3. Decodificação direta e formatos de arquivo

Brotli não é só HTTP. O decoder aparece em: zlib.brotliDecompress() chamado manualmente; Parquet comprimido com Brotli; JPEG XL (camada de compressão é Brotli); PDFs; arquivos e caches. Se sua pipeline aceita arquivos de terceiros e os abre em processo, ela descomprime com o mesmo código C.

A lista que ninguém audita: cópias embutidas

A Strobes fez o exercício que faltava: procurar cópias vendored do decoder em outros projetos. Em 24 de outubro, ainda sem correção embutida:

  • .NET (cópia interna do Brotli)
  • Extensão PHP brotli
  • Gem Ruby
  • DuckDB e ClickHouse
  • Apache Arrow, libjxl, MuPDF, EDK II (firmware!)

Já corrigidos à época: Chromium, Firefox, ngx_brotli, Brotli4j. Não afetados por usarem implementações próprias: as reimplementações Java/JavaScript/C#, e o brotli-decompressor de Rust. E com uma nota que tranquiliza equivocadamente: Apache e Nginx, nos defaults, não são vetores — eles comprimem respostas, não descomprimem corpos de requisição. O perigo são as camadas que decodificam.

No lado Python há um agravante de gestão: o CVE foi publicado contra o repositório Google, e por dias pip-audit, Dependabot e Safety não acusavam nada — o pacote Brotli no PyPI continuava “limpo” nos relatórios. Auditoria por nome de pacote não basta; é preciso olhar a procedência do código.

Como auditar seu ambiente em cinco comandos

# Node.js: versão do brotli embutido
node -p "process.versions.brotli"        # 1.1.0 = vulnerável; 1.2.1+ = ok

# Python: os pacotes que importam o decoder C
pip show Brotli brotlicffi
pipdeptree -r -p Brotli                  # quem puxa essa dependência

# Node: middleware que descomprime requisição
npm ls express body-parser               # Express 5.x + body-parser 2.x = inflate por padrão

# Onde mais o código aparece (grep nos fontes/lockfiles)
grep -ri "brotlidec\|brotli-decompressor\|libbrotlidec" --include=*.lock --include=*.toml .

# Processos rodando com o decoder carregado em memória
grep -l brotlidec /proc/*/maps

E os lugares onde esse checklist costuma dar positivo e ninguém olha: imagens de container, runners de CI, funções serverless e lockfiles de projetos internos antigos.

Mitigação quando atualizar não é imediato

  1. Rejeitar Content-Encoding: br em corpos de requisição no proxy/WAF (não afeta o vetor resposta).
  2. express.json({ inflate: false }) (e equivalentes nos frameworks que usam body-parser 2).
  3. Desinstalar os pacotes Python Brotli/brotlicffi se nada precisa deles — é a única medida da lista que cobre o vetor resposta, porque os clientes HTTP só descomprimem Brotli quando o pacote existe.
  4. Depois de atualizar: reiniciar todos os processos e reconstruir as imagens — o decoder está compilado dentro do binário, atualizar pacote sem reiniciar não troca o código em execução.

Nenhuma dessas medidas substitui o patch. Elas reduzem a superfície enquanto a atualização não acontece.

O que o ataque tem de detectável

Sem enviar tráfego de teste para produção, os sinais disponíveis são comportamentais: corpos Brotli anormalmente grandes e repetitivos (o vetor conhecido empacota milhões de comandos idênticos — na nossa reprodução, um padrão de 7 bytes repetido até formar ~29 MB); processos com CPU alta num único core após processar conteúdo comprimido (o loop infinito do decoder); crashes de segmentação em workers; e, em sistemas já corrigidos, o aumento do erro ERR__ERROR_FORMAT_BLOCK_SWITCH como indicador de sondagem. A Sysdig publicou orientações de detecção para quem opera runtime security.

Nossa reprodução do diferencial entre o Node.js 24.22.0 (vulnerável) e o 24.22.1 (corrigido) está no post do Node2Shell — com o processo vulnerável travado em loop infinito e o corrigido rejeitando o mesmo stream em milissegundos.

Conclusão

O HTTP2Shell formaliza algo que o incidente merecia escalar para além do Node: quando uma vulnerabilidade mora numa biblioteca C onipresente, o inventário de “quem a embute” é a própria pergunta de segurança — e nenhuma ferramenta de SCA com nome de pacote vai responder por você. Express 5 com json() e inflate ligado, um Brotli esquecido no requirements.txt, um crawler que busca URLs de terceiros: cada um desses é um decoder C sem membrane de segurança rodando dentro do seu processo.

Atualize, desinstale o que não usa, reinicie tudo. E da próxima vez que um CVE de biblioteca nativa estourar, antes de checar “usamos esse runtime?”, pergunte: “quem mais compilou esse código?”

Fontes