Le développement sécurisé
Partie 2 sur 5
3Les grandes familles d’erreurs
Pour savoir où concentrer ses efforts, on s’appuie sur des classements établis à partir d’observations réelles. Le plus connu est celui de l’OWASP (Open Worldwide Application Security Project), une fondation à but non lucratif qui publie des guides gratuits sur la sécurité des applications. Son classement des dix risques les plus courants pour les applications web, mis à jour tous les trois à quatre ans, existe en édition 2025. Un second outil est la liste des CWE (Common Weakness Enumeration, « catalogue des faiblesses courantes »), qui donne un numéro et un nom à chaque type de défaut, ce qui permet aux outils et aux équipes de parler de la même chose.
3.1Les dix risques de l’édition 2025
L’édition 2025 du classement OWASP, la huitième, garde en tête le même risque que l’édition 2021 et fait entrer deux nouveautés. Dans l’ordre :
- Contrôle d’accès défaillant. Toujours numéro un. Les contrôles qui décident « qui a le droit de faire quoi » sont absents, incomplets ou contournables. Cette catégorie englobe maintenant les attaques où un serveur est amené à faire des requêtes à la place de l’attaquant.
- Mauvaise configuration de sécurité. Montée de la cinquième à la deuxième place : mots de passe par défaut, services inutiles ouverts, messages d’erreur trop bavards, autorisations trop larges.
- Défaillances de la chaîne d’approvisionnement logicielle. Nouvelle catégorie, qui élargit l’ancien risque des « composants vulnérables et périmés » à toute la chaîne : dépendances, outils de construction, distribution (partie 5).
- Défaillances cryptographiques. Chiffrement absent, trop faible ou mal employé (voir la cryptographie).
- Injection. Des données venues de l’extérieur sont interprétées comme des instructions (voir l’injection SQL et les scripts intersites).
- Conception non sécurisée. Les failles qui viennent d’un défaut de réflexion initial, pas d’une erreur de code (partie 2).
- Défaillances d’authentification. Mots de passe faibles acceptés, sessions mal gérées, absence de seconde vérification (voir l’authentification).
- Défaillances d’intégrité des logiciels ou des données. On fait confiance à du code ou à des données sans vérifier qu’ils n’ont pas été modifiés.
- Défaillances de journalisation et d’alerte. Le nom a changé pour insister sur l’alerte : consigner ne sert à rien si personne n’est prévenu à temps.
- Mauvaise gestion des conditions exceptionnelles. Seconde nouveauté : le logiciel réagit mal aux situations anormales (erreur inattendue, ressource manquante, entrée absurde), ce qui ouvre des brèches ou fait tomber le service.
Un classement n’est pas un programme : il aide à ne rien oublier, mais ne remplace pas la réflexion sur votre propre système. Il a aussi une limite : il décrit des tendances sur de grands jeux de données, pas votre cas particulier.
3.2Le contrôle d’accès : l’erreur numéro un
Imaginez un site de factures où l’adresse d’une facture ressemble à /factures/1042. Si le serveur affiche la facture 1043 à n’importe quel utilisateur connecté, sans demander si elle lui appartient, chacun peut lire les factures des autres en changeant un chiffre. Rien de savant : le contrôle manquait. C’est l’erreur la plus répandue, parce qu’elle ne fait pas planter le logiciel : tout « marche » pour les gentils, et personne ne teste ce que fait le logiciel pour les autres.
Les remèdes sont de principe : décider des droits côté serveur (ce qui s’affiche ou non dans le navigateur n’est qu’un confort, jamais une protection) ; vérifier le droit à chaque requête, sans supposer qu’un utilisateur arrivé sur une page y est autorisé ; refuser par défaut ; centraliser les règles dans un seul endroit plutôt que de les recopier page par page ; et écrire des tests qui essaient explicitement l’accès avec le mauvais compte.
3.3Les injections : quand une donnée devient un ordre
Dans une injection, un programme construit une commande en collant du texte fourni par l’utilisateur, et le destinataire de la commande (la base de données, le système, le navigateur) ne sait plus où s’arrête la donnée et où commence l’instruction. Le principe est toujours le même, quelle que soit la technologie. Le remède l’est aussi : ne jamais fabriquer une commande par assemblage de texte. On utilise des interfaces qui séparent clairement la commande de ses paramètres, comme les requêtes dites paramétrées pour une base de données. En voici la forme générale :
# À éviter : on colle la saisie de l'utilisateur dans la requête requete = "SELECT * FROM clients WHERE nom = '" + saisie + "'" # À faire : la requête et la valeur voyagent séparément requete = "SELECT * FROM clients WHERE nom = ?" resultat = base.executer(requete, [saisie])
Dans le second cas, la base reçoit la requête d’un côté et la valeur de l’autre ; quoi que contienne la saisie, elle n’est jamais lue comme une instruction. Le même raisonnement vaut pour les commandes système (on passe une liste d’arguments, pas une phrase), pour les pages web (on encode ce qu’on affiche, voir l’article sur les scripts intersites) et pour tous les langages de requête.
3.4La cryptographie : ne rien inventer
L’erreur classique est de croire qu’on peut écrire son propre chiffrement. Les algorithmes éprouvés ont été examinés pendant des années par des centaines de spécialistes ; un algorithme maison ne l’a été par personne. La règle est donc : employer des bibliothèques reconnues, avec leurs réglages recommandés, et ne pas bricoler. Pour les mots de passe, on ne les stocke jamais en clair, ni même chiffrés de façon réversible : on conserve leur empreinte calculée avec une fonction volontairement lente et salée (voir les fonctions de hachage et les mots de passe). Pour les échanges, on active le chiffrement de la connexion (voir le chiffrement des échanges), et on laisse le logiciel vérifier les certificats au lieu de désactiver ce contrôle « pour que ça marche en test ».
3.5Les erreurs de mémoire
Dans des langages comme le C et le C++, c’est au programmeur de gérer la mémoire. Lire ou écrire au-delà d’une zone prévue, utiliser une zone déjà libérée : ces erreurs sont à l’origine d’une grande part des failles les plus graves de l’histoire, dont Heartbleed. Les équipes de grands éditeurs ont publié, chacune de leur côté, des analyses concordantes indiquant que de l’ordre des deux tiers de leurs failles graves venaient de ce type d’erreurs. C’est pourquoi les autorités de plusieurs pays, dont l’agence américaine de cybersécurité, recommandent pour tout nouveau projet des langages dits à mémoire sûre (Rust, Go, Java, C# et d’autres), qui rendent ces erreurs impossibles ou très rares (voir Rust et la gestion de la mémoire). Quand on doit garder du C ou du C++, on utilise les protections du compilateur, les bibliothèques de chaînes et de tableaux vérifiés, et les outils de test de la partie 6.
3.6Les cas anormaux et les messages d’erreur
La nouveauté de 2025, la « mauvaise gestion des conditions exceptionnelles », rappelle qu’un programme se juge à sa tenue quand tout ne va pas bien. Que se passe-t-il quand la base de données ne répond pas ? Quand un fichier est vide ? Quand deux demandes arrivent en même temps ? Les bons réflexes : prévoir un traitement pour chaque erreur possible plutôt que d’ignorer les erreurs ; en cas de doute, refuser (si le service qui vérifie les droits est injoignable, on n’ouvre pas l’accès) ; ne pas montrer à l’utilisateur les détails techniques d’une erreur (ils aident l’attaquant), mais les consigner pour l’équipe ; et limiter les ressources qu’une seule demande peut consommer.
Pour s’exercer
Exercice 1 : trouver le contrôle manquant
Un site de réservation affiche les réservations d’un client à l’adresse /reservations/5821. Le serveur vérifie que l’utilisateur est connecté, mais pas à qui appartient la réservation. Quel risque, quelle catégorie de la liste de l’OWASP, et que faire ?
Voir la réponse
Tout client connecté peut lire les réservations des autres en changeant le numéro : c’est un contrôle d’accès défaillant, premier de la liste 2025. Il faut vérifier, côté serveur et à chaque requête, que la réservation demandée appartient bien à l’utilisateur connecté (ou qu’il a un rôle qui l’autorise), refuser sinon, et ajouter un test automatique qui essaie d’accéder à la réservation d’un autre compte. Utiliser des identifiants difficiles à deviner est un plus, mais ne remplace pas le contrôle.
Exercice 2 : requête paramétrée
Vous lisez ce code : requete = "SELECT * FROM comptes WHERE email = '" + saisie + "'". Quel est le problème, comment le corriger, et pourquoi le simple fait de refuser les guillemets ne suffit pas ?
Voir la réponse
La saisie est collée dans la requête : la base ne distingue plus la donnée de l’instruction. On corrige avec une requête paramétrée : "... WHERE email = ?" et la valeur passée à part. Refuser certains caractères est une liste d’interdits, toujours incomplète (il existe d’autres façons de tromper une requête, selon la base et l’encodage), alors que la séparation structurelle règle le problème à la racine, quelle que soit la saisie.
4Les habitudes d’écriture qui évitent les failles
Au-delà des familles d’erreurs, quelques habitudes quotidiennes font l’essentiel du travail. Elles tiennent sur une page, et c’est leur régularité qui compte.
4.1Valider ce qui entre, encoder ce qui sort
Toute donnée qui franchit une frontière de confiance est vérifiée à l’entrée : son type, sa longueur, son format, ses valeurs permises. La méthode la plus sûre est la liste d’autorisation : on décrit ce qui est accepté (un code postal est composé de cinq chiffres) plutôt que d’énumérer ce qui est interdit, car la liste des interdits n’est jamais complète. La validation côté navigateur n’est qu’une aide à l’utilisateur : elle se contourne trivialement, donc la vraie vérification est toujours refaite côté serveur. À la sortie, on encode les données selon l’endroit où elles sont placées (page web, adresse, fichier), pour qu’elles restent des données.
4.2Garder les secrets hors du code
Un secret est un mot de passe, une clé d’accès, un jeton qui ouvre une porte. L’erreur la plus fréquente est de l’écrire dans le code, puis de publier le code, parfois sur un dépôt public. Des robots parcourent en permanence les dépôts publics à la recherche de ces clés, et celles-ci sont exploitées en quelques minutes. Règles : aucun secret dans le code ni dans l’historique du dépôt (voir Git, qui garde tout) ; les secrets sont fournis au programme au moment de son lancement, par un coffre-fort de secrets ou par la configuration de l’environnement ; chaque secret a un rôle limité et une date d’expiration ; en cas de fuite, on ne se contente pas de supprimer le fichier : on révoque la clé et on en émet une nouvelle. Des outils de détection de secrets, branchés sur le dépôt, bloquent l’envoi d’un code qui en contient.
4.3Les mots de passe et les sessions
Un logiciel qui gère des comptes doit éviter d’inventer sa propre solution d’authentification. Mieux vaut s’appuyer sur un service ou une bibliothèque reconnus, offrir la seconde vérification, ou mieux les clés d’accès sans mot de passe (voir les clés d’accès), limiter le nombre d’essais, ne jamais indiquer lequel des deux éléments (identifiant ou mot de passe) était faux, régénérer l’identifiant de session après la connexion et le faire expirer. Ce ne sont pas des détails : ce sont les endroits où la plupart des comptes sont perdus.
4.4Journaliser sans fuir
Un bon journal permet de comprendre après coup ce qui s’est passé : qui s’est connecté, quelle action sensible a été faite, quelles demandes ont été refusées. Il doit contenir de quoi enquêter (heure, compte, adresse, action) et ne jamais contenir de quoi nuire : ni mots de passe, ni numéros de carte, ni données personnelles superflues. On protège les journaux en écriture, on les envoie hors de la machine surveillée, et surtout on les exploite : une alerte sur une série de refus anormale est utile, un fichier jamais lu ne l’est pas (voir la détection).
4.5La relecture par une deuxième personne
La relecture de code (code review) est l’un des moyens les plus efficaces et les moins chers d’attraper une erreur : une deuxième paire d’yeux voit ce que l’auteur ne voit plus. Pour la sécurité, on peut y associer une courte liste de questions : ce code accepte-t-il des données de l’extérieur ? Les vérifie-t-il ? Les droits sont-ils contrôlés ? Y a-t-il un secret ? Un cas d’erreur est-il oublié ? Les changements les plus sensibles (authentification, droits, chiffrement) sont relus par une personne formée, et aucune modification ne part en production sans cette relecture.
4.6Des règles de codage écrites
Chaque langage a ses pièges et ses bonnes pratiques. Il est utile que l’équipe les mette par écrit en une ou deux pages, reprises de guides publics (l’agence nationale française de la sécurité des systèmes d’information publie ainsi des règles de programmation pour certains langages, et l’OWASP propose des fiches pratiques par sujet). L’objectif est de réduire le nombre de décisions à prendre à chaque ligne : lorsque les règles sont écrites et vérifiées par des outils, la bonne façon de faire devient la plus simple.
Pour s’exercer
Exercice 3 : un secret publié par erreur
Un développeur s’aperçoit qu’il a envoyé sur un dépôt public, il y a deux jours, un fichier contenant la clé d’accès au stockage de l’entreprise. Il a supprimé le fichier dans la dernière version. Est-ce réglé ? Que faire ?
Voir la réponse
Non. L’historique du dépôt garde le fichier, et des robots ont pu copier la clé dans les minutes qui ont suivi. Il faut révoquer la clé immédiatement et en émettre une nouvelle, vérifier dans les journaux du stockage si elle a été utilisée par quelqu’un d’autre, traiter l’affaire comme un incident (voir l’article sur la réponse aux incidents), puis mettre en place une détection de secrets avant l’envoi du code et un coffre-fort pour que cela ne se reproduise pas.