Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
cve-2026-93687-braces — 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. | Kitploit
Strumenti/GitHubGitHub/canmenzo/cve-2026-93687-braces
Analisi StaticaAnalisi delle VulnerabilitàFuzzingPaper e RicercaApprendimento e Formazione
GitHubcanmenzo/cve-2026-93687-braces

cve-2026-93687-braces

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.

Vedi Repository
126 giorni faNon ancora revisionato
Condividi

CVE-2026-93687 / GHSA-vfj7-8cjw-p6xm: una verifica indipendente

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.

Cosa afferma il CVE

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.

Cosa dice il maintainer

Nella issue #70 di micromatch/braces il maintainer (jonschlinkert, 2026-10-05) l'ha definita "una completa assurdità" e ha fatto tre osservazioni:

  1. Una profondità di annidamento di 5.000 richiede almeno 10.001 caratteri, quindi impostare maxLength al di sotto di tale valore è tutto ciò che serve, ed è già supportato.
  2. Non lasciare che gli utenti definiscano glob o regex, la stessa regola per cui non si lascia mai che gli utenti scrivano SQL grezzo. Se non lo fai, "questo CVE descrive come ti attaccheresti da solo".
  3. Un'opzione 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.

Cosa abbiamo misurato

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:

  • Il 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:

  • A freddo significa un processo nuovo che effettua la chiamata per la prima volta, prima che il JIT ottimizzi le funzioni ricorsive. I frame non ottimizzati sono più grandi, quindi lo stack va in overflow a una profondità inferiore. Questo è ciò che un server a lunga esecuzione incontra alla sua prima richiesta malevola.
  • A caldo significa la stessa funzione chiamata molte volte in un processo già in esecuzione, dopo che il JIT ha ridotto i frame, quindi sopravvive più in profondità.

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 ingressoformaprofondità di rottura a freddolunghezza del patternfreddocaldo
braces()commaNested250010001guardedguarded@2500
braces()braceNested35107021stackguarded@5000
braces()rangeNested142910007guardedguarded@1429
braces.expand()commaNested250010001guardedguarded@2500
braces.expand()braceNested39847969stackguarded@5000
braces.expand()rangeNested142910007guardedguarded@1429
braces.compile()braceNested~3500~7000stack (al limite)guarded@5000
braces.parse()braceNested500010001guardedguarded@5000
micromatch()commaNested565322613altro (regex troppo grande)invariato
micromatch()braceNested1638332767altro (regex troppo grande)invariato
micromatch()rangeNested936265538guardedinvariato
micromatch.isMatch()braceNested1638332767altro (regex troppo grande)invariato
fast-glob.generateTasks()braceNested~3976~7953stack (al limite)guarded@5000
fast-glob.sync()braceNested128257altro (benigno glob Error)invariato
(tutti braces/fast-glob)commaNested / rangeNested2500 / 1429~10000guardedguarded

Lettura della tabella:

  • A freddo, con le opzioni predefinite e lo stack predefinito, 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.
  • A caldo, lo stesso pattern a graffe non va in overflow: il JIT riduce abbastanza i frame che la ricorsione raggiunge prima il limite di lunghezza di 10000 (guarded@5000). È per questo che un benchmark ingenuo in-process nasconde il bug. Misurare a freddo è il punto.
  • Le forme a virgola e a intervallo non vanno in crash nemmeno a freddo: a 4 e 7 caratteri per livello il limite di 10000 le confina a profondità 2500 e 1429, al di sotto della soglia di overflow a freddo, quindi vince il guard. La frase del maintainer "depth 5000 needs 10001 chars" è un'affermazione relativa alla forma a virgola ed è corretta per quella forma; la forma a graffe è quella che riesce a raggiungere una profondità di crash entro il limite.
  • braces.parse() non va mai in overflow (è iterativo), su qualsiasi forma.
  • micromatch non va mai in stack overflow. Ha il proprio guard (picomatch 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.
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    546
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    477
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    377
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    324
  • 5

    estorides

    grisuno/estorides

    Aggrega in parallelo oltre 99 fonti OSINT gratuite, risolve le entità in un knowledge graph ed esporta in STIX 2.1, MISP o GraphML con analisi assistita da LLM.

    269
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    252

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →