Les attaquants de la chaîne d'approvisionnement font évoluer leurs tactiques, se concentrant sur le vol d'accès plutôt que sur la simple injection de code malveillant. Les campagnes récentes ciblant les gestionnaires de paquets et les registres de conteneurs démontrent un schéma clair : la récolte d'identifiants à partir des environnements de développement et des pipelines CI/CD. Cela inclut les clés d'API, les identifiants cloud, les clés SSH et les jetons. Ce changement exige une nouvelle perspective sur la sécurité de la chaîne d'approvisionnement logicielle. ### Au-delà des mesures de sécurité traditionnelles Traditionnellement, les efforts de sécurité se concentraient sur les systèmes partagés tels que les dépôts de code source, les plateformes CI/CD et les gestionnaires de paquets. Bien que ces domaines restent critiques, une approche plus globale est nécessaire. La livraison de logiciels moderne commence au poste de travail du développeur, où le code est écrit, les dépendances sont installées et les identifiants sont testés. Ces postes de travail font partie intégrante de la chaîne d'approvisionnement logicielle et ne doivent pas être traités comme de simples terminaux. ### Attaques de la chaîne d'approvisionnement : opérations de récolte d'identifiants Des incidents récents, notamment les campagnes **TeamPCP** et **Shai-Hulud**, soulignent la convergence des attaques de la chaîne d'approvisionnement et du vol d'identifiants. Les attaquants exploitent des paquets empoisonnés, des images compromises et des outils de développement vulnérables pour accéder à des informations sensibles. La campagne **TeamPCP** a impliqué la récolte de jetons, d'identifiants cloud, de clés SSH, de fichiers de configuration **npm** et de variables d'environnement. **Shai-Hulud** a exploité davantage les environnements de développement infectés pour collecter des milliers de secrets sur **GitHub**, les services cloud et les systèmes internes. Cela représente un passage d'une simple falsification de logiciel à une collecte ciblée d'identifiants aux points de confiance inhérents. Les identifiants compromis permettent aux attaquants de modifier, publier, construire, déployer ou usurper l'identité de systèmes logiciels de confiance. La vitesse de l'automatisation moderne permet aux mises à jour malveillantes de se propager rapidement. ### Le chemin de l'attaquant : le contexte du côté du développeur Les postes de travail des développeurs sont des cibles précieuses en raison de leur concentration de contexte. Ils contiennent souvent des dépôts locaux, des fichiers `.env`, l'historique du shell, des clés SSH, des identifiants de gestionnaire de paquets, des scripts de build et des sessions de navigateur. Ces informations agrégées sont considérablement plus dangereuses que des points de données isolés. Par exemple, un seul jeton d'accès combiné à des informations sur le remote Git, des scripts de déploiement et des configurations CI fournit aux attaquants une compréhension claire de son impact potentiel. La compromission d'un poste de travail de développeur peut exposer les systèmes de contrôle de source, les comptes cloud, les flux de publication de paquets, les systèmes CI/CD et les API internes. ### Machines de développeurs : autorité concentrée Alors qu'un ordinateur portable d'employé standard peut exposer des données d'entreprise, un poste de travail de développeur peut exposer la capacité de modifier des logiciels. Cette distinction est cruciale pour les considérations de sécurité des terminaux. Les développeurs ont besoin d'un accès large pour accomplir leur travail, y compris l'accès aux dépôts privés, aux services cloud et aux outils internes. Leurs machines deviennent un nexus de code source, d'identifiants, d'automatisation et d'autorité de livraison. Une exposition locale peut fournir aux attaquants un chemin vers les systèmes qui construisent, modifient, publient ou exploitent des logiciels. Questions clés pour les équipes de sécurité : * Pouvez-vous identifier quels identifiants sont utilisables depuis les postes de travail des développeurs ? * Pouvez-vous limiter la valeur et la durée de vie de ces identifiants ? * Pouvez-vous détecter le matériel sensible avant qu'il n'entre dans l'historique Git, les journaux CI ou le chat ? * Pouvez-vous révoquer et faire pivoter rapidement l'accès en cas de compromission suspectée d'un poste de travail ? * Pouvez-vous différencier une exposition locale à faible impact des identifiants dotés de privilèges d'administrateur ? Répondre à ces questions nécessite une collaboration entre les équipes de sécurité AppSec, endpoint, identité, plateforme et cloud. ### Automatisation et IA : amplification de la surface d'exposition L'automatisation réduit le temps entre la compromission et l'impact. Les robots de mise à jour des dépendances et les systèmes CI/CD peuvent propager rapidement les changements. Le développement assisté par l'IA introduit de nouveaux points de transfert pour les données sensibles, y compris les invites, la sortie du terminal et le code généré. Les équipes de sécurité devraient évaluer le risque de codage de l'IA selon la même optique que le risque de la chaîne d'approvisionnement. Considérez quelles sources et quelles données l'outil peut accéder, ce qu'il peut exécuter, où va la sortie et quels identifiants se trouvent à proximité. ### Contrôles en aval : nécessaires, mais insuffisants Le scan des dépôts, la protection des branches, la politique CI/CD, la signature des artefacts, l'analyse des dépendances et les contrôles d'exécution restent essentiels. Cependant, la vitesse des attaques modernes nécessite des mesures proactives. Capturer le matériel sensible pendant le développement, avant qu'il n'atteigne l'historique Git ou les journaux CI, minimise l'impact potentiel. Les programmes matures devraient différencier les actions qui devraient être bloquées, averties ou simplement générer des télémétries pour enquête. ### Traiter le poste de travail comme une frontière locale de la chaîne d'approvisionnement La chaîne d'approvisionnement logicielle moderne commence au poste de travail du développeur, où convergent le code, les identifiants, l'automatisation et la confiance. Il est crucial de traiter le poste de travail du développeur comme une frontière locale de la chaîne d'approvisionnement, englobant l'IDE, le terminal, le client Git, le gestionnaire de paquets, les outils de conteneurisation et les assistants IA. C'est là que les actions individuelles des développeurs se traduisent en risque de livraison logicielle organisationnelle.