TruffleHog : Détectez les infos sensibles sur un dépôt GitHub

Une clé API oubliée dans un dépôt GitHub, un mot de passe laissé dans un fichier de configuration ou un token exposé par erreur peuvent rapidement devenir un véritable problème de sécurité. TruffleHog permet de détecter automatiquement ces informations sensibles sur un dépôt GitHub ou dans le code de vos projets.

Dans ce tutoriel, vous allez découvrir comment installer, configurer et utiliser TruffleHog pour analyser vos projets, vos dépôts Github ou Git et votre historique de développement. Que vous soyez développeur débutant ou curieux sur la question de la sécurité, vous apprendrez à repérer efficacement les secrets cachés de projets.

• Détecter clés API, mots de passe et jetons d’accès sur un dépôt GitHub ou dans vos projets.
• Adopter une méthode simple et efficace pour vérifier rapidement vos projets et dépôts Git avant leur publication.
• Intégrer de bonnes pratiques de protection d’informations sensibles afin de développer des applications plus sûres dès le départ.

Lorsque l’on développe un site web, une application ou même un simple script, il arrive parfois de laisser traîner des informations sensibles sans s’en rendre compte. Un fichier de configuration ou encore un jeton d’accès publié par erreur peuvent rapidement devenir une catastrophe.

C’est précisément pour résoudre ce problème que TruffleHog a été créé. Cet outil open source permet de rechercher automatiquement des informations sensibles exposés dans du code, des dépôts Git, des services cloud et bien d’autres sources.

Qu’est-ce que TruffleHog ?

TruffleHog est un outil de sécurité spécialisé dans la détection de secrets.

Le terme « secret » désigne toute information sensible permettant d’accéder à un service ou à des données. Il peut s’agir :

• d’une clé API
• d’un mot de passe
• d’un token GitHub
• d’une clé AWS
• d’un certificat
• d’informations d’authentification.

Son objectif est simple : parcourir automatiquement vos fichiers ou ceux d’un dépôt GitHub et détecter les informations confidentielles qui ne devraient pas s’y trouver.

Imaginez que vous développiez une application et que vous écriviez ceci dans votre code :

$api_key = "sk_live_123456789abcdef";

Vous pensez supprimer cette ligne avant la mise en production mais vous l’oubliez. Le projet est envoyé sur GitHub et votre clé devient accessible.

• TruffleHog est capable de repérer ce type d’erreur avant qu’elle ne se transforme en incident de sécurité.

Pourquoi utiliser TruffleHog ?

Lorsqu’on débute en développement, on pense souvent que les pirates informatiques attaquent uniquement les grandes entreprises.

La réalité est différente.

De nombreux robots parcourent Internet en permanence à la recherche de secrets exposés. Dès qu’une clé AWS, GitHub ou Stripe apparaît publiquement, elle peut être récupérée en quelques minutes.

Les conséquences peuvent être importantes :

• suppression de données
• factures cloud inattendues
• vol d’informations
• compromission de comptes
• interruption de services.

TruffleHog permet donc de réduire considérablement ce risque.

Comment fonctionne TruffleHog ?

TruffleHog utilise plusieurs techniques de détection.

La recherche par expressions régulières

L’outil possède une base de signatures capables d’identifier différents formats de secrets.

Par exemple :

• les clés AWS
• les tokens GitHub
• les clés Stripe
• les clés Google Cloud.

Lorsqu’un fichier contient une chaîne ressemblant à l’un de ces formats, TruffleHog la signale.

L’analyse de l’historique Git

L’un des points forts de TruffleHog est sa capacité à examiner l’ensemble de l’historique d’un dépôt Git.

• C’est extrêmement important.

Supposons que vous ayez ajouté un mot de passe dans un fichier puis supprimé ce mot de passe quelques jours plus tard.

Même s’il n’est plus présent aujourd’hui, il reste enregistré dans l’historique Git.

TruffleHog est capable de le retrouver.

La vérification des secrets

Les versions récentes vont encore plus loin.

Elles tentent parfois de vérifier si le secret découvert est réellement valide.

Cela permet de réduire les faux positifs et d’obtenir des résultats plus pertinents.

Installation de TruffleHog

L’installation dépend de votre système d’exploitation.

