Explorer l’analyse de la composition des logiciels

10 minutes

L’analyse de composition logicielle (SCA) est un processus automatisé permettant d’identifier les composants open source et tiers dans les applications, en analysant leurs vulnérabilités de sécurité, leur conformité aux licences et la qualité du code. Étant donné que les applications modernes s’appuient de plus en plus sur les dépendances externes, l’autorité de certification est devenue essentielle pour gérer les risques associés aux chaînes d’approvisionnement logicielles.

Qu’est-ce que l’analyse de composition logicielle ?

L’analyse de composition logicielle est la pratique de la découverte, du catalogage et de l’analyse automatique de tous les composants open source et tiers utilisés dans une application. Les outils SCA examinent les manifestes de package, les fichiers de verrouillage de dépendance, le code source et les fichiers binaires compilés pour créer une facture logicielle complète de matériaux (SBOM).

Fonctionnalités SCA de base

Découverte des dépendances :

Analyse du manifeste : Les outils SCA lisent les fichiers manifeste de package (package.json, requirements.txt, pom.xml, *.csproj) pour identifier les dépendances déclarées.
Analyse des fichiers de verrouillage : Analysez les fichiers de verrouillage (package-lock.json, Pipfile.lock, Gemfile.lock) montrant les versions installées exactes y compris les dépendances transitives.
Analyse binaire : Les outils avancés analysent les artefacts compilés, les images conteneur et les applications déployées pour découvrir les dépendances incorporées non déclarées dans les manifestes.
Prise en charge multilingue : Les outils complets prennent en charge des dizaines de langages de programmation et d’écosystèmes de package (npm, PyPI, Maven, NuGet, RubyGems, Go modules).

Analyse des vulnérabilités :

Correspondance CVE : comparez les dépendances découvertes par rapport aux bases de données CVE (Common Vulnerabilities and Exposures).
Évaluation de la gravité : Calculez les scores du système CVSS (Common Vulnerability Scoring System) indiquant la sévérité des vulnérabilités de 0 (pas de gravité) à 10 (critique).
Exploit Intelligence : Identifiez les vulnérabilités qui ont des exploits connus exploités activement par des attaquants.
Recommandations sur les correctifs : Suggérer des mises à niveau de version spécifiques qui résolvent les vulnérabilités tout en conservant la compatibilité.

Conformité des licences :

Détection de licence : Identifiez les licences pour toutes les dépendances en analysant les fichiers de licence, les métadonnées de package et les en-têtes de code source.
Mise en application des politiques : Marquer automatiquement les dépendances en violation des politiques de licence de l'organisation.
Analyse de compatibilité : Détectez les licences en conflit qui ne peuvent pas être combinées légalement dans la même application.
Suivi des obligations : Documentez les exigences de licence telles que les avis d’attribution, la divulgation de code source ou les restrictions de travail dérivées.

Évaluation de la qualité :

État de maintenance : Déterminez si les dépendances sont activement conservées ou abandonnées.
Santé communautaire : Évaluer l’activité des contributeurs, la taille de la communauté et la durabilité des projets.
Pratiques de sécurité : Vérifiez que les projets ont des processus de divulgation responsable et des avis de sécurité.
Recommandations de mise à jour : Identifiez les dépendances obsolètes et suggèrez des alternatives plus sûres et plus actuelles.

Pourquoi SCA est critique pour DevOps

Les pratiques de développement de logiciels modernes rendent SCA indispensable :

L’explosion de dépendance

Les applications contiennent des centaines de dépendances :

Dépendances directes : L’application classique référence directement de 20 à 50 paquets externes.
Dépendances transitives : Chaque dépendance directe apporte ses propres dépendances, créant des arborescences de dépendances avec 200 à 500 packages totaux.
Plusieurs écosystèmes : Les applications combinent souvent des dépendances à partir de plusieurs écosystèmes de langage (serveur frontal JavaScript, back-end Python, microservices Java).
Dépendances de conteneur : Les applications conteneurisées incluent les dépendances d’image de base et les dépendances d’application.

Le suivi manuel est impossible :

Échelle: Il est impratique de suivre manuellement des centaines de dépendances dans des dizaines d’applications.
Vitesse: De nouvelles vulnérabilités sont divulguées quotidiennement, ce qui rend tout inventaire manuel immédiatement obsolète.
Complexité: Comprendre les chaînes de dépendances transitives et leurs interactions nécessite une analyse automatisée.
Propriété distribuée : Dépendances conservées par des milliers de projets open source indépendants dans le monde entier.

Impératif de sécurité

Les vulnérabilités dans les dépendances sont activement exploitées :

