Regola
Guardia contro il rallentamento espressioni espressioni.
Espressioni espressioni con quantificatori quantificatori o
modelli modelli possono causare un backtracking
passi indietro e problemi .
Lingue supportate: 45+Introduzione
Le espressioni regolari possono bloccare l'applicazione per alcuni secondi o minuti se viene immesso l'input giusto. Il backtracking catastrofico si verifica quando i motori delle espressioni regolari esplorano percorsi che aumentano in modo esponenziale mentre cercano di trovare una corrispondenza con un pattern. Un'espressione regolare come (a+)+b Ci vogliono pochi microsecondi per verificare la validità di un input, ma possono essere necessarie ore per rifiutare una stringa composta esclusivamente da "a" senza una "b" finale. Gli hacker sfruttano questa vulnerabilità tramite attacchi di tipo "Regular Expression Denial of Service" (ReDoS), inviando input appositamente manipolati che inducono il motore delle espressioni regolari a consumare il 100% della CPU fino a quando non si verifica il timeout della richiesta o il processo va in crash.
Perché è importante
Implicazioni per la sicurezza (attacchi ReDoS): un malintenzionato può paralizzare l'applicazione con una singola richiesta contenente dati appositamente manipolati. La convalida delle e-mail e gli schemi di analisi degli URL sono bersagli comuni. A differenza degli attacchi DoS tradizionali, che richiedono larghezza di banda, gli attacchi ReDoS necessitano solo di payload minimi.
Deterioramento delle prestazioni: un normale input da parte dell'utente può innescare un backtracking catastrofico, causando un'impennata dei tempi di risposta da millisecondi a secondi. Ciò genera una latenza imprevedibile, difficile da risolvere poiché si manifesta solo con specifici modelli di input.
Incidenti di produzione: un'espressione regolare vulnerabile blocca il ciclo degli eventi in Node.js o consuma le risorse del pool di thread. Man mano che le richieste si accumulano, l'utilizzo della memoria aumenta e il sistema smette di rispondere. Nei microservizi, un'espressione regolare vulnerabile provoca un effetto a cascata di errori sui servizi dipendenti.
Difficoltà di individuazione: gli schemi che funzionano correttamente durante i test con input brevi diventano esponenzialmente lenti con input più lunghi. La vulnerabilità spesso passa inosservata fino alla fase di produzione, rendendo necessaria un'implementazione d'emergenza nel corso di un incidente in corso.
Esempi di codice
❌ Non conforme:
function validateEmail(email) {
const regex = /^([a-zA-Z0-9_\-\.]+)+@([a-zA-Z0-9_\-\.]+)+\.([a-zA-Z]{2,5})$/;
return regex.test(email);
}
function extractURLs(text) {
const regex = /(https?:\/\/)?([\w\-])+\.(\w+)+([\w\-\.,@?^=%&:/~\+#]*)+/g;
return text.match(regex);
}
Perché non è sicuro: I quantificatori annidati ([a-zA-Z0-9_\\-\\.]+)+ creare un backtracking esponenziale. Per un'e-mail come aaaaaaaaaaaaaaaaaaaaaaaaa!, il motore delle espressioni regolari prova innumerevoli combinazioni prima di fallire. L'espressione regolare dell'URL presenta diversi quantificatori annidati che aggravano il problema, rendendola facilmente vulnerabile a input quali lunghe stringhe di caratteri validi prive della struttura prevista.
✅ Conforme:
function validateEmail(email) {
const regex = /^[a-zA-Z0-9_\-\.]+@[a-zA-Z0-9_\-\.]+\.[a-zA-Z]{2,5}$/;
return regex.test(email);
}
function extractURLs(text) {
const regex = /https?:\/\/[\w\-]+\.[\w\-]+(?:[\w\-\.,@?^=%&:/~\+#]*)?/g;
return text.match(regex);
}
Perché è sicuro: la rimozione dei quantificatori annidati elimina il backtracking catastrofico. I quantificatori singoli come [a-zA-Z0-9_\-\.]+ vengono eseguiti in tempo lineare. Il modello URL utilizza gruppi non catturanti con suffisso opzionale (?:...)? anziché ripetizioni annidate, garantendo prestazioni prevedibili indipendentemente dalla lunghezza o dal contenuto dell'input.
Conclusione
Le prestazioni delle espressioni regolari rappresentano un problema di sicurezza, non solo una questione di ottimizzazione. Verificate tutti i pattern di espressioni regolari alla ricerca di quantificatori annidati, classi di caratteri sovrapposte nei gruppi di ripetizione e alternative ambigue. Testate i pattern di espressioni regolari con input patologici (lunghe stringhe di caratteri validi seguite da terminazioni non valide) per individuare eventuali backtracking catastrofici prima della distribuzione. Ove possibile, sostituite le espressioni regolari complesse con funzioni di analisi delle stringhe che presentino caratteristiche prestazionali prevedibili.
