Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Outils/GitHubGitHub/trufflesecurity/trufflehog
Scanners de VulnérabilitésAnalyse Dynamique (Sandboxing)Analyse de CodeSécurité CloudDevSecOpsDétection de SecretsRenseignement sur les MenacesSécurité de la Chaîne LogistiqueRéponse aux IncidentsTop en DevSecOps n°4Top en Détection de Secrets n°2Top en Sécurité de la Chaîne Logistique n°19
GitHubtrufflesecurity/trufflehog

trufflehog

Trouver, vérifier et analyser les identifiants divulgués

Voir le dépôtSite web
27.4k2.5k302il y a 22h 48mVérifié par Kitploit
Partager
<p align="center">
  <img alt="GoReleaser Logo" src="https://assets.kitploit.com/production/public/readmes/3815/31dbdb577b88b3a967e2c18f9b0f3d4a7031dafe7e392c51320178aba6352603.png" height="140" />
  <h2 align="center">TruffleHog</h2>
  <p align="center">Trouvez les identifiants divulgués.</p>
</p>

---

<div align="center">

[![Go Report Card](https://goreportcard.com/badge/github.com/trufflesecurity/trufflehog/v3)](https://goreportcard.com/report/github.com/trufflesecurity/trufflehog/v3)
[![License](https://img.shields.io/badge/license-AGPL--3.0-brightgreen)](/LICENSE)
[![Total Detectors](https://img.shields.io/github/directory-file-count/trufflesecurity/truffleHog/pkg/detectors?label=Total%20Detectors&type=dir)](/pkg/detectors)

</div>

---

# :mag_right: _Analyse en cours_

<div align="center">

<img src="https://raw.githubusercontent.com/trufflesecurity/trufflehog/HEAD/assets/scanning_logos.svg">

**...et plus encore**

Pour en savoir plus sur TruffleHog, ses fonctionnalités et ses capacités, consultez notre [page produit](https://trufflesecurity.com/trufflehog?gclid=CjwKCAjwouexBhAuEiwAtW_Zx5IW87JNj97Ci7heFnA5ar6-DuNzT2Y5nIl9DuZ-FOUqx0Qg3vb9nxoClcEQAvD_BwE).

</div>

# :globe_with_meridians: TruffleHog Enterprise

Vous souhaitez surveiller en continu **Git, Jira, Slack, Confluence, Microsoft Teams, Sharepoint (et plus encore)** à la recherche d'identifiants ? Nous proposons un produit d'entreprise qui peut vous aider ! En savoir plus sur <https://trufflesecurity.com/trufflehog-enterprise>.

Nous utilisons les revenus du produit d'entreprise pour financer davantage de projets open source formidables dont toute la communauté peut bénéficier.

</div>

# Qu'est-ce que TruffleHog 🐽

TruffleHog est l'outil le plus puissant de **Découverte, Classification, Validation** et **Analyse** de secrets. Dans ce contexte, un secret désigne un identifiant qu'une machine utilise pour s'authentifier auprès d'une autre machine. Cela inclut les clés d'API, les mots de passe de bases de données, les clés de chiffrement privées, et plus encore.

## Découverte 🔍

TruffleHog peut rechercher des secrets dans de nombreux endroits, notamment Git, les messageries, les wikis, les journaux, les plateformes de test d'API, les stockages d'objets, les systèmes de fichiers, et plus encore.

## Classification 📁

TruffleHog classe plus de 800 types de secrets, en les associant à l'identité spécifique à laquelle ils appartiennent. S'agit-il d'un secret AWS ? D'un secret Stripe ? D'un secret Cloudflare ? D'un mot de passe Postgres ? D'une clé privée SSL ? Il est parfois difficile de le dire à première vue, c'est pourquoi TruffleHog classe tout ce qu'il trouve.

## Validation ✅

Pour chaque secret que TruffleHog peut classer, il peut également se connecter pour confirmer si ce secret est actif ou non. Cette étape est essentielle pour savoir s'il existe ou non un danger actif et présent.

## Analyse 🔬

Pour une vingtaine des types d'identifiants les plus fréquemment divulgués, au lieu d'envoyer une seule requête pour vérifier si le secret peut se connecter, TruffleHog peut envoyer de nombreuses requêtes pour apprendre tout ce qu'il y a à savoir sur le secret. Qui l'a créé ? À quelles ressources peut-il accéder ? Quelles autorisations possède-t-il sur ces ressources ?

# :loudspeaker: Rejoignez notre communauté

Des questions ? Des retours ? Rejoignez-nous sur Slack ou Discord pour discuter avec nous.

Rejoignez notre [communauté Slack](https://join.slack.com/t/trufflehog-community/shared_invite/zt-pw2qbi43-Aa86hkiimstfdKH9UCpPzQ)

Rejoignez le [Discord Secret Scanning](https://discord.gg/8Hzbrnkr7E)

# :tv: Démo

![GitHub scanning demo](https://storage.googleapis.com/truffle-demos/non-interactive.svg)

```bash
docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --org=trufflesecurity
```

# :floppy_disk: Installation

Plusieurs options s'offrent à vous :

### Utilisateurs de MacOS

```bash
brew install trufflehog
```

### Docker :

<sub><i>_Assurez-vous que le moteur Docker est en cours d'exécution avant d'exécuter les commandes suivantes :_</i></sub>

#### &nbsp;&nbsp;&nbsp;&nbsp;Unix

```bash
docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys
```

#### &nbsp;&nbsp;&nbsp;&nbsp;Invite de commandes Windows

```bash
docker run --rm -it -v "%cd:/=\%:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys
```

#### &nbsp;&nbsp;&nbsp;&nbsp;Windows PowerShell

```bash
docker run --rm -it -v "${PWD}:/pwd" trufflesecurity/trufflehog github --repo https://github.com/trufflesecurity/test_keys
```

#### &nbsp;&nbsp;&nbsp;&nbsp;Mac M1 et M2

```bash
docker run --platform linux/arm64 --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys
```

### Versions binaires

```bash
Download and unpack from https://github.com/trufflesecurity/trufflehog/releases
```

### Compiler depuis les sources

```bash
git clone https://github.com/trufflesecurity/trufflehog.git
cd trufflehog; go install
```

### Utilisation du script d'installation

```bash
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /usr/local/bin
```

### Utilisation du script d'installation, vérification de la signature de la somme de contrôle (nécessite que cosign soit installé)

```bash
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -v -b /usr/local/bin
```

### Utiliser le script d'installation pour installer une version spécifique

```bash
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /usr/local/bin <ReleaseTag like v3.56.0>
```

# :closed_lock_with_key: Vérification des artefacts

Des sommes de contrôle sont appliquées à tous les artefacts, et le fichier de sommes de contrôle résultant est signé à l'aide de cosign.

Vous avez besoin de l'outil suivant pour vérifier la signature :

- [Cosign](https://docs.sigstore.dev/cosign/system_config/installation/)

Les étapes de vérification sont les suivantes :

1. Téléchargez les fichiers d'artefacts souhaités, ainsi que les fichiers suivants depuis la page [releases](https://github.com/trufflesecurity/trufflehog/releases).

   - trufflehog\_{version}\_checksums.txt
   - trufflehog\_{version}\_checksums.txt.pem
   - trufflehog\_{version}\_checksums.txt.sig

2. Vérifiez la signature :

   ```shell
   cosign verify-blob <path to trufflehog_{version}_checksums.txt> \
   --certificate <path to trufflehog_{version}_checksums.txt.pem> \
   --signature <path to trufflehog_{version}_checksums.txt.sig> \
   --certificate-identity-regexp 'https://github\.com/trufflesecurity/trufflehog/\.github/workflows/.+' \
   --certificate-oidc-issuer "https://token.actions.githubusercontent.com"
   ```

3. Une fois la signature confirmée comme valide, vous pouvez procéder à la validation de la concordance des sommes SHA256 avec l'artefact téléchargé :

   ```shell
   sha256sum --ignore-missing -c trufflehog_{version}_checksums.txt
   ```

Remplacez `{version}` par la version des fichiers téléchargés

Alternativement, si vous utilisez le script d'installation, passez l'option `-v` pour effectuer la vérification de signature.
Cela nécessite que le binaire Cosign soit installé avant d'exécuter le script d'installation.

# :rocket: Démarrage rapide

## 1 : Analyser un dépôt pour ne détecter que les secrets vérifiés

Commande :

```bash
trufflehog git https://github.com/trufflesecurity/test_keys --results=verified
```

Expected output:

```
🐷🔑🐷  TruffleHog. Unearth your secrets. 🐷🔑🐷

Found verified result 🐷🔑
Detector Type: AWS
Decoder Type: PLAIN
Raw result: AKIAYVP4CIPPERUVIFXG
Line: 4
Commit: fbc14303ffbf8fb1c2c1914e8dda7d0121633aca
File: keys
Email: counter <[email protected]>
Repository: https://github.com/trufflesecurity/test_keys
Timestamp: 2022-06-16 10:17:40 -0700 PDT
...
```

## 2 : Analyser une organisation GitHub pour ne détecter que les secrets vérifiés

```bash
trufflehog github --org=trufflesecurity --results=verified
```

## 3 : Analyser une organisation GitHub en excluant les dépôts archivés

```bash
trufflehog github --org=trufflesecurity --exclude-archived
```

## 4 : Analyser un dépôt GitHub pour ne détecter que les secrets vérifiés et obtenir une sortie JSON

Commande :

```bash
trufflehog git https://github.com/trufflesecurity/test_keys --results=verified --json
```

Expected output:

```
{"SourceMetadata":{"Data":{"Git":{"commit":"fbc14303ffbf8fb1c2c1914e8dda7d0121633aca","file":"keys","email":"counter \[email protected]\u003e","repository":"https://github.com/trufflesecurity/test_keys","timestamp":"2022-06-16 10:17:40 -0700 PDT","line":4}}},"SourceID":0,"SourceType":16,"SourceName":"trufflehog - git","DetectorType":2,"DetectorName":"AWS","DecoderName":"PLAIN","Verified":true,"Raw":"AKIAYVP4CIPPERUVIFXG","Redacted":"AKIAYVP4CIPPERUVIFXG","ExtraData":{"account":"595918472158","arn":"arn:aws:iam::595918472158:user/canarytokens.com@@mirux23ppyky6hx3l6vclmhnj","user_id":"AIDAYVP4CIPPJ5M54LRCY"},"StructuredData":null}
...
```

TruffleHog peut également produire une sortie [SARIF](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html) avec `--sarif` au lieu de `--json`. L'analyse de code GitHub comprend nativement le SARIF, de sorte que son téléversement fait apparaître les résultats directement dans les diffs des pull requests et dans l'onglet Sécurité du dépôt, et suit les résultats comme nouveaux/corrigés d'une analyse à l'autre au lieu de signaler le même à chaque exécution — consultez la section [TruffleHog Github Action](#octocat-trufflehog-github-action) ci-dessous pour savoir comment le téléverser. Notez que, contrairement aux autres formats de sortie, les résultats SARIF sont mis en mémoire tampon pendant toute la durée de l'analyse et écrits à la fin, car SARIF exige un document JSON unique plutôt qu'un flux — ce qui convient aux analyses typiques, mais les analyses produisant un très grand nombre de résultats utiliseront proportionnellement plus de mémoire.

## 5 : Analyser un dépôt GitHub + ses issues et pull requests

```bash
trufflehog github --repo=https://github.com/trufflesecurity/test_keys --issue-comments --pr-comments
```

## 6 : Analyser un bucket S3 pour obtenir des résultats à haute confiance (vérifiés + inconnus)

```bash
trufflehog s3 --bucket=<bucket name> --results=verified,unknown
```

## 7 : Analyser les buckets S3 à l'aide des rôles IAM

```bash
trufflehog s3 --role-arn=<iam role arn>
```

## 8 : Analyser un dépôt Github à l'aide de l'authentification SSH dans Docker

```bash
docker run --rm -v "$HOME/.ssh:/root/.ssh:ro" trufflesecurity/trufflehog:latest git ssh://github.com/trufflesecurity/test_keys
```

## 9 : Analyser des fichiers ou des répertoires individuels

```bash
trufflehog filesystem path/to/file1.txt path/to/file2.txt path/to/dir
```

## 10 : Analyser un dépôt git local

Clonez le dépôt git. Par exemple, le dépôt [test keys](https://github.com/trufflesecurity/trufflehog/blob/main/git%40github.com%3Atrufflesecurity/test_keys.git).
```bash
git clone [email protected]:trufflesecurity/test_keys.git
```

Exécutez trufflehog depuis le répertoire parent (en dehors du dépôt git).
```bash
trufflehog git file://test_keys --results=verified,unknown
```

Pour se protéger contre les configurations git malveillantes lors de l'analyse locale (voir CVE-2025-41390), TruffleHog clone les dépôts git locaux dans un répertoire temporaire avant l'analyse. Cela suit les [bonnes pratiques de sécurité de Git](https://git-scm.com/docs/git#_security). Si vous souhaitez spécifier un chemin personnalisé pour cloner le dépôt (au lieu de tmp), vous pouvez utiliser l'option `--clone-path`. Si vous souhaitez ignorer le processus de clonage local et analyser le dépôt directement (à ne faire que pour des dépôts de confiance), vous pouvez utiliser l'option `--trust-local-git-config`.

## 11 : Analyser les buckets GCS pour les secrets vérifiés uniquement

```bash
trufflehog gcs --project-id=<project-ID> --cloud-environment --results=verified
```

## 12 : Analyser une image Docker pour ne détecter que les secrets vérifiés

Utilisez le flag `--image` plusieurs fois pour analyser plusieurs images.

```bash
# to scan from a remote registry
trufflehog docker --image trufflesecurity/secrets --results=verified

# to scan from the local docker daemon
trufflehog docker --image docker://new_image:tag --results=verified

# to scan from an image saved as a tarball
trufflehog docker --image file://path_to_image.tar --results=verified
```

## 13 : Analyse dans la CI

Définissez l'option `--since-commit` sur votre branche par défaut vers laquelle les personnes fusionnent (ex : « main »). Définissez l'option `--branch` sur le nom de la branche de votre PR (ex : « feature-1 »). Selon la plateforme CI/CD que vous utilisez, cette valeur peut être récupérée dynamiquement (ex : [CIRCLE_BRANCH dans Circle CI](https://circleci.com/docs/variables/) et [TRAVIS_PULL_REQUEST_BRANCH dans Travis CI](https://docs.travis-ci.com/user/environment-variables/)). Si le dépôt est cloné et que la branche cible est déjà extraite pendant le workflow CI/CD, alors `--branch HEAD` devrait suffire. L'option `--fail` renverra un code d'erreur 183 si des identifiants valides sont trouvés.

```bash
trufflehog git file://. --since-commit main --branch feature-1 --results=verified,unknown --fail
```

## 14 : Analyser un espace de travail Postman

Utilisez les options `--workspace-id`, `--collection-id`, `--environment` plusieurs fois pour analyser plusieurs cibles.

```bash
trufflehog postman --token=<postman api token> --workspace-id=<workspace id>
```

## 15 : Analyser un serveur Jenkins

```bash
trufflehog jenkins --url https://jenkins.example.com --username admin --password admin
```

## 16 : Analyser un serveur Elasticsearch

### Analyser un cluster local

Il existe deux façons de s'authentifier auprès d'un cluster local avec TruffleHog : (1) nom d'utilisateur et mot de passe, (2) jeton de service.

#### Se connecter à un cluster local avec un nom d'utilisateur et un mot de passe

```bash
trufflehog elasticsearch --nodes 192.168.14.3 192.168.14.4 --username truffle --password hog
```

#### Se connecter à un cluster local avec un jeton de service

```bash
trufflehog elasticsearch --nodes 192.168.14.3 192.168.14.4 --service-token ‘AAEWVaWM...Rva2VuaSDZ’
```

### Analyser un cluster Elastic Cloud

Pour analyser un cluster sur Elastic Cloud, vous aurez besoin d'un Cloud ID et d'une clé API.

```bash
trufflehog elasticsearch \
  --cloud-id 'search-prod:dXMtY2Vx...YjM1ODNlOWFiZGRlNjI0NA==' \
  --api-key 'MlVtVjBZ...ZSYlduYnF1djh3NG5FQQ=='
```

## 17. Analyser un dépôt GitHub à la recherche de références d'objets entre forks et de commits supprimés

La commande suivante énumérera les commits supprimés et masqués d'un dépôt GitHub, puis les analysera à la recherche de secrets. Il s'agit d'une fonctionnalité en version alpha.

```bash
trufflehog github-experimental --repo https://github.com/<USER>/<REPO>.git --object-discovery
```

En plus de la sortie normale de TruffleHog, l'option `--object-discovery` crée deux fichiers dans un nouveau répertoire `$HOME/.trufflehog` : `valid_hidden.txt` et `invalid.txt`. Ils servent à suivre l'état pendant l'énumération des commits, ainsi qu'à fournir aux utilisateurs une liste complète de tous les commits cachés et supprimés (`valid_hidden.txt`). Si vous souhaitez supprimer automatiquement ces fichiers après le scan, veuillez ajouter l'option `--delete-cached-data`.

**Remarque** : L'énumération de tous les commits valides d'un dépôt à l'aide de cette méthode prend entre 20 minutes et quelques heures, selon la taille de votre dépôt. Nous avons ajouté une barre de progression pour vous tenir informé de la durée de l'énumération. Le scan réel des secrets s'exécute extrêmement rapidement.

Pour plus d'informations sur les références d'objets inter-forks (Cross Fork Object References), veuillez [lire notre article de blog](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github).

## 18. Scanner Hugging Face

### Scanner un modèle, un jeu de données, un Space ou un bucket Hugging Face

```bash
trufflehog huggingface \
    --model <model_id> \
    --dataset <dataset_id> \
    --space <space_id> \
    --bucket <bucket_id>
```

### Analyser tous les modèles, jeux de données, espaces et buckets appartenant à une organisation ou à un utilisateur Hugging Face

```bash
trufflehog huggingface --org <orgname> --user <username>
```

(Facultatif) Lors du scan d'une organisation ou d'un utilisateur, vous pouvez ignorer une classe entière de ressources avec `--skip-all-models`, `--skip-all-datasets`, `--skip-all-spaces`, `--skip-all-buckets` OU une ressource particulière avec `--ignore-models <model_id>`, `--ignore-datasets <dataset_id>`, `--ignore-spaces <space_id>`, `--ignore-buckets <bucket_id>`.

### Analyser les discussions et les commentaires de PR

```bash
trufflehog huggingface --model <model_id> --include-discussions --include-prs
```

## 19. Analyser l'entrée stdin

```bash
aws s3 cp s3://example/gzipped/data.gz - | gunzip -c | trufflehog stdin
```

# :question: FAQ

- Tout ce que je vois, c'est `🐷🔑🐷  TruffleHog. Unearth your secrets. 🐷🔑🐷` et le programme se termine, pourquoi ?
  - Cela signifie qu'aucun secret n'a été détecté
- Pourquoi l'analyse prend-elle longtemps lorsque j'analyse une organisation GitHub ?
  - Les analyses GitHub non authentifiées sont soumises à des limites de débit. Pour améliorer vos limites de débit, incluez l'option `--token` avec un jeton d'accès personnel
- Il est indiqué qu'une clé privée a été vérifiée, qu'est-ce que cela signifie ?
  - Un résultat vérifié signifie que TruffleHog a confirmé la validité de l'identifiant en le testant contre l'API du service. Pour les clés privées, nous avons confirmé que la clé peut être utilisée en conditions réelles pour l'authentification SSH ou SSL. Consultez notre article de blog Driftwood pour en savoir plus [Article de blog](https://trufflesecurity.com/blog/driftwood-know-if-private-keys-are-sensitive/)
- Existe-t-il un moyen simple d'ignorer des secrets spécifiques ?
  - Si la source analysée [prend en charge les numéros de ligne](https://github.com/trufflesecurity/trufflehog/blob/d6375ba92172fd830abb4247cca15e3176448c5d/pkg/engine/engine.go#L358-L365), vous pouvez alors ajouter un commentaire `trufflehog:ignore` sur la ligne contenant le secret pour ignorer ce secret.
- Puis-je trouver des secrets incluant `trufflehog:ignore` ?
  - Passez `--no-ignore-tag` pour signaler les résultats même lorsque leur ligne porte un commentaire `trufflehog:ignore`. Cela est utile pour examiner des résultats précédemment acceptés.

# :newspaper: Quoi de neuf dans la v3 ?

TruffleHog v3 est une réécriture complète en Go avec de nombreuses nouvelles fonctionnalités puissantes.

- Nous avons **ajouté plus de 700 détecteurs d'identifiants qui prennent en charge la vérification active contre leurs API respectives**.
- Nous avons également ajouté la **prise en charge native de l'analyse de GitHub, GitLab, Docker, systèmes de fichiers, S3, GCS, Circle CI et Travis CI**.
- **Vérifiez instantanément les clés privées** contre des millions d'utilisateurs GitHub et des **milliards** de certificats TLS grâce à notre technologie [Driftwood](https://trufflesecurity.com/blog/driftwood).
- Analysez des binaires, des documents et d'autres formats de fichiers
- Disponible en tant que GitHub Action et hook pre-commit

## Qu'est-ce que la vérification des identifiants ?

Pour chaque identifiant potentiel détecté, nous avons implémenté avec soin une vérification programmatique contre l'API à laquelle nous pensons qu'il appartient. La vérification élimine les faux positifs et fournit trois statuts de résultat :

- **verified** : identifiant confirmé comme valide et actif par test de l'API
- **unverified** : identifiant détecté mais non confirmé comme valide (peut être invalide, expiré ou la vérification désactivée)  
- **unknown** : vérification tentée mais échouée en raison d'erreurs, telles qu'une défaillance réseau ou de l'API

Par exemple, le [détecteur d'identifiants AWS](https://github.com/trufflesecurity/trufflehog/blob/main/pkg/detectors/aws/access_keys/accesskey.go) effectue un appel API `GetCallerIdentity` contre l'API AWS pour vérifier si un identifiant AWS est actif.

# :memo: Utilisation

TruffleHog dispose d'une sous-commande pour chaque source de données que vous pouvez souhaiter analyser :

- git
- github
- gitlab
- huggingface
- docker
- s3
- filesystem (fichiers et répertoires)
- syslog
- circleci
- travisci
- gcs (Google Cloud Storage)
- postman
- jenkins
- elasticsearch
- stdin
- multi-scan

Chaque sous-commande peut avoir des options que vous pouvez consulter avec l'option `--help` fournie à la sous-commande :

```
$ trufflehog git --help
usage: TruffleHog [<flags>] <command> [<args> ...]

TruffleHog is a tool for finding credentials.


Flags:
  -h, --[no-]help                Show context-sensitive help (also try --help-long and --help-man).
      --log-level=0              Logging verbosity on a scale of 0 (info) to 5 (trace). Can be
                                 disabled with "-1".
      --[no-]profile             Enables profiling and sets a pprof and fgprof server on :18066.
  -j, --[no-]json                Output in JSON format.
      --[no-]json-legacy         Use the pre-v3.0 JSON format. Only works with git, gitlab,
                                 and github sources.
      --[no-]github-actions      Output in GitHub Actions format.
      --[no-]sarif               Output in SARIF format for upload to GitHub code scanning (e.g.
                                 via github/codeql-action/upload-sarif).
      --concurrency=12           Number of concurrent workers.
      --[no-]no-verification     Don't verify the results.
      --results=RESULTS          Specifies which type(s) of results to output: verified (confirmed
                                 valid by API), unknown (verification failed due to error),
                                 unverified (detected but not verified), filtered_unverified
                                 (unverified but would have been filtered out). Defaults to
                                 verified,unverified,unknown.
      --[no-]no-color            Disable colorized output
      --[no-]allow-verification-overlap
                                 Allow verification of similar credentials across detectors
      --[no-]filter-unverified   Only output first unverified result per chunk per detector if there
                                 are more than one results.
      --filter-entropy=FILTER-ENTROPY
                                 Filter unverified results with Shannon entropy. Start with 3.0.
      --config=CONFIG            Path to configuration file.
      --[no-]print-avg-detector-time
                                 Print the average time spent on each detector.
      --[no-]no-update           Don't check for updates.
      --[no-]fail                Exit with code 183 if results are found.
      --[no-]fail-on-scan-errors
                                 Exit with non-zero error code if an error occurs during the scan.
      --verifier=VERIFIER ...    Set custom verification endpoints.
      --[no-]custom-verifiers-only
                                 Only use custom verification endpoints.
      --detector-timeout=DETECTOR-TIMEOUT
                                 Maximum time to spend scanning chunks per detector (e.g., 30s).
      --archive-max-size=ARCHIVE-MAX-SIZE
                                 Maximum size of archive to scan. (Byte units eg. 512B, 2KB, 4MB)
      --archive-max-depth=ARCHIVE-MAX-DEPTH
                                 Maximum depth of archive to scan.
      --archive-timeout=ARCHIVE-TIMEOUT
                                 Maximum time to spend extracting an archive.
      --include-detectors="all"  Comma separated list of detector types to include. Protobuf name or
                                 IDs may be used, as well as ranges.
      --exclude-detectors=EXCLUDE-DETECTORS
                                 Comma separated list of detector types to exclude. Protobuf name
                                 or IDs may be used, as well as ranges. IDs defined here take
                                 precedence over the include list.
      --[no-]no-verification-cache
                                 Disable verification caching
      --[no-]force-skip-binaries
                                 Force skipping binaries.
      --[no-]force-skip-archives
                                 Force skipping archives.
      --[no-]skip-additional-refs
                                 Skip additional references.
      --user-agent-suffix=USER-AGENT-SUFFIX
                                 Suffix to add to User-Agent.
      --[no-]version             Show application version.

Commands:
help [<command>...]
    Show help.

git [<flags>] <uri>

    Find credentials in git repositories.

github [<flags>]
    Find credentials in GitHub repositories.

github-experimental --repo=REPO [<flags>]
    Run an experimental GitHub scan. Must specify at least one experimental sub-module to run:
    object-discovery.

gitlab --token=TOKEN [<flags>]
    Find credentials in GitLab repositories.

filesystem [<flags>] [<path>...]
    Find credentials in a filesystem.

s3 [<flags>]
    Find credentials in S3 buckets.

gcs [<flags>]
    Find credentials in GCS buckets.

syslog --format=FORMAT [<flags>]
    Scan syslog

circleci --token=TOKEN
    Scan CircleCI

docker [<flags>]
    Scan Docker Image


travisci --token=TOKEN
    Scan TravisCI

postman [<flags>]
    Scan Postman

elasticsearch [<flags>]
    Scan Elasticsearch

jenkins --url=URL [<flags>]
    Scan Jenkins

huggingface [<flags>]
    Find credentials in HuggingFace datasets, models, spaces and buckets.

stdin
    Find credentials from stdin.

multi-scan
    Find credentials in multiple sources defined in configuration.

json-enumerator [<path>...]
    Find credentials from a JSON enumerator input.

analyze
    Analyze API keys for fine-grained permissions information.
```

Par exemple, pour analyser un dépôt `git`, commencez par

```
trufflehog git https://github.com/trufflesecurity/trufflehog.git
```

## Configuration

TruffleHog prend en charge la définition de [détecteurs regex personnalisés](#custom-regex-detector-alpha)
et de plusieurs sources dans un fichier de configuration fourni via le flag `--config`.
Les détecteurs regex peuvent être utilisés avec n'importe quelle sous-commande, tandis que les sources définies
dans la configuration sont réservées à la sous-commande `multi-scan`.

Le format de configuration des sources est disponible sur la
[page de documentation sur la configuration des sources](https://trufflesecurity.com/docs/connect-sources) de Truffle Security.

Exemple de configuration d'une source GitHub et [référence des options](https://docs.trufflesecurity.com/github#Fvm1I) :

```yaml
sources:
- connection:
    '@type': type.googleapis.com/sources.GitHub
    repositories:
    - https://github.com/trufflesecurity/test_keys.git
    unauthenticated: {}
  name: example config scan
  type: SOURCE_TYPE_GITHUB
  verify: true
```

Vous pouvez définir plusieurs connexions sous la clé `sources` (voir ci-dessus), et
TruffleHog analysera toutes les sources simultanément.

Pour voir les journaux de débogage d'une seule source, ajoutez-y `debug: true`. Cette source
écrit tous ses journaux de débogage, et toutes les autres sources conservent le niveau de journalisation normal.
Cela est utile lorsqu'une source parmi plusieurs se comporte anormalement :

```yaml
sources:
- connection:
    '@type': type.googleapis.com/sources.GitHub
    repositories:
    - https://github.com/trufflesecurity/test_keys.git
    unauthenticated: {}
  name: example config scan
  type: SOURCE_TYPE_GITHUB
  debug: true
```

Pour activer les journaux de débogage pour chaque source, utilisez plutôt `--log-level=5`.

## S3

La source S3 prend en charge l'endossement de rôles IAM pour l'analyse, en plus des utilisateurs IAM. Cela permet aux utilisateurs de scanner plus facilement plusieurs comptes AWS sans avoir à dépendre d'identifiants codés en dur pour chaque compte.

L'identité IAM que TruffleHog utilise initialement devra disposer des privilèges `AssumeRole` en tant que principal dans la [politique de confiance](https://aws.amazon.com/blogs/security/how-to-use-trust-policies-with-iam-roles/) de chaque rôle IAM à endosser.

Pour scanner un bucket spécifique à l'aide d'identifiants définis localement ou des métadonnées d'instance si vous êtes sur une instance EC2 :

```bash
trufflehog s3 --bucket=<bucket-name>
```

Pour analyser un bucket spécifique à l'aide d'un rôle assumé :

```bash
trufflehog s3 --bucket=<bucket-name> --role-arn=<iam-role-arn>
```

Plusieurs rôles peuvent être passés comme arguments séparés. La commande suivante tentera de scanner chaque bucket que chaque rôle a la permission de lister dans l'API S3 :

```bash
trufflehog s3 --role-arn=<iam-role-arn-1> --role-arn=<iam-role-arn-2>
```

### Restreindre une analyse à des objets spécifiques

Les grands buckets contiennent souvent des données qui ne valent jamais la peine d'être analysées, comme les archives, les médias et les artefacts de build. Deux ensembles d'options permettent d'exclure ces objets d'une analyse. Les deux sont comparés à la clé de l'objet avant que celui-ci ne soit téléchargé, de sorte qu'un objet ignoré ne coûte aucune requête GET.

Analyser uniquement les objets situés sous un ou plusieurs préfixes de clé :

```bash
trufflehog s3 --bucket=<bucket-name> --include-prefix=infra/ --include-prefix=services/
```

Ignorer les objets sous un préfixe de clé :

```bash
trufflehog s3 --bucket=<bucket-name> --exclude-prefix=projects/archived/
```

Les deux indicateurs de préfixe peuvent être utilisés ensemble pour analyser une sous-arborescence tout en en excluant une partie. Un objet qui correspond à un préfixe d'exclusion est toujours ignoré, même s'il correspond également à un préfixe d'inclusion :

```bash
trufflehog s3 --bucket=<bucket-name> --include-prefix=src/ --exclude-prefix=src/vendor/
```

Les préfixes sont mis en correspondance littéralement, et non comme des globs, et ils ne sont pas limités à une frontière de chemin. `--include-prefix=log` correspond à la fois à `logs/app.txt` et à `logs-archive/app.txt`.

Les extensions de fichier sont filtrées séparément. Écrivez-les sans point initial :

```bash
trufflehog s3 --bucket=<bucket-name> --exclude-extension=zip --exclude-extension=mp4
```

```bash
trufflehog s3 --bucket=<bucket-name> --include-extension=tf --include-extension=yaml
```

Contrairement aux options de préfixe, `--include-extension` et `--exclude-extension` ne peuvent pas être combinées, car nommer les extensions à analyser exclut déjà toutes les autres. L'utilisation des deux échoue au démarrage.

La correspondance des extensions est insensible à la casse, donc `--exclude-extension=zip` ignore également `BACKUP.ZIP`. Un objet dont la clé n'a aucune extension, comme `Makefile`, ne correspond à aucune entrée : il est ignoré lorsque `--include-extension` est défini, et conservé lorsque seul `--exclude-extension` est défini.

Deux points à surveiller lors de l'utilisation de `--include-extension`. Un fichier caché (dotfile) est considéré comme entièrement constitué d'extension, donc `.env` a l'extension `env` et toute liste d'inclusion qui omet `env` ignorera chaque fichier `.env` du bucket. Comme les fichiers `.env` sont un emplacement courant pour les secrets, ajoutez `--include-extension=env` sauf si vous souhaitez les ignorer. De plus, seule la dernière extension compte, donc `backup.tar.gz` a l'extension `gz` : `--exclude-extension=tar.gz` ne correspond à rien, tandis que `--exclude-extension=gz` fonctionne.

---

[Read more](https://github.com/trufflesecurity/trufflehog)
Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    593
  • 3

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    371
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    336
  • 5

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    326
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    322

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →