Des agents de code comme Copilot, Claude Code, Cursor, Devin et Codex ouvrent désormais des pull requests tout seuls. Une personne les relit toujours, et cette personne lit le diff : la logique, les tests, le nommage. Cette relecture vaut la peine, mais ce n'est pas là qu'apparaît l'essentiel du risque pour la supply chain.

Les changements qui peuvent vous nuire le plus sont ceux qu'un diff montre le plus mal. Une modification d'une ligne dans un manifeste peut introduire un paquet dont personne n'a jamais entendu parler. Un changement de lockfile s'étend sur des centaines de lignes que personne ne lit. Un script d'installation n'apparaît jamais dans le diff, pas plus qu'un fichier que le build télécharge au moment du build. Cet article présente les contrôles qu'une équipe peut placer entre la pull request d'un agent et une release, et ce que chacun détecte.

Le diff n'est pas le bon endroit pour chercher le risque supply chain

La revue de code a été conçue pour du code qu'une personne a écrit et peut expliquer. Avec un agent, l'auteur ne peut pas vous dire pourquoi il a choisi un paquet, et le relecteur est tenté d'approuver un changement qui compile et passe ses tests. Quatre types de changements méritent plus d'attention qu'ils n'en reçoivent :

  • Dépendances nouvelles ou modifiées. La ligne du manifeste est courte ; ce qu'elle apporte ne l'est pas.
  • Remous dans le lockfile. Des centaines de versions résolues et de hashes, généralement repliés par défaut dans l'interface de revue.
  • Ce que fait le build, et non ce que contient le dépôt. Scripts d'installation, scripts de build qui téléchargent, images de base, curl dans une étape de workflow.
  • Fichiers de workflow. Un changement dans .github/workflows/ modifie ce qui s'exécute avec vos secrets.

Aucun de ces cas n'exige que l'agent soit compromis. Un modèle qui écrit du code plausible écrit aussi des noms de paquets plausibles, et un nom plausible est tout ce dont un attaquant a besoin.

Nouvelles dépendances : vérifiez que le paquet existe vraiment

Les modèles de langage suggèrent parfois des paquets qui n'existent pas. Une étude présentée à USENIX Security 2025 a généré 576 000 échantillons de code avec 16 modèles et constaté qu'au moins 5,2 % des paquets suggérés par les modèles commerciaux, et 21,7 % de ceux suggérés par les modèles open source, n'existaient pas, avec 205 474 noms inventés uniques. Enregistrer ces noms et attendre s'appelle le slopsquatting. C'est du typosquatting sans la faute de frappe, et un agent qui installe des paquets tout seul retire la personne qui aurait pu s'en apercevoir.

Avant de merger une pull request qui ajoute une dépendance, vérifiez :

  • Qu'elle existe et que c'est bien celle voulue. Comparez le nom, caractère par caractère, avec le projet que l'agent cherchait à utiliser.
  • Son âge. Un paquet ou une version publiés il y a quelques jours méritent la méfiance. Le réglage minimumReleaseAge de pnpm refuse les versions publiées depuis moins d'un nombre de minutes donné, y compris les versions transitives.
  • Qui est derrière. Un dépôt source lié, un historique de releases et plus d'un mainteneur ne prouvent pas la sécurité, mais leur absence est un signal d'alerte.
  • Si vous en aviez besoin. Les agents ajoutent des paquets pour des choses que la bibliothèque standard ou une dépendance existante font déjà. Moins de dépendances, c'est le contrôle le moins cher qui soit.

L'action dependency review de GitHub s'exécute sur les pull requests, liste les changements de dépendances et peut faire échouer le check en cas de vulnérabilités connues ou de licences non autorisées. Elle ignore tout d'un paquet publié hier sans advisory : elle complète donc les contrôles ci-dessus au lieu de les remplacer.

Changements de lockfile : lisez-les, et sachez ce qu'ils omettent

Un lockfile fige les versions exactes et les hashes d'intégrité résolus par votre gestionnaire de paquets. Dans la pull request d'un agent, c'est la trace la plus précise de ce qui a changé : rendez-le visible. Dépliez-le pendant la revue, et faites échouer le build quand le lockfile et le manifeste ne concordent pas (npm ci, pnpm install --frozen-lockfile).