Violations de profil élevé : Les principaux incidents de sécurité impliquent régulièrement l’exploitation des vulnérabilités connues dans les packages open source populaires.
Attaques de chaîne d’approvisionnement : Les attaquants compromissent les packages légitimes pour distribuer des programmes malveillants aux consommateurs en aval.
Vulnérabilités zéro jour : Les vulnérabilités précédemment inconnues dans les packages largement utilisés peuvent affecter des milliers d’organisations simultanément.
Urgence des correctifs : Les vulnérabilités critiques nécessitent une identification et une correction rapides sur toutes les applications affectées.

Les outils de sécurité traditionnels manquent les vulnérabilités de dépendance :

Analyse statique : Les outils d’analyse du code source analysent votre code, mais pas le code de dépendance.
Tests dynamiques : Les tests d’intrusion peuvent manquer des vulnérabilités dans les dépendances non déclenchées pendant les tests.
Révision manuelle : Les équipes de sécurité ne peuvent pas examiner le code source de centaines de packages tiers.
Détection spécialisée : Les outils SCA spécifiquement conçus pour identifier les vulnérabilités des dépendances sont nécessaires.

Exigence de conformité

Les violations de licence présentent des risques importants :

Responsabilité légale : L’utilisation de dépendances sans se conformer aux termes du contrat de licence peut entraîner des poursuites et des dommages-intérêts.
Open sourcing forcé : des licences copyleft fortes (PG, AGPL) peuvent nécessiter l’approvisionnement complet d’applications entières.
Restrictions de distribution : Certaines licences interdisent la distribution commerciale ou imposent des limitations d’utilisation.
Exigences d’audit : Les cadres réglementaires exigent de plus en plus que les organisations maintiennent une facture de matériel logicielle précise.

Complexité des licences :

Centaines de types de licences : L’écosystème open source comprend des centaines de licences distinctes avec des obligations variables.
Problèmes de compatibilité : Différentes licences ont des termes contradictoires qui interdisent leur utilisation ensemble.
Licence transitive : Les obligations de licence des dépendances transitives doivent être suivies et satisfaites.
Modifications de licence : Les projets modifient parfois les licences entre les versions, nécessitant une surveillance continue.

Fonctionnement des outils SCA

Les outils SCA utilisent plusieurs techniques pour découvrir et analyser les dépendances :

Mécanismes de découverte

Analyse des fichiers manifestes :

Formats spécifiques à la langue : Les outils comprennent les formats de manifeste de package pour chaque langage (package.json pour npm, requirements.txt pour Python, pom.xml pour Maven).
Résolution des dépendances : Analysez les spécifications de version des dépendances, notamment les plages, les contraintes et les règles de résolution.
Analyse de l’espace de travail : Analysez de manière récursive les répertoires de projet pour rechercher tous les fichiers manifestes dans les espaces de travail monorepos et multi-projets.
Prise en charge de la configuration : Considérez séparément les dépendances spécifiques à l’environnement (développement, test, production).

Analyse des fichiers de verrouillage de dépendance :

Versions exactes : Les fichiers de verrouillage enregistrent des versions précises de toutes les dépendances, y compris les dépendances transitives.
État d’installation : Représentez les dépendances installées réelles plutôt que les exigences abstraites.
Résolution déterministe : Les fichiers de verrouillage garantissent des versions de dépendance cohérentes entre les environnements.
Graphiques de dépendance complets : Incluez l’arborescence de dépendances transitive complète avec les résolutions de version.

Analyse binaire et d’artefact :

Artefacts compilés : Analysez les fichiers JAR, les fichiers roues, les DLL et les exécutables pour identifier les dépendances incorporées.
Couches d’images conteneur : Analysez les couches d’images conteneur pour découvrir les composants d’image de base et les dépendances d’application.
Analyse du système de fichiers : Examinez les systèmes de fichiers d’application déployés pour rechercher les dépendances non déclarées dans les manifestes.
Empreintes digitales: Utilisez le hachage de chiffrement pour identifier des versions de package spécifiques, même sans métadonnées.

Intégration de build :

Plug-ins d’outil de génération : Intégrer à des systèmes de build (Maven, Gradle, webpack, pip) pour capturer les informations de dépendance pendant les builds.
Crochets de résolution : Connectez-vous aux processus de résolution des dépendances pour enregistrer les versions exactes installées.
Génération d’artefacts : générer une facture logicielle d’artefacts de matériaux (SBOM) pendant les builds pour la consommation en aval.
Intégration du pipeline : Exécutez les étapes automatisées dans les pipelines CI/CD pour analyser chaque build.

Fonctionnalités d’analyse

Correspondance des vulnérabilités :

