Dans les environnements DevOps modernes, les pipelines CI/CD automatisent le développement, les tests et le déploiement du code, permettant une livraison rapide et scalable tout en élargissant significativement la surface d’attaque.
Les audits CI/CD réalisés en 2025 et 2026 ont révélé que des identifiants exposés dans des dépôts, des runners mal configurés, des stockages d’artefacts non sécurisés et des rôles cloud trop permissifs constituent autant de vecteurs d’attaque que des acteurs malveillants peuvent exploiter afin d’obtenir un accès persistant et fortement privilégié à l’ensemble de l’infrastructure.
Une vue d’ensemble des outils DevOps est illustrée ci-dessous :
Une compromission à n’importe quelle étape du pipeline peut ouvrir une voie vers des systèmes plus sensibles.
Cet article décrit une chaîne d’attaque CI/CD représentative visant un environnement CI/CD, fondée sur des scénarios observés en conditions réelles. Il met en évidence les vecteurs d’attaque les plus couramment exploités ainsi que les principales mesures de durcissement permettant de réduire la surface d’attaque à chaque étape du pipeline, depuis le code source jusqu’au déploiement en production.
La chaîne d’attaque: de la reconnaissance à la persistance
Reconnaissance et accès initial
La chaîne d’attaque débute généralement par une attaque de phishing ciblant les développeurs afin de voler des identifiants et des codes MFA, bien que le MFA puisse lui-même être contourné via le vol de jetons d’accès ou de détournement de sessions.
Il convient de noter que la compromission d’identifiants seule n’est pas toujours suffisante pour accéder directement à des portails administratifs sensibles. Les contrôles de sécurité autour des interfaces d’administration Microsoft 365 ont été renforcés par des mécanismes de MFA ainsi que, le cas échéant, par des politiques d’accès conditionnel, limitant l’impact du phishing sur les accès hautement privilégiés.
Cependant, dans les environnements d’entreprise modernes où la majorité des applications reposent sur le Single Sign-On (SSO), la compromission d’une session Microsoft (par exemple via le vol de cookies de session) peut donner aux attaquants accès à un large éventail de services interconnectés, incluant les dépôts de code et les plateformes CI/CD. Les attaquants utilisent généralement ce point d’entrée initial pour identifier les environnements de développement et établir une persistance via des mécanismes tels que les Jetons d’accès personnels (PAT).
Un risque souvent négligé survient lorsqu’un compte utilisateur est désactivé au niveau du fournisseur d’identité (ex. Entra ID) mais n’est pas entièrement désactivé dans les plateformes de dépôt. Dans ce cas, des PATs précédemment émis peuvent rester valides, permettant à un attaquant de conserver un accès malgré la révocation du compte.
D’autres vecteurs d’entrée incluent l’exploitation de CVE connues ainsi qu’une mauvaise gestion des identifiants. De nombreuses vulnérabilités majeures sur les outils DevOps sont régulièrement découvertes, ce qui souligne la nécessité d’une gestion continue des vulnérabilités. L’exploitation d’une vulnérabilité critique peut directement fournir un accès privilégié à un outil de la chaîne.
Exemples :
- CVE-2024-23897 (Jenkins), permettant à des attaquants non authentifiés de lire des fichiers arbitraires présents sur le contrôleur Jenkins, exposant ainsi des secrets sensibles,
- CVE-2023-7028 (GitLab), dans laquelle les emails de réinitialisation de mot de passe pouvaient être envoyés vers une adresse électronique non vérifiée.
- CVE-2023-36561 (Azure DevOps Server), une vulnérabilité d’élévation de privilèges permettant à un attaquant d’obtenir un accès non autorisé à certaines fonctionnalités d’Azure DevOps Server, avec un impact potentiel sur les pipelines, les secrets et les ressources des projets.
REMÉDIATION – Renforcer les contrôles d’accès aux dépôts de code source
Afin de réduire les risques liés à l’accès initial, les organisations doivent mettre en œuvre des contrôles permettant d’empêcher les accès non autorisés, de détecter les mécanismes de persistance et de renforcer la gouvernance des identités.
Appliquer des politiques d’accès strictes et réduire l’exposition réseau
- Eviter l’utilisation des comptes génériques ou partagés,
- Utiliser des identités développeurs dédiées, séparées des comptes bureautiques standards (messagerie et outils collaboratifs), afin de réduire l’exposition au phishing et l’impact d’une compromission dans les environnements CI/CD,
- Imposer des mécanismes MFA résistants au phishing (clés FIDO2, certificats, etc),
- Mettre en place des politiques d’accès conditionnel basées sur des critères contextuels (localisation réseau, conformité des appareils).
Mettre en place des mécanismes de détection de persistance
- Surveiller la création ou l’utilisation suspecte de PAT dans GitLab, ainsi que les activités anormales (ex. déploiements à des horaires inhabituels),
- Surveiller l’ajout de nouvelles méthodes d’authentification dans Entra ID, notamment les méthodes sans mot de passe, après un événement de phishing.
Réviser périodiquement les accès et supprimer les comptes inutilisés
- Désactiver ou supprimer les comptes inutilisés ou inactifs,
- Révoquer les accès des collaborateurs sortis de l’organisation sur tous les systèmes,
- Réaliser des revues d’accès périodiques, au minimum tous les six mois pour les utilisateurs à risque élevé.
Compromission des dépôts de code et des pipelines
Les dépôts de code sont souvent directement intégrés aux pipelines CI/CD, ce qui signifie que toute modification du code peut déclencher automatiquement des processus de build et de déploiement. Ainsi, la compromission d’un compte développeur peut influencer la manière dont les applications sont construites et déployées.
Pour réduire le risque de modifications non autorisées en production, les organisations protègent généralement les branches de production (ex. main ou master) via des pull requests, des validations et des contrôles automatisés. En revanche, les branches de développement sont souvent moins strictement contrôlées afin de favoriser la rapidité de développement et de test.
Dans le scénario observé, l’attaquant cible la branche de développement et modifie le fichier de configuration du pipeline (gitlab-ci.yml), en y injectant une commande malveillante (visant à établir un accès distant) au sein d’un job existant. Lors de l’exécution du pipeline, cette commande est exécutée sur le runner CI/CD, ce qui permet à l’attaquant d’obtenir un accès distant à ce dernier.
Une fois dans le runner CI/CD, l’attaquant peut alors exécuter du code arbitraire sur le runner CI/CD et, entre autres, énumérer les variables d’environnement contenant des paramètres de configurations et les secrets définis dans le projet GitLab.
Cependant, il arrive que certains composants de la chaîne CI/CD ne sont pas dupliqués entre environnements pour des raisons de coûts. Dans ce cas précis, les secrets GitLab ne sont pas segmentés entre les environnements de production et de développement. Ainsi l’attaquant est en capacité de lister les secrets de production depuis le runner CI/CD de développement.
Un exemple de variables d’environnement rencontrées dans les pipelines CI/CD est présenté ci-dessous.
Ce flux d’attaque montre comment la manipulation de pipeline permet l’exécution de code dans le runner et l’extraction de variables sensibles de production depuis un environnement de développement.
Parmi les identifiants récupérés dans l’environnement CI/CD compromis, l’attaquant obtient un jeton d’accès à Nexus, système de gestion d’artefacts utilisé pour stocker et distribuer les artefacts de build de confiance consommés par les pipelines situés en aval.
REMÉDIATION – Durcir la sécurité des dépôts de code
La sécurisation du dépôt de code est essentielle pour empêcher l’exploitation des pipelines CI/CD après un accès initial, car les dépôts contrôlent directement le build et le déploiement.
Durcir les dépôts pour limiter les déclenchements de pipeline
- Configurer des branches protégées pour les branches de déploiement,
- Mettre en place des workflows d’approbation multi-niveaux pour les merge requests déclenchant des pipelines et interdire l’auto-approbation,
- Utiliser la propriété du code (ownership) pour assigner et exiger l’approbation des responsables désignés sur les fichiers sensibles (ex. configuration CI/CD).
Limiter la visibilité et les permissions
- Limiter les droits d’écriture aux seuls utilisateurs qui en ont besoin,
- Restreindre la visibilité des projets selon le principe du besoin de savoir (interne ou privé recommandé).
Mettre en place une bonne hygiène de gestion des secrets
- Configurer des secrets CI/CD scopés au niveau projet et privilégier des identifiants éphémères,
- Détecter les secrets en clair le plus tôt possible (au moment du commit ou avant la publication du code) et les révoquer immédiatement en cas d’exposition,
- Réaliser des revues périodiques (ex. audits internes, exercices de red team) sur des plateformes telles que les dépôts Git, Jira ou Confluence afin d’identifier d’éventuelles fuites de secrets passées inaperçues.
REMÉDIATION – Renforcer la sécurité des runners auto-hébergés
Les runners sont des composants critiques des pipelines CI/CD car ils exécutent le code et manipulent des données sensibles. S’ils sont compromis, ils peuvent permettre des mouvements latéraux, l’accès aux secrets ou la prise de contrôle de l’environnement.
Réduire l’exposition réseau et le périmètre d’exécution
- Restreindre le trafic réseau des runners uniquement à ce qui est nécessaire à l’exécution des pipelines, et appliquer des contrôles réseau tels que des proxies et de la segmentation afin d’empêcher tout accès Internet non contrôlé et limiter les mouvements latéraux au sein des réseaux internes,
- Restreindre les déclenchements depuis des dépôts non fiables ou personnels.
Considérer les runners comme des systèmes sensibles
- Considérer les runners comme des serveurs critiques (Application régulière des correctifs du système d’exploitation et durcissement),
- Déployer des solutions de Endpoint Detection and Response (EDR) pour la surveillance des processus, y compris dans les environnements conteneurisés.
Utiliser des runners dédiés et éphémères
- Privilégier des runners dédiés par projet ou environnement. Le partage de runners entre plusieurs contextes augmente le risque de contamination inter-projets et d’escalade de privilèges,
- Utiliser des runners éphémères / autoscalés détruits après chaque job,
- S’assurer que les runners basés sur VM soient également éphémères et isolés afin qu’aucune donnée ou accès résiduel ne persiste entre les exécutions. En complément, s’appuyer uniquement sur des images de base durcies et de confiance (par exemple des golden images pour les runners VM et des images conteneurs approuvées), afin d’éviter toute exécution dans des environnements compromis ou non vérifiés.
Sécuriser les runners containerisés
- N’autoriser que des images approuvées et de confiance dans les exécutions de pipelines afin d’éviter l’introduction de code malveillant via des images compromises ou non vérifiées,
- Appliquer le principe du moindre privilège dans les environnements d’exécution conteneurisés,
- Éviter le mode privilégié et supprimer les capacités Linux inutiles,
- Utiliser des moteurs de build sécurisés (BuildKit / Buildah) lorsque le Docker-in-Docker est requis.
Durcir les runners cloud
- Lors de l’utilisation de runners managés dans le cloud, appliquer une isolation stricte et un périmètre d’identité, restreindre l’accès aux métadonnées afin d’éviter l’exposition d’identifiants depuis l’infrastructure sous-jacente, et s’assurer que les rôles CI/CD sont gouvernés par des politiques IAM strictes en moindre privilège afin d’éviter des permissions excessives.
Empoisonnement d’artefacts et attaques sur les dépendances
Dans les environnements de livraison logicielle, les systèmes de gestion d’artefacts stockent et distribuent les sorties générées par les pipelines CI/CD. Ces sorties, appelées artefacts, représentent les résultats packagés du processus de build, tels que des binaires compilés, des packages applicatifs ou des images de déploiement.
Les artefacts sont stockés de manière centralisée afin d’assurer le versioning, la traçabilité et la réutilisation à travers plusieurs pipelines. En plus des sorties spécifiques aux applications, ces dépôts hébergent souvent également des composants partagés tels que des golden images, des bibliothèques réutilisables ou des dépendances runtime communes. Comme ils proviennent de processus de build considérés comme fiables, les artefacts sont généralement supposés sûrs et largement consommés par les pipelines en aval sans validation supplémentaire.
Dans le scénario observé, l’attaquant utilise des identifiants précédemment obtenus pour s’authentifier au dépôt d’artefacts (Nexus dans cet exemple) avec des permissions excessives (lecture/écriture sur plusieurs catégories, plutôt que limitées à un périmètre applicatif unique), et obtient ainsi un accès à la fois aux artefacts de production et aux artefacts partagés.
Parmi ces derniers, l’attaquant identifie un binaire Terraform légitime utilisé dans le processus de déploiement d’infrastructure (appelé ici le binaire tofu), qui est couramment approuvé et consommé par les pipelines CI/CD pour provisionner et gérer les ressources cloud.
L’attaquant télécharge cet artefact localement et en modifie le contenu en injectant une logique malveillante tout en conservant sa fonctionnalité d’origine, et y intègre un comportement caché conçu pour interagir avec les services AWS Identity and Access Management (IAM) et AWS Security Token Service (STS) afin de récupérer des identifiants.
Le binaire modifié est ensuite téléversé de nouveau dans Nexus, remplaçant la version légitime par un artefact compromis.
À partir de ce moment, tout pipeline CI/CD consommant cet artefact récupère automatiquement le binaire compromis lors de la résolution des dépendances, car il est toujours considéré comme fiable.
Lors de son exécution, le binaire compromis active la charge malveillante intégrée, dont l’objectif est de récupérer le jeton d’accès AWS utilisé par le contexte d’exécution Terraform et de l’envoyer vers un serveur contrôlé par l’attaquant pour exfiltration. Il génère ensuite une sortie obfusquée encodée en Base32. Le décodage permet de reconstruire un objet JSON contenant des identifiants AWS (AccessKeyId, SecretAccessKey et SessionToken).
L’attaquant configure ensuite ces identifiants localement et utilise AWS STS (appel API GetCallerIdentity) pour confirmer l’usurpation d’identité du runner CI/CD.
Cette illustration montre la chaîne d’attaque : compromission d’artefact, injection de logique malveillante, propagation via les pipelines CI/CD et vol final d’identifiants AWS menant à la compromission de l’environnement.
En conséquence, l’attaquant obtient un accès non autorisé aux ressources AWS sous une identité légitime.
REMÉDIATION – Améliorer la gestion des accès à l’Artifactory
Les dépôts d’artefacts tels que Nexus sont des composants clés des pipelines CI/CD utilisés pour stocker et distribuer les dépendances et artefacts de build. Ce sont des cibles à forte valeur pour les attaques de chaîne d’approvisionnement.
La sécurité nécessite des contrôles d’accès forts, une gouvernance des dépendances et une surveillance continue de l’intégrité.
Durcir la plateforme d’artefacts
- Autoriser une large lecture du dépôt uniquement sous deux conditions : depuis le service nécessaire (CI/CD) et si une gestion de mots de passe dans les dépendances existe,
- Restreindre fortement les permissions d’écriture,
- Modifier les identifiants par défaut.
Analyse de composition logicielle (SCA)
- Appliquer une analyse de composition logicielle aux dépendances internes (stockées dans des dépôts locaux) ainsi qu’aux dépendances externes (récupérées depuis des dépôts distants ou proxy) afin de détecter les vulnérabilités connues et les composants obsolètes.
Restreindre les sources d’artefacts
- Maintenir une whitelist de dépôts de confiance afin de garantir que seules des sources approuvées sont utilisées,
- Appliquer des contrôles au niveau des dépôts pour exclure les versions non approuvées ou vulnérables, par exemple dans Nexus ou via des règles d’exclusion dans JFrog Artifactory,
- Empêcher les pipelines CI/CD d’accéder à des sources externes non fiables en imposant des frontières strictes entre dépôts.
Compromission cloud via abus des workloads CI/CD
Dans les environnements cloud, les runners CI/CD sont généralement associés à des rôles IAM privilégiés pour effectuer des opérations de déploiement, incluant la création, modification et suppression de ressources d’infrastructure. Ces rôles incluent souvent des permissions larges telles que AdministratorAccess ou des politiques personnalisées trop permissives, permettant au runner d’interagir avec un large ensemble de services AWS, incluant les services de calcul, le stockage et la gestion des identités.
Lorsqu’un runner CI/CD est compromis, un attaquant peut directement abuser de ces privilèges sans nécessiter d’escalade supplémentaire. Cela peut conduire à un accès immédiat à des ressources sensibles telles que des buckets S3 ou des bases de données RDS, permettant l’exfiltration de données. L’attaquant peut également exploiter les permissions IAM pour assumer d’autres rôles dans d’autres comptes ou projets AWS, facilitant les mouvements latéraux au sein de l’organisation. En outre, l’accès aux services de compute peut être utilisé pour déployer, modifier ou maintenir des charges malveillantes, aboutissant finalement à une compromission complète de l’environnement cloud.
De la compromission initiale du développeur à la prise de contrôle cloud : vue complète de la chaîne CI/CD
la chaîne d’attaque CI/CD commence par la compromission initiale du développeur jusqu’à la prise de contrôle complète de l’environnement cloud.
L’illustration suivante met en évidence les opportunités clés de détection et de surveillance à travers l’écosystème CI/CD. Elle montre comment les données de télémétrie de sécurité peuvent être collectées et corrélées tout au long des différentes étapes de la chaîne d’attaque CI/CD, depuis les activités de développement jusqu’aux runners CI/CD, aux dépôts d’artefacts et aux opérations IAM dans le cloud.
Dans l’ensemble, bien que les pipelines CI/CD élargissent significativement la surface d’attaque, ils offrent également de multiples points d’interception stratégiques où une journalisation centralisée et une surveillance de sécurité peuvent permettre une détection précoce et une réponse aux activités malveillantes.
En conclusion, pour obtenir un pipeline CI/CD sécurisé, la sécurité doit être pensée de bout en bout, des environnements développeurs jusqu’aux systèmes de production.
Les développeurs sont le premier maillon de la chaîne, et la sécurisation de leurs comptes est essentielle. Cela doit être complété par de bonnes pratiques telles que la gestion sécurisée des secrets et la sensibilisation régulière à la sécurité.
Il est également crucial d’assurer une bonne isolation entre environnements et d’appliquer strictement le principe du moindre privilège, aussi bien pour les utilisateurs que pour les comptes de service.
Les problèmes de sécurité ne peuvent pas être corrigés par de simples correctifs si la conception globale du pipeline est faible.
Enfin, les cas d’usage de déploiement doivent être définis clairement dès le départ, car ils influencent directement l’architecture et les choix IAM.
Au-delà des aspects techniques, la sécurité CI/CD doit être évaluée en continu via des audits techniques réguliers ainsi que des revues organisationnelles du cycle de développement afin de maintenir les risques sous contrôle.
Pour une perspective plus large et des recommandations de haut niveau sur le positionnement du CI/CD comme pilier du système d’information, voir l’article RiskInsight : « CI/CD: the new cornerstone of the information system ».
