Aller au contenu principal
own2pwn
Gitleaks : détecter les secrets dans Git (mesure sur trois corpus à secrets connus)

Gitleaks : détecter les secrets dans Git (mesure sur trois corpus à secrets connus)

Gitleaks scanne l'historique Git à la recherche de clés d'API et de tokens. Je l'ai lancé sur trois corpus dont je connais chaque secret : ce qu'il trouve, ce qu'il rate, et ce qu'une .gitleaks.toml cache en coupant le bruit.

Maxime J9 min de lecture

Des secrets qui traînent dans vos dépôts ?

SecAI cherche secrets, dépendances vulnérables et failles de code dans vos pipelines.

Scanner mes secrets

J'ai installé le binaire gitleaks version 8.28.0 et je l'ai lancé sur trois corpus locaux dont je connais chaque secret : le dépôt d'entraînement leaky-repo (88 secrets annotés), 25 jetons fictifs au format réel, et un petit dépôt de 14 leurres (exemples de documentation, nonce de la RFC 6455, fixtures, clé TLS de test) mélangés à 7 secrets plantés. Résultat : gitleaks trouve vite ce qui a une forme reconnaissable, rate presque tout le reste, et la configuration anti-bruit qu'on écrit ensuite cache aussi de vrais secrets si on ne la teste pas.

On regarde comment gitleaks cherche, ce qu'il trouve et ce qu'il rate, pourquoi la règle générique produit l'essentiel du bruit, et surtout comment écrire une .gitleaks.toml qui fait taire les faux positifs sans jamais cacher une vraie fuite de secrets. Toutes les commandes sont reproductibles, les valeurs sont masquées, et aucun dépôt n'est montré du doigt.

Méthode de la mesure

Trois corpus locaux, tous fictifs : leaky-repo (88 secrets annotés, mesure du 6 octobre 2026), 25 jetons fictifs aux formats récents, et un dépôt de 14 leurres et 7 secrets plantés construit le 7 octobre 2026. Gitleaks 8.28.0, réseau coupé, classement vrai / faux positif fait à la main contre la liste des secrets plantés, valeurs jamais reproduites ici. Le dépôt de leurres est une démonstration, pas un échantillon : je l'ai écrit en connaissant déjà l'allowlist présentée plus bas, il illustre un comportement et ne mesure aucune fréquence. Aucun dépôt tiers n'a été scanné : on y trouverait les secrets de quelqu'un d'autre.

Comment gitleaks cherche un secret

Gitleaks est un binaire Go qui ne fait rien de magique : il lit du texte et le confronte à des règles. Chaque règle combine trois signaux. Un motif (une expression régulière) qui décrit la forme du secret, par exemple le préfixe ghp_ suivi de 36 caractères pour un token GitHub. Un jeu de mots-clés qui pré-filtre les lignes candidates avant même de lancer le regex, pour la vitesse. Et un seuil d'entropie (l'entropie de Shannon) qui mesure le désordre d'une chaîne : un vrai secret ressemble à du bruit aléatoire, un mot du dictionnaire non.

Le jeu de règles par défaut de la version 8.28.0 compte plus de 200 règles, pour plus d'une centaine de fournisseurs (AWS, Stripe, Slack, clés SSH, JWT). Quand aucune règle spécifique ne colle, une règle attrape-tout nommée generic-api-key prend le relais : elle cherche une variable au nom évocateur (key, token, secret) assignée à une chaîne à forte entropie. C'est elle qui rattrape ce que les autres ratent, et c'est aussi elle qui génère l'essentiel du bruit, on va le voir.

Deux commandes séparent les deux façons de scanner. Le choix entre les deux décide de ce que vous voyez.

bash
# gitleaks 8.28.0 (binaire officiel, releases GitHub)
gitleaks version           # => 8.28.0

# Analyser l'arbre de travail : uniquement les fichiers PRESENTS
gitleaks dir ./mon-repo --redact=100 --no-banner \
  --report-format json --report-path rapport.json

# Rejouer tout l'historique via 'git log -p' : voit aussi les secrets SUPPRIMES
gitleaks git ./mon-repo --redact=100 --no-banner \
  --report-format json --report-path histoire.json