Interrogation de bases de données : Interrogez la base de données de vulnérabilité nationale (NVD), gitHub Advisory Database et les bases de données de vulnérabilité propriétaires.
Correspondance de la plage de versions : Déterminez si des versions de package spécifiques se trouvent dans des plages de versions vulnérables.
Validation des correctifs : Vérifiez si les correctifs appliqués résolvent réellement les vulnérabilités signalées.
Hiérarchisation : Classer les vulnérabilités par gravité, exploitabilité et impact sur l’entreprise.

Identification de licence :

Plusieurs sources : Extrayez les informations de licence des métadonnées du package, des fichiers de licence, des en-têtes de source et des fichiers README.
Normalisation des licences : Mappez différents noms et identificateurs de licence (SPDX, OSI) aux types de licence standardisés.
Double licence : Gérer les packages publiés sous plusieurs licences alternatives.
Licences personnalisées : Identifiez les licences non standard nécessitant une révision légale.

Analyse de la portée :

Construction du graphe d’appel : Générer des graphiques d’appels montrant le code de dépendance qui est réellement exécuté par votre application.
Détection de code mort : Identifiez les dépendances regroupées, mais jamais réellement utilisées.
Analyse du chemin d’accès d’exploitation : Déterminez si les chemins de code vulnérables sont accessibles à partir de points d’entrée d’application.
Affinement des risques : Réduisez le bruit en mettant l’accent sur les vulnérabilités exploitables dans le code réellement utilisé.

Surveillance continue :

Alertes en temps réel : Recevez des notifications immédiates lorsque de nouvelles vulnérabilités affectant vos dépendances sont divulguées.
Analyse planifiée : Réanalysez régulièrement les applications pour détecter les vulnérabilités nouvellement découvertes dans les dépendances inchangées.
Comparaison de référence : Suivez les modifications apportées à l’état de vulnérabilité et de conformité au fil du temps.
Prévention de régression : Alerte quand de nouvelles dépendances introduisent des vulnérabilités ou des violations de licence.

Modèles d’intégration SCA

L’implémentation efficace de la SCA implique l’intégration à plusieurs points du cycle de vie du développement :

Station de travail développeur

Intégration de l’IDE :

Commentaires en temps réel : Analysez les dépendances à mesure que les développeurs les ajoutent à des projets.
Avertissements inline : Affichez les avertissements de vulnérabilité et de licence directement dans l’IDE.
Suggestions de correction : Suggérer d’autres versions de package ou des packages de remplacement.
Application de la stratégie : Empêchez l’ajout de dépendances qui violent les stratégies organisationnelles.

Validation avant engagement :

Crochets Git : Exécutez des vérifications SCA avant les validations pour empêcher l’introduction de dépendances vulnérables.
Analyse locale : Analysez les modifications localement avant de les pousser vers des dépôts distants.
Commentaires rapides : Fournissez des commentaires immédiats aux développeurs pendant le développement actif.
Détection anticipée : Interceptez les problèmes avant d’atteindre les branches partagées et les pipelines CI/CD.

Gestion des sources

Validation des demandes de tirage :

Vérifications automatisées : Exécutez l’analyse SCA sur toutes les pull requests pour détecter les changements de dépendances.
Passer en revue les commentaires : Publiez les résultats sous forme de commentaires de pull request pour permettre au réviseur de les voir.
Blocage de fusion : Empêchez la fusion des demandes de fusion qui introduisent des vulnérabilités critiques ou des violations de licence.
Suivi des modifications de dépendances : Documentez clairement les modifications de dépendances que chaque pull request introduit.

Intégration de GitHub Dependabot :

Mises à jour automatisées : Créez automatiquement des pull requests lorsque les mises à jour de sécurité des dépendances sont disponibles.
Alertes de vulnérabilité : Recevez des alertes de sécurité GitHub pour les dépendances vulnérables.
Graphique des dépendances : Visualisez les relations de dépendance dans la fonctionnalité de graphique de dépendances de GitHub.
Passez en revue les flux de travail : Tirez parti des processus de révision et d’approbation de GitHub pour les mises à jour des dépendances.

Pipelines CI/CD

Analyse au moment de la compilation :

Étapes du pipeline : Ajoutez l’analyse SCA en tant que étapes de génération automatisées dans les pipelines CI/CD.
Portes de qualité : les builds échouent qui ne répondent pas aux exigences de sécurité et de conformité.
Génération de SBOM : créez une facture logicielle d’artefacts de matériaux en même temps que les sorties de build.
Pistes d’audit : Enregistrez les résultats des scans à des fins de conformité et de criminalistique.

Portes de déploiement :

