OWASP Top 10 expliqué avec des exemples pratiques
Vous avez probablement entendu parler de l'OWASP Top 10—la liste des risques de sécurité les plus critiques pour les applications web. Mais connaître les noms ne suffit pas. Pour vraiment protéger vos applications, vous devez voir comment ces vulnérabilités se manifestent dans du code réel et comprendre les étapes concrètes pour les corriger.
Dans cet article, nous allons parcourir chaque catégorie de l'OWASP Top 10 avec des exemples pratiques. Vous verrez des extraits de code vulnérables, comprendrez pourquoi ils sont dangereux et obtiendrez des stratégies de mitigation actionnables. Que vous soyez développeur, testeur ou ingénieur en sécurité, ce guide vous aidera à écrire du code plus sûr et à repérer les faiblesses avant que les attaquants ne le fassent.
1. Contrôle d'accès défaillant
Le contrôle d'accès défaillant se produit lorsque les utilisateurs peuvent agir en dehors de leurs permissions prévues—accéder aux données d'autres utilisateurs, effectuer des actions d'administration ou consulter des fichiers sensibles. C'est le risque n°1 car il est courant et impactant.
Exemple : Référence directe non sécurisée à un objet (IDOR)
// Vulnérable : L'utilisateur peut changer l'ID et voir n'importe quelle facture
app.get('/invoice/:id', (req, res) => {
const invoice = db.getInvoice(req.params.id);
res.json(invoice);
});
Un attaquant change simplement le paramètre id pour accéder aux factures d'autres utilisateurs.
Mitigation
- Appliquez des contrôles d'accès côté serveur pour chaque requête.
- Utilisez un contrôle d'accès basé sur les rôles ou les attributs (RBAC/ABAC).
- Refusez par défaut ; accordez explicitement les permissions.
2. Défaillances cryptographiques
Anciennement appelée « Exposition de données sensibles », cette catégorie couvre les défaillances liées à la protection des données en transit et au repos. Les problèmes courants incluent l'utilisation d'algorithmes faibles, le codage en dur de secrets ou la transmission de données via HTTP.
Exemple : Stockage de mots de passe en clair
# Vulnérable : Stockage de mot de passe en clair
user.password = request.form['password']
db.save(user)
Si la base de données est compromise, tous les mots de passe sont exposés.
Mitigation
- Utilisez des algorithmes de hachage forts et adaptatifs comme bcrypt, scrypt ou Argon2.
- Chiffrez les données sensibles au repos et en transit (TLS).
- Ne codez jamais de secrets en dur ; utilisez des variables d'environnement ou des gestionnaires de secrets.
3. Injection
Les failles d'injection se produisent lorsque des données non fiables sont envoyées à un interpréteur dans le cadre d'une commande ou d'une requête. L'injection SQL, l'injection NoSQL, l'injection de commandes OS et l'injection ORM sont trop courantes.
Exemple : Injection SQL
// Vulnérable : Concaténation de chaînes
const query = "SELECT * FROM users WHERE username = '" + username + "'";
db.query(query);
Un attaquant peut saisir ' OR '1'='1 pour contourner l'authentification.
Mitigation
- Utilisez des requêtes paramétrées ou des déclarations préparées.
- Utilisez un ORM correctement (évitez les requêtes brutes avec concaténation).
- Validez et assainissez toutes les entrées côté serveur.
4. Conception non sécurisée
La conception non sécurisée fait référence à des contrôles de sécurité manquants ou inefficaces lors de la phase de conception. Il ne s'agit pas de bugs d'implémentation mais de défauts architecturaux.
Exemple : Absence de limitation de débit sur la connexion
Sans limitation de débit, les attaquants peuvent forcer les mots de passe ou effectuer du credential stuffing.
Mitigation
- Modélisation des menaces lors de la conception.
- Implémentez la limitation de débit, le verrouillage de compte et le CAPTCHA.
- Utilisez des modèles de conception sécurisés et des architectures de référence.
5. Mauvaise configuration de sécurité
C'est le problème le plus courant—comptes par défaut, fonctionnalités inutiles activées, messages d'erreur détaillés, en-têtes de sécurité manquants, etc.
Exemple : Exposition des traces de pile
app.use((err, req, res, next) => {
res.status(500).send(err.stack); // Divulgue des informations sensibles
});
Mitigation
- Durcissez vos serveurs : désactivez les comptes par défaut, supprimez les services inutilisés.
- Utilisez des en-têtes de sécurité (CSP, HSTS, X-Content-Type-Options).
- Automatisez les vérifications de configuration avec des outils comme OWASP ZAP ou Docker Bench.
6. Composants vulnérables et obsolètes
L'utilisation de bibliothèques, frameworks ou logiciels avec des vulnérabilités connues est un risque majeur. Les attaquants exploitent les systèmes non corrigés.
Exemple : Utilisation d'une ancienne version de Lodash
Les anciennes versions de Lodash avaient des vulnérabilités de pollution de prototype.
Mitigation
- Mettez régulièrement à jour les dépendances.
- Utilisez des outils comme
npm audit, OWASP Dependency-Check ou Snyk. - Supprimez les dépendances inutilisées.
7. Défaillances d'identification et d'authentification
Des mécanismes d'authentification faibles permettent aux attaquants de compromettre des mots de passe, des clés ou des jetons de session.
Exemple : ID de session prévisibles
// Vulnérable : ID de session basé sur l'horodatage
const sessionId = Date.now().toString();
Les attaquants peuvent deviner ou forcer les ID de session.
Mitigation
- Utilisez des ID de session forts et aléatoires.
- Implémentez l'authentification multifacteur (MFA).
- Appliquez des politiques de mots de passe et limitez les tentatives de connexion.
8. Défaillances d'intégrité des logiciels et des données
Cette catégorie se concentre sur le code et l'infrastructure qui ne protègent pas contre les violations d'intégrité—comme l'utilisation de CDN non fiables, la désérialisation non sécurisée ou les pipelines CI/CD sans vérifications d'intégrité.
Exemple : Désérialisation non sécurisée
// Vulnérable : Désérialisation de données non fiables
$data = unserialize($_COOKIE['data']);
Les attaquants peuvent injecter des objets malveillants menant à l'exécution de code à distance.
Mitigation
- Évitez de désérialiser des données non fiables ; utilisez des formats sûrs comme JSON.
- Vérifiez l'intégrité des logiciels et des données (signatures numériques, sommes de contrôle).
- Sécurisez votre pipeline CI/CD avec des contrôles d'accès appropriés.
9. Défaillances de journalisation et de surveillance
Sans journalisation et surveillance adéquates, les violations passent inaperçues. Cela inclut l'absence de journaux, des journaux peu clairs ou leur non-surveillance.
Exemple : Aucune journalisation des connexions échouées
Les attaques par force brute passent inaperçues.
Mitigation
- Journalisez les événements d'authentification, les échecs de contrôle d'accès et les échecs de validation des entrées.
- Assurez-vous que les journaux sont stockés en toute sécurité et surveillés.
- Configurez des alertes pour les activités suspectes.
10. Falsification de requête côté serveur (SSRF)
SSRF se produit lorsqu'un attaquant peut amener le serveur à effectuer des requêtes vers des ressources internes. Cela peut entraîner une fuite de données ou un balayage du réseau interne.
Exemple : Récupération d'une URL à partir de l'entrée utilisateur
// Vulnérable : Récupère n'importe quelle URL
app.get('/fetch', (req, res) => {
fetch(req.query.url).then(data => res.send(data));
});
Un attaquant peut demander des points de terminaison de métadonnées internes (par exemple, http://169.254.169.254/).
Mitigation
- Validez et assainissez les URL ; utilisez des listes blanches.
- Désactivez les schémas d'URL inutiles (par exemple,
file://,gopher://). - Utilisez la segmentation réseau et le moindre privilège.
Tableau comparatif : L'OWASP Top 10 en un coup d'œil
| Risque | Exemple courant | Mitigation rapide |
|---|---|---|
| Contrôle d'accès défaillant | IDOR | Vérifications d'accès côté serveur |
| Défaillances cryptographiques | Mots de passe en clair | Utiliser bcrypt/Argon2 |
| Injection | Injection SQL | Requêtes paramétrées |
| Conception non sécurisée | Pas de limitation de débit | Modélisation des menaces |
| Mauvaise configuration de sécurité | Traces de pile | Durcir les configurations |
| Composants vulnérables | Ancien Lodash | Mises à jour régulières |
| Défaillances d'authentification | ID de session faibles | MFA, ID forts |
| Défaillances d'intégrité | Désérialisation non sécurisée | Utiliser JSON, vérifier les signatures |
| Défaillances de journalisation | Pas de journaux de connexion échouée | Journalisation centralisée |
| SSRF | Récupération d'URL internes | Listes blanches d'URL |
FAQ
Qu'est-ce que l'OWASP Top 10 ?
L'OWASP Top 10 est une liste régulièrement mise à jour des risques de sécurité les plus critiques pour les applications web, publiée par l'Open Web Application Security Project (OWASP). Elle sert de base aux développeurs et aux professionnels de la sécurité pour prioriser leurs efforts de sécurité.
À quelle fréquence l'OWASP Top 10 est-il mis à jour ?
OWASP met à jour la liste tous les quelques années en fonction des données des entreprises de sécurité et des retours de la communauté. La version la plus récente date de 2021, avec une nouvelle version attendue dans les années à venir.
Puis-je utiliser l'OWASP Top 10 comme une liste de contrôle ?
Bien que ce soit un excellent point de départ, l'OWASP Top 10 n'est pas exhaustif. Il vise à sensibiliser et à guider la priorisation. Pour un programme de sécurité complet, combinez-le avec d'autres ressources OWASP comme l'Application Security Verification Standard (ASVS) et les contrôles proactifs.
Vous voulez analyser rapidement vos logs Nginx pour détecter des signes d'attaques comme l'injection SQL ou la force brute ? Essayez notre Analyseur de logs Nginx pour visualiser et détecter les schémas suspects.