Règle
Se prémunir contre lenteur régulières lentes.
Les régulières avec des imbriquées quantificateurs imbriqués ou 
ambiguës ambiguës peuvent causer catastrophique 
retour en arrière et des performance de performance.
Langues prises en charge : 45+

Introduction

Les expressions régulières peuvent bloquer votre application pendant des secondes ou des minutes avec la bonne entrée. Le backtracking catastrophique se produit lorsque les moteurs d'expressions régulières explorent des chemins augmentant de manière exponentielle en essayant de faire correspondre un motif. Une regex comme (a+)+b prend des microsecondes pour correspondre à une entrée valide, mais peut prendre des heures pour rejeter une chaîne de 'a' sans 'b' final. Les attaquants exploitent cela via des attaques par déni de service par expression régulière (ReDoS), en envoyant une entrée spécialement conçue qui fait consommer 100 % du CPU à votre moteur d'expressions régulières jusqu'à ce que des délais d'attente de requête se produisent ou que le processus plante.

Pourquoi c'est important

Implications de sécurité (attaques ReDoS) : Un attaquant peut paralyser votre application avec une seule requête contenant une entrée spécialement conçue. Les motifs de validation d'e-mail et d'analyse d'URL sont des cibles courantes. Contrairement aux attaques DoS traditionnelles qui nécessitent de la bande passante, les attaques ReDoS n'ont besoin que de très petites charges utiles.

Dégradation des performances: Une entrée utilisateur normale peut déclencher un backtracking catastrophique, faisant passer les temps de réponse de millisecondes à des secondes. Cela crée une latence imprévisible difficile à déboguer car elle ne se manifeste qu'avec des schémas d'entrée spécifiques.

Incidents de production : Une regex vulnérable bloque la boucle d'événements dans Node.js ou consomme les ressources du pool de threads. À mesure que les requêtes s'accumulent, la mémoire augmente et le système devient insensible. Dans les microservices, une regex vulnérable propage les défaillances aux services dépendants.

Difficulté de détection : Les modèles qui fonctionnent bien en test avec des entrées courtes deviennent exponentiellement lents avec des entrées plus longues. La vulnérabilité passe souvent inaperçue jusqu'à la production, nécessitant un déploiement d'urgence lors d'un incident actif.

Exemples de code

❌ 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);
}

Pourquoi c'est dangereux : Les quantificateurs imbriqués ([a-zA-Z0-9_\\-\\.]+)+ créer un backtracking exponentiel. Pour un e-mail comme aaaaaaaaaaaaaaaaaaaaaaaaa!, le moteur d'expressions régulières tente d'innombrables combinaisons avant d'échouer. L'expression régulière d'URL comporte plusieurs quantificateurs imbriqués qui aggravent le problème, la rendant trivialement exploitable avec des entrées telles que de longues chaînes de caractères valides sans la structure attendue.

✅ 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);
}

Pourquoi c'est sûr : La suppression des quantificateurs imbriqués élimine le backtracking catastrophique. Les quantificateurs simples comme [a-zA-Z0-9_\-\.]+ s'exécutent en temps linéaire. Le motif d'URL utilise des groupes non-capturants avec un suffixe optionnel (?:...)? au lieu d'une répétition imbriquée, garantissant des performances prévisibles quelle que soit la longueur ou le contenu de l'entrée.

Conclusion

La performance des expressions régulières est une préoccupation de sécurité, pas seulement une optimisation. Examinez tous les motifs regex pour détecter les quantificateurs imbriqués, les classes de caractères qui se chevauchent dans les groupes de répétition et les alternatives ambiguës. Testez les motifs regex avec des entrées pathologiques (longues chaînes de caractères valides suivies de terminaisons invalides) pour identifier le backtracking catastrophique avant le déploiement. Lorsque cela est possible, remplacez les regex complexes par des fonctions d'analyse de chaînes de caractères ayant des caractéristiques de performance prévisibles.