La clé API qui finit publiée sur GitHub n'est presque jamais le résultat d'une négligence unique et spectaculaire. C'est presque toujours la conséquence d'un détail d'outillage mal compris : un .gitignore ajouté après le premier commit, un build tool qui inline des variables sans prévenir, ou un historique git qu'on croit "nettoyé" parce que le fichier n'apparaît plus dans l'état courant. Comprendre le mécanisme exact derrière chaque fuite permet de la bloquer à la source, plutôt que de réagir après coup.
Le piège du .gitignore tardif
Ajouter .env à .gitignore n'a aucun effet sur les fichiers déjà suivis par git. Git ignore uniquement les fichiers non trackés ; si .env a été commité une seule fois, ne serait-ce que dans le tout premier commit du projet, il reste dans l'historique indéfiniment, même si on le supprime et l'ignore ensuite.
# Ce commit NE supprime PAS .env de l'historique
git rm --cached .env
echo ".env" >> .gitignore
git commit -m "chore: remove env file from tracking"
# .env reste lisible via :
git show <commit-initial>:.env
Le vrai nettoyage nécessite de réécrire l'historique avec git filter-repo (ou, en dernier recours, BFG Repo-Cleaner), puis de forcer un push, en coordination avec toute l'équipe puisque ça réécrit les SHA. Et même après ça : tout secret qui a été poussé publiquement doit être considéré comme compromis et révoqué, pas seulement effacé de l'historique. Un historique public, même brièvement, a pu être cloné, mis en cache par des miroirs, ou indexé.
Les faux positifs de "c'est côté backend, c'est safe"
Une variable d'environnement n'est pas automatiquement privée. Dans la plupart des frameworks frontend modernes, une convention de préfixe détermine explicitement ce qui est exposé au navigateur :
# .env - Next.js
DATABASE_URL=postgres://user:pass@host:5432/db # reste côté serveur
NEXT_PUBLIC_API_BASE_URL=https://api.example.com # inliné dans le bundle JS
Avec Vite, c'est VITE_, avec Create React App c'était REACT_APP_. Le danger vient de la confusion inverse : un développeur qui préfixe par réflexe une clé sensible (clé API tierce, secret de signature) avec NEXT_PUBLIC_ ou VITE_ parce que "c'est plus simple pour y accéder dans le composant". Le build tool l'inline alors littéralement en clair dans le JavaScript servi au navigateur, visible pour n'importe qui via les devtools, indépendamment de tout dépôt git.
// Ce code expose la clé dans le bundle final, pas seulement dans le repo
const stripeSecret = process.env.NEXT_PUBLIC_STRIPE_SECRET_KEY;
La règle est simple et non négociable : tout secret qui doit rester confidentiel ne porte jamais le préfixe public, et doit être consommé exclusivement côté serveur (route API, server action, backend séparé), jamais importé dans un composant qui s'exécute côté client.
Le cas des secrets dans les logs CI/CD
Un pipeline CI qui echo $API_KEY pour debug, ou qui logue la commande complète exécutée (y compris ses arguments) laisse le secret en clair dans les logs de build, souvent accessibles à toute l'équipe voire publics selon la configuration du repo. GitHub Actions masque automatiquement les valeurs des secrets déclarés via secrets.*, mais seulement si la variable passe réellement par ce mécanisme, et seulement si elle apparaît telle quelle (un secret encodé en base64 ou concaténé échappe au masquage).
# .github/workflows/deploy.yml
- name: Deploy
env:
API_KEY: ${{ secrets.API_KEY }}
run: |
echo "Deploying with key: $API_KEY" # apparaît masqué dans les logs GitHub
curl -H "Authorization: Bearer $API_KEY" https://... # idem si bien déclaré en secret
Le vrai risque vient des scripts qui manipulent le secret avant de l'utiliser (transformation, découpage, interpolation dans une URL) : la valeur transformée n'est plus reconnue comme le secret original et n'est donc pas masquée.
Diagnostiquer une fuite déjà commise
Avant de paniquer ou de réagir au hasard, il faut établir précisément ce qui a fuité et où. git log -p -- .env montre l'historique complet du fichier s'il a été tracké. Des outils comme trufflehog ou gitleaks scannent tout l'historique d'un dépôt à la recherche de patterns de secrets connus (clés AWS, tokens Stripe, clés privées) et donnent une liste exhaustive plutôt qu'une impression.
gitleaks detect --source . --log-opts="--all" --report-path gitleaks-report.json
Cette étape de diagnostic est systématiquement ignorée en situation de panique, alors qu'elle seule permet de savoir si l'incident concerne un fichier ou dix, un commit isolé ou tout un historique.
La bonne architecture pour éviter de refaire la même erreur
Le correctif durable n'est pas une discipline personnelle ("je vais faire attention"), c'est une architecture qui rend l'erreur impossible ou immédiatement visible :
- Un
.env.exampleversionné, avec les noms de variables mais des valeurs factices, pour que l'onboarding n'implique jamais de copier un vrai.envexistant. - Un secret manager dédié (Doppler, Vault, AWS Secrets Manager, ou les "Environment Secrets" natifs de la plateforme de déploiement) plutôt que des fichiers
.envdistribués par Slack ou copiés d'un poste à l'autre. - Un hook pre-commit (
gitleaks protectougit-secrets) qui bloque le commit avant qu'il n'entre dans l'historique, plutôt qu'un scan après coup.
# .pre-commit-config.yaml
repos:
- repo: https://github.com/gitleaks/gitleaks
rev: v8.18.4
hooks:
- id: gitleaks
- La rotation systématique de tout secret qui a transité par un canal non audité (email, chat, fichier partagé en clair), indépendamment de toute fuite confirmée.
Quand la rotation seule ne suffit pas
Révoquer et régénérer une clé API coupe l'accès futur, mais ne répare rien si le secret compromis a déjà servi à exfiltrer des données ou créer des ressources (instances cloud, utilisateurs IAM, webhooks) pendant la fenêtre d'exposition. Dans ce cas, la rotation doit s'accompagner d'un audit des logs d'accès du service concerné (CloudTrail pour AWS, logs d'API Stripe, etc.) sur toute la période où le secret a été exposé, pour vérifier qu'aucune action non légitime n'a eu lieu. Cette étape dépasse souvent le périmètre d'un développeur seul et relève d'une procédure de réponse à incident formalisée avec l'équipe sécurité ou l'hébergeur.
Le piège des secrets dans les images Docker
Un ARG ou une variable injectée pendant un docker build semble disparaître une fois le conteneur en production, mais elle reste en réalité imprimée dans les métadonnées de chaque couche de l'image, consultable avec docker history ou en inspectant le filesystem de la couche concernée, même si une étape ultérieure du Dockerfile la supprime du filesystem final.
# Mauvais : le secret reste visible dans l'historique de l'image
ARG NPM_TOKEN
RUN echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > .npmrc && \
npm install && \
rm .npmrc
# docker history <image> montre encore la commande complète avec le token en clair
La bonne approche utilise les secrets de build dédiés de BuildKit, qui montent le secret uniquement pendant l'exécution de l'instruction concernée, sans jamais l'écrire dans une couche persistante de l'image :
# syntax=docker/dockerfile:1
RUN --mount=type=secret,id=npm_token \
NPM_TOKEN=$(cat /run/secrets/npm_token) && \
echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > .npmrc && \
npm install && rm .npmrc
docker build --secret id=npm_token,src=./npm_token.txt .
Ce mécanisme garantit que le secret n'apparaît dans aucune couche intermédiaire de l'image finale, contrairement à un ARG ou un ENV classique.
À retenir : un secret qui fuite est presque toujours un problème de mécanisme, pas de vigilance individuelle, retirer .env du suivi git ne l'efface pas de l'historique, préfixer une variable "publique" l'inline dans le bundle client, et le seul correctif fiable face à une fuite confirmée est la révocation immédiate du secret, jamais sa simple suppression du code.