--redact=100 masque intégralement la valeur trouvée dans le rapport : on garde le nom de la règle, le fichier et la ligne, jamais la clé. C'est la première chose à câbler quand un rapport gitleaks doit atterrir dans un ticket ou un log de CI, sinon on recopie le secret là où il ne devrait pas être. Les commandes detect et protect des anciennes versions existent toujours mais sont masquées de l'aide : sur une version récente, on écrit gitleaks git et gitleaks dir.

La mesure : gitleaks sur trois corpus à secrets connus, sans réglage

Jeu de règles par défaut, arbre de travail. Comme on connaît chaque secret planté, on peut compter ce qui est trouvé, ce qui est raté et ce qui sonne pour rien.

mesure-brute
CorpusAlertesVrais secrets trouvésFaux positifs
leaky-repo (88 secrets annotés)2221 sur 880
25 jetons fictifs au format réel2423 sur 250
Dépôt de leurres (7 secrets, 14 leurres)136 sur 74 leurres sur 14
Mesure own2pwn, gitleaks 8.28.0 configuration par défaut, réseau coupé. leaky-repo mesuré le 6 octobre 2026, jetons fictifs et dépôt de leurres le 7 octobre 2026. Une alerte informative ou un doublon n'est ni un vrai ni un faux positif.

Deux leçons. D'abord, gitleaks est excellent sur ce qui a une forme reconnaissable : 23 jetons fictifs sur 25, et aucun faux positif sur leaky-repo. Mais sur ce même dépôt, 67 secrets sur 88 passent sous le radar : mots de passe en clair, hachages, mots de passe chiffrés, tout ce qui n'a ni préfixe ni entropie marquée. Sur le dépôt de leurres, le secret raté est justement un mot de passe de base de données écrit en clair dans le code.

Ensuite, les 4 leurres qui sonnent sont exactement ceux qu'on attend : le nonce d'exemple du handshake WebSocket, celui gravé dans la RFC 6455 (il se décode en "the sample nonce"), une clé TLS de test, une constante dans un fichier _test.go, et le jeton d'une fixture. Ce n'est pas un défaut de gitleaks, c'est la contrepartie d'une règle attrape-tout. Le curseur se règle après coup, avec une allowlist, et c'est là que ça se complique.

Pourquoi le bruit vient toujours des mêmes endroits

Regardez où atterrissent les faux positifs : documentation, dossiers de tests, fichiers de fixtures, certificats .pem d'exemple. Ce sont les zones d'un dépôt où l'on écrit des valeurs qui ressemblent à des secrets sans en être. Un tutoriel montre une clé d'API pour illustrer ; un test unitaire a besoin d'un token bidon pour exercer un parseur ; une suite HTTP embarque une clé privée jetable pour monter un serveur TLS local. Tout ça est légitime, et tout ça déclenche l'entropie.

tri-secret
Entrée
Chaîne à forte entropie repérée
generic-api-key lève une alerte sur key, token ou secret + valeur désordonnée.
Cas 1
Docs, tests, fixtures
Placeholder ou constante de test. Faux positif : à mettre en allowlist par chemin.
Cas 2
Certificat .pem de test
Vraie clé, mais jetable et intentionnelle. Bruit : allowlist par extension.
Cas 3
Code applicatif, config, .env
Vrai secret : à révoquer et sortir de l'historique. C'est la seule alerte qui compte.
Le même signal d'entropie élevée sort trois choses très différentes. La règle les traite pareil ; c'est à vous de trancher.

L'idée d'une bonne configuration n'est donc pas de désactiver la règle bruyante, ce serait jeter le bébé, mais de dire à gitleaks où le bruit est attendu. On garde la détection partout, on la neutralise seulement dans les zones non applicatives. C'est le rôle des allowlists par chemin.

La .gitleaks.toml qui coupe le bruit, et ce qu'elle cache

Voici la configuration que j'ai testée sur les trois corpus. Elle étend le jeu de règles par défaut (useDefault = true), ajoute deux allowlists globales et une règle maison. La syntaxe suit le format courant de gitleaks 8.28 : [[allowlists]] au pluriel, avec une condition, des paths et des stopwords.

toml
title = "own2pwn baseline"

[extend]
useDefault = true   # herite du jeu de regles standard (plus de 200 en 8.28)

# Le bruit vient presque toujours des memes endroits : docs, tests, fixtures.
[[allowlists]]
description = "Chemins non applicatifs"
condition   = "OR"
paths = [
  '''(^|/)docs?/''',
  '''(^|/)(test|tests|testdata|__tests__|spec|fixtures?)/''',
  '''\.(rst|md|txt)$''',
  '''(^|/)[^/]*\.pem$''',           # certificats de test
  '''_test\.(go|py|js|ts|rb)$''',    # convention Go/JS : suffixe, pas dossier
]