Validation de prédéploiement : Analysez les artefacts avant de les déployer dans des environnements de production.
Stratégies spécifiques à l’environnement : Appliquez des stratégies plus strictes pour les déploiements de production que les déploiements de développement.
Déclencheurs de restauration : Restaurez automatiquement les déploiements découverts qui contiennent des vulnérabilités critiques.
Approbations de déploiement : Exiger une approbation manuelle pour les déploiements avec des risques connus mais acceptés.

Supervision du runtime

Analyse de production :

Analyse de l’application déployée : Analysez réellement les applications déployées pour détecter les dépendances d’exécution.
Analyse du registre de conteneurs : Analysez en continu les images conteneur stockées dans les registres.
Analyse des fonctions serverless : Analysez les fonctions serverless déployées et leurs dépendances.
Détection de dérive : Identifiez les différences entre les dépendances déployées prévues et réelles.

Surveillance continue des vulnérabilités :

Surveillance continue : Surveillez les applications déployées pour les vulnérabilités nouvellement divulguées affectant les dépendances actuelles.
Réponse aux incidents : Déclenchez des flux de travail de réponse aux incidents lorsque des vulnérabilités critiques sont découvertes en production.
Planification des correctifs : Générez des plans de déploiement de correctifs pour résoudre les vulnérabilités dans les applications déployées.
Conformité du contrat SLA : Suivez les délais de correction pour garantir la conformité aux contrats SLA de sécurité.

Bonnes pratiques relatives au flux de travail SCA

L’implémentation SCA réussie suit les flux de travail éprouvés :

Établir une base de référence

Inventaire initial :

Découverte complète : Exécutez des outils SCA sur toutes les applications pour créer un inventaire complet des dépendances.
Évaluation du risque: Comprendre l’exposition actuelle aux vulnérabilités et aux problèmes de conformité des licences.
Hiérarchisation : Identifiez les applications et vulnérabilités qui nécessitent une attention immédiate.
Documentation de référence : Documentez l’état actuel en tant que base de référence pour mesurer l’amélioration.

Définir des stratégies

Stratégies de sécurité :

Seuils de gravité des vulnérabilités : Définissez les niveaux de gravité acceptables (par exemple, aucun niveau critique, élevé limité).
Délais de correction : établissez des contrats SLA pour corriger différentes gravités de vulnérabilité (critiques dans les 7 jours, élevés dans les 30 jours).
Processus d’exception : Créez des flux de travail pour accepter les risques lorsque la correction immédiate n’est pas réalisable.
Suivi des exemptions : Maintenir la piste d’audit des risques acceptés avec des justifications métier.

Stratégies de conformité :

Listes d’autorisation de licence : Spécifiez les licences toujours acceptables (MIT, Apache 2.0, BSD).
Listes de refus de licence : Interdire les licences spécifiques incompatibles avec le modèle métier (PG pour les logiciels propriétaires).
Flux de travail d’approbation : Exiger une révision légale des dépendances avec certaines licences (LGPL, MPL, licences personnalisées).
Exigences d’attribution : Définissez la façon dont les attributions de licence doivent être fournies dans des logiciels distribués.

Automatiser l’application

Intégration du pipeline :

Analyse automatisée : Exécutez les vérifications SCA automatiquement à chaque build et pull request.
Portes de qualité : Configurez des portes de pipeline qui bloquent les builds ou les déploiements qui ne respectent pas les stratégies.
Correction automatisée : Utilisez des outils tels que GitHub Dependabot pour créer automatiquement des pull requests pour les mises à jour de sécurité.
Rapports: Générez des rapports de conformité pour la visibilité de l’audit et de la gestion.

Amélioration continue

Suivi des métriques :

Temps moyen de correction (MTTR) : Mesurez la rapidité avec laquelle les vulnérabilités sont corrigées après la découverte.
Réduction des vulnérabilités : Suivez le nombre de vulnérabilités décroissants au fil du temps.
Taux de conformité : Surveillez le pourcentage de dépendances qui répondent aux stratégies de licence.
Couverture: Vérifiez que les outils SCA analysent toutes les applications et toutes les dépendances.

Affinement du processus :

Gestion des faux positifs : Paramétrez les outils pour réduire les faux positifs par le biais de la configuration et des exceptions.
Formation pour les développeurs : Informez les développeurs sur la sélection et la gestion des dépendances sécurisées.
Évolution de la stratégie : Mettez à jour les stratégies en fonction des menaces émergentes et des exigences métier.
Évaluation de l’outil : Évaluez régulièrement de nouveaux outils et fonctionnalités SCA.

L’analyse de la composition logicielle fournit les fonctionnalités automatisées essentielles à la gestion des risques de sécurité et de conformité dans les applications modernes qui dépendent fortement des composants open source. L’unité suivante explore comment implémenter GitHub Dependabot, un outil SCA spécifique intégré à GitHub.

Commentaires

Cette page a-t-elle été utile ?