Les attaques contre les applications web
Partie 3 sur 3
5Les grandes familles de failles
Les attaques décrites jusqu’ici ont des noms divers, mais on peut les ranger en un petit nombre de familles. C’est exactement ce que fait l’OWASP (Open Worldwide Application Security Project, projet ouvert mondial de sécurité des applications web), une fondation ouverte, qui publie depuis 2003 un classement des dix risques les plus répandus, l’OWASP Top 10. Ce classement, mis à jour tous les trois ou quatre ans, est le point de départ de presque toutes les formations et de nombreux cadres réglementaires. La figure 2 présente cinq familles essentielles.
5.1Le contrôle d’accès défaillant
C’est la faille que nous avons rencontrée en changeant un paramètre : l’application ne vérifie pas que l’utilisateur a le droit de faire ce qu’il demande. Elle est, depuis l’édition de 2021 du classement, la première du palmarès, et elle l’est restée dans l’édition de 2025, ce qui dit son importance. La parade tient en une phrase : vérifier les droits à chaque requête, côté serveur, pour chaque ressource, sans jamais supposer qu’un utilisateur ne demandera que ce qu’on lui a proposé. Le principe du moindre privilège (ne donner à chaque compte que les droits strictement nécessaires) en est le complément.
5.2L’injection, dont l’injection SQL
La famille des injections naît d’une erreur d’architecture : un programme qui construit une commande en collant du texte fourni par l’utilisateur. Le cas le plus connu est l’injection de commandes SQL (voir l’injection SQL). SQL est le langage qui sert à interroger les bases de données (voir SQL). Une application qui, pour rechercher un client, assemble « sélectionne le client dont le nom est » suivi de ce que l’utilisateur a saisi, donne à l’utilisateur le pouvoir d’écrire une partie de la commande : si la saisie contient des éléments de syntaxe SQL, la base de données les exécutera comme des ordres, et non comme du texte. Cela peut permettre de lire, de modifier ou de supprimer des données auxquelles on n’avait pas droit. C’est l’une des deux grandes attaques sur les applications ; elle a causé quelques-unes des plus grandes fuites de données de l’histoire du Web.
La parade est connue et efficace, quand on l’applique partout : les requêtes paramétrées (ou « préparées »). On sépare strictement la commande (qui est écrite par le développeur) de la donnée (qui vient de l’utilisateur) : la base de données reçoit la commande d’un côté, les valeurs de l’autre, et traite toujours les valeurs comme du texte, jamais comme des ordres. Si l’on devait retenir une seule consigne de ce chapitre, ce serait celle-là : ne jamais construire une commande par assemblage de texte venant de l’extérieur. Le même principe vaut pour toutes les autres formes d’injection : commandes du système d’exploitation, requêtes vers un annuaire, bases non relationnelles, génération de pages à partir de modèles.
5.3Le script intersite (XSS)
Le script intersite (en anglais Cross-Site Scripting, abrégé XSS) est l’autre grande attaque, que l’on présente aussi sous le nom d’« injection de code HTML ». Elle exploite les sites qui affichent, sans précaution, un texte fourni par un utilisateur : un commentaire, un nom, un message. Si ce texte contient du code exécutable par le navigateur, et que le site le renvoie tel quel dans sa page, alors ce code s’exécute dans le navigateur de chaque visiteur qui consulte la page, avec les droits du site. L’attaquant ne s’en prend pas au serveur, mais aux autres utilisateurs : il peut ainsi voler leur jeton de session, afficher de faux formulaires, ou agir en leur nom (voir le script intersite).
La parade est l’échappement des sorties : au moment d’insérer une donnée dans une page, on transforme les caractères qui pourraient être pris pour du code en simples caractères d’affichage. Les cadres de développement modernes (voir les cadres de développement web) le font désormais par défaut, ce qui a beaucoup réduit le problème. On y ajoute une politique de sécurité de contenu, un en-tête que le site envoie pour dire au navigateur quels scripts il a le droit d’exécuter, et qui limite les dégâts si une faille subsiste.
5.4Les sessions et leurs identifiants
Une autre faiblesse concerne les identifiants de session : le numéro, remis à l’utilisateur après sa connexion, qui permet au site de le reconnaître d’une requête à l’autre. Si ces identifiants sont faciles à deviner (numéros qui se suivent), s’ils voyagent en clair, ou s’ils ne sont pas renouvelés, un attaquant peut en prendre un qui n’est pas le sien et se retrouver connecté à la place d’un autre. La parade : des identifiants longs et aléatoires, renouvelés à chaque connexion, transmis par un canal chiffré, avec des cookies marqués sécurisés et inaccessibles aux scripts, et une durée de vie limitée (voir l’écoute et l’homme du milieu pour le vol de session).
5.5La configuration et les composants
Beaucoup de compromissions ne tiennent à aucune faille subtile, mais à une négligence : une interface d’administration laissée ouverte, un mot de passe d’usine jamais changé, un répertoire de sauvegardes accessible, un composant logiciel périmé qui contient une faille publiée depuis des années. L’édition de 2025 du classement de l’OWASP a d’ailleurs placé en bonne position la mauvaise configuration de sécurité (deuxième) et les défaillances de la chaîne d’approvisionnement logicielle (troisième : le risque que représentent les bibliothèques et outils que l’on importe, voir la chaîne d’approvisionnement). Une application moderne repose sur des centaines de composants écrits par d’autres ; sa sécurité dépend de leur tenue à jour.
5.6Le classement de l’OWASP en 2025
Le classement le plus récent, publié en 2025, énumère dix catégories de risques : contrôle d’accès défaillant (1), mauvaise configuration de sécurité (2), défaillances de la chaîne d’approvisionnement logicielle (3), défaillances cryptographiques (4), injection (5), conception non sécurisée (6), défaillances d’authentification (7), défaillances d’intégrité des logiciels ou des données (8), défaillances de journalisation et d’alerte de sécurité (9), et mauvaise gestion des conditions exceptionnelles (10, c’est-à-dire les erreurs et situations inattendues mal traitées). On remarquera que l’injection, vedette des années 2000, a reculé au cinquième rang, et que les catégories qui montent concernent la conception, la configuration et la chaîne d’approvisionnement plutôt que des erreurs de syntaxe : les cadres de développement modernes ont éliminé une grande part des injections « faciles », et la sécurité s’est déplacée vers ce que l’on construit et ce que l’on importe.
6Se défendre : la défense en profondeur
Aucune mesure ne suffit seule. La défense d’une application web repose sur le principe de la défense en profondeur : plusieurs barrières successives, de sorte que l’échec de l’une soit rattrapé par la suivante (figure 3). En voici les éléments, dans l’ordre de la vie d’une application.
- Conception. Réfléchir aux menaces avant d’écrire du code (« que se passe-t-il si un utilisateur malveillant fait ceci ? »), prévoir qui a droit à quoi, et choisir des outils qui font la sécurité par défaut. C’est le sujet de le développement sécurisé.
- Entrées. Valider toute donnée reçue : valeur, type, format, longueur, avec une liste blanche. Refuser, plutôt que « nettoyer », ce qui ne correspond pas.
- Traitement. Utiliser des requêtes paramétrées, ne jamais construire de commande ni de chemin de fichier par assemblage de texte extérieur, et vérifier les droits à chaque opération.
- Sorties. Échapper ce que l’on affiche, selon le contexte (page, attribut, script), et envoyer les en-têtes de sécurité (politique de contenu, cookies sécurisés).
- Exploitation. Appliquer les correctifs, supprimer le superflu, surveiller les journaux, et placer devant le site un pare-feu applicatif (en anglais Web Application Firewall, abrégé WAF), c’est-à-dire un filtre qui examine le contenu des requêtes web, là où un pare-feu réseau ne regarde que l’adresse et le port. Il bloque les formes d’attaque connues, et donne du temps pour corriger une faille que l’on vient de découvrir. Mais il ne remplace pas la correction du code : un filtre se contourne, une faille corrigée ne se contourne plus.
6.1Tester ses applications
Une application se teste comme un pont : par des essais, avant que la charge réelle n’arrive. Les équipes de développement emploient des analyses automatiques du code, des tests d’intrusion (une personne mandatée cherche les failles, avec une autorisation écrite), et des primes aux failles (des programmes où l’on rémunère les chercheurs qui signalent un problème). L’OWASP publie un guide de vérification précis qui fournit une liste de contrôle. Un test d’intrusion n’a de valeur que s’il est autorisé ; l’attaquer sans accord est un délit, même avec de bonnes intentions (voir l’encadré « Le coin cyber »).
6.2Et l’utilisateur ?
L’utilisateur d’un site a moins de leviers, mais en a. Il peut utiliser un mot de passe unique par site et la double authentification (voir l’authentification), garder son navigateur à jour, se méfier des liens reçus (une faille XSS se déclenche souvent par un lien piégé), ne pas saisir d’informations sensibles sur un site qui n’est pas en https, et signaler à l’organisation tout comportement étrange (une page qui affiche les données d’un autre, par exemple). Sa meilleure défense reste la prudence face à l’hameçonnage (voir l’hameçonnage).
Pour s’exercer
Exercice 7 : le pare-feu applicatif suffit-il ?
Une entreprise installe un pare-feu applicatif devant son site et décide de ne plus corriger le code vulnérable, jugé « protégé ». Quel est le défaut de ce raisonnement ?
Voir la réponse
Un pare-feu applicatif reconnaît des formes d’attaque connues ; un attaquant peut en contourner un en reformulant sa requête (changement d’encodage, détours), et il ne comprend pas la logique de l’application, donc il ne détecte pas un contrôle d’accès défaillant. Il achète du temps, mais la faille demeure dans le code. La bonne démarche : filtrer pour gagner du temps, et corriger la cause. C’est la défense en profondeur : une couche ne remplace jamais les autres.
7Ce qui a changé depuis
L’essentiel reste valable. Voici ce qui mérite d’être mis à jour.
- « SSL » est devenu TLS. On écrit encore souvent SSL, ancien nom du protocole. Les versions de SSL sont aujourd’hui abandonnées pour raisons de sécurité, et l’on utilise TLS. La leçon, elle, reste intacte : le chiffrement ne protège pas contre la falsification par l’utilisateur.
- Le Top 10 a bougé. Autrefois, injection et script intersite dominaient. Aujourd’hui, le contrôle d’accès défaillant est en tête, et la configuration et la chaîne d’approvisionnement logicielle ont rejoint le podium. Les cadres de développement modernes ont réduit les injections « faciles ».
- SOAP et XML-RPC ont cédé la place à des interfaces plus légères (REST, GraphQL, gRPC), qui ont leurs propres risques (voir les microservices et les interfaces modernes).
- Les applications sont devenues des assemblages. Elles reposent sur des dizaines de bibliothèques, de services extérieurs et de composants hébergés dans le nuage : la sécurité est devenue une question de chaîne d’approvisionnement.
- Les attaques sont industrialisées. Des robots parcourent Internet en continu pour trouver les sites vulnérables, dès la publication d’une faille. Le temps entre la publication d’un correctif et son exploitation s’est réduit à quelques heures ou jours.
- Les protections se sont généralisées : pare-feu applicatifs, en-têtes de sécurité, politiques de contenu, navigateurs qui marquent comme « non sécurisés » les sites sans chiffrement.
Un fil conducteur relie les deux époques. Dans toutes ces attaques, le programme fait confiance à ce qu’il reçoit, et quelqu’un en profite. La défense consiste à ne jamais accorder cette confiance à une donnée venant de l’extérieur, à toutes les étapes du traitement.