
Trouver, vérifier et analyser les identifiants divulgués
<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">
[](https://goreportcard.com/report/github.com/trufflesecurity/trufflehog/v3)
[](/LICENSE)
[](/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

```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>
#### Unix
```bash
docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys
```
#### Invite de commandes Windows
```bash
docker run --rm -it -v "%cd:/=\%:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys
```
#### Windows PowerShell
```bash
docker run --rm -it -v "${PWD}:/pwd" trufflesecurity/trufflehog github --repo https://github.com/trufflesecurity/test_keys
```
#### 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)