Deux points à surveiller :

  • Une source modifiée. Un paquet qui était résolu depuis votre registre interne et l'est désormais depuis le registre public, c'est le schéma de la confusion de dépendances. Rattachez vos paquets internes à votre registre par un scope, afin que le registre public ne soit jamais interrogé.
  • Les sauts transitifs. Une petite mise à jour directe peut déplacer des dizaines de paquets transitifs. Ce sont les versions que personne n'a choisies.

Un lockfile n'enregistre toutefois que ce que le gestionnaire de paquets a résolu. Il ne dit rien de ce que télécharge un script d'installation, de ce que récupère un script de build Rust, de l'image de base qu'un Dockerfile tire ou de ce qu'une étape de workflow récupère avec curl. Ce sont des dépendances cachées, et elles se retrouvent quand même dans le produit.

Les scripts d'installation s'exécutent avant toute relecture

Voici la partie gênante : la CI s'exécute sur la pull request. Dès que la branche de l'agent est buildée, ses nouvelles dépendances sont installées, et leurs scripts preinstall et postinstall s'exécutent avec tout ce que le job peut atteindre. La relecture vient après.

La compromission de Nx en août 2025 a montré où cela mène. Des versions malveillantes de Nx sur npm contenaient un script postinstall qui, selon le postmortem des mainteneurs, tentait d'utiliser des outils d'IA locaux comme Claude et Gemini pour fouiller la machine à la recherche de fichiers sensibles.

Comment réduire l'exposition :

  • N'exécutez pas les scripts de cycle de vie par défaut. pnpm considère les scripts de build des dépendances comme non vérifiés tant que vous ne les autorisez pas ; avec npm, --ignore-scripts les désactive.
  • Retenez la CI sur les pull requests d'agents jusqu'à ce que quelqu'un regarde. Le Copilot cloud agent de GitHub le fait par défaut : les workflows ne sont déclenchés qu'une fois l'exécution approuvée par un utilisateur disposant d'un accès en écriture.
  • Tenez les secrets à l'écart des jobs de pull request. Un job de test a rarement besoin d'un token de publication. Consultez Secrets GitHub Actions : comment ils fuient et comment les verrouiller.

Comparez ce que le build a récupéré avec la dernière release

Le contrôle le plus solide ne regarde pas du tout la pull request. Il regarde ce que le build a fait : quels paquets et fichiers le job a réellement récupérés, et d'où. Une SBOM générée au build l'enregistre pendant l'exécution du build, et inclut donc les dépendances cachées qu'un lockfile omet.

Comparez-la avec la SBOM de votre dernière release, et les questions deviennent concrètes :

  • Quels composants sont nouveaux, et lesquels ont changé de version ?
  • Un paquet provient-il désormais d'une autre source ?
  • Le build a-t-il téléchargé quelque chose depuis un hôte qu'il n'avait jamais contacté ?

Tout élément nouveau doit être expliqué par une ligne dans la description de la pull request. Un composant que personne ne sait expliquer, c'est celui qui doit vous arrêter. Pour les façons de produire une SBOM en CI, voir comment générer une SBOM dans GitHub Actions.

Les fichiers de workflow ont besoin de leur propre responsable

Un agent qui modifie un workflow peut changer ce qui s'exécute avec vos tokens et vos secrets. Traitez .github/workflows/ comme du code sensible pour la sécurité, avec ses propres relecteurs. La référence d'utilisation sécurisée de GitHub suggère de placer le répertoire sous CODEOWNERS :

/.github/workflows/ @your-org/platform-security

Dans ces changements, cherchez :

  • Des permissions élargies. Un nouveau contents: write ou id-token: write doit avoir une raison. Voir Permissions de GITHUB_TOKEN.
  • De nouveaux déclencheurs. pull_request_target s'exécute avec un token en lecture et écriture et les secrets du dépôt, même pour les pull requests issues de forks.
  • Des actions non épinglées. Une nouvelle action référencée par un tag plutôt que par un SHA de commit complet peut changer à votre insu.
  • Des secrets à de nouveaux endroits. Un secret transmis à une étape qui n'en avait pas besoin auparavant.

Limitez ce que le build peut atteindre

Chacun des contrôles ci-dessus peut échouer. Un paquet malveillant tout neuf n'a pas d'advisory, porte un nom convaincant et présente un diff propre. Ce dont il a besoin, c'est d'une connexion réseau : pour récupérer sa deuxième étape, ou pour envoyer vos secrets quelque part.

Une politique de trafic sortant autorise le build à atteindre les registres et les hôtes dont il a besoin, et rien d'autre. Elle ne dépend pas de la connaissance de l'attaque, et fonctionne donc dès la première fois qu'une nouvelle attaque s'exécute dans votre pipeline.

Gardez une personne dans le circuit d'approbation

Les agents ne devraient pas pouvoir approuver leur propre travail, pas plus que la personne qui l'a demandé. Le Copilot cloud agent de GitHub empêche l'utilisateur qui lui a demandé de créer une pull request de l'approuver, et les protections de branche et checks obligatoires existants s'appliquent toujours.

Faites en sorte qu'il en soit de même pour chaque agent avec des rulesets sur la branche par défaut :

  • Exigez une pull request et au moins une approbation.
  • Exigez une revue des code owners, pour que les changements de workflow et de dépendances parviennent aux bonnes personnes.
  • Annulez les approbations obsolètes quand de nouveaux commits modifient le diff, car les agents continuent de pousser après la revue.
  • Exigez des status checks, y compris les contrôles de dépendances et de SBOM ci-dessus.

Certains outils avancent le contrôle. AI CodeOps, par exemple, n'ouvre une pull request qu'une fois la suite de tests réussie sur cette version précise, une revue IA du diff revenue sans problème et l'approbation d'une personne obtenue.

Contrôlez la release, pas seulement le merge

Un contrôle au merge voit un seul changement. Un contrôle à la release voit tout ce qui a changé depuis la dernière release, y compris des dépendances qui étaient saines au moment du merge et se sont depuis révélées vulnérables. Avant de livrer :

  • Revérifiez les composants de la release par rapport aux advisories actuels, et bloquez en cas de vulnérabilités critiques connues et de releases malveillantes connues.
  • Vérifiez les licences de tout ce qui est nouveau depuis la dernière release.
  • Conservez la trace de ce que le build de release a récupéré, pour pouvoir répondre plus tard à la question « Étions-nous touchés ? ». Voir Sommes-nous touchés ? Évaluer une nouvelle CVE sur l'ensemble de vos builds.

La place de CRACI

CRACI ne relit pas le code qu'écrit un agent. Il ne détecte pas non plus les nouveaux paquets malveillants : vérifiez donc les nouvelles dépendances avec les contrôles ci-dessus. Ce qu'il couvre, c'est le build.

CRACI exécute vos jobs GitHub Actions sur ses propres runners, environ deux fois plus rapides que les runners hébergés par GitHub. Vous remplacez runs-on par craci, et les exécutions apparaissent toujours dans GitHub. Pendant l'exécution de chaque job, CRACI enregistre chaque paquet qu'il a réellement récupéré, y compris les paquets restaurés depuis les caches CI et les dépendances cachées comme le code téléchargé par les hooks d'installation npm : un enregistreur, pas un scanner. La SBOM de chaque job porte un état de complétude qui signale ce que CRACI n'a pas pu voir, et s'exporte en CycloneDX ou SPDX, ce qui vous permet de comparer le build d'une pull request avec votre dernière release. Un diff de release intégré figure sur la roadmap.

Sur le runner, une politique de trafic sortant décide quels hôtes un job peut atteindre. Elle est validée avant le démarrage du job, bloque tout en cas d'échec et peut être réglée sur un refus par défaut : une dépendance malveillante dans la pull request d'un agent ne peut donc pas atteindre un hôte dont le build n'a pas besoin, même si personne n'a encore vu l'attaque. Les violations de la politique déclenchent des alertes. Des contrôles de politique peuvent bloquer un build en fonction des résultats, y compris les builds qui contiennent une CVE précise, et des règles de politique de licences peuvent bloquer un build à cause d'une licence. Après la release, CRACI continue de réévaluer les SBOM qu'il surveille au regard des nouveaux advisories, et l'historique des builds montre quels builds contenaient une dépendance vulnérable.

Réservez une démo pour voir la trace de l'un de vos propres builds.