Le développement sécurisé
Un logiciel est un ensemble de décisions humaines, et chaque décision peut cacher une erreur. La plupart des cyberattaques réussies n’utilisent pas de génie : elles exploitent une erreur ordinaire, écrite un jour par quelqu’un de pressé, restée là des années. Le développement sécurisé est l’ensemble des habitudes qui réduisent ces erreurs : réfléchir aux menaces avant d’écrire, éviter les familles de défauts les plus fréquentes, surveiller le code des autres que l’on emploie, tester de façon méthodique, puis corriger vite une fois le logiciel livré. Cet article en présente les principes pour les personnes qui écrivent du code comme pour celles qui commandent ou utilisent des logiciels : les idées de conception, la liste des dix risques les plus courants publiée par une fondation spécialisée, les bonnes pratiques d’écriture, la protection de la chaîne qui va du code à la mise en service, les tests et le cadre légal européen qui rend ces pratiques obligatoires pour les fabricants.
- Rubrique
- Sécurité informatique
- Niveau
- Intermédiaire
- Lecture
- 36 min (essentiel)
38 min (complet) - Révision
- 4 novembre 2026
En bref
- Une faille est presque toujours une erreur ordinaire : il vaut mieux l’empêcher par la conception et par des habitudes que la chercher après coup.
- On réfléchit aux menaces avant d’écrire le code, et on applique quelques règles simples : droits minimaux, valeurs par défaut prudentes, séparation des rôles.
- Les erreurs les plus fréquentes (contrôle d’accès oublié, mauvaise configuration, données mêlées aux instructions) ont des remèdes connus qu’il suffit d’appliquer partout.
- Une grande part du code d’un logiciel vient d’autrui : il faut savoir ce qu’on utilise, le tenir à jour et vérifier d’où il vient.
- Tests automatiques, relecture, correction rapide et politique de signalement des failles font partie du logiciel au même titre que ses fonctions.
Prérequis conseillés : La sécurité informatique · Le génie logiciel et le cycle de vie
1Pourquoi la sécurité du code est un sujet à part
Quand un logiciel plante, l’utilisateur perd un peu de temps. Quand un logiciel a une faille, c’est quelqu’un d’autre qui décide de ce qu’il en fait : voler des données, prendre le contrôle d’une machine, bloquer un service contre rançon. La différence est capitale. Un défaut ordinaire se manifeste quand une personne tombe dessus par hasard ; un défaut de sécurité est cherché par des gens dont c’est le métier, avec de l’outillage, de la patience et, souvent, des moyens importants.
Cet article parle du développement sécurisé : l’art d’écrire, de tester, de livrer et d’entretenir un logiciel de façon à ce que ces défauts soient rares, repérés tôt et corrigés vite. Il s’adresse d’abord à celles et ceux qui programment, mais il est écrit pour être compris par les chefs de projet, les acheteurs et les curieux : vous n’avez pas besoin de savoir coder pour saisir les idées, et vous en avez besoin si vous devez choisir, financer ou auditer un logiciel. Les exemples de code restent courts et sont tous défensifs : l’article n’explique pas comment attaquer, seulement comment ne pas être attaqué.
1.1Une faille est presque toujours une erreur banale
Il est tentant d’imaginer les failles comme des pièges très savants. En réalité, les analyses publiées depuis des années montrent que l’immense majorité vient de quelques familles d’erreurs, toujours les mêmes : un contrôle d’accès oublié sur une page, une donnée qui n’est pas vérifiée avant d’être utilisée, un mot de passe écrit en clair dans un fichier, une bibliothèque qui n’a jamais été mise à jour. Ce sont des oublis, rarement des inventions. C’est une bonne nouvelle : ce qui est banal peut être prévenu par des habitudes, des listes de contrôle et des outils.
Deux affaires célèbres le montrent. En avril 2014, on a découvert dans OpenSSL (la bibliothèque qui assure le cadenas des sites web, c’est-à-dire la connexion chiffrée dite HTTPS, voir le chiffrement des échanges web) un défaut surnommé Heartbleed (« cœur qui saigne ») : il manquait une simple vérification de longueur, et un correspondant pouvait donc lire des morceaux de la mémoire du serveur. Une ligne de contrôle oubliée a suffi à exposer des millions de serveurs. En décembre 2021, la faille Log4Shell a touché Log4j, une bibliothèque Java très répandue servant à écrire des journaux d’événements : elle interprétait comme des instructions des textes qui n’étaient que de simples données. Là encore, aucun génie : une fonction pratique, trop puissante, utilisée partout sans que personne se demande ce qu’elle ferait d’un texte venu de l’extérieur.
1.2Corriger tôt coûte moins cher
Les spécialistes répètent une règle d’expérience : plus une erreur est trouvée tard, plus elle coûte cher à corriger. Une faille repérée sur un schéma, avant tout code, se règle en effaçant une flèche. La même faille repérée pendant l’écriture demande de reprendre quelques lignes. Repérée pendant les tests, elle oblige à retoucher et à retester. Repérée après la livraison, elle impose de prévenir les clients, de diffuser un correctif, d’espérer qu’ils l’installent, et parfois de gérer un incident (voir la réponse aux incidents). On dit pour cela qu’il faut « décaler la sécurité vers la gauche » sur la ligne du temps du projet : plus près du début, là où les choix sont encore bon marché. La figure 1 résume l’idée.
1.3Ce que dit désormais la loi européenne
Longtemps, la qualité de sécurité d’un logiciel relevait de la bonne volonté de son éditeur. Ce n’est plus le cas en Europe. Le règlement (UE) 2024/2847, appelé en anglais Cyber Resilience Act (« loi sur la cyber-résilience », en abrégé CRA), est entré en vigueur le 10 décembre 2024. Il impose aux fabricants de produits comportant du numérique (logiciels compris) de les concevoir, de les livrer et de les entretenir avec un niveau de sécurité défini. Ses obligations de signalement des failles activement exploitées s’appliquent depuis le 11 septembre 2026, et l’ensemble de ses règles sera applicable à partir du 11 décembre 2027. Les amendes peuvent aller jusqu’à 15 millions d’euros ou 2,5 % du chiffre d’affaires mondial pour les manquements les plus graves. L’article sur le règlement de cyber-résilience détaille ce texte. Pour le développeur, la conséquence est simple : ce qui était une bonne pratique devient un devoir.
1.4Le plan de l’article
La partie 2 traite de la conception et de la réflexion sur les menaces. La partie 3 passe en revue les grandes familles d’erreurs (figure 2). La partie 4 donne les habitudes d’écriture qui les évitent. La partie 5 s’occupe du code venu d’ailleurs et de la chaîne de livraison (figure 3). La partie 6 présente les tests de sécurité, la partie 7 l’automatisation, la partie 8 la vie du logiciel après sa livraison. La partie 9 parle de la culture d’équipe, la partie 10 des assistants d’écriture fondés sur l’intelligence artificielle, la partie 11 propose un plan d’action. Les exercices corrigés suivent.
2Penser la sécurité dès la conception
Tout commence avant la première ligne de code. À ce stade, on décide ce que le logiciel doit faire, pour qui, avec quelles données, et face à quels risques. Les erreurs de conception sont les plus difficiles à réparer ensuite : on peut remplacer une ligne, on remplace difficilement l’architecture d’un système en production.
2.1La modélisation des menaces : quatre questions
La modélisation des menaces est un exercice d’une à deux heures, que l’on peut faire avec un tableau blanc. Un spécialiste du sujet, Adam Shostack, l’a ramenée à quatre questions que n’importe quelle équipe peut se poser :
- Sur quoi travaillons-nous ? On dessine le système : les utilisateurs, les programmes, les bases de données, les flux de données entre eux. On marque les frontières de confiance, c’est-à-dire les endroits où l’on passe d’une zone que l’on maîtrise à une zone que l’on ne maîtrise pas (le navigateur de l’utilisateur, un service d’un partenaire, Internet).
- Qu’est-ce qui peut mal tourner ? Pour chaque flèche et chaque frontière, on se demande qui pourrait se faire passer pour un autre, modifier une donnée, nier avoir fait une action, lire ce qui doit rester secret, bloquer le service, ou obtenir plus de droits qu’il ne devrait. Une liste connue sous le nom de STRIDE (six types de menaces dont les initiales forment le mot, en anglais) sert d’aide-mémoire.
- Que faisons-nous pour y répondre ? Pour chaque menace, on choisit : l’éliminer (supprimer la fonction), la réduire (ajouter un contrôle), la transférer (confier à un service plus solide) ou l’accepter en connaissance de cause, par écrit.
- Avons-nous bien travaillé ? On relit, on vérifie que chaque décision se retrouve dans les exigences et dans les tests, et on recommence quand le système change.
Le résultat n’est pas un gros document, mais une liste courte de décisions qui entrent dans le suivi du projet. L’important est de le faire avec les personnes qui connaissent le système, pas à leur place.
2.2Les principes qui reviennent partout
Les ouvrages de sécurité énoncent depuis les années 1970 des principes de conception restés valables. En voici les plus utiles, avec leur sens concret.
- Le moindre privilège. Chaque programme, chaque compte, chaque clé ne reçoit que les droits nécessaires à sa tâche. Un service qui lit des fiches clients n’a pas besoin de pouvoir les supprimer. Si ce service est compromis, les dégâts restent bornés.
- Sûr par défaut. La configuration livrée doit être la plus prudente : fonctions risquées éteintes, mots de passe d’usine interdits, connexions chiffrées. Un utilisateur pressé ne change pas les réglages ; autant qu’ils soient bons dès le départ.
- La défense en profondeur. On ne compte jamais sur un seul contrôle. Si la vérification dans le formulaire est contournée, une autre doit exister côté serveur, puis une autre au niveau de la base de données. Comme les couches d’un oignon, chacune ralentit l’attaquant et offre une chance de détection.
- Réduire la surface d’attaque. Chaque fonction, chaque port ouvert, chaque format de fichier accepté est une porte supplémentaire. Ce qui n’existe pas ne peut pas être attaqué : on retire ce qui ne sert pas.
- La séparation des tâches. Une action sensible (un virement important, une mise en production) demande l’accord de deux personnes ou de deux composants distincts.
- La simplicité. Un système simple se comprend, donc se vérifie. La complexité est l’amie des failles ; une règle de dix lignes vaut mieux qu’une règle de cent.
- Ne jamais se fier à l’extérieur. Tout ce qui vient de l’extérieur de la frontière de confiance (formulaire, fichier envoyé, réponse d’un service tiers) est considéré comme non sûr jusqu’à vérification.
- Échouer proprement. Quand une vérification ne peut pas être menée à bien, la réponse par défaut est le refus, pas l’autorisation.
2.3Minimiser les données
La meilleure protection d’une donnée est de ne pas la détenir. Chaque champ collecté « au cas où » devient un risque en cas de fuite, une obligation légale (voir le règlement européen sur les données personnelles) et un poids pour l’équipe. Ce règlement impose d’ailleurs, à son article 25, la protection des données dès la conception et par défaut, ce qui traduit en droit les principes ci-dessus. En pratique : ne demander que le nécessaire, fixer une durée de conservation, supprimer ce qui est périmé, et pour ce qu’on garde, décider précisément qui peut le lire.
2.4Écrire les exigences de sécurité
Une exigence de sécurité est une phrase testable, au même titre qu’une exigence fonctionnelle. « Le logiciel doit être sécurisé » n’est pas testable. « Toute page affichant un dossier client vérifie que l’utilisateur connecté a le droit de voir ce dossier » l’est. « Les mots de passe ne sont jamais stockés en clair ni dans les journaux » l’est aussi. Plus les exigences sont précises, plus elles se transforment en tests automatiques (partie 6) qui protègent le logiciel à chaque modification.