Votre agent de code écrit un journal de secrets
La version courte
La partie dangereuse d'un agent de code n'est pas toujours la commande qu'il exécute.
C'est parfois la commande dont il se souvient.
L'entreprise de sécurité Apiiro a analysé des dépôts GitHub publics et trouvé 2 539 credentials distincts dans 1 994 dépôts, au sein de réglages d'agents de code, de l'historique Git, de transcriptions, de fichiers de mémoire et de notes de passation.
Le chemin le plus clair passe par Claude Code.
Quand Claude Code demande l'autorisation d'exécuter une commande Bash, l'utilisateur peut choisir « Yes, and don't ask again ». La documentation d'Anthropic indique que cette autorisation permanente est écrite dans .claude/settings.local.json sous forme de règle d'autorisation.
Si la commande contient un mot de passe de base de données, un token API, une chaîne de connexion ou un en-tête d'autorisation, la règle enregistrée peut aussi contenir le secret.
Apiiro a trouvé 104 185 copies publiques de ce fichier de réglages local. L'entreprise a classé 1 122 d'entre elles comme contenant au moins un secret réel, soit 1 379 credentials distincts dans les fichiers actuels. L'ancien historique Git, les réglages partagés et d'autres artefacts d'agents font monter le total à 2 539.
Ces chiffres demandent une réserve.
Apiiro a classé comme réels les clés qui correspondent au format d'un fournisseur, ainsi que les mots de passe ou tokens placés près d'un hôte public. L'entreprise n'a pas démontré que chaque credential était encore actif. Elle précise qu'une organisation touchée a confirmé que sa clé avait été valide.
Cela suffit néanmoins à établir le problème d'ingénierie.
Une autorisation qui paraît temporaire dans l'interface peut créer un état durable. Cet état peut survivre à la session, se retrouver dans un commit, rester dans l'historique Git, puis se propager dans des forks et des clones.
La leçon pratique dépasse un seul fichier de Claude Code :
Tout fichier écrit par un agent à propos de son travail doit être considéré comme potentiellement porteur de secrets.
« Ne plus demander » est une opération d'écriture
L'interface présente l'autorisation permanente comme une réduction des interruptions.
L'utilisateur voit plusieurs fois la même commande, décide qu'elle est sûre et demande à l'agent de cesser de l'interrompre. Cela ressemble à un changement de préférence.
En dessous, le produit doit mémoriser ce qui a été autorisé. Claude Code le fait en écrivant une règle de permission dans un fichier de réglages local au projet.
La distinction compte, car une commande n'est pas seulement un verbe.
Elle peut aussi transporter des données :
- une URL de base de données avec un mot de passe intégré
- une requête
curlavec un bearer token - une variable d'environnement affectée directement dans la commande
- une commande SSH avec un mot de passe
- une commande de package manager avec un token de registre
Enregistrer la commande exacte revient à enregistrer à la fois le motif d'autorisation et les données qui se trouvaient dedans.
Ce comportement a été signalé dans le tracker public d'Anthropic en août 2025. L'issue contient des étapes de reproduction montrant des credentials écrits tels quels dans l'allowlist. Elle a ensuite été fermée automatiquement pour inactivité, pas à la suite d'un correctif de sécurité documenté.
La question importante n'est pas de savoir si le modèle a décidé de faire fuiter un secret.
Ce n'est pas le cas.
Il s'agit d'un comportement du produit autour du modèle : le système de permissions a persisté une commande, puis un développeur a committé le fichier obtenu.
Cette séparation évite un mauvais diagnostic. Un meilleur alignement du modèle ne corrigerait pas un design de stockage qui conserve des arguments sensibles.
Une exclusion globale ne protège qu'une machine
Anthropic essaie bien d'empêcher l'entrée de .claude/settings.local.json dans Git.
Sa documentation actuelle indique que Claude Code ajoute le chemin au fichier global d'exclusion Git du développeur lors de la première écriture du fichier local. Cela couvre le cas ordinaire sur cette machine.
Mais une exclusion globale reste un état local.
Il ne voyage pas avec le dépôt.
Un nouvel ordinateur, un runner CI, un conteneur, un environnement de développement cloud ou le clone d'un collègue peut ne pas posséder la même règle. Un dossier peut devenir un dépôt Git après la création du fichier. Un fichier créé à la main peut ne jamais déclencher l'exclusion automatique. Un fichier déjà suivi le reste même si une règle d'exclusion apparaît ensuite.
La documentation d'Anthropic reconnaît une partie de cette limite : si l'utilisateur crée le fichier lui-même, il doit l'ajouter à .gitignore.
Les données d'Apiiro montrent le résultat de ces cas limites quand ils rencontrent le comportement normal des développeurs. Sur 1 105 dépôts touchés que l'entreprise a pu retracer, 539 contenaient un commit modifiant le fichier et attribuant à Claude le rôle de coauteur.
Cela ne signifie pas que Claude a publié 539 secrets de manière autonome.
Cela signifie que les commits assistés par agent font entrer l'état généré dans la même opération générale de staging que le code source. Si le dépôt ne déclare pas lui-même ce qui doit rester local, la personne et l'agent dépendent tous deux d'une configuration propre à une machine, qu'aucun ne vérifiera forcément avant git add.
La politique de sécurité doit voyager avec le projet.
Un état créé pour le confort ne devrait pas bénéficier d'une frontière plus faible simplement parce qu'un outil l'a généré.
Les scanners comprennent mieux les formats que l'intention
L'analyse révèle aussi une seconde faille.
Apiiro a exécuté Gitleaks et TruffleHog sur les 104 185 fichiers de réglages locaux publics. Parmi les 1 122 fichiers classés comme contenant un secret réel, 215 n'ont été signalés par aucun des deux scanners.
Ce résultat n'est pas surprenant une fois l'artefact compris.
Les scanners de secrets sont les plus efficaces quand un credential possède une structure reconnaissable : un préfixe fournisseur, une longueur connue, un alphabet particulier ou une syntaxe voisine qui nomme un service courant.
Un mot de passe intégré à une commande shell autorisée peut ressembler à un mot ordinaire.
Le fichier apporte un contexte sémantique que le scanner générique ne possède pas toujours. Une chaîne devient dangereuse parce qu'elle se trouve après un flag de mot de passe, dans une URL de connexion ou à côté d'un hôte de base de données public. Le même motif peut apparaître dans des transcriptions, des fichiers de mémoire, des notes de déploiement et des logs de débogage.
La push protection de GitHub reste utile. Elle peut bloquer les formats de secrets pris en charge avant leur arrivée dans un dépôt. GitHub accepte aussi des motifs personnalisés pour les credentials propres à une organisation.
Aucune de ces fonctions ne garantit la détection de chaque argument ressemblant à un mot de passe.
Le bon modèle comporte plusieurs couches :
- ne pas placer de secret dans une commande lorsqu'une référence plus sûre est disponible
- ne pas enregistrer de commandes sensibles exactes comme autorisations réutilisables
- exclure les artefacts locaux des agents du dépôt par une politique propre au projet
- analyser les fichiers actuels et tout l'historique
- bloquer les secrets reconnaissables au moment du push
- faire tourner tout credential qui a franchi la frontière
Le scan constitue la dernière chance de rattraper un défaut de conception, pas une autorisation à le créer.
L'état de l'agent entre dans la supply chain logicielle
La partie la plus importante du rapport d'Apiiro ne se limite pas à .claude/settings.local.json.
Les chercheurs ont aussi trouvé des credentials dans les réglages Claude partagés, les transcriptions enregistrées, les fichiers de mémoire des agents, les notes de passation et de déploiement, des exports Cursor, des logs Aider et les réglages d'approbation automatique de Copilot.
Ces fichiers occupent une catégorie inconfortable.
Ils ne sont pas du code source, donc les développeurs peuvent les relire avec moins d'attention.
Ils ne sont pas des coffres à secrets traditionnels, donc les outils de sécurité peuvent ne pas les surveiller.
Ils sont souvent en texte brut, car l'agent doit pouvoir les lire.
Et ils deviennent de plus en plus utiles, car les agents qui travaillent longtemps ont besoin de mémoire, de permissions, d'un état reprenable, de configuration d'outils et d'un historique du travail précédent.
C'est précisément cette utilité qui va faire croître la catégorie.
Un agent qui ne se souvient de rien est frustrant. Un agent qui se souvient de tout devient un système de rétention. Le travail d'ingénierie consiste à décider quelles informations peuvent persister, où, pendant combien de temps et quel processus peut les publier.
Les équipes posent déjà ces questions pour les fichiers .env, les variables CI, les gestionnaires de credentials, les logs, les crash dumps et les sauvegardes de bases de données.
Les artefacts d'agents appartiennent au même inventaire.
Ils doivent avoir des responsables, des règles de rétention, des règles de dépôt, une couverture de scan, des contrôles d'accès et des procédures de suppression. Les produits doivent distinguer les motifs de permission exécutables de l'historique littéral des commandes. Les secrets devraient être passés par référence au moyen de variables d'environnement limitées ou de courtiers de credentials, pas copiés dans des chaînes de politique réutilisables.
Le modèle n'est qu'un participant dans ce système.
C'est le harness qui décide ce qui est écrit.
Ce que les équipes devraient faire maintenant
Commencez par inventorier les fichiers d'agents déjà suivis.
Pour Claude Code, vérifiez .claude/settings.local.json et le fichier partagé .claude/settings.json dans chaque dépôt. Inspectez tout l'historique Git, pas seulement la branche actuelle. Étendez l'inventaire aux transcriptions, aux fichiers de mémoire, aux notes de passation et aux autres répertoires d'agents de code employés par l'équipe.
Effectuez cette revue localement. Ne collez pas le contenu suspect dans un autre modèle ou dans un outil de tickets.
Considérez ensuite tout credential découvert comme exposé.
Faites-le tourner ou révoquez-le avant de nettoyer le dépôt. Supprimer le fichier actuel ne retire pas le secret des anciens commits, forks, clones, caches ou artefacts de build. Réécrire l'historique peut réduire l'exposition, mais ne peut pas rendre à nouveau digne de confiance un credential déjà copié.
Placez ensuite la règle du dépôt dans le dépôt.
Ajoutez les réglages locaux des agents et les autres états personnels au .gitignore du projet, aux templates de l'organisation et aux contrôles de politique. Gardez les réglages partagés minimaux et sans credentials littéraux. Refusez les artefacts sensibles d'agents dans la CI, même si l'ignore global d'un développeur a échoué.
Changez aussi la manière dont les commandes reçoivent les secrets.
Préférez les credentials à courte durée de vie, les références à des variables d'environnement, les gestionnaires de secrets et les courtiers qui injectent un credential uniquement au moment de l'exécution. Une permission réutilisable devrait décrire la forme d'une action autorisée, pas conserver une commande entièrement résolue avec des données de production.
Enfin, analysez au-delà des formats de clés connus.
Recherchez les positions d'arguments sensibles et les structures de chaînes de connexion dans les dossiers propres aux agents. Activez la push protection, définissez des motifs personnalisés pour les credentials internes et examinez les contournements. Considérez une allowlist volumineuse ou en forte croissance comme un signal de risque, pas comme une preuve de productivité.
En bref
Claude Code n'a pas téléversé seul 2 539 secrets.
Apiiro a mis en évidence une chaîne de petites décisions de design et de workflow :
- des commandes transportaient des credentials
- les autorisations permanentes ont conservé ces commandes
- l'état des agents vivait à côté du code source
- les règles d'exclusion propres à une machine n'ont pas toujours tenu
- des commits larges ont inclus ces fichiers
- les scanners ont manqué certains mots de passe non structurés
- l'historique Git a gardé ce que les développeurs ont supprimé ensuite
Aucune étape ne paraît spectaculaire prise séparément.
Ensemble, elles créent une nouvelle forme de prolifération des secrets.
Les agents de code deviennent des collaborateurs durables. Ils conservent des permissions, des mémoires, des transcriptions, des plans et des passations, car la continuité les rend plus utiles.
La continuité crée aussi des traces.
La frontière de sécurité ne peut plus s'arrêter à l'arborescence du code et au fichier .env. Elle doit inclure chaque artefact que l'agent écrit en apprenant à travailler.
Si un agent peut se souvenir d'une commande, partez du principe qu'il peut se souvenir du secret qu'elle contient.
Puis concevez le système pour qu'il n'ait jamais à le faire.