Installation sous macOS avec Homebrew

Si vous utilisez Homebrew, une simple commande suffit :

brew install trufflesecurity/trufflehog/trufflehog

Vous pouvez ensuite vérifier l’installation :

trufflehog --version

Installation sous Linux

Téléchargez la dernière version depuis le dépôt officiel puis rendez-la exécutable.

Par exemple :

chmod +x trufflehog

Puis :

./trufflehog --version

Installation avec Docker

Docker permet d’utiliser TruffleHog sans installation complète.

docker run --rm trufflesecurity/trufflehog --help

Cette méthode est souvent appréciée car elle évite de modifier le système.

Premier scan d’un dépôt Git

Passons maintenant à la pratique.

Imaginons que vous souhaitiez analyser un dépôt Git local.

Placez-vous dans le dossier concerné :

cd mon-projet

Puis lancez :

trufflehog git file://.

Décortiquons cette commande.

trufflehog

Lance le programme.

git

Indique que la source analysée est un dépôt Git.

file://.

Correspond au dépôt local actuel.

TruffleHog commence alors à parcourir l’ensemble de l’historique.

Comprendre les résultats

Après quelques instants, vous obtenez des résultats similaires à ceci :

Detector Type: GitHub Token
Verified: true

Raw result:
ghp_xxxxxxxxxxxxxxxxxxxxxxxxx

Analysons les informations affichées.

Detector Type

Il s’agit du type de secret détecté.

Dans cet exemple :

GitHub Token

TruffleHog pense avoir trouvé un jeton GitHub.

Verified

Verified: true

Cela signifie que le secret semble valide.

C’est généralement le signal qu’il faut agir rapidement.

Raw Result

Cette section contient la valeur trouvée.

Pour des raisons de sécurité, évitez toujours de partager ces informations.

Scan d’un de mes dépôt Github

Il s’agit du dépôt de mon extension WordPress sur le maillage interne.

trufflehog git https://github.com/crea-troyes/Internal-Linking-Pro-WP.gi

Dans cet exemple, TruffleHog a analysé l’intégralité du dépôt GitHub Internal-Linking-Pro-WP ainsi que son historique Git.

L’outil a parcouru 370 blocs de données représentant un total d’environ 805 Ko de fichiers et de versions enregistrées dans le dépôt. L’analyse a été particulièrement rapide puisqu’elle n’a nécessité qu’un peu plus d’une seconde.

• La partie la plus importante du rapport se trouve à la fin : verified_secrets: 0 et unverified_secrets: 0.

Cela signifie que TruffleHog n’a détecté aucun mot de passe, clé API, jeton d’accès ou autre information sensible connue dans le code analysé. C’est un résultat rassurant qui indique qu’aucun secret exposé n’a été identifié au moment du scan.

Attention toutefois : même si le résultat est excellent, il reste recommandé de lancer régulièrement ce type d’analyse après chaque évolution importante du projet afin de vérifier qu’aucune information confidentielle n’a été ajoutée par erreur.

Scanner un dépôt GitHub distant

Vous pouvez également analyser un dépôt hébergé sur GitHub.

Par exemple :

trufflehog git https://github.com/utilisateur/projet.git

L’outil va cloner temporairement le dépôt puis examiner son contenu.

Cette fonctionnalité est particulièrement utile pour auditer :

• vos propres projets
• des projets open source
• des dépôts internes d’entreprise.

Attention toutefois à toujours respecter les autorisations d’accès et les règles de confidentialité.

Rechercher des secrets dans un dossier

TruffleHog peut également scanner un simple répertoire.

Créons un exemple :

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

mon-projet/
├── config.php
├── test.txt
└── app.js

Commande :

trufflehog filesystem .

Cette fois, aucun historique Git n’est analysé. L’outil inspecte directement les fichiers présents.

C’est très pratique pour vérifier un projet avant une mise en ligne.

Exemple concret : détection d’une clé API

Prenons un fichier PHP :

<?php

$apiKey = "AIzaSyDxxxxxxxxxxxxxxxxxxxxx";

echo "Bonjour";

L’analyse :

trufflehog filesystem .

peut produire un résultat indiquant la présence d’une clé Google.

L’intérêt est évident.

