
Harness de medição independente que verifica a CVE-2026-93687: reproduz o esgotamento de pilha em processo frio no braces 3.0.3 sob o maxLength padrão e testa mitigações.
Este repositório verifica, por meio de medições, a afirmação da CVE-2026-93687 (GHSA-vfj7-8cjw-p6xm)
de que o pacote npm braces na versão 3.0.3 e anteriores é vulnerável a
"esgotamento de pilha por meio de padrões profundamente aninhados" (CWE-674, recursão
não controlada). O aviso não lista nenhuma versão corrigida.
Este é um repositório de verificação, não de correção. Ele não faz fork nem corrige o braces. Ele
fixa as versões afetadas exatas, aciona todos os pontos de entrada públicos e relata
números.
Padrões de chaves profundamente aninhados (por exemplo {a,{a,{a,...}}} ou {{{...}}}) levam
funções recursivas em braces além do limite da pilha de chamadas, lançando
RangeError: Maximum call stack size exceeded e derrubando o processo. As
referências do aviso apontam para o código recursivo em lib/compile.js (L49-53),
lib/expand.js (L102-105) e lib/parse.js (L38-40) do braces 3.0.3.
Na issue #70 de micromatch/braces, o mantenedor (jonschlinkert, 2026-10-05) chamou isso de "completa bobagem" e fez três pontos:
maxLength abaixo disso é tudo o que é necessário, e já é suportado.maxDepth não resolveria o DoS de glob em geral: padrões glob são
expressões regulares, a negação força o motor a construir e inverter um DFA,
e esse espaço de estados pode explodir exponencialmente (o problema da altura de estrela).O upstream coletou doze PRs de correção desde que a issue foi aberta (#72 a #89), cinco ainda abertos, todos variações de limitação da profundidade de aninhamento. Nenhum foi mesclado.
Máquina: Apple Mac mini (Mac16,10), arm64, macOS 25.6 (Darwin 25.6.0). Node: v26.8.1. braces 3.0.3, micromatch 4.0.8, fast-glob 3.3.1, versões fixadas exatas.
Dois fatos sobre o braces moldam tudo:
maxLength padrão (lib/constants.js MAX_LENGTH) é de 10000
caracteres, não os 65536 de versões mais antigas. Foi reduzido para 10000 no
PR upstream #40 (2024).lib/parse.js define o limite efetivo como Math.min(MAX_LENGTH, opts.maxLength).
Portanto, maxLength só pode reduzir o limite de 10000, nunca aumentá-lo ou desativá-lo.
braces não aceitará uma entrada com mais de 10000 caracteres. parse também é
iterativo (um array stack explícito), então nunca recorre e nunca
estoura; a recursão está em expand e compile.A questão é, portanto, se um padrão de 10000 caracteres ou menos se aninha
profundamente o suficiente para estourar o expand/compile recursivo. A resposta depende
de se a chamada é fria ou quente, e isso importa muito:
Cada sonda abaixo, portanto, é executada em seu próprio processo node novo
(repro/child.mjs via spawnSync): uma compilação, uma chamada, imprime o resultado. A
coluna warm repete a mesma busca dentro de um único processo, para mostrar a diferença.
Resultados: stack (um RangeError capturado), guarded (a proteção de comprimento o rejeitou
primeiro), other (um erro capturado diferente, por exemplo, V8 "regex too large"), ok.
Formatos: commaNested = {a,{a,...}} (cerca de 4 caracteres por nível), braceNested =
{{{...a...}}} (cerca de 2 por nível), rangeNested = {1..2,{1..2,...}} (cerca de
7 por nível). maxLength padrão = 10000.
| ponto de entrada | forma | profundidade de quebra a frio | comprimento do padrão | frio | quente |
|---|---|---|---|---|---|
| braces() | commaNested | 2500 | 10001 | protegido | protegido@2500 |
| braces() | braceNested | 3510 | 7021 | stack | protegido@5000 |
| braces() | rangeNested | 1429 | 10007 | protegido | protegido@1429 |
| braces.expand() | commaNested | 2500 | 10001 | protegido | protegido@2500 |
| braces.expand() | braceNested | 3984 | 7969 | stack | protegido@5000 |
| braces.expand() | rangeNested | 1429 | 10007 | protegido | protegido@1429 |
| braces.compile() | braceNested | ~3500 | ~7000 | stack (limite) | protegido@5000 |
| braces.parse() | braceNested | 5000 | 10001 | protegido | protegido@5000 |
| micromatch() | commaNested | 5653 | 22613 | outro (regex muito grande) | igual |
| micromatch() | braceNested | 16383 | 32767 | outro (regex muito grande) | igual |
| micromatch() | rangeNested | 9362 | 65538 | protegido | igual |
| micromatch.isMatch() | braceNested | 16383 | 32767 | outro (regex muito grande) | igual |
| fast-glob.generateTasks() | braceNested | ~3976 | ~7953 | stack (limite) | protegido@5000 |
| fast-glob.sync() | braceNested | 128 | 257 | outro (Error de glob benigno) | igual |
| (todos braces/fast-glob) | commaNested / rangeNested | 2500 / 1429 | ~10000 | protegido | protegido |
Lendo a tabela:
braces() e
braces.expand() estouram a pilha na forma de chaves com um comprimento de
padrão de cerca de 7000 a 8000 caracteres, bem abaixo do limite de 10000. Isso é
determinístico em execuções novas repetidas (confirmado 5 de 5 na profundidade 4000, comprimento
8001, para ambos). O caminho de compilação e fast-glob.generateTasks ficam na
mesma faixa de limite a frio (cerca de profundidade 3500 a 4000); bem no
limite a profundidade exata oscila algumas centenas entre execuções, mas algumas centenas mais fundo é
uma falha confiável.braces.parse() nunca estoura (é iterativo), em qualquer forma.MAX_LENGTH = 65536) e faz seu próprio tratamento de chaves; abaixo desse limite ele constrói
uma regex tão grande que o V8 lança um
SyntaxError: Invalid regular expression ... too large capturável. O padrão longo
não é encaminhado para um estouro de pilha de braces. picomatch é um pacote
diferente de braces.fast-glob.sync() (um glob real em um diretório temporário) não é o vetor de DoS: ele
lança um Error comum e capturável muito cedo (profundidade 128), não um estouro de
pilha. O caminho de análise de padrões generateTasks é o que pode alcançar
a recursão.Em todos os casos de falha, o estouro é um RangeError que um try/catch
circundante captura; o processo filho imprime seu resultado e sai com 0, então é
um erro lançado, não um aborto não capturável. Não há exposição de dados nem execução
de código.