Éliminer les bugs avant la mise en prod : vers une approche préventive de la sécurité informatique

La sécurité des logiciels commence avant même que le codage ne démarre. La modélisation des menaces, des paramètres par défaut plus sûrs, la gestion rigoureuse des dépendances et la mise en place de garde-fous dans le flux de travail des développeurs peuvent contribuer à prévenir les vulnérabilités.

Par

  • 11 min

stopping-bugs-before-they-ship-the-shift-to-preventative-security

Les points clés à retenir sur la sécurité du code à l'heure de l'IA

  • La sécurité des logiciels doit être prise en compte avant même le codage.
  • La modélisation des menaces aide les équipes de cybersécurité à détecter rapidement les hypothèses risquées.
  • Une bonne gestion des dépendances permet d'éviter les risques cachés liés à la chaîne d'approvisionnement.

Les logiciels ont un cycle de vie. De l'étincelle d'une idée au codage, en passant par les tests, le déploiement, l'utilisation par les clients et, finalement, la révision ou le retrait, chaque ligne, chaque module et chaque composant s'ancrent davantage, se solidifient au sein de la solution globale et deviennent donc beaucoup plus difficiles à corriger si des problèmes surviennent par la suite.

Pourtant, nous corrigeons souvent les logiciels en nous basant uniquement sur leur utilisation à un stade avancé.

Dans cet article, nous aborderons des stratégies proactives visant à empêcher les failles d'atteindre la production avant le déploiement.

Sécurisé à la source et sécurisé dès la conception

Deux termes sont essentiels à cette approche :

  • « Secure-at-the-source » (sécurisé à la source)
  • « Secure-by-design » (sécurisé dès la conception)

Ces deux termes font référence au processus consistant à intégrer la sécurité et la fiabilité dans le code dès les premières étapes du cycle de vie du logiciel. Nous nous concentrerons sur la manière dont la sécurité peut être intégrée à toutes les phases, depuis les exigences et la conception jusqu’au codage, en passant par la sélection des dépendances, les pipelines de build, le déploiement et la maintenance.

Cette approche nécessite un changement de mentalité tout au long du cycle de vie. Auparavant, nous aurions peut-être demandé : « En combien de temps pouvons-nous trouver et corriger ce qui ne va pas ? » C’est toujours une question valable. Mais nous cherchons à poser une autre question bien plus tôt : « Où les risques s’introduisent-ils dans notre processus de développement, et que pouvons-nous modifier dans nos conceptions, nos outils, nos modèles, nos dépendances et nos revues pour qu’un plus petit nombre d’entre eux atteigne le code dès le départ ? »

La prévention commence avant le code

Le codage commence toujours par une vision du résultat souhaité. Ce processus déclenche une phase de conception, au cours de laquelle les concepteurs et les codeurs (parfois la même personne ou les mêmes personnes) déterminent comment aborder le processus de codage.

C'est là, avant même que la première ligne de code ne soit écrite, que les vulnérabilités commencent à se manifester.

Cette situation survient parce que les décisions de conception ont un impact sur la mise en œuvre.

Les 6 critères à prendre en compte

Lors de l’élaboration de la conception, examinez attentivement les facteurs suivants :

  • Limites de confiance : des limites mal définies entre les utilisateurs, les services, les réseaux ou les systèmes peuvent signifier qu’une zone compromise affecte des parties de l’application qui auraient dû être isolées.
  • Identité : Si le système ne sait pas de manière fiable qui ou quoi effectue une requête, chaque décision de sécurité en aval devient discutable.
  • Autorisation : Si l'architecture n'applique pas de manière cohérente ce que chaque utilisateur ou service est autorisé à faire, les attaquants peuvent accéder à des actions ou à des données auxquelles ils ne devraient pas avoir accès.
  • Exposition des données : Si des données sensibles transitent par un trop grand nombre de systèmes, de journaux, d'API ou de composants côté client, elles sont plus susceptibles de faire l'objet de fuites ou d'être utilisées à mauvais escient.
  • Journalisation : Si la journalisation fait défaut, est excessive ou mal conçue, les équipes risquent soit de passer à côté d'attaques, soit de stocker accidentellement des informations sensibles là où elles n'ont pas leur place.
  • Modes de défaillance : Si le système tombe en panne alors que les données sont accessibles, divulgue des informations lors d'erreurs ou se comporte de manière imprévisible en situation de stress, les pannes et les attaques peuvent se transformer en incidents de sécurité.

Nous avons tous entendu l'expression « Qu'est-ce qui pourrait bien mal tourner ? ». Elle est généralement prononcée après qu'un plan audacieux et potentiellement imprudent a été proposé.

Réfléchir dès le début aux décisions de conception

Mais si vous inversez cette phrase et posez la question « Qu'est-ce qui pourrait bien mal tourner ? » avec une intention sérieuse, vous pouvez commencer à modéliser les menaces pesant sur votre logiciel. Voici d'autres questions que vous pouvez vous poser avant de vous engager dans une conception : Qui utilisera ce système ? Quelles données traitera-t-il ? À quels services fera-t-il confiance ? Quels comportements malveillants un attaquant pourrait-il tenter ? Que se passerait-il si une partie tombait en panne ou était compromise ?

