Points clés
Supposez que chaque fonctionnalité connectée sera sondée par quelqu’un.
L’exposition est la norme. Howard et LeBlanc partent d’un constat sans détour: les logiciels en réseau seront confrontés à des entrées hostiles, que leurs concepteurs s’attendent ou non à attirer l’attention. Un serveur de test Microsoft mis en ligne un vendredi a été repéré et attaqué dès le lundi. Lors d’essais distincts, des machines connectées à Internet et configurées pour observer les attaquants ont souvent été découvertes en quelques jours. Il suffit à l’attaquant d’un seul point d’entrée vulnérable; le développeur, lui, doit les prendre tous en compte.
La sécurité est une qualité du produit. Une application compromise peut exposer des données privées, interrompre le service, nuire à la confiance des clients et entraîner des réparations coûteuses. Le livre cite une estimation d’environ 100 000 dollars pour un seul bulletin de sécurité et le correctif correspondant, sans compter les perturbations pour les clients ni les atteintes à la réputation. Le niveau de protection approprié dépend de la fonction du logiciel et de ce que ses utilisateurs risquent de perdre.
Le livre commence avec force en remplaçant la question rassurante « Qui voudrait s’en prendre à nous ? » par une hypothèse d’ingénierie portant sur l’exposition. Cela rappelle l’ingénierie de la sécurité, où une conception est mise à l’épreuve face aux défaillances prévisibles plutôt qu’à l’optimisme de l’exploitant. L’argument est particulièrement convaincant pour les services accessibles en permanence. Cela dit, tous les produits ne justifient pas le même investissement. Un modèle de menace doit relier les dommages possibles aux données, aux utilisateurs et au contexte d’exploitation à protéger, plutôt que de traiter la sécurité comme une exigence illimitée.
Formez toute l’équipe avant l’apparition du premier bogue de sécurité.
Les compétences doivent se diffuser. Dans le cadre du Windows Security Push de Microsoft, environ 8 500 employés ont suivi une formation à la sécurité en dix jours, parmi lesquels des développeurs, des testeurs, des responsables de programme et des cadres dirigeants. L’objectif n’était pas simplement de recruter quelques spécialistes. Toutes les personnes participant à la création du produit devaient reconnaître comment des fonctionnalités ordinaires pouvaient devenir des voies d’attaque et comment prévenir les défauts à leur source.
La pratique change ce que les réviseurs repèrent. Dans une expérience décrite par les auteurs, deux programmeurs ont d’abord trouvé 10 et 16 défauts dans mille lignes de code C. Après une leçon d’une heure sur la sécurité, ils en ont découvert respectivement 45 et 41 autres. La formation s’accompagnait de revues par les pairs, d’un travail ciblé sur les bogues et d’un suivi des défauts, afin que les leçons modifient les habitudes quotidiennes au lieu de se limiter à un cours en salle.
Ce récit remet en cause l’idée que l’on puisse confier la sécurité à une petite équipe de réviseurs. Un vocabulaire partagé permet aux concepteurs, aux développeurs et aux testeurs de repérer différents modes de défaillance dans une même fonctionnalité. L’expérience illustre cette idée de façon frappante, sans constituer une preuve scientifique générale : elle ne concerne que deux personnes et un seul échantillon de code. Sa leçon durable est d’ordre organisationnel. La formation est particulièrement utile lorsqu’elle s’accompagne de revues régulières, de responsabilités clairement attribuées et de retours qui aident à ne pas répéter les mêmes erreurs.
Cartographiez les menaces avant de choisir des technologies de sécurité.
Commencez par modéliser le système. Un modèle de menace décrit de façon structurée les éléments d’un système, la circulation des données, les problèmes susceptibles de survenir et les risques qui méritent une attention particulière. Un diagramme de flux de données peut faire apparaître les processus, les magasins de données, les utilisateurs et les frontières entre les parties de confiance et celles qui ne le sont pas. L’équipe se demande ensuite comment un attaquant pourrait usurper une identité, modifier ou exposer des données, interrompre le service ou obtenir des privilèges supérieurs. STRIDE désigne cette méthode de classement des menaces en six catégories.
Établissez les priorités avant de construire les défenses. Les arbres de menace décomposent une attaque générale en étapes que l’attaquant devrait accomplir. DREAD est une méthode de notation qui compare les dommages possibles, la facilité de répétition et d’exploitation, l’étendue des utilisateurs concernés et la probabilité de découverte. Les auteurs indiquent que leurs équipes ont trouvé environ la moitié des bogues de sécurité grâce à l’analyse des menaces. Pour un service de paie, par exemple, suivre les données des employés sur un réseau permet de repérer les possibilités d’interception avant de choisir un chiffrement.
L’apport pratique réside dans l’ordre des opérations : comprendre le système et ses menaces avant de choisir un mécanisme à la mode. La sécurité devient ainsi une activité de conception, plutôt qu’une couche technologique ajoutée une fois les décisions prises. Les scores de risque aident les équipes à comparer les tâches, mais ils peuvent donner une fausse impression de précision, surtout lorsqu’il est difficile d’estimer la probabilité. STRIDE et DREAD sont surtout des outils pour susciter une discussion rigoureuse. Leur intérêt est de faire apparaître des voies négligées, et non de donner à des jugements subjectifs un vernis de certitude mathématique.
Désactivez ce dont les utilisateurs n’ont pas besoin et réduisez les privilèges.
Réduisez la surface d’exposition. Le modèle SD3 du livre regroupe les bonnes pratiques autour de trois objectifs: intégrer la sécurité à la conception, choisir des paramètres initiaux prudents et faciliter la gestion du produit après son installation. Des paramètres par défaut sûrs consistent à n’installer que les fonctionnalités dont la plupart des utilisateurs ont besoin et à laisser les autres désactivées jusqu’à ce qu’une personne les active délibérément. Les auteurs proposent une règle empirique 80/20: activer par défaut le petit ensemble de fonctionnalités dont la plupart des utilisateurs ont besoin et rendre les autres faciles à ajouter.
Limitez les dégâts. Le principe du moindre privilège consiste à n’accorder à un processus que les permissions nécessaires à sa tâche. Si un attaquant prend le contrôle d’un service exécuté avec les privilèges SYSTEM, la compromission peut s’étendre bien au-delà des fonctions de ce service. Le livre évoque des services et du code Web qui s’exécutaient autrefois avec des privilèges excessifs. Séparer l’administration privilégiée des activités courantes peut circonscrire une attaque réussie au lieu de lui livrer toute la machine.
Les paramètres par défaut sûrs et le principe du moindre privilège se complètent : les premiers réduisent le nombre de portes, le second limite ce qu’une intrusion peut atteindre. C’est une forme de confinement familière en ingénierie de la sécurité, où les systèmes sont conçus pour empêcher qu’une défaillance n’en entraîne d’autres. La difficulté tient à la facilité d’utilisation. Une fonctionnalité désactivée par défaut peut frustrer les utilisateurs ou empêcher de fonctionner des logiciels qui en dépendent ; le réglage doit donc être compréhensible et facile à modifier. Un paramètre sûr par défaut est particulièrement efficace s’il réduit l’exposition sans transformer la configuration courante en casse-tête.
Validez les entrées à un point de contrôle unique, pas là où cela vous arrange.
La confiance commence à la frontière. Une frontière de confiance sépare les données contrôlées par l’application de celles fournies par les utilisateurs, les fichiers, les clients ou d’autres systèmes. Un point de contrôle des entrées (input chokepoint) est le chemin désigné par lequel les données d’une source doivent passer avant d’entrer dans un traitement de confiance. La validation devient ainsi cohérente et les réviseurs disposent d’un endroit précis où examiner les hypothèses. Une vérification côté client ne suffit pas: un attaquant peut contourner le client et envoyer une requête directement au serveur.
N’acceptez que ce qui est valide. Une requête de base de données construite en concaténant du texte fourni par l’utilisateur à une instruction SQL peut être modifiée par une entrée spécialement conçue, ce qui risque d’exposer ou de modifier des enregistrements. Les requêtes paramétrées séparent les données des instructions de la requête, tandis qu’un compte de base de données aux permissions limitées réduit les conséquences d’une erreur. Pour les pages Web, validez les entrées autorisées et encodez les données avant de les afficher, car du texte ordinaire peut autrement être interprété comme un script.
Un point de validation unique et visible rend concrète une règle abstraite. Cela reflète aussi un principe utile de conception des systèmes : les responsabilités doivent être attribuées aux interfaces, là où les hypothèses passent d’un composant à un autre. Cette frontière ne dispense pas des mesures de protection adaptées au contexte. Une chaîne sûre pour une base de données ne l’est pas nécessairement pour du HTML, et une entrée syntaxiquement valide peut tout de même enfreindre des règles métier. La validation, l’encodage des sorties et l’autorisation répondent à des questions différentes et ne doivent pas être confondus.
N’autorisez jamais l’accès à partir d’un nom avant d’en avoir résolu toutes les représentations.
Les noms peuvent tromper. La canonicalisation consiste à convertir des représentations équivalentes dans une forme standard. Des contrôles de sécurité fondés sur un nom de fichier ou une URL non traité peuvent diverger du comportement du composant qui l’ouvre finalement. Les noms de fichiers longs de Windows peuvent avoir des alias courts au format 8.3; une URL encodée peut dissimuler des caractères de traversée de répertoires; et une faille d’IIS permettait autrefois à une requête visant un flux de données alternatif de révéler le code source au lieu d’en afficher le résultat après traitement.
Privilégiez la ressource elle-même. L’approche la plus sûre consiste à utiliser les contrôles d’accès du système d’exploitation plutôt qu’à décider des permissions à partir d’un nom de fichier. Lorsqu’un nom doit être vérifié, définissez un ensemble restreint de formes valides, normalisez-le au moyen du composant système concerné et rejetez tout ce qui ne respecte pas la règle. L’exemple du livre, où l’accès à un répertoire supposément protégé était possible en modifiant les majuscules et minuscules du nom, montre que les règles de comparaison d’un composant peuvent différer de celles du système de fichiers.
Les échecs de canonicalisation sont en réalité des échecs de coordination : deux couches interprètent différemment la même chaîne, et la décision de sécurité est prise entre ces deux interprétations. Le même phénomène apparaît chaque fois que des données sont décodées, normalisées ou réécrites en transit. Il ne suffit donc pas de se demander si une entrée a été vérifiée ; il faut aussi se demander si elle l’a été sous la même forme que celle qu’utilisera le gestionnaire de ressources. Des listes d’autorisation strictes réduisent l’ambiguïté, mais peuvent aussi rejeter des noms légitimes, notamment dans les environnements internationaux ou anciens.
Délimitez chaque tampon et considérez les protections du compilateur comme un recours supplémentaire.
Les erreurs mémoire deviennent des erreurs de contrôle. En C et en C++, copier une entrée sans en vérifier la longueur au-delà des limites d’un tampon peut écraser des données voisines et détourner l’exécution. Le livre montre que les débordements de pile ne sont pas les seuls dangers: la corruption du tas, les écritures avec dépassement d’une unité, les indices de tableau non vérifiés, les erreurs de chaînes de format et la confusion entre taille en caractères et taille en octets peuvent également modifier le comportement du programme. Les fonctions de chaîne plus sûres ne sont utiles que si leurs limites et leurs valeurs de retour sont correctement utilisées. Un nombre de caractères n’est pas toujours un nombre d’octets.
La complexité peut elle aussi être exploitée. Une fonction qui décalait sans cesse une chaîne pour supprimer les caractères en double a mis environ 36 minutes à traiter une entrée d’un million de caractères sur la machine de test des auteurs; une méthode en temps linéaire a pris environ 20 millisecondes. L’option /GS de Visual C++ peut détecter certains écrasements de pile, mais elle n’empêche ni les attaques visant le tas ni toutes les erreurs de pointeur. C’est une protection supplémentaire, pas un substitut aux vérifications de limites et aux tests.
Ce chapitre relie la sûreté mémoire à la fois à la correction du programme et à la complexité computationnelle. Une fonction peut éviter de corrompre la mémoire tout en restant exploitable par une consommation disproportionnée de processeur ou de ressources. Les langages modernes à mémoire sûre éliminent de nombreuses catégories d’erreurs de bas niveau, mais ne règlent pas automatiquement les problèmes d’autorisation, d’analyse syntaxique, de déni de service ou de frontières natives non sûres. Les conseils du livre restent pertinents même lorsque ses API sont obsolètes : mesurez soigneusement les longueurs, vérifiez les échecs, simplifiez les routines complexes et ne prenez jamais une mesure de protection du compilateur pour une preuve de sécurité.
Utilisez une cryptographie éprouvée et limitez le nombre de secrets ainsi que leur durée de vie.
Le chiffrement n’est pas une panacée. La cryptographie peut protéger la confidentialité, authentifier des identités et détecter les altérations, mais elle ne peut pas corriger un débordement de tampon ni un système de permissions mal conçu. Les auteurs mettent en garde contre les algorithmes développés en interne et les générateurs de nombres aléatoires prévisibles, tels que les implémentations courantes de rand. Utilisez les services reconnus du système d’exploitation ou du framework pour générer des nombres aléatoires et effectuer des opérations cryptographiques, et associez le chiffrement à un code d’authentification de message ou à une signature lorsque l’intégrité des données est importante.
Protégez la clé, pas seulement les données. Une clé intégrée à un exécutable peut être récupérée, et un secret transmis à de nombreuses fonctions est exposé à davantage de code. Si un vérificateur suffit, évitez de stocker un secret. Lorsque le stockage est nécessaire, l’API de protection des données (DPAPI) de Windows peut protéger les données pour un utilisateur ou une machine, sous réserve de contrôles d’accès adaptés. Ne conservez les données en clair en mémoire que le temps nécessaire, puis effacez-les avec une méthode que le compilateur n’éliminera pas lors de l’optimisation.
La correction centrale de ce chapitre consiste à déplacer l’attention de la réputation des algorithmes vers l’ensemble du cycle de vie des clés. Un chiffrement robuste protège peu si une clé est codée en dur, réutilisée sans précaution ou accessible à des processus disposant de privilèges étendus. Cette vision systémique est plus utile que de considérer la cryptographie comme une simple fonctionnalité à cocher. Elle a toutefois une limite pratique : un logiciel ne peut pas protéger complètement les secrets contre un administrateur ou un code malveillant exécuté avec les mêmes privilèges que l’utilisateur. L’objectif est de réduire l’exposition et d’adapter la protection aux menaces.
Testez comme un attaquant, puis corrigez toute la catégorie de bogues.
Mettez chaque interface à l’épreuve. Les tests de sécurité vérifient que les défenses résistent aux usages malveillants, et pas seulement que les fonctionnalités marchent dans des conditions normales. Commencez par le modèle de menace, identifiez les interfaces et les données qu’elles reçoivent, puis faites varier ces données: rendez-les mal formées, trop volumineuses, absentes, dupliquées, dans le désordre, ou valides mais assorties d’un élément malveillant. Effectuez les tests avec des privilèges d’utilisateur ordinaires et avec des privilèges d’administrateur. Un service qui plante face à une entrée hostile peut entraîner un déni de service, même si aucune donnée n’est dérobée.
Transformez les découvertes en mesures préventives. Lorsqu’une faille apparaît, recherchez les défauts apparentés, ajoutez des tests de non-régression et identifiez l’hypothèse qui a échoué. Les auteurs décrivent une équipe produit qui a consacré quatre heures à examiner un schéma de bogue récurrent, puis a trouvé et corrigé quatre autres cas en moins de vingt heures-personnes. Le programmeur à l’origine du code doit participer à la correction, afin que l’équipe apprenne au lieu de simplement confier le bogue à quelqu’un d’autre.
Les tests adversariaux sont plus efficaces lorsqu’ils sont systématiques que lorsqu’ils cherchent à faire sensation. Le fuzzing aléatoire peut révéler des plantages, tandis que des modifications structurées et réfléchies permettent d’atteindre des chemins de code plus profonds qu’une simple entrée invalide ne mettrait jamais à l’épreuve. Aucune de ces approches ne prouve l’absence de défauts : les résultats doivent donc alimenter les revues de code, les modifications de conception et les suites de non-régression. Le livre considère aussi les tests comme une composante d’un dispositif de réaction continu : des vulnérabilités apparaîtront encore après la mise en production, et la qualité du triage, des correctifs et de la communication avec les clients détermine le résultat réel en matière de sécurité.
Rendez la confidentialité visible, limitez la collecte et expliquez les risques réels.
La confidentialité est une responsabilité du produit. Dans sa présentation de Safe Harbor, le livre organise la gestion responsable des données autour de l’information des personnes, de leur choix, des limites au partage, de l’accès, de la sécurité, de l’exactitude des données et de l’application des règles. Les applications ne devraient recueillir que les informations nécessaires à un objectif annoncé, permettre aux personnes de les consulter ou de les corriger et les protéger contre tout accès non autorisé comme contre toute modification abusive. La confidentialité est liée à la sécurité, mais elle régit également l’usage des informations par les personnes qui y sont autorisées.
Rendez les choix compréhensibles. Une politique de confidentialité devrait préciser quelles données sont recueillies, pourquoi, combien de temps elles sont conservées et avec qui elles sont partagées. Le livre présente P3P comme un moyen, lisible par machine, permettant aux sites Web de communiquer leurs pratiques en matière de confidentialité. La documentation et les messages d’erreur comptent aussi: les utilisateurs ont besoin de comprendre clairement les conséquences et de conseils applicables, pas de jargon ni d’avertissements vagues. Un paramètre sûr par défaut ne devrait pas obliger les utilisateurs à dénicher une instruction essentielle dans un manuel.
La confidentialité ajoute une question de gouvernance à laquelle le contrôle d’accès ne suffit pas à répondre : même lorsqu’une personne est autorisée à consulter des données, devrait-elle les recueillir ou les utiliser à cette fin ? La minimisation des données réduit à la fois l’exposition et la charge liée à la gestion du consentement, de la conservation et de la suppression. Des avis clairs sont utiles, mais informer ne remplace pas la retenue. L’accent mis par le chapitre sur des choix compréhensibles relève aussi de la prise en compte des facteurs humains : une politique que les utilisateurs ne peuvent pas interpréter peut satisfaire à une procédure sans leur donner un contrôle réel.
Analyse
Écrire Du Code Sécurisé; Techniques Et Stratégies Pour Écrire Des Applications Sûres est un manuel pratique d’ingénierie fondé sur un principe: les logiciels connectés doivent être conçus pour résister à des usages hostiles, et pas seulement vérifiés quant à leur bon fonctionnement dans des conditions ordinaires. Son apport le plus général tient à l’enchaînement des responsabilités. Les équipes apprennent les risques, modélisent les flux de données et les frontières de confiance, choisissent des mesures proportionnées, les mettent en œuvre au moyen d’une programmation défensive, testent des cas hostiles et entretiennent un processus de réaction après la mise en production. Les récits concrétisent cet enchaînement: un serveur attaqué au cours d’un week-end sans avoir été annoncé, puis des programmeurs qui découvrent bien plus de défauts après une courte formation à la sécurité.
Le livre est particulièrement convaincant lorsqu’il transforme la sécurité, jusque-là domaine réservé de spécialistes, en pratique reproductible. La modélisation des menaces relie la conception aux tests; des paramètres par défaut sûrs réduisent la dépendance envers les administrateurs; le principe du moindre privilège limite les dégâts causés par des failles inévitables; et les analyses rétrospectives transforment les incidents en apprentissages pour l’organisation. Il est particulièrement important de souligner que même des fonctionnalités sans lien apparent avec la sécurité peuvent comporter des défauts de sécurité. Un service de paie, un utilitaire de gestion de fichiers ou un jeu peuvent tous devenir des voies d’attaque, simplement parce qu’ils acceptent des entrées ou s’exécutent avec des privilèges.
Ses systèmes de notation et ses listes de contrôle sont des outils de réflexion, pas des garanties. Les scores DREAD peuvent donner à des jugements subjectifs une apparence de précision excessive, tandis que le décompte des surfaces d’attaque ne mesure ni la qualité du code ni la probabilité d’une exploitation particulière. Leur véritable intérêt est comparatif: ils aident les équipes à se demander ce qui a changé, ce qui reste exposé et ce qui devrait être examiné en priorité. De même, la sécurité ne se résume pas à multiplier les contrôles. Des avertissements excessifs, des paramètres par défaut contraignants et des mesures impraticables peuvent pousser les utilisateurs à adopter des solutions de contournement peu sûres.
La deuxième édition s’inscrit dans le contexte des plateformes Microsoft du début des années 2000, et bon nombre des API, des comportements de systèmes d’exploitation et des détails d’implémentation qu’elle mentionne sont propres à cette époque. Les lecteurs ne devraient pas prendre tous les exemples de code pour des recommandations de mise en œuvre actuelles. Sa valeur durable tient à son raisonnement: se méfier des données externes, réduire les privilèges et l’exposition, utiliser des mécanismes de sécurité éprouvés, mettre les hypothèses à l’épreuve et prévoir la reprise. En ce sens, il s’agit moins d’un catalogue d’API intemporelles que d’une méthode rigoureuse pour rendre les logiciels plus difficiles à détourner et plus faciles à défendre.
Résumé des avis
Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres reçoit des avis mitigés, avec une note moyenne de 4,01/5. Les lecteurs apprécient sa présentation des principes de sécurité et de la modélisation des menaces, mais critiquent l’accent mis sur Windows et la programmation en C. Beaucoup jugent son contenu daté, surtout pour les langages et plateformes modernes. Certains saluent ses exemples concrets et ses pratiques générales de sécurité, tandis que d’autres soulignent son applicabilité limitée en dehors du développement Windows. Le livre est considéré comme un bon point de départ pour découvrir les vulnérabilités de sécurité, même si sa pertinence a diminué depuis sa publication en 2001.
Les lecteurs ont aussi lu
Glossaire
SD3
Trois objectifs de conception de la sécuritéUn modèle de développement qui invite les équipes à intégrer la sécurité à la conception, à livrer le produit avec des paramètres par défaut prudents et à permettre une exploitation sécurisée après le déploiement. Ces trois objectifs portent sur différentes étapes : l’architecture, l’exposition initiale et l’administration continue. Ensemble, ils découragent de traiter la sécurité comme un correctif de dernière minute ou comme une simple vérification du code.
STRIDE
Liste de contrôle des catégories de menacesUn cadre permettant d’examiner six grandes catégories de menaces : l’usurpation d’identité, la modification de données, la répudiation, la divulgation d’informations, le déni de service et l’élévation de privilèges. Les équipes appliquent ces catégories aux processus, aux magasins de données, aux utilisateurs et aux flux de données dans un modèle du système. STRIDE aide à rendre la recherche de menaces systématique, mais ne les classe pas par ordre de priorité et ne les atténue pas à lui seul.
DREAD
Méthode de classement des menacesUne méthode de notation des risques qui prend en compte les dommages potentiels, la reproductibilité, la facilité d’exploitation, le nombre d’utilisateurs concernés et la facilité de découverte d’une menace. Les équipes attribuent des notes et les combinent pour hiérarchiser les investigations et les mesures d’atténuation. Cette méthode est utile pour comparer les problèmes de façon cohérente, mais ses scores reposent sur le jugement et ne doivent pas être confondus avec des probabilités précises.
modèle de menace
Analyse structurée des attaquesUne analyse documentée des composants d’un système, de ses flux de données, de ses frontières de confiance, de ses actifs, des attaques possibles et des défenses. Elle aide une équipe à déterminer quels risques sont les plus importants et à les relier aux choix de conception et aux plans de test. Un modèle de menace doit évoluer au gré des changements du produit, de son environnement de déploiement et de la compréhension des attaques.
frontière de confiance
Séparation entre éléments fiables et non fiablesUn point de l’architecture d’une application où des données ou un contrôle passent entre des composants ayant différents niveaux de confiance. Les données provenant d’un utilisateur, d’un réseau, d’un fichier ou d’un service externe et entrant dans un traitement considéré comme fiable doivent être considérées comme non fiables jusqu’à leur vérification. Rendre ces frontières explicites aide les développeurs à déterminer où se situent les responsabilités de validation et d’autorisation.
quotient relatif de surface d’attaque (Relative Attack Surface Quotient, RASQ)
Décompte pondéré de l’expositionUne mesure comparative créée dans le livre pour estimer l’exposition d’une application en dénombrant les vecteurs d’attaque et en attribuant à chacun un coefficient de gravité. Les exemples incluent les sockets ouverts, les services privilégiés, les autorisations faibles et les fonctionnalités activées. Le RASQ peut aider à comparer différentes versions d’un même produit, mais ne mesure pas la qualité du code et n’établit pas un niveau absolu de sécurité.
API de protection des données (DPAPI)
Protection des données par le système d’exploitationDes fonctions Windows qui chiffrent et authentifient des données afin qu’une application puisse stocker des informations sensibles sans mettre en œuvre son propre système de gestion des clés. La protection peut être associée à un utilisateur ou, avec une option à l’échelle de la machine, à l’ordinateur. La DPAPI rend l’accès non autorisé plus difficile, mais les données stockées nécessitent toujours des contrôles d’accès appropriés et ne sont pas protégées contre du code s’exécutant déjà avec les autorisations de l’utilisateur.
point de contrôle des entrées (input chokepoint)
Point d’entrée à validation contrôléeUn chemin désigné que les données provenant d’une source donnée doivent emprunter avant d’entrer dans la logique applicative considérée comme fiable. La validation à ce point réduit le risque de vérifications incohérentes dispersées dans le code et donne aux personnes chargées de la revue un endroit précis où examiner la manière dont les hypothèses sont établies. Des sources distinctes peuvent nécessiter des points de contrôle séparés, par exemple un pour les entrées réseau et un autre pour les fichiers de configuration.
FAQ
De quoi parle Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres ?
- L’accent sur la sécurité : Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres de Michael Howard met l’accent sur l’importance des pratiques de développement logiciel sécurisé pour prévenir les vulnérabilités.
- Des conseils complets : le livre aborde un large éventail de sujets, notamment les techniques de programmation sécurisée, la modélisation des menaces et les mécanismes de contrôle d’accès.
- Des exemples concrets : il propose des conseils pratiques et des exemples du monde réel, en particulier tirés des initiatives de sécurité de Microsoft, afin d’illustrer des concepts clés.
Pourquoi lire Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres ?
- Approfondir ses connaissances en sécurité : le livre comble les lacunes de la formation traditionnelle en programmation en se concentrant sur les pratiques de programmation sécurisée.
- Des conseils pratiques : il propose des conseils et des techniques applicables directement au développement logiciel dans le monde réel.
- Éviter des erreurs coûteuses : comprendre les principes exposés permet d’éviter les pièges courants qui entraînent des vulnérabilités de sécurité.
Quels sont les principaux enseignements de Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres ?
- La sécurité est la responsabilité de tous : elle doit être une priorité pour tous les membres de l’équipe, et pas seulement pour les personnes occupant des rôles spécialisés.
- Développer la sécurité de façon proactive : le livre préconise une approche proactive, qui comprend la modélisation des menaces et les pratiques de programmation sécurisée.
- Apprendre en continu : la formation et la sensibilisation continues sont essentielles, car le paysage de la sécurité logicielle évolue sans cesse.
Quelles sont les meilleures citations de Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres et que signifient-elles ?
- « La sécurité est une priorité absolue » : cette citation souligne qu’il faut intégrer la sécurité à tous les aspects de la conception et de la mise en œuvre des logiciels.
- « On ne peut pas construire un système sécurisé sans comprendre les menaces » : elle met en évidence l’importance de la modélisation des menaces au cours du cycle de développement logiciel.
- « Ne corrigez pas uniquement les bogues que vous pensez exploitables » : cette citation préconise de traiter toutes les vulnérabilités, quelle que soit leur gravité supposée.
Comment Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres définit-il les tests de sécurité ?
- Un processus de vérification : les tests de sécurité vérifient qu’une application peut résister aux attaques et que ses mécanismes de sécurité fonctionnent correctement.
- L’accent sur les vulnérabilités : contrairement aux tests fonctionnels, ils visent à démontrer que les vulnérabilités ne peuvent pas être exploitées.
- Des techniques et des méthodes : le livre présente diverses techniques, dont la modélisation des menaces et la modification des données, pour réaliser des tests de sécurité efficaces.
Qu’est-ce que la modélisation des menaces dans Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres et pourquoi est-elle importante ?
- Une analyse structurée de la sécurité : la modélisation des menaces aide à repérer les menaces potentielles en analysant l’architecture d’une application et ses flux de données.
- Hiérarchiser les risques : elle permet aux développeurs de classer les risques de sécurité par ordre de priorité et de déterminer quelles menaces doivent être atténuées.
- Améliorer la compréhension : ce processus approfondit la compréhension de l’application par l’équipe, ce qui favorise de meilleures décisions de conception et réduit les défauts de sécurité.
Quelles sont les vulnérabilités de sécurité courantes abordées dans Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres ?
- Les dépassements de tampon : ils se produisent lorsque des données dépassent la taille du tampon alloué, ce qui peut entraîner l’exécution de code arbitraire.
- L’injection SQL : le livre explique comment des attaquants peuvent manipuler des requêtes SQL en y injectant des données malveillantes.
- Les scripts intersites (XSS) : il explique comment des attaques XSS peuvent se produire lorsque les entrées des utilisateurs ne sont pas correctement assainies.
Comment Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres recommande-t-il de prévenir les injections SQL ?
- Utiliser des requêtes paramétrées : le livre recommande vivement d’utiliser des requêtes paramétrées plutôt que la concaténation de chaînes pour construire des instructions SQL.
- Valider les entrées des utilisateurs : il insiste sur l’importance de valider et d’assainir les données fournies par les utilisateurs avant de les traiter.
- Limiter les autorisations de la base de données : limiter les autorisations des comptes applicatifs de la base de données réduit les conséquences potentielles d’une injection SQL réussie.
Quelle est l’importance de la canonicalisation en matière de sécurité selon Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres ?
- Comprendre la canonicalisation : la canonicalisation consiste à convertir les données dans un format standard afin de prévenir les vulnérabilités de sécurité.
- Éviter les ambiguïtés : une canonicalisation inadéquate peut entraîner des comportements inattendus et des vulnérabilités, telles que des attaques par traversée de répertoires.
- Validation stricte : le livre recommande de mettre en œuvre des processus stricts de validation et de normalisation pour garantir que les données sont interprétées de manière cohérente et sûre.
Comment Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres traite-t-il des scripts intersites (XSS) ?
- Assainissement des entrées : le livre insiste sur la nécessité d’assainir soigneusement les entrées pour prévenir les attaques XSS.
- Encodage des sorties : il recommande d’encoder les données en sortie pour empêcher l’exécution de scripts malveillants.
- Tests de sécurité : il encourage la réalisation régulière de tests de sécurité afin de repérer et de corriger les vulnérabilités XSS.
Comment Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres recommande-t-il de traiter les données sensibles ?
- Utiliser le chiffrement : le livre recommande de chiffrer les données sensibles au repos comme en transit afin de les protéger contre les accès non autorisés.
- Limiter l’exposition des données : les développeurs doivent réduire au minimum la quantité de données sensibles stockées et partagées.
- Mettre en place des contrôles d’accès : des contrôles d’accès appropriés doivent être appliqués pour limiter les personnes autorisées à consulter ou à modifier les données sensibles.
Comment appliquer les principes de Écrire Du Code Sécurisé ; Techniques Et Stratégies Pour Écrire Des Applications Sûres à mon processus de développement ?
- Intégrer la sécurité au cycle de développement logiciel : faire de la sécurité un élément fondamental du cycle de développement logiciel.
- Organiser régulièrement des formations à la sécurité : veiller à ce que tous les membres de l’équipe connaissent les meilleures pratiques de sécurité et les vulnérabilités courantes.
- Mettre en œuvre des tests rigoureux : adopter des méthodes de test complètes, notamment les tests de sécurité et la modélisation des menaces, afin de repérer et de traiter les vulnérabilités.
Télécharger le PDF
Télécharger l'EPUB
.epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.