# Placeholders evidents, quel que soit le fichier. regexTarget = "match"
# fait porter le stopword sur le texte matche, pas sur le chemin.
[[allowlists]]
description = "Placeholders"
condition   = "OR"
regexTarget = "match"
stopwords   = ["example", "dummy", "changeme", "placeholder", "sample", "test"]

# Une regle maison : detecte un token interne au format prj_live_<32 alphanum>.
[[rules]]
id          = "own2pwn-internal-token"
description = "Token interne own2pwn"
regex       = '''prj_live_[0-9a-zA-Z]{32}'''
keywords    = ["prj_live_"]

L'effet sur le dépôt de leurres : les alertes passent de 13 à 6, et les 4 faux positifs tombent. Mais elle cache aussi 2 des 6 secrets que gitleaks trouvait : une paire AWS au format réel oubliée dans tests/integration/, et un webhook Slack collé dans docs/. Ce 2 sur 6 est construit, pas mesuré : j'ai placé ces deux secrets dans tests/ et docs/, deux endroits où un vrai secret atterrit facilement, et l'allowlist les a fait disparaître sans bruit. Le constat suivant, lui, vient d'un corpus que je n'ai pas écrit : sur leaky-repo, la seule alerte qu'elle retire est une vraie clé privée rangée dans un .pem, et il reste 20 vrais secrets détectés au lieu de 21. Une allowlist par chemin ne distingue pas un faux secret d'un vrai secret rangé au mauvais endroit. Le seul test qui valide une allowlist : la rejouer contre un corpus où l'on sait qu'il y a des secrets, et regarder ce qu'elle fait disparaître. Si vous gardez l'exclusion des dossiers de tests, gardez au moins un scan sans allowlist en CI, non bloquant, dont on relit les nouveautés.

Un détail piège, vérifié en rejouant la configuration sans la ligne en question : une allowlist par nom de dossier tests/ ne suffit pas partout. En Go, un fichier de test s'appelle xxx_test.go et vit à côté du code, pas dans un dossier dédié. Sans la ligne _test\.(go|py|...)$, la constante du fichier _test.go sonnait encore.

Le hook pre-commit : bloquer avant que le secret parte

Gitleaks sait scanner l'index Git juste avant qu'un commit parte, avec le drapeau --staged. Deux façons de le câbler. La plus propre passe par le framework pre-commit, qui gère l'installation du binaire et la version :

yaml
# .pre-commit-config.yaml
repos:
  - repo: https://github.com/gitleaks/gitleaks
    rev: v8.28.0
    hooks:
      - id: gitleaks   # scanne l'index a chaque 'git commit'

Si vous n'utilisez pas pre-commit, un hook Git natif fait le même travail. On le pose dans .git/hooks/pre-commit (ou, mieux, dans un dossier versionné pointé par core.hooksPath pour qu'il suive l'équipe) :

bash
#!/usr/bin/env bash
# .git/hooks/pre-commit  (chmod +x)
# Bloque le commit si un secret est detecte dans l'index.
if ! gitleaks git --staged --redact=100 --no-banner; then
  echo "Secret detecte : commit refuse. Corrigez, ou #gitleaks:allow si faux positif."
  exit 1
fi

Le code de sortie fait tout : gitleaks renvoie 1 quand il trouve quelque chose, ce qui interrompt le commit. Pour lever un faux positif ponctuel sans toucher la config, on annote la ligne fautive d'un #gitleaks:allow, ou on enregistre son empreinte dans un fichier .gitleaksignore. Ce garde-fou local ne remplace pas un scan côté CI : un développeur peut toujours passer outre avec --no-verify. Les deux couches se cumulent, comme dans une chaîne d'analyse de code bien conçue.

Scanner l'historique, pas seulement l'arbre courant

Sur leaky-repo (25 commits), gitleaks dir (arbre de travail) lève 22 alertes ; gitleaks git (historique complet) en lève 26. J'ai d'abord cru que les quatre de plus étaient des secrets supprimés depuis. C'était faux : en comparant les alertes par fichier et par empreinte de la valeur, les 26 et les 22 portent sur les mêmes 19 secrets. Les quatre alertes en plus sont des secrets toujours présents dans l'arbre, retrouvés une seconde fois dans un autre commit. Sur ce dépôt, aucun secret ne survit seulement dans l'historique.

