Sécuriser votre application: prévenir les attaques redos avec un rege exercé efficace

Les attaques Redos exploitent des modèles regex inefficaces pour provoquer le déni de service via une utilisation excessive du processeur. 1. Évitez les quantificateurs imbriqués comme (a) en simplifiant à a. 2. Utilisez des groupes atomiques (?> ...) pour éviter de revenir en arrière. 3. Limiter la longueur d'entrée avant l'évaluation regex. 4. Évitez les regex complexes dans les chemins critiques; Précompiler et définir des délais d'attente. 5. Utilisez des outils comme Regex-Static-Analysis ou Eslint-Plugin-Security pour détecter tôt les vulnérabilités. Préférez toujours les modèles simples, validez les e-mails avec des bibliothèques dédiées et traitez les experts en exploits comme des vecteurs d'attaque potentiels pour créer des applications sécurisées et résilientes.

Les expressions régulières sont des outils puissants pour la correspondance des modèles et la validation des entrées dans les applications, mais ils peuvent devenir une responsabilité de sécurité s'ils ne sont pas utilisés avec soin. Une vulnérabilité souvent négligée est le déni de service de l'expression régulière (redos) - un type d'attaque de déni de service qui exploite les modèles regex inefficaces pour consommer des ressources CPU excessives, provoquant un ralentissement ou de ne pas répondre à une application.

Qu'est-ce qu'une attaque Redos?

Les redos se produisent lorsqu'un moteur regex passe une quantité excessive de temps à évaluer une entrée crafée de manière malveillante contre une expression régulière mal conçue. Cela se produit en raison du retour en arrière exponentiel dans les modèles qui contiennent des quantificateurs imbriqués ou des alternatives ambiguës (par exemple .*.* , (a ) , ou (\d )* ).

Par exemple, considérez ce regex:

 ^ (a) $

Cela semble inoffensif, mais lorsqu'il est testé contre une chaîne comme "aaaaX" , le moteur essaie d'innombrables combinaisons de la façon dont les groupes a peuvent correspondre à l'entrée avant de conclure qu'il ne correspond pas. Avec des intrants plus longs, cela peut prendre des secondes, voire des minutes, un problème grave dans les applications à fort trafic.

Comment Redos a un impact sur votre application

Lorsqu'un attaquant envoie des entrées conçues pour déclencher des performances regex du pire cas:

• Les points de terminaison de l'API utilisant de tels regex peuvent accrocher.
• Les temps de réponse du serveur augmentent considérablement.
• Les pointes d'utilisation du processeur, affectant potentiellement d'autres services.
• Dans les cas extrêmes, l'ensemble du service devient indisponible.

Cela fait de Redos une réelle menace, en particulier dans l'authentification, le routage ou la logique de désinfection d'entrée où l'expulsion est courante.

Stratégies pour prévenir les redos

1. Évitez les quantificateurs ambigus ou imbriqués

Des modèles comme (.*.*) , (ab )* , ou (.\*)* Sont des drapeaux rouges. Ils créent un potentiel de retour en arrière massif. Au lieu de cela, simplifiez-les ou réécrivez-les.

✅ Alternative plus sûre : si vous devez faire correspondre un ou plusieurs a suivi de quelque chose, utilisez des groupes atomiques ou des quantificateurs possessifs (le cas échéant) ou restructurer la logique.

Par exemple, remplacer:

 ^ (a) $

avec:

 ^ A $

2. Utilisez des groupes non capturiques et atomiques lorsque cela est possible

Le regroupement sans capture réduit les frais généraux. Les groupes atomiques (par exemple, (?>...) ) Empêchent le retour de retour dans le groupe une fois apparié, limitant les pires scénarios.

Exemple:

 ^ (?> (a)) $

Cela échoue plus rapidement sur les entrées non correspondantes car le moteur ne réessayera pas les combinaisons internes.

3. Appliquer les limites de longueur d'entrée

Même les regexants sûrs peuvent être dangereux sur des intrants extrêmement longs. Imposez toujours des restrictions de longueur d'entrée raisonnables avant l'évaluation regex.

Par exemple:

 if (input.length> 1000) {
  lancer une nouvelle erreur ("entrée trop longue");
}
// alors appliquez le regex

Cela empêche les attaquants d'envoyer des charges utiles de kilobyte conçues pour exploiter les cas Edge.

4. Utilisez Regex en toute sécurité dans les chemins critiques

Évitez les regex complexes dans les chemins de code à haute fréquence comme l'authentification ou le routage. Si vous devez les utiliser:

• Modèles regex pré-compiles.
• Test des performances avec les entrées les pires cas.
• Définissez les délais d'expiration si votre environnement le prend en charge (par exemple, certaines bibliothèques regex autorisent les limites d'exécution).

5. Tire des outils pour détecter les modèles vulnérables

Utilisez des outils d'analyse statique pour attraper des regex anciens au cours du développement:

• Regex-statique-analyse - détecte les vulnérabilités redos.
• Les plugins Eslint comme le drapeau eslint-plugin-security Utilisation de l'expulsion risquée.
• Les scanners en ligne comme Regex101 (avec prudence) peuvent aider à visualiser le retour en arrière.

Exemple du monde réel: la validation des e-mails a mal tourné

Une erreur courante consiste à utiliser des examens trop complexes pour la validation des e-mails:

 ^ [a-za-z0-9 ._% -] @ [a-za-z0-9.-] \. [a-za-z] {2,} $

Bien que cela semble bien, l'ajout de quantificateurs imbriqués (par exemple, (. ) @ ) Ou permettre une flexibilité excessive peut ouvrir la porte aux redos.

✅ Meilleure approche:

• Utilisez une correspondance de motifs simples pour les vérifications de format de base.
• Comptez sur des bibliothèques de validation par e-mail dédiées.
• Ou valider via des e-mails de confirmation au lieu d'un regex complexe.

Réflexions finales

Les regex sont pratiques mais dangereux lorsqu'ils sont mal utilisés. Les attaques Redos exploitent des inefficacités subtiles qui sont difficiles à repérer lors de l'examen du code. La clé est de:

• Écrivez des modèles simples et précis.
• Évitez l'ambiguïté et le retour en arrière.
• Limiter la taille de l'entrée.
• Utilisez des outils pour détecter les vulnérabilités tôt.

En traitant les regex d'exploitation comme des vecteurs d'attaque potentiels - pas seulement des fonctions d'utilité - vous pouvez créer des applications plus résilientes et sécurisées.

Fondamentalement, si votre regex a l'air trop intelligent, cela pourrait être trop risqué. Gardez les choses simples, testez-le dur et ne faites jamais confiance à la saisie des utilisateurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!