AI CodeOps

Que faire lorsqu'un secret a été commité dans Git

Mis à jour le

La marche à suivre, étape par étape, quand un identifiant est commité dans un dépôt Git : révoquer et faire la rotation d'abord, rechercher les abus, nettoyer l'historique, éviter la récidive.

Lorsqu'un secret, comme une clé API, un token, un mot de passe ou une clé privée, est commité dans un dépôt Git, révoquez-le et faites-en la rotation d'abord, puis déterminez à quoi il donnait accès et s'il a été utilisé, puis retirez-le du code et, si votre politique l'exige, de l'historique. Supprimer la ligne dans un nouveau commit ne sert à rien à lui seul : Git conserve chaque version antérieure, et chaque clone, fork et cache de CI en possède une copie. Considérez l'identifiant comme compromis dès l'instant où il a été poussé.

Cette page développe la partie consacrée à la détection de secrets de Comment sécuriser le code généré par l'IA ?.

Pourquoi supprimer la ligne ne suffit pas

Un dépôt Git est un historique, pas un dossier. Retirer un secret dans un nouveau commit le laisse dans le commit précédent, où toute personne qui a accès au dépôt peut le lire avec une seule commande. Des copies existent aussi en dehors du dépôt :

  • le clone de chaque développeur et chaque fork ;
  • les systèmes de CI qui ont cloné le dépôt, ainsi que leurs caches et leurs journaux ;
  • les vues du commit propres à l'hébergeur Git, et toute pull request qui le contenait ;
  • les images de conteneur ou les artefacts de build produits à partir de ce commit ;
  • les sauvegardes et les miroirs.

Les dépôts publics sont analysés en continu par des outils automatisés qui cherchent des identifiants : pour un dépôt public, partez donc du principe que le secret a été vu dès qu'il a été poussé. Pour un dépôt privé, l'audience est plus restreinte, mais pas nulle.

Étape 1 : révoquer et faire la rotation

La rotation est la seule étape qui rend la valeur divulguée inutilisable. Faites-la en premier, avant tout nettoyage.

  1. Émettez un identifiant de remplacement auprès du fournisseur.
  2. Déployez le remplacement partout où il est utilisé légitimement.
  3. Révoquez l'identifiant divulgué pour qu'il ne fonctionne plus.

Si le secret a un fort impact et que l'exposition est publique, révoquez-le immédiatement et acceptez une courte panne plutôt que de laisser un identifiant valide exposé pendant que vous déployez le remplacement. Certains fournisseurs détectent leurs propres clés dans les dépôts publics et les révoquent automatiquement ; ne comptez pas là-dessus.

Étape 2 : comprendre le périmètre

Notez ce que l'identifiant permettait de faire :

  • Ce qu'il accorde. Un accès en lecture seule à un service, ou un accès administrateur à un compte cloud ?
  • Où il est utilisé ailleurs. Un identifiant partagé signifie davantage de systèmes où faire la rotation.
  • Quand il a été exposé. L'heure du commit marque le début de la période à examiner.
  • Qui pouvait le voir. Le public, toute l'organisation ou une seule équipe ? Y avait-il des forks ?

Cela détermine l'ampleur de l'enquête que demande l'incident, et qui doit être informé.

Étape 3 : rechercher les abus

Consultez les journaux d'audit ou d'accès du fournisseur pour repérer toute activité utilisant l'identifiant pendant la période d'exposition : adresses IP inconnues, régions inattendues, nouvelles ressources, accès inhabituels aux données, ou pics d'utilisation et de facturation. Si vous trouvez un abus, l'affaire est devenue un incident de sécurité qui appelle sa propre réponse : contenir, établir ce qui a été consulté, et prévenir les personnes que vos politiques et vos obligations imposent d'informer.

Étape 4 : nettoyer le code et l'historique

Retirez le secret du code actuel et remplacez-le par une référence à l'endroit où se trouve désormais la valeur : une variable d'environnement, un gestionnaire de secrets ou un fichier de configuration qui n'est pas commité.

Réécrire aussi l'historique ou non dépend de votre politique. Si vous le faites :

  • Utilisez un outil conçu pour cela, comme git filter-repo ou BFG Repo-Cleaner. Le projet Git recommande git filter-repo plutôt que l'ancien git filter-branch.
  • Coordonnez-vous avec toutes les personnes qui travaillent sur le dépôt. Une réécriture change les empreintes des commits : les clones existants doivent donc être reclonés ou réinitialisés avec soin.
  • Vérifiez ce que conserve votre hébergeur Git. Les références de pull request et les vues en cache peuvent encore afficher les anciens commits ; la documentation de l'hébergeur explique comment les faire supprimer.
  • N'oubliez pas que les forks et les clones sont hors de portée. C'est pour cela que la rotation passe en premier.

Nettoyez les journaux de CI et reconstruisez les artefacts ou les images qui contenaient le secret.

Étape 5 : corriger la cause

