Una semplice regex può bloccare un server: come riconoscere quelle pericolose

Una semplice regex può rallentare o bloccare un server: come funzionano gli attacchi ReDoS e come prevenirli con Python e JavaScript.

Una espressione regolare, o regex, può trasformare una semplice operazione di verifica in un problema di sicurezza. Basta una sequenza di caratteri costruita opportunamente per costringere il motore che interpreta l’espressione regolare o regular expression a eseguire milioni di tentativi, impegnando la CPU fino a rallentare o bloccare un’applicazione.

Il fenomeno prende il nome di catastrophic backtracking ed è alla base di una particolare forma di attacco denominata ReDoS (Regular Expression Denial of Service). Non richiede espressioni particolarmente elaborate: anche poche istruzioni, apparentemente innocue, possono nascondere un costo computazionale enorme.

Il problema interessa applicazioni Web, API, sistemi di autenticazione e qualunque software che utilizzi espressioni regolari per elaborare dati provenienti dall’esterno.

Perché una regex può diventare estremamente lenta

Le regex descrivono schemi di testo da riconoscere: un’applicazione può utilizzarle per verificare un indirizzo email, identificare un codice o controllare il formato di un campo.

Consideriamo l’espressione riportata di seguito. Il simbolo ^ indica l’inizio della stringa, $ la fine, mentre + richiede una o più ripetizioni dell’elemento precedente:

^(a+)+$

La particolarità riguarda due quantificatori annidati: uno ripete il carattere a, l’altro ripete l’intero gruppo (a+).

Con una stringa composta esclusivamente da lettere a, il risultato arriva rapidamente. Aggiungendo un carattere incompatibile alla fine, invece, il motore deve verificare numerose combinazioni alternative prima di stabilire che la corrispondenza non esiste.

Il meccanismo si chiama backtracking: il motore torna sui propri passi e tenta una diversa suddivisione della stringa: il numero di tentativi può crescere esponenzialmente rispetto alla lunghezza dell’input.

Esperimento pratico: misurare il problema con Python

Possiamo osservare il fenomeno con uno script Python che utilizza re, il modulo standard per le espressioni regolari:

import re
import time

regex = re.compile(r"^(a+)+$")

for n in [10, 12, 14, 16, 18, 20]:
    testo = "a" * n + "!"

    inizio = time.perf_counter()
    risultato = regex.fullmatch(testo)
    durata = time.perf_counter() - inizio

    print(f"{n:2} a | {durata * 1000:.3f} ms")

Lo script produce stringhe progressivamente più lunghe, tutte destinate a fallire il controllo. Il limite di 20 caratteri evita di lanciare involontariamente elaborazioni eccessivamente costose. In una misurazione sperimentale, i tempi di esecuzione possono seguire un andamento simile al seguente:

Numero di lettere a Tempo di elaborazione
10 0,094 ms
12 0,126 ms
14 0,515 ms
16 2,074 ms
18 8,133 ms
20 32,047 ms

I valori sono indicativi e non costituiscono un benchmark riproducibile su ogni sistema. Dipendono dal processore, dalla versione di Python e dal carico della macchina.

Con appena 20 lettere a, seguite da un punto esclamativo, il controllo può richiedere decine di millisecondi. L’aumento non è lineare: aggiungere pochi caratteri può moltiplicare il tempo necessario.

Ripetere il test con JavaScript

Anche JavaScript permette di riprodurre il comportamento. Salviamo il seguente codice nel file regex-test.js ed eseguiamolo con node regex-test.js:

const regex = /^(a+)+$/;

for (const n of [10, 12, 14, 16, 18, 20]) {
    const testo = "a".repeat(n) + "!";

    const inizio = performance.now();
    const risultato = regex.test(testo);
    const durata = performance.now() - inizio;

    console.log(`${n} a | ${durata.toFixed(3)} ms`);
}

In una prova con Node.js 22, la stringa più lunga può richiedere diversi millisecondi, contro una frazione di millisecondo per quelle più corte. I risultati variano anche in funzione delle ottimizzazioni del motore JavaScript.

Nei server Node.js il rischio è particolarmente rilevante: JavaScript gestisce normalmente le operazioni applicative attraverso un event loop, meccanismo che coordina l’esecuzione del codice e la gestione degli eventi, comprese le richieste HTTP in arrivo. Se una regex sincrona richiede troppo tempo per completare un controllo, occupa il thread JavaScript principale e impedisce all’event loop di proseguire con le altre operazioni. Anche le richieste di utenti che non hanno nulla a che fare con la regex problematica possono subire forti rallentamenti o andare in timeout. È proprio il principio sfruttato negli attacchi ReDoS contro le applicazioni Node.js.

Come correggere una regex vulnerabile

Nell’esempio precedente, i due quantificatori non servono. Se vogliamo riconoscere una sequenza composta esclusivamente da lettere a, basta scrivere quanto segue:

^a+$

L’espressione elimina le suddivisioni alternative che provocavano il problema. Python, dalla versione 3.11, supporta inoltre i quantificatori possessivi e i gruppi atomici. Nel nostro caso, una variante è:

regex = re.compile(r"^(a++)+$")

Il quantificatore ++ impedisce al motore di restituire caratteri già acquisiti per tentare combinazioni alternative: è una tecnica utile, ma bisogna verificare che non modifichi il significato della regex originale. Per maggiori dettagli si può consultare la documentazione ufficiale del modulo re di Python.

Un’altra possibilità consiste nell’adottare motori come come Google RE2, progettati per evitare l’esplosione dei tempi di elaborazione tipica del catastrophic backtracking. RE2 garantisce infatti una complessità lineare rispetto alla lunghezza del testo analizzato: in termini semplici, se la stringa da controllare raddoppia, anche il lavoro necessario cresce in modo proporzionale, anziché moltiplicarsi in maniera esponenziale. Una regex vulnerabile, al contrario, può richiedere tempi enormemente superiori anche aggiungendo pochi caratteri. RE2 presenta tuttavia alcune limitazioni rispetto ai motori tradizionali, perché non supporta determinate funzionalità.

Come riconoscere le espressioni regolari rischiose

I quantificatori annidati costituiscono un segnale d’allarme, ma non rappresentano l’unica struttura problematica. Anche espressioni come (a|aa)+ possono generare numerosi percorsi alternativi, soprattutto quando l’input contiene una lunga sequenza compatibile seguita da caratteri che impediscono la corrispondenza.

Per individuare i rischi, conviene esaminare le regex applicate a input non attendibili, verificare le ripetizioni sovrapposte e misurare i tempi con stringhe che non soddisfano il modello.

Limitare la lunghezza dei dati in ingresso riduce l’esposizione, ma non corregge l’algoritmo. Analogamente, un timeout HTTP non garantisce l’interruzione immediata di una regex bloccata in un’elaborazione sincrona.

Per i controlli più delicati è opportuno valutare motori con garanzie sui tempi di esecuzione oppure isolare le elaborazioni in processi con limiti di risorse.

Le vulnerabilità Ruby di novembre 2026: un problema differente

Il 18 novembre 2026, il team Ruby ha pubblicato 7 advisory di sicurezza relativi al motore delle espressioni regolari e alla conversione delle stringhe.

Le vulnerabilità comprendono buffer overflow, double free e accessi alla memoria fuori dai limiti consentiti; alcune vulnerabilità possono consentire persino l’esecuzione di codice arbitrario, in condizioni specifiche.

È fondamentale separare le due questioni: il catastrophic backtracking sfrutta una inefficienza algoritmica per consumare risorse, mentre le vulnerabilità Ruby riguardano errori nella gestione della memoria e nell’implementazione di determinate operazioni. Aggiornare Ruby corregge le falle segnalate, ma non rende automaticamente sicure tutte le regex scritte dagli sviluppatori.

Un’espressione regolare non va valutata soltanto per la correttezza dei risultati, ma anche per il tempo che impiega a produrli: un controllo mai svolto o non effettuato con l’attenzione del caso potrebbe trasformarsi nel punto più debole di un intero servizio Web.

Ti consigliamo anche

Link copiato negli appunti