Réfléchir dès le début aux décisions de conception, en gardant à l’esprit les menaces et les questions de sécurité, peut vous aider à repérer rapidement les hypothèses risquées, tant que la conception est encore flexible. Votre équipe pourra alors faire des choix plus sûrs avant que ces choix ne se transforment en code coûteux, en dépendances de production ou en faiblesses visibles par les clients.

Avant de commencer à coder, réfléchissez à ce que signifie « suffisamment sûr ». Planifier à l'avance les considérations de sécurité implique d'intégrer dès le départ dans votre conception l'authentification, l'autorisation, le chiffrement, l'auditabilité, la conservation des données, les cas d'abus et le comportement de récupération.

Secure by design pour la Cisa

La CISA (Cybersecurity and Infrastructure Security Agency) est la principale agence américaine de cyberdéfense. La CISA promeut une stratégie « Secure by Design », dans laquelle les fournisseurs intègrent la cybersécurité dès la conception et la fabrication des produits technologiques.

Selon la CISA, « les produits conçus selon les principes du Secure by Design accordent la priorité à la sécurité des clients en tant qu'exigence commerciale fondamentale, plutôt que de la traiter simplement comme une fonctionnalité technique ».

Si cette approche vous intéresse (et elle devrait vraiment vous intéresser), je vous recommande de lire le document détaillé de la CISA sur cette stratégie.

La prévention se poursuit au sein du flux de travail des développeurs

Je me souviens du jour, il y a plusieurs décennies, où les éditeurs se sont transformés en environnements de développement interactifs (IDE) et sont devenus de véritables aides. La fonctionnalité phare était le débogueur symbolique, qui permettait de tracer les flux de code, d’inspecter les variables et d’installer des points d’arrêt. Les IDE ont instantanément amélioré la qualité de mon code, car je pouvais surveiller chaque variable en continu et voir ce qui changeait et à quel moment.

Depuis lors, les IDE n’ont cessé de s’améliorer. À un moment donné, les développeurs ont ajouté des fonctionnalités permettant de surveiller votre code au fur et à mesure que vous l’écriviez, en signalant les erreurs dès la saisie. Pour ceux d’entre vous qui ne sont pas programmeurs, cette fonctionnalité est comparable au correcteur orthographique de votre traitement de texte qui affiche ces lignes ondulées sous les mots, mais pour des sections entières de code.

Malgré l’engouement autour du « vibe coding », les humains continueront d’écrire du code. Peut-être pas tout, et peut-être pas tous les codeurs, mais il y aura toujours des développeurs expérimentés qui créent du code ligne par ligne. Pour ces développeurs, la sécurité à la source signifie que l’IDE doit être capable de signaler les problèmes de sécurité autant que les problèmes de syntaxe, pendant la rédaction du code.

Le mauvais exemple d'Amazon

Parmi les autres ajouts « secure-at-the-source » au workflow des développeurs, on trouve les vérifications des pull requests avant la fusion, les alertes de dépendances dans les dépôts, la détection des secrets avant que les commits ne se transforment en incidents, les tests automatisés dans les pipelines CI/CD, des conseils plus sûrs sur les paquets lors du choix des bibliothèques, le suivi des problèmes qui relie les découvertes au travail réel, et les vérifications de déploiement qui empêchent les modifications risquées d’atteindre la production sans être remarquées.

Cette année encore, Amazon (une entreprise qui devrait pourtant mieux savoir) a déployé une modification de code qui a empêché les clients de passer commande, de consulter les produits et d’accéder à leurs comptes. Même si certains d’entre nous préféreraient que cela arrive plus souvent pour nous empêcher d’envoyer tout notre argent à Bezos, le fait est qu’une simple erreur de déploiement a coûté des millions à Amazon. Cette coûteuse bourde illustre le prix à payer lorsqu’on ne détecte pas les erreurs et les vulnérabilités avant la mise en production.

À un moment donné du processus de déploiement, Amazon n'a pas mis en œuvre de mesures de sécurité préventives. Ses garde-fous (en supposant qu'il en ait eu) n'ont pas fonctionné.

S’appuyer dès le départ sur des modèles de codage sécurisés établis

Dans le cadre du processus de développement, les programmeurs et les équipes de programmation peuvent contribuer à sécuriser leurs livrables en s’appuyant dès le départ sur des modèles de codage sécurisés établis. L’utilisation de frameworks approuvés, de bibliothèques d’authentification et d’autorisation réutilisables, de paramètres par défaut sûrs, de modèles sécurisés et de services de plateforme fournit une base standardisée pour le code, grâce à laquelle les développeurs n’ont pas à choisir des modèles d’implémentation pour chaque module.

Le National Institute of Standards and Technology (NIST), une agence fédérale américaine, a proposé un framework visant à « atténuer le risque de vulnérabilités logicielles ». La norme NIST SP 800-218 propose des bonnes pratiques pour le cycle de vie du développement logiciel qui permettent de réduire les vulnérabilités.