Le cas qui justifie le scan d'historique est ailleurs, et il est mécanique : une clé retirée par un commit de nettoyage reste dans le diff qui l'a ajoutée. gitleaks dir ne la voit plus, gitleaks git si, et toute personne qui clone le dépôt la récupère avec le reste de l'historique.

worktree-vs-histoire
Ce que fait le dépôt
Deux commits
  1. Le commit A ajoute clef.env et y écrit le secret S, qui entre dans l'historique.
  2. Le commit B supprime clef.env, mais le secret S reste gravé dans le commit A.
Ce que voit gitleaks
Deux commandes
  1. gitleaks dir ne voit pas S, puisque le fichier est absent de l'arbre de travail d'aujourd'hui.
  2. gitleaks git voit S, parce qu'il relit le diff du commit A.
Un secret retiré de l'arbre de travail survit dans l'historique. Le supprimer ne le révoque pas.

Supprimer un secret ne le révoque pas

Le premier réflexe après une fuite est souvent de retirer la clé dans un nouveau commit. C'est inutile : la valeur reste lisible dans l'historique, et surtout elle a peut-être déjà été clonée, indexée ou collectée. La seule action qui compte est de révoquer le secret côté fournisseur et d'en générer un nouveau. Réécrire l'historique (filter-repo, BFG) nettoie le dépôt, mais ne rend jamais mort un token déjà parti ailleurs. Le sujet rejoint celui, plus large, des fuites de données.

En pratique : gitleaks git une fois sur tout l'historique pour l'état des lieux (et la liste des secrets à révoquer), puis --staged en pre-commit pour que le problème n'augmente plus. C'est la même logique de fond que le traitement d'une gestion des vulnérabilités sérieuse : on arrête l'hémorragie, puis on remédie l'existant dans l'ordre.

Gitleaks, trufflehog ou detect-secrets ?

Trois outils reviennent dès qu'on parle de secret scanning, et ils ne jouent pas le même rôle. Gitleaks détecte par motif et entropie : rapide, sans dépendance, idéal en pre-commit et en CI. Son angle mort assumé, c'est qu'une alerte ne dit pas si la clé est encore active.

TruffleHog répond à ça : pour chaque secret qu'il sait classer, il tente de s'authentifier auprès du fournisseur pour confirmer si la clé est vivante. Son README annonce plus de 800 types de secrets reconnus, dont plus de 700 avec vérification active. Un secret "verified" est une urgence au même titre qu'un mot de passe compromis encore actif, un secret non vérifié attend. Cette information de vivacité change l'ordre de la remédiation. En contrepartie, la vérification interroge des API externes, ce qui a un coût et des implications réseau.

detect-secrets (Yelp) vise un troisième objectif : la prévention plutôt que l'archéologie. Son fichier de baseline acte les secrets déjà présents pour se concentrer sur les nouveaux, avec un workflow d'audit qui trie vrais et faux positifs. C'est adapté aux gros dépôts hérités où tout remédier d'un coup est illusoire. Dit autrement : gitleaks pour bloquer et scanner l'historique, un outil à vérification pour prioriser, un outil à baseline pour tenir un legacy. Ils se cumulent bien plus qu'ils ne se remplacent.

À retenir

  • Gitleaks trouve ce qui a une forme, et rate le reste : 6 des 7 secrets plantés et 23 jetons fictifs sur 25, mais 67 des 88 secrets de leaky-repo lui échappent (mots de passe en clair, hachages). Sur le dépôt de leurres, la règle generic-api-key porte 3 des 4 faux positifs.
  • Une .gitleaks.toml coupe le bruit, et des secrets avec : sur le dépôt de leurres, elle fait tomber les 4 faux positifs mais aussi les 2 secrets que j'avais placés dans un test et dans la doc (démonstration construite), et, mesuré sur leaky-repo, une vraie clé privée.
  • Toujours vérifier qu'une allowlist ne rend pas aveugle : on la teste contre un corpus où l'on sait qu'il y a des secrets.
  • Scanner l'historique, pas que l'arbre courant : sur leaky-repo, gitleaks git lève 26 alertes contre 22 pour gitleaks dir, sur les mêmes 19 secrets. Le vrai enjeu est le secret supprimé par un commit ultérieur : seul le scan d'historique le voit encore.
  • Supprimer un secret ne le révoque pas : la seule réponse correcte est la rotation côté fournisseur.
  • Le pre-commit arrête l'hémorragie : gitleaks git --staged refuse le commit, à doubler d'un scan CI puisqu'un hook local se contourne.