Découvrez comment le secret est arrivé dans le dépôt, et fermez cette voie.

  • Gardez les secrets hors des fichiers suivis. Les fichiers de configuration locaux comme .env ont leur place dans .gitignore, avec un fichier d'exemple commité qui contient des valeurs fictives.
  • Analysez avant le commit. Des hooks pre-commit qui exécutent un scanner de secrets, comme gitleaks, TruffleHog ou detect-secrets, interceptent la plupart des erreurs sur le poste du développeur.
  • Analysez au push. Certains hébergeurs Git proposent une protection au push (push protection) qui rejette un push contenant un identifiant reconnu.
  • Analysez l'historique une fois. Une analyse ponctuelle de tout l'historique trouve les fuites plus anciennes que personne n'a remarquées.
  • Injectez les identifiants au moment du build et de l'exécution. Les jobs de build et de déploiement reçoivent les secrets d'un gestionnaire de secrets ou du coffre de secrets du système de CI, limités aux jobs qui en ont besoin et masqués dans les journaux.
  • Préférez les identifiants à courte durée de vie. Lorsque les fournisseurs le permettent, l'identité de charge de travail (workload identity) ou des tokens qui expirent en quelques minutes limitent les dégâts de toute fuite.

Étape 6 : consigner ce qui s'est passé

Rédigez un bref compte rendu : ce qui a fuité, quand, combien de temps l'exposition a duré, à quoi cela donnait accès, si cela a été utilisé, ce qui a fait l'objet d'une rotation et ce qui a changé pour éviter la récidive. C'est utile pour les audits, et c'est le meilleur moyen de remarquer quand le même type d'erreur se répète.

Les secrets et les agents de codage IA

Les agents IA ouvrent de nouvelles voies de fuite pour les secrets. Un agent qui lit un fichier .env peut recopier une vraie clé dans du code, une fixture de test ou un exemple de configuration. Un agent à qui l'on donne un identifiant dans son prompt ou son contexte peut l'écrire dans sa sortie, dans des journaux ou dans une requête envoyée à un fournisseur de modèles. Et les journaux de prompts côté fournisseur peuvent désormais contenir le secret eux aussi, ce qui signifie que la réponse est, là encore, la rotation, et non la suppression.

Le contrôle le plus efficace est simple : les agents qui écrivent du code ne devraient jamais avoir d'identifiants de production dans leur contexte. Confiez les secrets au job de build ou de déploiement qui en a besoin, pas à l'agent.

Comment AI CodeOps gère les secrets

AI CodeOps n'analyse pas vos dépôts à la recherche de secrets ; continuez d'utiliser un scanner de secrets dans votre propre pipeline. Ce qu'il fait, c'est tenir les secrets de l'espace de travail à l'écart des agents IA et enregistrer la façon dont ils sont gérés.

  • Chiffrés et masqués. Les secrets de l'espace de travail sont chiffrés au repos avec AES-256-GCM. Après l'enregistrement, la console n'affiche plus qu'un masque.
  • Périmètre limité, rotation possible. Un secret peut être limité à des workflows précis, recevoir une date d'expiration, être désactivé ou faire l'objet d'une rotation sur place, avec l'heure et la version de la rotation enregistrées.
  • Tenus à l'écart des agents. Les secrets parviennent aux jobs de build sous forme de variables d'environnement, et leurs valeurs sont retirées du journal de build. Les agents IA ne les reçoivent jamais.
  • Audités. La création, la mise à jour, l'activation ou la désactivation et la suppression d'un secret sont enregistrées dans le journal d'audit. Le rôle Secret Manager peut gérer les secrets sans aucun autre accès.
  • Changements relus. La revue des constats de chaque changement de l'IA couvre la sécurité, et le Security Auditor recherche les secrets exposés dans les workflows qui l'incluent. Une règle de politique peut refuser les changements sur des chemins comme config/secrets/**.

Consultez Sécurité et SBOM, l'entrée du glossaire détection de secrets et Sécurité et suivi des SBOM pour la vue d'ensemble.

Questions fréquentes

Supprimer le secret dans un nouveau commit suffit-il ?

Non. Le secret reste dans l'historique du dépôt, dans chaque clone et chaque fork, et peut-être dans des journaux et des caches de CI. Révoquez-le et faites-en la rotation ; le supprimer du code est une étape de nettoyage ultérieure.

Faut-il réécrire l'historique Git après la fuite d'un secret ?

Seulement après la révocation du secret, et seulement si votre politique l'exige. Une réécriture n'atteint pas les clones et les forks existants, et elle perturbe tous ceux qui travaillent sur le dépôt, si bien qu'elle ne remplace jamais la rotation.

Et si le dépôt est privé ?

Faites quand même la rotation. Toutes les personnes qui y ont accès, chaque système de CI qui le clone, chaque fork et chaque sauvegarde détiennent désormais le secret. Un dépôt privé réduit l'exposition ; il ne la supprime pas.

Comment éviter que des secrets soient commités dès le départ ?

Gardez les secrets hors des fichiers qui sont commités, analysez avant chaque commit avec un hook pre-commit, activez la protection au push si votre hébergeur Git la propose, et injectez les identifiants dans les jobs de build depuis un gestionnaire de secrets au lieu de les stocker dans le dépôt.