OWASP Top 10 expliqué avec des exemples pratiques

Security2026-11-17TryQuickToolBox

Vous avez probablement entendu parler de l'OWASP Top 10, mais savez-vous à quoi ressemble chaque vulnérabilité dans du code réel ? De nombreux développeurs le considèrent comme une liste de contrôle théorique, pourtant ces failles sont à l'origine d'innombrables violations. Cet article parcourt chaque catégorie de l'OWASP Top 10 avec des exemples pratiques et des correctifs concrets, afin que vous puissiez les repérer et les arrêter dans vos projets.

1. Contrôle d'accès défaillant

Le contrôle d'accès définit ce que les utilisateurs authentifiés sont autorisés à faire. Lorsqu'il est défaillant, les utilisateurs peuvent accéder à des données ou effectuer des actions en dehors de leurs permissions.

Exemple : Référence directe non sécurisée à un objet (IDOR)

// Vulnérable : tout utilisateur connecté peut voir n'importe quelle commande en changeant l'ID
app.get('/orders/:id', (req, res) => {
  const order = db.getOrder(req.params.id);
  res.json(order);
});

// Corrigé : vérifier la propriété
app.get('/orders/:id', (req, res) => {
  const order = db.getOrder(req.params.id);
  if (order.userId !== req.user.id) return res.status(403).end();
  res.json(order);
});

Correctif : Appliquez le contrôle d'accès côté serveur, refusez par défaut et journalisez les échecs.

2. Défaillances cryptographiques

Les données sensibles doivent être chiffrées en transit et au repos. Les erreurs courantes incluent l'utilisation d'algorithmes faibles ou le codage en dur des clés.

Exemple : Stockage des mots de passe avec MD5

// Vulnérable
const hash = md5(password);

// Corrigé : utiliser bcrypt ou argon2
const hash = await bcrypt.hash(password, 12);

Correctif : Utilisez un hachage fort et salé pour les mots de passe ; chiffrez les données sensibles avec AES-256 ; utilisez toujours HTTPS.

3. Injection

L'injection se produit lorsque des données non fiables sont envoyées à un interpréteur dans le cadre d'une commande ou d'une requête.

Exemple : Injection SQL

// Vulnérable : concaténation de chaînes
const query = "SELECT * FROM users WHERE name = '" + name + "'";

// Corrigé : requête paramétrée
const query = 'SELECT * FROM users WHERE name = ?';
db.execute(query, [name]);

Correctif : Utilisez des requêtes paramétrées, des ORM et validez les entrées. Pour les commandes système, évitez l'exécution shell ou utilisez des API sûres.

4. Conception non sécurisée

Cette catégorie se concentre sur les défauts de conception et d'architecture, pas seulement sur les bugs d'implémentation. La modélisation des menaces et les modèles de conception sécurisés sont essentiels.

Exemple : Absence de limitation de taux sur la réinitialisation de mot de passe

Sans limitation de taux, les attaquants peuvent brute-forcer les jetons de réinitialisation. Correctif : Implémentez une limitation de taux, utilisez des jetons forts et faites-les expirer rapidement.

5. Mauvaise configuration de sécurité

Les configurations par défaut, les erreurs détaillées et les fonctionnalités inutiles sont des causes fréquentes.

Exemple : Exposition des traces de pile

// Vulnérable : erreur détaillée au client
app.use((err, req, res, next) => {
  res.status(500).send(err.stack);
});

// Corrigé : message générique, détails journalisés côté serveur
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something went wrong');
});

Correctif : Renforcez les configurations, supprimez les fonctionnalités inutilisées et utilisez des en-têtes de sécurité comme CSP et HSTS.

6. Composants vulnérables et obsolètes

Utiliser des bibliothèques présentant des vulnérabilités connues, c'est comme laisser une porte ouverte.

Exemple : Ancienne version de lodash avec pollution de prototype

Correctif : Mettez régulièrement à jour les dépendances, utilisez des outils comme npm audit ou OWASP Dependency-Check, et surveillez les avis de sécurité.

7. Défaillances d'identification et d'authentification

Une authentification faible permet aux attaquants de compromettre des mots de passe ou des jetons de session.

Exemple : ID de session dans l'URL

