Fuite de secrets par les agents IA : scanner ou confiner ?
Fuites de secrets via les listes « Ne plus demander » des agents IA : scanner ou confiner, et garde-fous pour bloquer les identifiants commis.

Des chercheurs en sécurité viennent de retrouver des mots de passe, des jetons API et des identifiants cloud dans plus d'un millier de fichiers GitHub publics — pas dans des fichiers .env bâclés, mais dans les paramètres d'agents de code IA. Le coupable est un schéma discret autour des fuites de secrets par les agents de code IA : le développeur approuve une commande comme curl -H "Authorization: Bearer sk-...", clique sur « Ne plus demander », et la commande complète, jeton compris, est écrite dans un fichier de configuration local. Vous committez ce fichier, et le secret devient public. Je fais de la sécurité d'infrastructure depuis des années, et c'est l'une des fuites les plus évitables que j'ai vues. C'est aussi une classe vraiment nouvelle, car le fichier qui la provoque n'existait pas il y a deux ans.
Les deux défenses auxquelles les équipes recourent sont le scan de secrets (détecter la fuite, puis nettoyer) et le confinement (s'assurer que le secret ne touche jamais ni l'agent ni le dépôt). Les deux sont nécessaires. Aucune ne suffit seule. Cet article les compare face à face, quand chacune gagne et où chacune échoue, et se termine par ce que je déploierais réellement dans une équipe utilisant Claude Code, Cursor ou tout agent doté d'une liste d'autorisations.
Un point à clarifier d'abord : ce n'est pas un plaidoyer contre les outils de codage agentique. Je les utilise au quotidien et je ne reviendrais pas en arrière. La demande de permission, l'agent qui demande « puis-je lancer ceci ? », est vraiment l'un des meilleurs mécanismes de sécurité que ces outils proposent. Le problème tient uniquement à ce qui se passe après votre « oui » : où ce « oui » est enregistré, et ce qu'il contient.
Comment la liste d'autorisations devient un coffre-fort de secrets
Pour comprendre le mode de défaillance, il faut regarder ce que « Ne plus demander » conserve réellement. Quand une CLI agentique demande à lancer une commande, l'implémentation naïve stocke la chaîne complète de la commande dans la règle de permission. Pas un motif. Pas un hash. La chaîne littérale que vous avez approuvée.
Donc, quand un développeur approuve aws s3 cp s3://bucket/backup.sql . --profile prod, c'est inoffensif. Mais quand il approuve psql postgresql://admin:hunter2@db.internal/myapp ou curl -u deploy:APIKEY123 https://.../deploy, les identifiants se retrouvent dans .claude/settings.local.json ou la configuration équivalente. Le fichier de paramètres est conçu pour rester local : Claude Code ignore même automatiquement ce fichier dans Git lorsque l'outil le crée lui-même. Mais si le développeur a créé le fichier à la main, ou l'a ajouté de force, ou si son gitignore global ne le couvre pas, un git add . et un push plus tard, il se retrouve sur GitHub. C'est exactement la chaîne derrière les 1 122 fichiers trouvés par les chercheurs.
Remarquez à quel point chaque maillon de cette chaîne est raisonnable pris isolément. Approuver une commande contenant un identifiant en clair, les développeurs le font de façon interactive depuis des décennies sans conséquence : la commande s'exécute, l'historique du shell la garde localement, personne ne s'en soucie. Cliquer sur « Ne plus demander » est rationnel ; la fatigue face aux demandes est réelle, et tout l'argument de vente de ces agents est de réduire les interruptions. Même git add . est défendable quand l'outil vous a indiqué que le fichier était local. L'incident n'est pas causé par un acte imprudent. Il est causé par un système où cinq actes anodins se composent en un identifiant public. Ce sont les pires failles à corriger, parce qu'aucun individu ne se voit faire quoi que ce soit de mal.
J'ai vu cette erreur exacte bien avant l'existence des agents. Un responsable d'équipe dans une fintech pour laquelle j'ai travaillé en consulting avait un allowed_commands.sh pour un bot d'aide au CI, la même idée codée à la main. Quelqu'un avait approuvé une migration de base de données ponctuelle avec le DSN en clair. Six mois plus tard, le dépôt a été rendu open source, et le DSN se trouvait dans l'historique Git d'un fichier que personne n'avait pensé à auditer parce qu'il « n'était pas de la configuration ». C'en était pourtant. Ça n'en avait simplement pas l'air.
C'est le cœur du problème : les listes d'autorisations sont des fichiers de configuration qui capturent des secrets opérationnels comme effet de bord. Personne ne les examine à la recherche de secrets, parce que personne ne les considère comme porteurs de secrets. Votre politique de gestion des secrets couvre .env, credentials.yml, peut-être l'état Terraform. Elle ne couvre presque certainement pas .claude/settings.local.json ni les configurations de .cursor/. Nous avons écrit sur un angle mort similaire dans l'audit des clients API considérés comme des coffres à identifiants : les outils que vous utilisez chaque jour accumulent des secrets dans des endroits que votre politique ne nomme pas.
Et la catégorie s'étend. Chaque outil agentique lancé ces dernières années propose une variante : listes d'autorisations, répertoires de confiance, approbations mémorisées, configurations de serveurs MCP avec des jetons en clair. Chacun ajoute un nouveau chemin de fichier que vos politiques, vos gitignore et vos configurations de scanner ne mentionnent pas. La prochaine version de cet incident sera la même erreur, dans un fichier portant un autre nom.
Scan de secrets vs confinement : les deux défenses
Voici la comparaison que je vais suivre dans la suite de l'article :
- Détection d'abord (scan de secrets) : hooks de pré-commit, scanners de dépôts comme gitleaks et trufflehog, protection au push de GitHub ou GitLab, plus des analyses périodiques de l'historique. On part du principe que les secrets finiront par fuiter ; on les repère vite et on les révoque.
- Confinement d'abord (garder les secrets à l'écart) : les secrets n'entrent dans les commandes que via des variables d'environnement, des CLI de gestionnaires de mots de passe ou des identifiants de courte durée ; les agents tournent dans des bacs à sable ou des VM éphémères ; les fichiers de paramètres locaux sont ignorés globalement par Git. On conçoit le système pour qu'il n'y ait rien à fuiter.
La détection est une opération de nettoyage. Le confinement est une propriété de conception. Ils échouent dans des directions opposées : le scan produit des faux négatifs et s'exécute toujours après coup ; le confinement a un coût d'adoption et frotte contre les habitudes des développeurs. Lequel gagne dépend du mode de défaillance que vous pouvez tolérer.
Il existe aussi une asymétrie dans leur dégradation au fil du temps. Le scan se dégrade en douceur : un secret manqué est grave, mais ceux qu'il attrape sont toujours attrapés, et les jeux de règles s'améliorent. Le confinement se dégrade par exception. À chaque fois qu'un développeur contourne la contrainte (« juste cette fois, je colle directement le jeton ») la propriété s'affaiblit, et aucun journal ne consigne cet affaiblissement. On découvre que le confinement a échoué de la même façon qu'on découvre qu'une porte est restée ouverte : quand quelqu'un vérifie. C'est pourquoi les deux vont ensemble plutôt que d'être rivaux, mais c'est aussi pourquoi je les pondère différemment. La section suivante explique pourquoi le scan, malgré son statut de réponse par défaut de l'industrie, est le plus faible des deux pour cette classe de fuite.
Scan de secrets : atouts et limites strictes
Le scan de secrets gagne quand la fuite a déjà eu lieu ou est sur le point d'avoir lieu, ce qui, vu la nature humaine, arrive souvent. La protection au push de GitHub bloque les formats de jetons connus au moment du push. gitleaks dans un hook de pré-commit attrape une quantité surprenante de choses avant qu'elles ne quittent le portable. Si vous ne faites rien d'autre de cet article, faites ceci :
# .pre-commit-config.yaml
repos:
- repo: https://github.com/gitleaks/gitleaks
rev: v8.18.4
hooks:
- id: gitleaks
Dix minutes de mise en place, et la classe de fuite précise de cette histoire (un jeton dans un fichier de paramètres commité) disparaît en grande partie, parce que gitleaks se moque que le fichier soit un JSON de paramètres. Il analyse le contenu, pas les noms de fichiers. Ajoutez une regex pour vos préfixes de jetons internes si vous en avez.
Il existe une couche de scan supplémentaire que les équipes oublient souvent : analyser périodiquement votre propre machine locale à la recherche de secrets non commités. Les hooks au niveau du dépôt ne se déclenchent qu'au moment du commit ou du push. Un fichier de paramètres qui reste sur le disque pendant trois mois avant qu'un git add . ne soit lancé représente une fenêtre de trois mois pendant laquelle le secret n'est qu'à une commande d'être public. Une tâche planifiée, même un cron hebdomadaire qui lance gitleaks sur les dotfiles de votre répertoire personnel, ramène cette fenêtre à quelques jours. C'est peu élégant, mais ça marche.
Mais le scan a trois limites strictes que l'affaire Claude Code met bien en lumière. D'abord, les détecteurs basés sur l'entropie manquent les secrets à faible entropie. Un mot de passe comme Winter2024! dans une chaîne de connexion psql ne déclenchera pas de contrôle d'entropie, et s'il ne correspond pas à un format de fournisseur connu, aucune règle ne s'applique. Les chercheurs ont trouvé beaucoup de mots de passe en clair, pas seulement des clés de type AWS. Ensuite, le scan intervient après coup, au niveau du push. La protection au push arrête le push, c'est très bien, mais si elle ne se déclenche pas, le secret est dans l'historique, et l'historique est éternel. Faire une rotation après une fuite oblige à traquer chaque endroit où l'identifiant était utilisé, et je n'ai jamais vu ce nettoyage prendre moins d'une journée. Enfin, le scan crée un faux sentiment d'exhaustivité. Les équipes voient la coche verte et cessent de réfléchir à la façon dont les secrets circulent. Comme nous l'avons déjà défendu dans notre article sur les scanners de sécurité IA, un scanner est un filet de sécurité, pas un substitut au fait de ne pas tomber.
Sur ce deuxième point, il faut être précis sur ce que « nettoyer » implique réellement lorsqu'un identifiant atterrit dans un dépôt public, car les équipes sous-estiment chroniquement cette tâche. La rotation est la partie facile : révoquer le jeton, en émettre un nouveau, mettre à jour le coffre à secrets. La partie difficile est l'archéologie : chaque pipeline de déploiement, tâche cron, portable de développeur et intégration tierce qui utilisait l'ancien identifiant doit être retrouvé et mis à jour, et en oublier un signifie une panne au pire moment possible. Il y a ensuite le problème miroir : si le dépôt est public, vous devez supposer que le secret a été récupéré en quelques minutes. Les bots de collecte d'identifiants surveillent le flux d'événements de GitHub en continu. Au moment où votre scanner vous alerte, le secret a probablement été cloné, indexé, et peut-être déjà testé sur vos points d'accès en production. La détection vous a apporté une prise de conscience. Elle ne vous a pas apporté la sécurité.
Cela dit, je veux être juste envers le scan, car il est écarté trop vite dans ces débats. Pour les grandes organisations, avec des centaines de dépôts et des milliers de développeurs, le scan est la seule couche qui passe à l'échelle sans changer les comportements. On ne peut pas se former pour sortir d'une fuite à cette échelle, mais on peut la bloquer en grande partie grâce à la protection au push. Si vous êtes dans une équipe plateforme et que vous décidez où investir votre première semaine d'effort, la réponse est le scan : il est peu coûteux, centralisé, et détecte les jetons de fournisseurs à forte entropie, qui causent le plus de dégâts. Ne le confondez simplement pas avec la solution complète.