Même si vous avez oublié cette information au milieu de milliers de lignes de code, TruffleHog est capable de la repérer rapidement.

Scanner une organisation GitHub

Dans un contexte professionnel, il est fréquent de gérer plusieurs dizaines de dépôts.

TruffleHog permet d’automatiser leur contrôle.

Exemple :

trufflehog github \
--org monorganisation

L’outil analyse alors les différents projets accessibles.

Cette fonctionnalité est particulièrement appréciée des équipes DevOps et sécurité.

Utiliser TruffleHog dans une chaîne CI/CD

La meilleure façon d’éviter les fuites de secrets consiste à les bloquer avant qu’elles n’atteignent la production.

C’est là qu’interviennent les pipelines CI/CD.

L’idée est simple :

1. un développeur envoie son code
2. une vérification automatique démarre
3. TruffleHog analyse les fichiers
4. le déploiement est bloqué si un secret est détecté.

Cette approche permet d’éviter de nombreux incidents.

Exemple GitHub Actions

Voici un exemple simplifié :

name: Scan Secrets

on:
  push:

jobs:
  scan:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Run TruffleHog
        run: |
          docker run \
          --rm \
          -v $PWD:/repo \
          trufflesecurity/trufflehog \
          filesystem /repo

Que fait ce fichier ?

À chaque envoi de code :

• GitHub récupère le projet
• TruffleHog démarre
• les fichiers sont analysés
• les secrets potentiels sont signalés.

Réduire les faux positifs

Comme tout outil automatisé, TruffleHog peut parfois se tromper.

Un identifiant aléatoire peut ressembler à une clé API alors qu’il ne s’agit que d’une valeur de test.

Il est donc important de toujours vérifier les résultats avant d’agir.

Une bonne pratique consiste à examiner :

• le contexte
• le fichier concerné
• l’historique Git
• la validité réelle du secret.

Ne supprimez jamais automatiquement un fichier uniquement parce qu’un scan l’a signalé.

Les bonnes pratiques avec TruffleHog

L’utilisation d’un scanner de secrets est une excellente habitude, mais elle doit s’accompagner de bonnes pratiques.

Utiliser des variables d’environnement

Évitez d’écrire ceci :

$password = "MonMotDePasse123";

Préférez :

$password = getenv('DB_PASSWORD');

Le mot de passe reste alors stocké à l’extérieur du code.

👉 Aller plus loin avec les Variable d’environnement

Ajouter les fichiers sensibles dans .gitignore

Par exemple :

.env
config.local.php
secret.json

Git n’enregistrera pas ces fichiers.

👉 Tout savoir sur le fichier .gitignore de Git.

Scanner régulièrement les projets

Une seule analyse n’est pas suffisante.

De nouvelles modifications arrivent chaque jour.

Programmez des scans réguliers afin de détecter rapidement les erreurs.

Faire tourner TruffleHog avant chaque publication

Avant d’envoyer un projet sur GitHub ou sur un serveur :

trufflehog filesystem .

Quelques secondes de vérification peuvent éviter plusieurs heures de stress.

Limites de TruffleHog

Même si l’outil est extrêmement performant, il ne remplace pas une stratégie de sécurité complète.

Par exemple, TruffleHog ne peut pas :

• corriger automatiquement votre code
• empêcher toutes les erreurs humaines
• remplacer un audit de sécurité global.

Il doit être considéré comme un détecteur d’alerte précoce. Un peu comme un détecteur de fumée dans une maison.

Il ne remplace pas les règles de sécurité, mais il vous prévient lorsqu’un problème apparaît.

TruffleHog face aux autres outils

Il existe plusieurs solutions similaires :

• GitLeaks
• Detect Secrets
• Secretlint
• GitGuardian.

Chaque outil possède ses avantages.

TruffleHog est particulièrement apprécié pour :

• sa simplicité
• sa rapidité
• sa capacité à vérifier certains secrets
• son support de nombreuses plateformes.

Pour un développeur débutant souhaitant découvrir la détection de secrets, c’est souvent l’un des meilleurs points de départ.

Cas pratique : sécuriser un projet avant sa mise en ligne

Imaginons que vous veniez de terminer un site web. Avant de publier le projet, vous pouvez suivre cette procédure :