// Vulnérable : ID de session dans la chaîne de requête
const sessionId = req.query.sessionId;

// Corrigé : utiliser des cookies sécurisés et HttpOnly
res.cookie('session', sessionId, { httpOnly: true, secure: true });

Correctif : Implémentez l'authentification multifacteur, imposez des mots de passe forts et utilisez une gestion de session sécurisée.

8. Défaillances d'intégrité des logiciels et des données

Cette catégorie concerne le code et l'infrastructure qui ne protègent pas contre les violations d'intégrité, comme la désérialisation non sécurisée ou l'utilisation de CDN non fiables.

Exemple : Désérialisation non sécurisée

// Vulnérable : désérialisation de données non fiables
const obj = deserialize(userInput);

// Corrigé : utiliser des formats sûrs comme JSON et valider le schéma
const obj = JSON.parse(userInput);
if (!isValidSchema(obj)) throw new Error('Invalid');

Correctif : Vérifiez l'intégrité avec des signatures numériques, utilisez des formats de sérialisation sûrs et examinez les pipelines CI/CD.

9. Défaillances de journalisation et de surveillance de la sécurité

Sans journalisation adéquate, les violations passent inaperçues. Les journaux doivent être générés, stockés en toute sécurité et surveillés.

Exemple : Ne pas journaliser les échecs de connexion

// Vulnérable : pas de journalisation
if (!valid) return res.status(401).end();

// Corrigé : journaliser l'événement
if (!valid) {
  logger.warn('Failed login attempt', { ip: req.ip, username });
  return res.status(401).end();
}

Correctif : Journalisez les événements de sécurité, configurez des alertes et assurez-vous que les journaux sont inviolables.

10. Falsification de requête côté serveur (SSRF)

La SSRF se produit lorsqu'un attaquant peut amener le serveur à envoyer des requêtes vers des emplacements non prévus.

Exemple : Récupération d'une URL sans validation

// Vulnérable : récupère n'importe quelle URL
app.get('/fetch', async (req, res) => {
  const response = await fetch(req.query.url);
  res.send(await response.text());
});

// Corrigé : valider l'URL par rapport à une liste blanche
const allowedHosts = ['api.example.com'];
app.get('/fetch', async (req, res) => {
  const url = new URL(req.query.url);
  if (!allowedHosts.includes(url.hostname)) return res.status(400).end();
  const response = await fetch(url);
  res.send(await response.text());
});

Correctif : Utilisez des listes blanches, validez les URL et limitez le trafic sortant.

Tableau comparatif : L'OWASP Top 10 en un coup d'œil

CatégorieExemple courantCorrectif principal
Contrôle d'accès défaillantIDORVérifications côté serveur
Défaillances cryptographiquesHachage de mot de passe faibleUtiliser bcrypt/argon2
InjectionInjection SQLRequêtes paramétrées
Conception non sécuriséeAbsence de limitation de tauxModélisation des menaces
Mauvaise configuration de sécuritéErreurs détailléesRenforcer les configurations
Composants vulnérablesBibliothèque obsolèteMises à jour régulières
Défaillances d'authentificationSession dans l'URLCookies sécurisés
Défaillances d'intégritéDésérialisation non sécuriséeValider et signer
Défaillances de journalisationPas de journaux d'échec de connexionJournalisation centralisée
SSRFRécupération d'URL non validéeValidation par liste blanche

FAQ

Qu'est-ce que l'OWASP Top 10 ?

L'OWASP Top 10 est un document de sensibilisation standard pour les développeurs et la sécurité des applications web. Il représente un large consensus sur les risques de sécurité les plus critiques pour les applications web.

À quelle fréquence l'OWASP Top 10 est-il mis à jour ?

OWASP met à jour la liste périodiquement pour refléter les menaces émergentes et les changements technologiques. La version la plus récente date de 2021, avec des mises à jour attendues à l'avenir.

L'OWASP Top 10 suffit-il pour sécuriser mon application ?

Non, c'est un point de départ. Un programme de sécurité complet inclut des pratiques de codage sécurisé, des tests réguliers et une surveillance continue au-delà du Top 10.

Prêt à vérifier vos payloads JSON pour des failles d'injection ? Utilisez notre JSON Formatter pour valider et embellir le JSON en toute sécurité.