← Voltar ao Blog

CVE-2026-111497 (Node2Shell): relatório de investigação e desenvolvimento de exploit

Relatório técnico: reconstruímos a escrita fora dos limites no decoder Brotli do Node.js a partir do diff, provamos por aritmética por que nenhum fuzzer acharia o gatilho, desenvolvemos uma rota própria de exploração (comandos fantasma do dicionário estático) e demonstramos em gravações reais de terminal as três consequências: exfiltração de memória por HTTP, negação de serviço no binário oficial e a cadeia de RCE até system().

G
Gila Security
25 de outubro de 2026
CVE-2026-111497 (Node2Shell): relatório de investigação e desenvolvimento de exploit

Em 21 de outubro de 2026 o Node.js corrigiu a CVE-2026-111497: uma escrita fora dos limites no decoder Brotli em C que o binário embute, com impacto de negação de serviço, vazamento de memória e execução remota de código. A Imperva demonstrou RCE no build oficial e chamou a exploração de “não determinística”. Nenhuma das análises públicas explicava o caminho completo.

Este relatório documenta o que fizemos com os nossos próprios meios: reconstrução da falha a partir do diff (o código do nosso laboratório é byte a byte o deps/brotli do Node 24.22.0 — verificado por comparação direta), uma campanha de fuzzing de ~770 mil casos que provou empiricamente o que a aritmética já dizia, o desenvolvimento de uma rota de exploração própria até então não publicada, e a validação das três consequências em gravações reais de terminal. Não publicamos o gerador de payload.

Primeiro, o Brotli: o que é e onde ele mora

Brotli é o formato de compressão lançado pelo Google em 2013 como sucessor do gzip na web. Mesmo papel — transformar uma resposta HTTP em bytes menores —, com 15 a 25% mais compressão. É o Content-Encoding: br que browsers, CDNs e APIs negociam por padrão em HTTP/2 e HTTP/3; é o que comprime as fontes da sua página e o corpo do seu webhook.

E aqui está o ponto de partida da CVE: o Node.js não implementa esse decoder em JavaScript. Ele compila o código C original da Google (deps/brotli) dentro do próprio binário. Toda aplicação Node carrega um decoder C em processo — mesmo que ninguém tenha escrito “brotli” em lugar nenhum. Basta um middleware que aceite corpo de requisição comprimido, ou um fetch() que recebe resposta comprimida, para dados de quem não confiamos chegarem a esse código C.

Como o formato funciona — o mínimo para entender a falha

Um arquivo Brotli é uma sequência de meta-blocos. Cada meta-bloco declara no cabeçalho o seu tamanho (MLEN) e, para cada uma das três categorias de dados — literais, comandos e distâncias — quantos tipos de bloco existem (NBLTYPES). Esses números dizem ao decoder como o conteúdo está organizado: se NBLTYPES = 1, a categoria inteira é um bloco só e nunca haverá troca de bloco nela; se for 2 ou mais, o decoder lerá, no meio do conteúdo, “trocas de bloco” — instruções que trocam o tipo corrente e renovam um contador de quantos itens ainda cabem no bloco atual.

Dentro do meta-bloco, tudo é comando: “insira N literais” seguido de “copie M bytes de até M posições atrás” (a mesma ideia do LZ77). E as cópias têm uma segunda origem: um dicionário estático embutido no próprio formato — um vocabulário fixo de palavras comuns da web —, cujas entradas podem passar por transformações (maiusculizar, cortar prefixo, cortar sufixo). Tudo é codificado em bits com códigos de Huffman, lidos na ordem, sem alinhamento de byte.

Como o decoder lê isso chegando em pedaços

Os dados não chegam inteiros: chegam em chunks, como a rede entrega. O decoder mantém o estado entre chamadas e, quando os bits acabam no meio de uma leitura, precisa dizer ao chamador “me mande mais dados” e guardar a sobra para retomar depois. Para essa sobra existe um buffer interno de 8 bytes — o formato foi desenhado para que 64 bits sempre bastem para continuar. Distinguir “faltam bits” (condição transitória, o chamador deve mandar mais) de “este stream é inválido” (erro permanente, o chamador deve rejeitar) é a decisão mais importante que o decoder toma a cada pedaço.

A falha: os dois casos viraram um

É exatamente essa distinção que quebra. A função que processa trocas de bloco, DecodeBlockTypeAndLength(), devolvia BROTLI_FALSE para dois casos opostos: “não tenho bits suficientes” (transitório) e “o stream pediu uma troca de bloco numa categoria que declara NBLTYPES = 1” — impossível, erro permanente. A macro BROTLI_SAFE do chamador traduz qualquer FALSE como NEEDS_MORE_INPUT. Diante de um stream que zera o contador de blocos sem ter declarado tipos de troca, o decoder nunca rejeita: estaciona “aguardando mais dados” para sempre.