Un scanner en pre-commit protège vos dépôts. Il ne dit rien des clés qui traînent déjà ailleurs : dans un dépôt public d'un ancien prestataire, un gist oublié, un job de CI verbeux, tout ce qu'une reconnaissance OSINT sait remonter. Cette surface-là se surveille en continu, et c'est le rôle de la détection de secrets exposés de la plateforme EASM own2pwn, qui recoupe fuites publiques et actifs pour pointer ce qui vous appartient. Côté code, l'analyse SAST de SecAI cherche secrets, dépendances vulnérables et failles dans vos pipelines. Et si vous préférez qu'un humain regarde votre périmètre en conditions réelles, le pentest web blackbox est fait pour ça. Pour discuter du contexte, la page contact répond sous 24 h.

Questions fréquentes sur gitleaks

Qu'est-ce que gitleaks ?

Gitleaks est un scanner de secrets open source écrit en Go. Il parcourt un dépôt Git, ou un simple dossier, à la recherche de clés d'API, de tokens et de clés privées, à l'aide d'expressions régulières, d'un seuil d'entropie et de mots-clés. Il tourne en local, en pre-commit ou en CI, et sort son verdict au format JSON, CSV ou SARIF.

Comment lancer gitleaks sur un dépôt ?

Deux commandes principales. gitleaks dir analyse les fichiers présents dans l'arbre de travail, sans regarder l'historique. gitleaks git rejoue tout l'historique via git log -p, donc il voit aussi les secrets supprimés depuis. On ajoute --redact=100 pour ne jamais afficher la valeur du secret, et --report-format json pour un rapport exploitable.

Gitleaks scanne-t-il l'historique Git ?

Oui, et c'est son intérêt principal. La commande gitleaks git lit chaque diff de chaque commit. Sur le dépôt d'entraînement leaky-repo, gitleaks git lève 26 alertes contre 22 pour gitleaks dir, mais les quatre de plus sont les mêmes secrets, retrouvés une seconde fois dans un autre commit : sur ce dépôt, aucun secret ne survit seulement dans l'historique. Le cas qui compte est ailleurs : une clé retirée par un commit de nettoyage reste dans le diff, gitleaks dir ne la voit plus, gitleaks git si.

Comment réduire les faux positifs de gitleaks ?

Par un fichier .gitleaks.toml qui garde useDefault mais ajoute des allowlists. On exclut les chemins non applicatifs (docs, tests, fixtures, fichiers .pem de certificats de test) et on liste des stopwords de placeholder comme example ou changeme. Mais une allowlist par chemin ne distingue pas un faux secret d'un vrai secret rangé au mauvais endroit : sur un petit corpus de démonstration où j'avais placé deux secrets dans tests/ et docs/, la config de cet article a fait tomber les 4 faux positifs, et aussi ces 2 secrets. Sur leaky-repo, elle retire une vraie clé privée rangée dans un .pem. On la teste toujours contre un corpus où l'on sait qu'il y a des secrets.

Gitleaks ou trufflehog : lequel choisir ?

Gitleaks détecte par motif et entropie, il est rapide et facile à câbler en pre-commit. TruffleHog va plus loin en vérifiant activement chaque secret classé : il tente de s'authentifier auprès du fournisseur pour savoir si la clé est encore vivante. Les deux sont complémentaires : gitleaks pour bloquer à la source, un scanner à vérification pour prioriser la rotation.

Un secret supprimé d'un commit est-il vraiment parti ?

Non. Supprimer une clé dans un nouveau commit la laisse intacte dans l'historique : n'importe qui peut la retrouver avec git log ou gitleaks git. La seule réponse correcte est de considérer le secret comme compromis et de le révoquer côté fournisseur. Réécrire l'historique aide à nettoyer, mais ne rend jamais valide un token déjà cloné ailleurs.

Veille sécurité

La suite, une fois par mois

Ce qui bouge vraiment sur la surface d'attaque externe, NIS2 et la sécurité applicative, écrit par le pentester qui signe ces articles. Un envoi par mois, désinscription en un clic.

Votre adresse ne sert qu'à cet envoi. Voir la politique de confidentialité.