OWASP Top 10 expliqué avec des exemples de code pratiques
Vous livrez une fonctionnalité, les tests passent, la démo est parfaite — puis une revue de sécurité signale trois problèmes dont vous ignoriez l'existence. La plupart des failles ne sont pas des zero-days exotiques. Elles proviennent d'un petit ensemble d'erreurs récurrentes que le OWASP Top 10 a été créé pour répertorier. Le problème est que la liste est souvent présentée sous forme de catégories abstraites, ce qui rend difficile le lien avec le code que vous écrivez réellement.
Cet article parcourt le OWASP Top 10 avec des exemples concrets, de style exécutable. Pour chaque risque, vous verrez à quoi ressemble le code vulnérable, pourquoi il échoue et le correctif que vous pouvez appliquer dans une pull request normale. L'objectif n'est pas de mémoriser la liste mais de reconnaître ces schémas lorsqu'ils apparaissent dans votre propre base de code.
Ce qu'est réellement le OWASP Top 10
Le OWASP Top 10 est un document de sensibilisation mis à jour périodiquement qui classe les risques de sécurité les plus critiques des applications web, sur la base de données communautaires et d'un consensus industriel. Ce n'est pas une checklist ni une certification. C'est un outil de priorisation : si vous corrigez ces catégories, vous éliminez une grande partie de la surface d'attaque réelle.
Chaque entrée décrit une catégorie, pas un bug unique. Une catégorie comme « Injection » couvre l'injection SQL, l'injection de commandes, l'injection LDAP, etc. Considérez chaque élément comme une famille d'erreurs ayant une cause racine commune.
A1 : Contrôle d'accès défaillant
Les défaillances de contrôle d'accès se produisent lorsqu'un utilisateur peut agir au-delà de ses permissions prévues. L'exemple classique est la référence directe non sécurisée à un objet : l'application récupère une ressource par ID sans vérifier la propriété.
// Vulnérable : tout utilisateur connecté peut lire n'importe quelle facture
app.get('/invoices/:id', auth, async (req, res) => {
const invoice = await db.invoice.findById(req.params.id);
res.json(invoice);
});
// Corrigé : limiter la requête à l'utilisateur courant
app.get('/invoices/:id', auth, async (req, res) => {
const invoice = await db.invoice.findOne({
id: req.params.id,
userId: req.user.id
});
if (!invoice) return res.status(404).end();
res.json(invoice);
});Le correctif consiste à appliquer l'autorisation au niveau de la couche de données, pas seulement au niveau de la route. Refusez par défaut, vérifiez la propriété sur chaque objet et journalisez les échecs de contrôle d'accès pour détecter les tentatives de sondage.
A2 : Défaillances cryptographiques
Cette catégorie couvre les données exposées parce que le chiffrement est absent, faible ou mal appliqué. Exemples courants : stocker des mots de passe avec MD5, envoyer des données sensibles en HTTP ou coder en dur des clés dans le code source.
- Hachez les mots de passe avec un algorithme lent et salé comme bcrypt, scrypt ou Argon2.
- Utilisez TLS partout, y compris pour le trafic interne entre services.
- Ne validez jamais de secrets ; chargez-les depuis un gestionnaire de secrets ou l'environnement.
- Chiffrez les champs sensibles au repos et faites tourner les clés régulièrement.
Un test rapide : recherchez dans votre base de code md5(, sha1( et password à proximité d'une concaténation de chaînes. Toute occurrence mérite une revue.
A3 : Injection
L'injection se produit lorsque des données non fiables sont interprétées comme du code ou des commandes. L'injection SQL est l'exemple le plus célèbre, mais le même schéma apparaît dans les commandes shell, les moteurs de template et les ORM.
# Vulnérable : interpolation de chaîne dans SQL
query = f"SELECT * FROM users WHERE email = '{email}'"
cursor.execute(query)
# Corrigé : requête paramétrée
cursor.execute("SELECT * FROM users WHERE email = %s", (email,))La règle est simple : ne construisez jamais de requêtes ou de commandes en concaténant des entrées utilisateur. Utilisez des requêtes paramétrées, des listes blanches pour les arguments de commandes et des moteurs de template sûrs. Si vous devez passer par le shell, passez les arguments sous forme de tableau, jamais sous forme de chaîne.
A4 : Conception non sécurisée
Certaines failles ne peuvent pas être corrigées par un meilleur code car la conception elle-même est dangereuse. Exemples : un flux de réinitialisation de mot de passe sans limite de débit, un paiement qui fait confiance à un prix fourni par le client ou une application multi-tenant sans modèle d'isolation des locataires.
Les mesures d'atténuation sont orientées processus : modélisation des menaces dès la conception, tests de cas d'abus et exigences de sécurité explicites dans les user stories. Demandez « comment un attaquant pourrait-il détourner cette fonctionnalité ? » avant d'écrire du code, pas après.
A5 : Mauvaise configuration de sécurité
La mauvaise configuration est la catégorie la plus facile à corriger et l'une des plus courantes. Les identifiants par défaut, les traces de pile détaillées en production, le listing de répertoires activé, le CORS permissif et les services inutiles en font partie.
| Mauvaise configuration | Correctif pratique |
|---|---|
| Mode debug en production | Définir DEBUG=false et vérifier en CI |
| Traces de pile renvoyées aux clients | Journaliser en interne, renvoyer des erreurs génériques |
| CORS générique avec credentials | Autoriser des origines spécifiques |
| Identifiants admin par défaut | Forcer la rotation à la première connexion |
| Listing de répertoires activé | Désactiver dans la configuration du serveur web |
Traitez la configuration comme du code. Versionnez-la, révisez-la et ajoutez des contrôles automatisés qui font échouer le build lorsqu'une valeur par défaut dangereuse réapparaît.
A6 : Composants vulnérables et obsolètes
Vos dépendances font partie de votre surface d'attaque. Une bibliothèque avec une CVE connue peut compromettre toute l'application, même si votre propre code est propre.
- Générez une nomenclature logicielle (SBOM) pour chaque build.
- Exécutez une analyse des dépendances en CI et échouez sur les vulnérabilités de haute gravité.
- Épinglez les versions et révisez les mises à niveau délibérément.
- Supprimez les bibliothèques inutilisées ; chaque dépendance est une responsabilité.
Les outils automatisés aident, mais la véritable discipline réside dans une cadence de mise à niveau régulière. Une dépendance que vous n'avez pas touchée depuis deux ans est une dépendance que vous ne comprenez pas.
A7 : Défaillances d'identification et d'authentification
Une authentification faible permet aux attaquants de prendre le contrôle de comptes. Exemples : autoriser des mots de passe faibles, absence de limitation de débit à la connexion, identifiants de session dans les URL et sessions qui n'expirent jamais.
- Appliquez une politique de mot de passe minimale et vérifiez contre les listes de fuites connues.
- Limitez le débit des tentatives de connexion et ajoutez un backoff exponentiel.
- Utilisez des cookies de session sécurisés, HttpOnly et SameSite.
- Proposez l'authentification multifacteur, en particulier pour les rôles d'administration.
- Invalidez les sessions à la déconnexion et lors d'un changement de mot de passe.
L'authentification est la porte d'entrée. De petites négligences ici ont un impact démesuré.
A8 : Défaillances d'intégrité des logiciels et des données
Cette catégorie couvre le code et les données auxquels on fait confiance sans vérification. Exemples : désérialiser des entrées non fiables, récupérer des mises à jour sur des canaux non chiffrés ou installer des paquets sans vérification d'intégrité.
Défenses pratiques : vérifiez les signatures des artefacts, utilisez des fichiers de verrouillage avec sommes de contrôle, évitez la désérialisation native des entrées utilisateur et traitez les pipelines CI/CD comme une infrastructure critique pour la sécurité. Si un attaquant peut pousser vers votre build, il contrôle votre produit.
A9 : Défaillances de journalisation et de surveillance de la sécurité
De nombreuses failles passent inaperçues pendant des mois car la journalisation est incomplète ou personne ne la consulte. Si vous ne pouvez pas voir une attaque, vous ne pouvez pas y répondre.
Journalisez les événements d'authentification, les échecs d'autorisation et les erreurs de validation des entrées. Incluez suffisamment de contexte pour enquêter sans journaliser de secrets ou de données personnelles complètes. Acheminez les journaux vers un système central et alertez sur des schémas comme des 403 répétés depuis une même IP ou un pic d'échecs de connexion.
A10 : Falsification de requête côté serveur (SSRF)
La SSRF se produit lorsque le serveur récupère une URL fournie par l'utilisateur. Sans validation, un attaquant peut atteindre des services internes, des points de terminaison de métadonnées cloud ou des panneaux d'administration localhost.
# Vulnérable : récupérer n'importe quelle URL fournie par l'utilisateur
url = request.args['url']
response = requests.get(url)
# Corrigé : liste blanche de noms d'hôtes et blocage des plages internes
allowed = {'api.example.com', 'cdn.example.com'}
parsed = urlparse(url)
if parsed.hostname not in allowed:
abort(400)
response = requests.get(url, timeout=5)Autorisez uniquement des destinations spécifiques, bloquez les plages d'IP privées, désactivez les redirections vers des hôtes internes et exécutez les requêtes sortantes depuis un segment réseau restreint.
Une routine de revue pratique
Vous n'avez pas besoin de mémoriser la liste. Intégrez plutôt ces contrôles dans votre flux de travail :
- Lors de la conception, demandez comment chaque fonctionnalité pourrait être détournée.
- Lors de la revue de code, recherchez les requêtes construites par concaténation, les vérifications de propriété manquantes et les URL non validées.
- En CI, exécutez l'analyse des dépendances, la détection de secrets et les contrôles de configuration.
- En production, centralisez les journaux et alertez sur les anomalies d'authentification et d'autorisation.
Lorsque vous déboguez des réponses API ou inspectez des payloads renvoyés par ces contrôles, un formateur JSON accélère considérablement la lecture des objets d'erreur imbriqués et la recherche de champs divulgués.
FAQ
Le OWASP Top 10 est-il une checklist de sécurité complète ?
Non. C'est un document de sensibilisation et de priorisation couvrant les catégories de risques les plus critiques. Un programme complet nécessite également une modélisation des menaces, des pratiques de SDLC sécurisé, une gestion des dépendances et des tests d'intrusion.
Quel élément du OWASP Top 10 dois-je corriger en premier ?
Commencez par le contrôle d'accès défaillant et l'injection. Ce sont les causes les plus fréquentes de failles graves et ils sont généralement corrigeables par des modifications ciblées du code. Ensuite, traitez la mauvaise configuration et l'hygiène des dépendances, qui sont peu coûteuses à améliorer.
À quelle fréquence le OWASP Top 10 est-il mis à jour ?
Il est révisé périodiquement à mesure que le paysage des menaces et les données communautaires évoluent. Consultez toujours le site officiel de l'OWASP pour l'édition actuelle plutôt que de vous fier à une version mise en cache.
Choisissez une catégorie de cet article et auditez un seul point de terminaison par rapport à elle aujourd'hui. Cette petite revue concrète vaut plus que lire la liste une douzaine de fois.