No estado estacionado, a sobra de cada chunk seguinte é anexada ao buffer de 8 bytes sem verificação alguma — o copy-tail copia tudo que o chamador entregar (while (*available_in) { s->buffer.u8[s->buffer_length] = *next_in++; ... }). A única proteção é um BROTLI_DCHECK, desativado em builds de produção. Os bytes que transbordam caem sobre os campos vizinhos da estrutura de estado: buffer_length (+80), pos — a posição de escrita no ring buffer (+88), limites de distância (+96/+104), ringbuffer_mask, e mais adiante os ponteiros ringbuffer (+136) e metadata_start_func (+720), um callback que o decoder invoca.

O gatilho que nenhum fuzzer acharia

Falta o difícil: como zerar o contador de blocos de uma categoria com NBLTYPES = 1? O decoder reinicia esses contadores a cada meta-bloco para 2^24, e a aritmética convencional impede esgotá-los: cada comando consome do MLEN (teto 2^24) os literais inseridos mais o comprimento da cópia — e como toda cópia produz no mínimo 2 bytes de saída, Σ(insert+copy) ≤ 2^24 nunca drena um contador de 2^24. Nenhum stream sintaticamente razoável chega lá. Confirmamos com ~770 mil casos de fuzzing estruturado — varredura paramétrica, mutação cega, mutação do corpus do encoder oficial, gramática aleatória completa: zero ocorrências do estado-gatilho. É também por isso que o OSS-Fuzz nunca achou a falha em quase dez anos: seu fuzzer do Brotli não faz streaming em pedaços, e o bug só existe no fluxo de múltiplas chamadas.

A rota que desenvolvemos lê o formato como um adversário — e volta justamente ao dicionário estático descrito acima. Existe um transform (OMIT_FIRST_4 com prefixo e sufixo vazios — strings de índice 49, o \0 implícito no fim de kPrefixSuffix) cujo resultado tem comprimento zero. Um comando com insert=0 e cópia resolvida nesse transform não consome MLEN, não avança a saída, mas decrementa o contador de blocos: um comando fantasma. São 2^24 deles — ~29 MB, o corpo do stream é um padrão de 7 bytes repetido 4.194.304 vezes — que zeram o contador com NBLTYPESI=1. O comando seguinte dispara a troca impossível. Esta rota é 100% por stream; o PoC público de 26/10 usa um gatilho de 13 bytes que depende de escrever um campo do decoder à mão para ativar a condição.

Dois limites que moldam toda a exploração

Medidos no nosso laboratório: a barreira dos 28 bytes (BROTLI_FAST_INPUT_SLACK) — no estado estacionado, qualquer chunk único com 28 ou mais bytes faz o caminho rápido do decoder girar sem consumir um bit, num loop infinito (é o vetor de DoS que demonstraremos). E o efeito do nível de otimização: em builds não otimizados, o byte que cai sobre buffer_length corrompe o próprio índice e salta a escrita para qualquer offset da estrutura (o caminho do RCE); em builds otimizados o contador vive em registrador e a corrupção fica linear. Essa diferença separa as demonstrações públicas (builds de laboratório) da exploração do binário oficial — e é a explicação mais provável para o “não determinístico” da Imperva.

As três provas

Gravações reais de terminal (asciinema convertidas para GIF): timing, digitação e saídas são da execução, sem edição.

1. Exfiltração de memória por HTTP

Um servidor com o decoder vulnerável aceita upload com Content-Encoding: br e mantém sessões em memória. Alice autentica; um segundo usuário, sem nenhuma credencial, envia o stream de 29 MB. O campo pos do decoder é sobrescrito (valor 0x4000); as rotinas de saída passam a ler além do ring buffer (alocação de ~1,5 KB) e entregam memória do processo como “conteúdo descomprimido” na resposta HTTP — na gravação, o token de sessão lido da heap aparece no curl do atacante. O stream tem output legítimo vazio: tudo que sai é memória.

Gravação real do terminal: exfiltração de memória por HTTP

Gravação real da sessão — versão interativa (play/pause, texto selecionável): asciinema.org/a/EpV3Z34QmZ9DSF1k

O abort corrupted size vs. prev_size do glibc ao final é a outra face do mesmo overflow: o WrapRingBuffer com tamanho controlado pelo pos corrompido escreve ~15 KB num buffer de 1,5 KB.

2. Negação de serviço no binário oficial

Binários do nodejs.org, mesmo payload. No 24.22.0 (sem correção), o decoder entra no loop infinito do caminho rápido: o processo não responde e não termina — o timeout é quem o mata (exit 124). Cada ataque deixa uma thread do pool do Node em 100% de CPU; quatro uploads paralelos esgotam o pool e a aplicação para para todos os usuários. No 24.22.1 (corrigido), o mesmo stream morre em milissegundos com ERR__ERROR_FORMAT_BLOCK_SWITCH — o erro criado pelo patch.

Gravação real do terminal: DoS no Node.js oficial 24.22.0 vs 24.22.1

Gravação real da sessão — versão interativa: asciinema.org/a/P1xOBoPmFrTAiyQB

3. Cadeia de RCE até system()

