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.
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
Brotliebrotlicffi≤ 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
Brotli1.2.1 ebrotlicffi1.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
inflatevemtrue). Uma linha inocente comoapp.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 Typepara 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,aiohttpehttpx(com o extra brotli) carregamBrotli/brotlicffise 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
- Rejeitar
Content-Encoding: brem corpos de requisição no proxy/WAF (não afeta o vetor resposta). express.json({ inflate: false })(e equivalentes nos frameworks que usam body-parser 2).- Desinstalar os pacotes Python
Brotli/brotlicffise nada precisa deles — é a única medida da lista que cobre o vetor resposta, porque os clientes HTTP só descomprimem Brotli quando o pacote existe. - 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
- Strobes — HTTP2Shell: Brotli RCE in Node.js and Python
- Sysdig — Node2Shell (CVE-2026-111497): Detecting the Node.js Brotli RCE
- Imperva — Node2Shell: From Brotli Data to Remote Code Execution
- Node.js — Wednesday, October 21, 2026 Security Releases
- Correção no google/brotli (commit 0ed4268a)
- HeroDevs — CVE-2026-111497 (Node2Shell): Node.js Brotli RCE Fix
- Gila Security — Node2Shell: análise técnica e reprodução em laboratório