
Harness di misurazione indipendente che verifica CVE-2026-93687: riproduce l'esaurimento dello stack nel processo a freddo in braces 3.0.3 con il maxLength predefinito e verifica le mitigazioni.
Questo repo verifica, con misurazioni, l'affermazione contenuta in CVE-2026-93687 (GHSA-vfj7-8cjw-p6xm)
secondo cui il pacchetto npm braces alla versione 3.0.3 e precedenti è vulnerabile a
"esaurimento dello stack tramite pattern profondamente annidati" (CWE-674, ricorsione
non controllata). L'advisory non elenca alcuna versione corretta.
Questo è un repo di verifica, non un repo di patch. Non esegue fork né corregge braces. Fissa
le esatte versioni interessate, esercita ogni punto di ingresso pubblico e riporta
i numeri.
Pattern con parentesi graffe profondamente annidati (ad esempio {a,{a,{a,...}}} o {{{...}}}) spingono
funzioni ricorsive in braces oltre il limite dello stack di chiamate, generando
RangeError: Maximum call stack size exceeded e mandando in crash il processo. I
riferimenti dell'advisory puntano al codice ricorsivo in lib/compile.js (L49-53),
lib/expand.js (L102-105) e lib/parse.js (L38-40) di braces 3.0.3.
Nella issue #70 di micromatch/braces il maintainer (jonschlinkert, 2026-10-05) l'ha definita "una completa assurdità" e ha fatto tre osservazioni:
maxLength al di sotto di tale valore è tutto ciò che serve, ed è già supportato.maxDepth non risolverebbe il DoS da glob in generale: i pattern glob sono
espressioni regolari, la negazione costringe il motore a costruire e invertire un DFA,
e quello spazio degli stati può esplodere esponenzialmente (il problema dell'altezza delle stelle).Upstream ha raccolto dodici PR di correzione da quando la issue è stata aperta (#72 fino alla #89), cinque ancora aperte, tutte varianti sul limitare la profondità di annidamento. Nessuna è stata unita.
Macchina: 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, pin esatti.
Due fatti su braces determinano tutto:
maxLength predefinito (lib/constants.js MAX_LENGTH) è di 10000
caratteri, non i 65536 delle versioni precedenti. È stato abbassato a 10000 nella
PR upstream #40 (2024).lib/parse.js imposta il limite effettivo a Math.min(MAX_LENGTH, opts.maxLength).
Quindi maxLength può solo abbassare il limite di 10000, mai alzarlo o disabilitarlo.
braces non accetterà un input più lungo di 10000 caratteri. Inoltre parse è
iterativo (un array stack esplicito), quindi non ricorre mai e non va mai
in overflow; la ricorsione risiede in expand e compile.La domanda è quindi se un pattern di 10000 caratteri o meno si annidi
abbastanza in profondità da mandare in overflow le funzioni ricorsive expand/compile. La risposta dipende
dal fatto che la chiamata sia a freddo o a caldo, e questo conta molto:
Ogni sonda qui sotto viene quindi eseguita nel proprio processo node nuovo
(repro/child.mjs tramite spawnSync): una build, una chiamata, stampa il risultato. La
colonna warm ripete la stessa ricerca all'interno di un singolo processo, per mostrare la differenza.
Risultati: stack (un RangeError intercettato), guarded (il controllo di lunghezza l'ha rifiutato
per primo), other (un diverso errore intercettato, ad es. "regex too large" di V8), ok.
Forme: commaNested = {a,{a,...}} (circa 4 caratteri per livello), braceNested =
{{{...a...}}} (circa 2 per livello), rangeNested = {1..2,{1..2,...}} (circa
7 per livello). maxLength predefinito = 10000.
| punto di ingresso | forma | profondità di rottura a freddo | lunghezza del pattern | freddo | caldo |
|---|---|---|---|---|---|
| braces() | commaNested | 2500 | 10001 | guarded | guarded@2500 |
| braces() | braceNested | 3510 | 7021 | stack | guarded@5000 |
| braces() | rangeNested | 1429 | 10007 | guarded | guarded@1429 |
| braces.expand() | commaNested | 2500 | 10001 | guarded | guarded@2500 |
| braces.expand() | braceNested | 3984 | 7969 | stack | guarded@5000 |
| braces.expand() | rangeNested | 1429 | 10007 | guarded | guarded@1429 |
| braces.compile() | braceNested | ~3500 | ~7000 | stack (al limite) | guarded@5000 |
| braces.parse() | braceNested | 5000 | 10001 | guarded | guarded@5000 |
| micromatch() | commaNested | 5653 | 22613 | altro (regex troppo grande) | invariato |
| micromatch() | braceNested | 16383 | 32767 | altro (regex troppo grande) | invariato |
| micromatch() | rangeNested | 9362 | 65538 | guarded | invariato |
| micromatch.isMatch() | braceNested | 16383 | 32767 | altro (regex troppo grande) | invariato |
| fast-glob.generateTasks() | braceNested | ~3976 | ~7953 | stack (al limite) | guarded@5000 |
| fast-glob.sync() | braceNested | 128 | 257 | altro (benigno glob Error) | invariato |
| (tutti braces/fast-glob) | commaNested / rangeNested | 2500 / 1429 | ~10000 | guarded | guarded |
Lettura della tabella:
braces() e
braces.expand() vanno in overflow dello stack sulla forma a graffe con una
lunghezza del pattern di circa 7000-8000 caratteri, ben al di sotto del limite
di 10000. Questo è deterministico su ripetute esecuzioni da zero (confermato
5 su 5 a profondità 4000, lunghezza 8001, per entrambi). Il percorso di compile
e fast-glob.generateTasks si collocano nella stessa fascia di soglia a
freddo (circa profondità 3500-4000); proprio al limite la profondità esatta
oscilla di qualche centinaio tra un'esecuzione e l'altra, ma qualche centinaio
più in profondità è un crash affidabile.braces.parse() non va mai in overflow (è iterativo), su qualsiasi forma.MAX_LENGTH = 65536) e gestisce le graffe per conto proprio; al di sotto di
quel limite costruisce una regex così grande che V8 lancia un
SyntaxError: Invalid regular expression ... too large intercettabile. Il
pattern lungo non viene inoltrato in un overflow dello stack di braces.
picomatch è un pacchetto diverso da braces.fast-glob.sync() (un glob reale su una directory temporanea) non è il
vettore DoS: lancia un normale Error intercettabile molto presto
(profondità 128), non uno stack overflow. Il percorso di parsing del pattern
generateTasks è quello che può raggiungere la ricorsione.