1. Vérifiez que tous vos fichiers sont présents.

Lancez ensuite :

trufflehog filesystem .

2. Analysez les résultats.

Si un secret est découvert :

• supprimez-le du code
• stockez-le dans une variable d’environnement
• générez éventuellement une nouvelle clé si l’ancienne a déjà été exposée.

3. Relancez le scan.

Lorsque plus aucun secret n’est détecté, vous pouvez publier votre projet avec davantage de sérénité.

Tableau récapitulatif des principales commandes de TruffleHog

Commande	Description	Exemple
trufflehog --help	Affiche l’aide complète et les options disponibles.	trufflehog --help
trufflehog --version	Affiche la version installée de TruffleHog.	trufflehog --version
trufflehog git file://.	Analyse le dépôt Git local courant, y compris son historique.	trufflehog git file://.
trufflehog git https://github.com/user/projet.git	Analyse un dépôt Git distant accessible via une URL.	trufflehog git https://github.com/user/projet.git
trufflehog filesystem .	Analyse tous les fichiers du dossier actuel à la recherche de secrets.	trufflehog filesystem .
trufflehog filesystem /chemin/projet	Analyse un répertoire spécifique.	trufflehog filesystem /var/www/site
trufflehog github --repo utilisateur/projet	Analyse un dépôt GitHub via l’API GitHub.	trufflehog github --repo moncompte/monprojet
trufflehog github --org organisation	Analyse tous les dépôts d’une organisation GitHub.	trufflehog github --org crea-troyes
trufflehog git file://. --json	Retourne les résultats au format JSON pour l’automatisation.	trufflehog git file://. --json
trufflehog git file://. --results verified	N’affiche que les secrets vérifiés comme valides.	trufflehog git file://. --results verified
trufflehog git file://. --results unknown	N’affiche que les résultats non vérifiés.	trufflehog git file://. --results unknown
trufflehog git file://. --only-verified	Filtre les résultats pour ne conserver que les secrets validés.	trufflehog git file://. --only-verified
trufflehog filesystem . --exclude-paths exclusions.txt	Ignore certains fichiers ou dossiers définis dans un fichier.	trufflehog filesystem . --exclude-paths exclusions.txt
trufflehog docker --image nom_image	Analyse une image Docker.	trufflehog docker --image wordpress:latest
trufflehog s3 --bucket nom-bucket	Analyse le contenu d’un bucket AWS S3.	trufflehog s3 --bucket sauvegardes-prod

Les 5 commandes à retenir pour débuter

# Vérifier l'installation
trufflehog --version

# Scanner un dossier
trufflehog filesystem .

# Scanner un dépôt Git local
trufflehog git file://.

# Scanner un dépôt GitHub
trufflehog git https://github.com/user/projet.git

# Afficher uniquement les secrets vérifiés
trufflehog git file://. --only-verified

Pour un développeur web débutant, les commandes filesystem et git file://. sont celles que vous utiliserez le plus souvent avant de publier un projet sur GitHub ou de le mettre en production.

Aller plus loin avec TruffleHog

Une fois les bases maîtrisées, vous pourrez explorer des fonctionnalités plus avancées :

• audit d’organisations complètes
• analyse de services cloud
• intégration dans des pipelines DevOps
• automatisation des contrôles de sécurité
• surveillance continue des dépôts.

À mesure que vos projets grandissent, ces fonctionnalités deviennent particulièrement intéressantes.

---

---

La sécurité informatique est souvent perçue comme un domaine complexe réservé aux experts. Pourtant, certaines bonnes pratiques sont accessibles à tous, même aux développeurs débutants.

TruffleHog fait partie de ces outils simples à prendre en main mais capables d’apporter une réelle valeur à vos projets. En quelques commandes seulement, vous pouvez identifier des clés API oubliées, des mots de passe exposés ou des jetons d’accès qui auraient pu provoquer de sérieux problèmes.

Le meilleur moment pour rechercher des secrets est avant qu’un incident ne survienne. Prenez donc l’habitude d’exécuter régulièrement TruffleHog sur vos projets, intégrez-le progressivement à vos workflows et transformez cette vérification en réflexe. Avec le temps, vous développerez naturellement une culture de sécurité qui vous accompagnera sur tous vos futurs développements.