Com a primitiva de escrita (o salto do buffer_length sobre builds não otimizados), sobrescrevemos metadata_start_func (+720) com system() e metadata_callback_opaque (+736) com o comando; um meta-bloco metadata de 7 bytes no stream dispara o callback. É a mesma cadeia do PoC público de 26/10 — reproduzida e auditada aqui, incluindo os offsets confirmados por offsetof. Os 16 bytes finais do ponteiro usam atalho de laboratório (escrita direta): a entrega 100% por stream desses bytes é a fronteira aberta, detalhada abaixo.

Gravação real do terminal: cadeia de RCE até system()

Gravação real da sessão — versão interativa: asciinema.org/a/RUd6YttdN2GrYvGW

Na gravação: [1] ringbuffer = 0xdeadbeefdeadbeef — primitiva de escrita com controle do valor, 100% por stream; [2] a saída de id; uname -a executada pelo decoder sequestrado; [3] pos = 0x13371337 — segundo campo controlado.

Onde este trabalho se encaixa no estado da arte

Peça da cadeiaImpervaPoC público 26/10Este trabalho
Condição da CVE 100% por streamnão divulgadanão (gatilho de 13 B + escrita manual)sim — comandos fantasma, 29 MB
Primitiva de escrita por streamnão divulgadasim (build não otimizado)sim, e caracterizada em -O0 vs -O2
Vazamento controladocitadonãosim — token da heap na resposta HTTP
Diferencial no binário oficialRCE (não determinístico)não executadoDoS comprovado; física do vazamento mapeada
Cadeia system()não divulgadasim, com atalhoreproduzida e auditada

A fronteira aberta: os 16 bytes que sequestram o ponteiro de callback exigem uma coreografia de chunks de até 27 bytes alternando o estado do decoder (num_block_types[1] entre 1 e 2, ligando e desligando a condição da CVE) — descrita pelo autor do PoC público como “funciona, mas exige sequenciamento cuidadoso” e jamais publicada em execução. Sobre o vazamento de credenciais de terceiros: a janela inicial (o primeiro KB alocado após o ring buffer) cobre o que o request do ataque e o próprio decoder alocaram; as senhas de outros logins moram em outros blocos do alocador — testamos corpos de login de 45 B, 2 KB e do tamanho exato do ring buffer, e a vizinhança não alinhou. É probabilidade, não impossibilidade: heap grooming fino, o mesmo degrau da coreografia.

A correção

O patch upstream (commit 0ed4268a, cherry-pick 8c5debbea4 no Node) elimina a ambiguidade do booleano:

 if (max_block_type <= 1) {
-  return BROTLI_FALSE;                              /* "manda mais dados" */
+  return BROTLI_DECODER_ERROR_FORMAT_BLOCK_SWITCH;   /* "stream inválido" */
 }

A função passa a devolver um código de três vias (sucesso / precisa de dados / erro permanente), e a nova macro BROTLI_SAFE_WITH_STATUS propaga erros em vez de engoli-los — inclusive no caminho rápido, que antes descartava o retorno. Detalhe: o código -17 ocupa o slot que a enumeração mantinha reservado desde 2017 — o caso era conhecido, só nunca era reportado.

Corrija: Node.js 22.23.4 / 24.22.1 / 26.12.1+; Bun 1.4.4+; Brotli nativo 1.2.1 / 1.1.1 / 1.0.10. O fix existia no upstream desde 27/02/2026, sem advisory — oito meses de janela para quem consome a biblioteca direto. Mitigações de contenção: rejeitar Content-Encoding: br em corpos de requisição no proxy, express.json({ inflate: false }), limitar tamanhos de corpo. Detecção: processos Node com CPU alta em thread única após processar conteúdo comprimido; corpos Brotli gigantes e altamente repetitivos; nos sistemas corrigidos, pico de ERR__ERROR_FORMAT_BLOCK_SWITCH indica sondação.

Cronologia

DataEvento
27/02/2026Commit 0ed4268a corrige a falha no Brotli, sem advisory público.
2026OpenAI Codex Security reporta ao Node.js (HackerOne 4107681).
21/10/2026Node.js 22.23.4 / 24.22.1 / 26.12.1 entre dez CVEs.
22/10/2026Primeiro PoC público (build deliberadamente enfraquecido).
23/10/2026Imperva: RCE no build oficial, “não determinístico”.
26/10/2026PoC público em C (primitiva por stream + RCE com atalho) — auditado neste relatório.

Conclusão

A barreira que protegia o decoder era aritmética — e aritmética se prova. Foi isso que 770 mil casos de fuzzing não derrubaram, e o que uma leitura adversarial do formato derrubou: um transform de comprimento zero no dicionário estático transformou “impossível” em “29 MB”. As três gravações acima são o resultado, reproduzível linha a linha.

Para quem defende: seu Node compila C que ninguém revisa junto com a aplicação — um booleano de dois significados e uma asserção desativada em produção bastaram, e oito meses separam o commit silencioso do patch. Para quem pesquisa: a fronteira aberta é a coreografia dos chunks finais; ela só cairá para quem fizer o dever de casa completo.

Fontes