Voici quelques-unes de ces pratiques :

  • Préparer l'organisation : définir les rôles, les normes, les formations et les workflows sécurisés.
  • Définir les exigences de sécurité : expliciter les attentes en matière de sécurité avant le développement.
  • Utiliser des paramètres par défaut sécurisés : réduire les choix risqués que les développeurs doivent effectuer manuellement.
  • Sécuriser les environnements de développement : protéger les outils, les référentiels, les pipelines et les identifiants.
  • Réviser le code source : détecter rapidement les faiblesses de conception et de mise en œuvre.
  • Tester le code exécutable : recourir aux tests dynamiques, au fuzzing et aux vérifications en exécution.
  • Protéger l'intégrité des logiciels : Vérifier les artefacts, la provenance et l'authenticité des versions.
  • Analyser les vulnérabilités : Comprendre les causes profondes, et pas seulement les bugs individuels.Les directives du NIST recommandent également de suivre, d'évaluer et de mettre à jour les dépendances. Nous aborderons ce sujet en détail dans la section suivante.

Gérer les risques liés à la chaîne d'approvisionnement des logiciels

Au cours des dernières années, nous avons tous pris conscience de ce qui se passe lorsqu'une chaîne d'approvisionnement est interrompue.

Le développement logiciel possède une chaîne d'approvisionnement, et son terme technique, ce sont les « dépendances ». Personne n'écrit tout le code d'un produit ou d'un service. Au contraire, la majeure partie de ce qui se passe est constituée de composants logiciels écrits par d'autres entreprises ou par des développeurs open source. Ces composants sont eux-mêmes souvent composés d'autres composants, des modules qui effectuent presque tout ce qui se passe en arrière-plan.

Le problème est que ces composants, sous la forme de bibliothèques open source, de conteneurs, d’API, d’outils de compilation, de composants SaaS et de code généré par l'IA, peuvent tous introduire des vulnérabilités et des failles dans la solution finale.

Mettre fortement l'accent sur l'hygiène des dépendances

Parfois, des acteurs malveillants soumettent des modifications aux outils open source que les développeurs principaux ne repèrent pas. D’autres fois, de simples erreurs de codage peuvent entraîner des vulnérabilités. Le fait est que ces dépendances sont des boîtes noires pour la plupart des développeurs. Pire encore, ce sont des cibles mouvantes. À mesure qu’elles sont mises à jour, ces mises à jour sont intégrées au logiciel de production. Cette étape signifie qu’une dépendance qui était autrefois parfaitement sûre peut être compromise lors d’une mise à jour ultérieure.

Pensez-y de cette façon. Même si votre code comporte des vulnérabilités, à moins qu’il ne soit largement utilisé, il faudra peut-être un certain temps aux acteurs malveillants pour les découvrir. Mais qu’en est-il de ces dépendances ? Ces vulnérabilités sont largement connues, souvent vendues sur des marchés illicites. Le moyen le plus simple pour votre logiciel de devenir vulnérable est de s’appuyer sur des logiciels vulnérables.

Toutes ces interactions impliquent qu'il faut mettre fortement l'accent sur l'hygiène des dépendances. Dans le cadre de votre processus d'intégration et de validation, veillez à choisir des paquets dont la maintenance est vérifiable, à verrouiller les versions connues, à examiner les dépendances transitives, à surveiller les vulnérabilités connues et à éviter les bibliothèques présentant une maintenance insuffisante, des changements de propriété suspects ou des signaux de sécurité médiocres.

Si cela implique de remplacer des dépendances ou de choisir d’autres fournisseurs, les avantages l’emportent largement sur les coûts liés au changement de chaîne d’approvisionnement.

Réduire la sécurité réactive

Réagir à une urgence de sécurité ou logicielle est pénible. Vous pouvez sentir votre pouls s'emballer lorsque, après deux gorgées de votre première tasse de café, un e-mail ou une notification vous informe que tout vient de partir en vrille. C'est encore pire lorsque ce problème survient au milieu de la nuit.

Concevoir et livrer des logiciels conçus pour être sécurisés peut réduire ces pics de stress. Cette approche peut également réduire la responsabilité globale de votre organisation, limiter la mauvaise presse et renforcer la confiance des clients.

Mettre en œuvre une modification de conception avant la mise en production sera sans aucun doute moins coûteux et moins pénible que les incidents de production, les notifications aux clients, les correctifs urgents ou les solutions de contournement par des contrôles compensatoires.

Ce changement est un changement culturel. La sécurité à la source fait de la qualité du développement une pratique fondamentale de la conception et du codage. La sécurité doit faire partie intégrante de la manière dont les logiciels sont écrits. N'attendez pas que tout soit codé et compilé pour découvrir ce qui doit être recodé et recompilé. Et surtout, si possible, n'attendez pas que des clients en colère vous hurlent dessus (demandez-moi comment je le sais) lorsque quelque chose sur lequel ils comptent tombe en panne de manière catastrophique.

Votre estomac (ou plutôt votre absence d’estomac) vous en remerciera.

Source : "ZDNet.com"

Connexion

Vous n’avez pas encore de compte ?

AUTOUR DE ZDNET
  • Gestion des cookies
SERVICES
À PROPOS
Accessibilité : non conforme