Confinement : variables d'environnement, bacs à sable et identifiants de courte durée
Le confinement gagne partout où le secret serait autrement écrit noir sur blanc, et c'est précisément là que vit cet incident. Si l'identifiant n'apparaît jamais comme chaîne littérale dans une commande, la liste d'autorisations n'a rien de dangereux à stocker. La commande approuvée devient curl -H "Authorization: Bearer $DEPLOY_TOKEN" ..., et le fichier de paramètres ne contient qu'un nom de variable inoffensif. Deux règles couvrent l'essentiel :
- Les secrets n'entrent dans les commandes que via des variables d'environnement ou une indirection (
$TOKEN,$(op read ...), un fichier de configuration que l'agent lit à l'exécution), jamais en valeurs littérales. - Les répertoires de configuration locaux aux agents (
.claude/,.cursor/,.aider*) vont dans votre gitignore global à l'échelle de la machine (~/.config/git/ignore), et pas seulement par dépôt, pour qu'aucun projet ne puisse jamais les committer.
# Global gitignore covers every repo on this machine
git config --global core.excludesFile ~/.config/git/ignore
cat >> ~/.config/git/ignore <<'EOF'
.claude/
.cursor/
.aider*
.env*
EOF
Pourquoi global plutôt que par dépôt ? Deux raisons. D'abord, les gitignore par dépôt n'existent que si quelqu'un pense à les ajouter à chaque nouveau dépôt, et les nouveaux dépôts sont justement créés quand personne ne pense à l'hygiène de sécurité. Ensuite, un gitignore global est une politique de machine, pas de projet : il ne peut pas être supprimé par accident dans une pull request qui « nettoie le gitignore », ce que j'ai vraiment vu arriver. La version par dépôt protège un dépôt. La version globale protège un développeur, et le développeur est l'unité la plus encline aux fuites ici.
La règle des variables d'environnement mérite le même examen, car elle a un mode de défaillance subtil : les profils de shell. Si le développeur « résout » l'exigence de variable en exportant DEPLOY_TOKEN=sk-... dans son .bashrc, vous avez simplement déplacé le secret d'un dotfile non relu à un autre. La règle doit aboutir à un vrai coffre à secrets : la CLI 1Password, direnv lisant un magasin chiffré, un gestionnaire de secrets cloud avec aws ssm ou op inject au démarrage de la session. L'agent reçoit la variable ; le disque ne reçoit jamais la valeur. C'est une indirection de plus, et c'est la différence entre le confinement et la cosmétique.
La version forte du confinement, c'est ce que j'appelle le vrai bac à sable : exécuter l'agent dans une VM ou un conteneur éphémère par tâche, sur un réseau isolé, avec un proxy devant les API externes. Une configuration d'un praticien que j'admire place un proxy d'API entre l'agent et une clé SaaS « toute-puissante » : les lectures passent, les écritures exigent une validation sur téléphone. C'est de la défense en profondeur bien faite. Même un agent totalement compromis lancé avec --dangerously-skip-permissions ne peut toucher que ce que le proxy autorise. Nous avons couvert le compromis plus large dans confinement contre surveillance pour les agents IA ; cette affaire plaide pour le confinement.
Les identifiants de courte durée sont l'autre moitié de la version forte, et ils sont sous-estimés car ils réduisent le rayon d'impact même quand toutes les autres couches échouent. Une clé d'accès AWS statique fuitée sur GitHub reste valable jusqu'à ce que quelqu'un s'en aperçoive. Un identifiant émis via OIDC avec une durée de vie d'une heure et fuité sur GitHub n'est plus qu'une entrée de journal. Si votre fournisseur cloud prend en charge la fédération d'identité de charge de travail, et tous les grands le font, les identifiants de l'agent doivent expirer plus vite que votre processus de réponse à incident ne peut même réunir une réunion.
Le coût honnête du confinement, c'est la friction. Les CLI de gestionnaires de mots de passe impliquent des demandes d'empreinte en pleine tâche. Les VM éphémères demandent du temps de mise en place et une latence de démarrage à chaque exécution. Les proxys ciblés exigent que quelqu'un les construise et les maintienne. Pour un développeur solo sur un projet personnel, un bac à sable complet est excessif, et la combinaison gitignore global et variables d'environnement est le bon choix. Pour une équipe dont les agents touchent des identifiants de production, la friction est le prix pour ne pas être la prochaine divulgation de violation.
La couche intermédiaire : corriger la liste d'autorisations elle-même
Il existe une troisième option, que possèdent les éditeurs d'outils et non vous : ne pas stocker la commande littérale. Une règle de permission qui conserve curl -H "Authorization: Bearer *" comme motif, avec les valeurs d'arguments masquées, est tout aussi utilisable pour la correspondance et ne contient aucun secret. L'équipe de Claude Code a dit examiner précisément cette classe de problème, et leur direction recommandée est un mode de permission automatique qui n'exige pas de maintenir des listes d'autorisation et de refus. C'est le bon instinct. Chaque liste d'autorisation maintenue à la main est un futur incident dont vous ne voyez pas encore l'horodatage.
Le filtrage par motif n'est pas un repas gratuit, soyons clairs. Un glob comme curl * correspond aussi bien à la commande de déploiement bénigne qu'à la commande d'exfiltration malveillante, donc un masquage agressif échange le risque de fuite contre un risque d'autorisations trop larges. La bonne conception est probablement structurelle plutôt que textuelle : conserver quel binaire et quels drapeaux ont été approuvés, jamais les valeurs des arguments. Cela garde la correspondance précise (oui pour curl avec des en-têtes, non pour curl qui envoie vers un nouveau domaine) sans stocker quoi que ce soit où un identifiant pourrait se cacher. Les éditeurs y viendront ; l'incitation est désormais un millier de fichiers publics comme preuve.
En attendant que les éditeurs livrent cela, vous pouvez vous en approcher par l'hygiène : lancer périodiquement un scanner sur vos propres fichiers de paramètres locaux. Une ligne comme gitleaks detect --no-git --source ~/.claude .claude audite exactement les fichiers dont parle cet article, avant qu'ils ne soient près d'un dépôt. Ajoutez-la à votre script d'installation de dotfiles, elle ne coûte rien.
Ma recommandation : confinement par défaut, scan en filet de sécurité
Si je devais n'en choisir qu'un, je choisirais le confinement. Une fuite qui n'arrive jamais vaut mieux qu'une fuite détectée rapidement, à chaque fois. Le scan est ce sur quoi vous vous appuyez quand le confinement échoue, et il échouera, car quelqu'un finira par coller une chaîne de connexion dans un chat à 1 h du matin, mais il doit être le gestionnaire d'exceptions, pas la politique.
Concrètement, pour une équipe qui déploie des outils de codage agentiques ce trimestre, par ordre d'effort :
- Gitignore global pour les répertoires de configuration des agents sur chaque machine de développeur : cinq minutes, et cela supprime entièrement la fuite de paramètres commités.
- Règle : les secrets uniquement via des variables d'environnement ou une CLI de gestionnaire de mots de passe, jamais en ligne dans les commandes. Mettez-la dans l'onboarding, pas dans un wiki que personne ne lit.
- gitleaks en hook de pré-commit plus protection au push sur la forge : le filet de sécurité pour tout ce qui précède.
- Identifiants de courte durée et restreints pour tout ce que touche l'agent (identifiants cloud émis via OIDC au lieu de clés statiques), pour qu'une fuite expire en quelques heures.
- Pour les agents qui ont accès à la production : bac à sable éphémère plus un proxy d'API qui limite ce que les identifiants de l'agent peuvent faire.
Notez l'ordre. Les deux éléments les moins coûteux relèvent du confinement, et ils éliminent toute la classe d'incidents au lieu de réduire sa probabilité. Les éléments de scan viennent en troisième position, non pas parce qu'ils sont secondaires, mais parce qu'ils constituent le filet sous le trapèze : on tend le filet après avoir vérifié les cordes. Les éléments quatre et cinq marquent le passage de la défense contre les accidents à la défense contre la compromission, vers laquelle les outils agentiques se dirigent, qu'on le prévoie ou non.

Les deux premiers éléments à eux seuls auraient empêché pratiquement tous les fichiers du jeu de données des chercheurs. C'est la partie frustrante de cet incident : ce n'est pas une attaque sophistiquée. C'est un nouveau type de fichier qui porte une vieille erreur, et la solution est la même hygiène que nous prêchons depuis le premier .env commité, appliquée à un répertoire que personne ne mentionne encore dans sa politique.
Mettez à jour votre politique. Les agents ne vont nulle part, et le bouton « Ne plus demander » non plus.


