Trova, verifica e analizza le credenziali trapelate
<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">Trova credenziali compromesse.</p>
</p>
---
<div align="center">
[](https://goreportcard.com/report/github.com/trufflesecurity/trufflehog/v3)
[](/LICENSE)
[](/pkg/detectors)
</div>
---
# :mag_right: _Ora in scansione_
<div align="center">
<img src="https://raw.githubusercontent.com/trufflesecurity/trufflehog/HEAD/assets/scanning_logos.svg">
**...e altro ancora**
Per saperne di più su TruffleHog e sulle sue funzionalità e capacità, visita la nostra [pagina prodotto](https://trufflesecurity.com/trufflehog?gclid=CjwKCAjwouexBhAuEiwAtW_Zx5IW87JNj97Ci7heFnA5ar6-DuNzT2Y5nIl9DuZ-FOUqx0Qg3vb9nxoClcEQAvD_BwE).
</div>
# :globe_with_meridians: TruffleHog Enterprise
Sei interessato a monitorare continuamente **Git, Jira, Slack, Confluence, Microsoft Teams, Sharepoint (e altro)** alla ricerca di credenziali? Abbiamo un prodotto enterprise che può aiutarti! Scopri di più su <https://trufflesecurity.com/trufflehog-enterprise>.
Utilizziamo i ricavi del prodotto enterprise per finanziare altri fantastici progetti open source di cui l'intera community può beneficiare.
</div>
# Cos'è TruffleHog 🐽
TruffleHog è lo strumento più potente per **Scoperta, Classificazione, Validazione** e **Analisi** dei segreti. In questo contesto, per segreto si intende una credenziale che una macchina utilizza per autenticarsi presso un'altra macchina. Questo include chiavi API, password di database, chiavi di crittografia private e altro ancora.
## Scoperta 🔍
TruffleHog può cercare segreti in molti luoghi, tra cui Git, chat, wiki, log, piattaforme di test delle API, object store, filesystem e altro ancora.
## Classificazione 📁
TruffleHog classifica oltre 800 tipi di segreti, riconducendoli all'identità specifica a cui appartengono. È un segreto AWS? Un segreto Stripe? Un segreto Cloudflare? Una password Postgres? Una chiave privata SSL? A volte è difficile capirlo guardandolo, quindi TruffleHog classifica tutto ciò che trova.
## Validazione ✅
Per ogni segreto che TruffleHog riesce a classificare, può anche effettuare l'accesso per confermare se quel segreto è attivo o meno. Questo passaggio è fondamentale per sapere se esiste o meno un pericolo attivo e presente.
## Analisi 🔬
Per una ventina dei tipi di credenziali più comunemente compromessi, invece di inviare una singola richiesta per verificare se il segreto può effettuare l'accesso, TruffleHog può inviare molte richieste per scoprire tutto ciò che c'è da sapere sul segreto. Chi l'ha creato? A quali risorse può accedere? Quali permessi ha su quelle risorse?
# :loudspeaker: Unisciti alla nostra community
Hai domande? Feedback? Entra su Slack o Discord e passa del tempo con noi.
Unisciti alla nostra [Community Slack](https://join.slack.com/t/trufflehog-community/shared_invite/zt-pw2qbi43-Aa86hkiimstfdKH9UCpPzQ)
Unisciti al [Discord di Secret Scanning](https://discord.gg/8Hzbrnkr7E)
# :tv: Demo

```bash
docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --org=trufflesecurity
```
# :floppy_disk: Installazione
Sono disponibili diverse opzioni:
### Utenti MacOS
```bash
brew install trufflehog
```
### Docker:
<sub><i>_Assicurati che il motore Docker sia in esecuzione prima di eseguire i seguenti comandi:_</i></sub>
#### Unix
```bash
docker run --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys
```
#### Prompt dei comandi di 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 e M2
```bash
docker run --platform linux/arm64 --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys
```
### Release binarie
```bash
Download and unpack from https://github.com/trufflesecurity/trufflehog/releases
```
### Compilare dal codice sorgente
```bash
git clone https://github.com/trufflesecurity/trufflehog.git
cd trufflehog; go install
```
### Utilizzo dello script di installazione
```bash
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /usr/local/bin
```
### Utilizzo dello script di installazione, verifica della firma del checksum (richiede che cosign sia installato)
```bash
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -v -b /usr/local/bin
```
### Utilizzo dello script di installazione per installare una versione specifica
```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: Verifica degli artefatti
I checksum vengono applicati a tutti gli artefatti e il file di checksum risultante viene firmato utilizzando cosign.
Per verificare la firma è necessario il seguente strumento:
- [Cosign](https://docs.sigstore.dev/cosign/system_config/installation/)
I passaggi di verifica sono i seguenti:
1. Scarica i file degli artefatti desiderati e i seguenti file dalla pagina [releases](https://github.com/trufflesecurity/trufflehog/releases).
- trufflehog\_{version}\_checksums.txt
- trufflehog\_{version}\_checksums.txt.pem
- trufflehog\_{version}\_checksums.txt.sig
2. Verifica la firma:
```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. Una volta confermata la validità della firma, è possibile procedere a verificare che i checksum SHA256 corrispondano all'artefatto scaricato:
```shell
sha256sum --ignore-missing -c trufflehog_{version}_checksums.txt
```
Sostituisci `{version}` con la versione dei file scaricati
In alternativa, se stai utilizzando lo script di installazione, passa l'opzione `-v` per eseguire la verifica della firma.
Ciò richiede che il binario Cosign sia installato prima di eseguire lo script di installazione.
# :rocket: Avvio rapido
## 1: Scansiona un repository solo per i segreti verificati
Comando:
```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: Scansiona una GitHub Org per soli segreti verificati
```bash
trufflehog github --org=trufflesecurity --results=verified
```
## 3: Scansiona una GitHub Org escludendo i repository archiviati
```bash
trufflehog github --org=trufflesecurity --exclude-archived
```
## 4: Scansiona un repository GitHub per soli segreti verificati e ottieni l'output JSON
Comando:
```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 può anche produrre output in formato [SARIF](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html) con `--sarif` invece di `--json`. La scansione del codice di GitHub comprende nativamente SARIF, quindi caricandolo si mostrano i risultati inline nei diff delle pull request e nella scheda Sicurezza del repository, e tiene traccia dei risultati come nuovi/corretti tra le scansioni invece di segnalare lo stesso ogni volta — consulta la sezione [TruffleHog Github Action](#octocat-trufflehog-github-action) qui sotto per come caricarlo. Nota che, a differenza degli altri formati di output, i risultati SARIF vengono memorizzati nel buffer in memoria per l'intera scansione e scritti al termine, poiché SARIF richiede un singolo documento JSON anziché uno stream — va bene per scansioni tipiche, ma le scansioni che producono un numero molto elevato di risultati utilizzeranno proporzionalmente più memoria.
## 5: Scansiona un repository GitHub + le sue issue e pull request
```bash
trufflehog github --repo=https://github.com/trufflesecurity/test_keys --issue-comments --pr-comments
```
## 6: Scansiona un bucket S3 per risultati ad alta affidabilità (verificati + sconosciuti)
```bash
trufflehog s3 --bucket=<bucket name> --results=verified,unknown
```
## 7: Scansionare i bucket S3 usando IAM Roles
```bash
trufflehog s3 --role-arn=<iam role arn>
```
## 8: Scansionare un repository Github utilizzando l'autenticazione SSH in Docker
```bash
docker run --rm -v "$HOME/.ssh:/root/.ssh:ro" trufflesecurity/trufflehog:latest git ssh://github.com/trufflesecurity/test_keys
```
## 9: Scansiona singoli file o directory
```bash
trufflehog filesystem path/to/file1.txt path/to/file2.txt path/to/dir
```
## 10: Scansiona un repository git locale
Clona il repository git. Ad esempio il repository [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
```
Esegui trufflehog dalla directory padre (all'esterno del repository git).
```bash
trufflehog git file://test_keys --results=verified,unknown
```
Per proteggersi da configurazioni git malevole durante la scansione locale (vedi CVE-2025-41390), TruffleHog clona i repository git locali in una directory temporanea prima della scansione. Ciò segue le [best practice di sicurezza di Git](https://git-scm.com/docs/git#_security). Se desideri specificare un percorso personalizzato in cui clonare il repository (invece di tmp), puoi usare il flag `--clone-path`. Se desideri saltare il processo di clonazione locale e scansionare direttamente il repository (fallo solo per repository attendibili), puoi usare il flag `--trust-local-git-config`.
## 11: Scansiona i bucket GCS solo per i segreti verificati
```bash
trufflehog gcs --project-id=<project-ID> --cloud-environment --results=verified
```
## 12: Scansiona un'immagine Docker per soli segreti verificati
Usa il flag `--image` più volte per scansionare più immagini.
```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: Scansione in CI
Imposta il flag `--since-commit` sul tuo branch predefinito in cui le persone effettuano il merge (es: "main"). Imposta il flag `--branch` sul nome del branch della tua PR (es: "feature-1"). A seconda della piattaforma CI/CD che utilizzi, questo valore può essere recuperato dinamicamente (es: [CIRCLE_BRANCH in Circle CI](https://circleci.com/docs/variables/) e [TRAVIS_PULL_REQUEST_BRANCH in Travis CI](https://docs.travis-ci.com/user/environment-variables/)). Se il repository viene clonato e il branch di destinazione è già estratto durante il workflow CI/CD, allora `--branch HEAD` dovrebbe essere sufficiente. Il flag `--fail` restituirà un codice di errore 183 se vengono trovate credenziali valide.
```bash
trufflehog git file://. --since-commit main --branch feature-1 --results=verified,unknown --fail
```
## 14: Scansionare un workspace Postman
Usa i flag `--workspace-id`, `--collection-id`, `--environment` più volte per scansionare più target.
```bash
trufflehog postman --token=<postman api token> --workspace-id=<workspace id>
```
## 15: Scansionare un server Jenkins
```bash
trufflehog jenkins --url https://jenkins.example.com --username admin --password admin
```
## 16: Scansionare un server Elasticsearch
### Scansionare un cluster locale
Esistono due modi per autenticarsi a un cluster locale con TruffleHog: (1) nome utente e password, (2) token di servizio.
#### Connettersi a un cluster locale con nome utente e password
```bash
trufflehog elasticsearch --nodes 192.168.14.3 192.168.14.4 --username truffle --password hog
```
#### Connettersi a un cluster locale con un token di servizio
```bash
trufflehog elasticsearch --nodes 192.168.14.3 192.168.14.4 --service-token ‘AAEWVaWM...Rva2VuaSDZ’
```
### Scansionare un cluster Elastic Cloud
Per scansionare un cluster su Elastic Cloud, sono necessari un Cloud ID e una chiave API.
```bash
trufflehog elasticsearch \
--cloud-id 'search-prod:dXMtY2Vx...YjM1ODNlOWFiZGRlNjI0NA==' \
--api-key 'MlVtVjBZ...ZSYlduYnF1djh3NG5FQQ=='
```
## 17. Scansiona un repository GitHub alla ricerca di riferimenti a oggetti tra fork e commit eliminati
Il seguente comando enumererà i commit eliminati e nascosti su un repository GitHub e poi li scannerizzerà alla ricerca di segreti. Questa è una funzionalità in versione alpha.
```bash
trufflehog github-experimental --repo https://github.com/<USER>/<REPO>.git --object-discovery
```
Oltre al normale output di TruffleHog, il flag `--object-discovery` crea due file in una nuova directory `$HOME/.trufflehog`: `valid_hidden.txt` e `invalid.txt`. Questi vengono utilizzati per tenere traccia dello stato durante l'enumerazione dei commit, nonché per fornire agli utenti un elenco completo di tutti i commit nascosti ed eliminati (`valid_hidden.txt`). Se desideri rimuovere automaticamente questi file dopo la scansione, aggiungi il flag `--delete-cached-data`.
**Nota**: l'enumerazione di tutti i commit validi su un repository utilizzando questo metodo richiede tra 20 minuti e alcune ore, a seconda delle dimensioni del repository. Abbiamo aggiunto una barra di avanzamento per tenerti aggiornato su quanto tempo richiederà l'enumerazione. La scansione effettiva dei segreti viene eseguita estremamente rapidamente.
Per ulteriori informazioni sui Cross Fork Object References, [leggi il nostro post sul blog](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github).
## 18. Scansione di Hugging Face
### Scansiona un modello, dataset, space o bucket di Hugging Face
```bash
trufflehog huggingface \
--model <model_id> \
--dataset <dataset_id> \
--space <space_id> \
--bucket <bucket_id>
```
### Scansiona tutti i Modelli, Dataset, Space e Bucket appartenenti a un'Organizzazione o Utente Hugging Face
```bash
trufflehog huggingface --org <orgname> --user <username>
```
(Facoltativo) Quando si esegue la scansione di un'organizzazione o di un utente, è possibile saltare un'intera classe di risorse con `--skip-all-models`, `--skip-all-datasets`, `--skip-all-spaces`, `--skip-all-buckets` OPPURE una particolare risorsa con `--ignore-models <model_id>`, `--ignore-datasets <dataset_id>`, `--ignore-spaces <space_id>`, `--ignore-buckets <bucket_id>`.
### Scansione dei commenti nelle discussioni e nelle PR
```bash
trufflehog huggingface --model <model_id> --include-discussions --include-prs
```
## 19. Scansione dell'input da stdin
```bash
aws s3 cp s3://example/gzipped/data.gz - | gunzip -c | trufflehog stdin
```
# :question: FAQ
- Vedo solo `🐷🔑🐷 TruffleHog. Unearth your secrets. 🐷🔑🐷` e il programma termina, cosa significa?
- Significa che non sono stati rilevati segreti
- Perché la scansione richiede molto tempo quando scansiono una org di GitHub
- Le scansioni GitHub non autenticate hanno limiti di frequenza. Per migliorare i limiti di frequenza, includi il flag `--token` con un personal access token
- Dice che una chiave privata è stata verificata, cosa significa?
- Un risultato verificato significa che TruffleHog ha confermato che la credenziale è valida testandola contro l'API del servizio. Per le chiavi private, abbiamo confermato che la chiave può essere utilizzata attivamente per l'autenticazione SSH o SSL. Consulta il nostro post sul blog Driftwood per saperne di più [Blog post](https://trufflesecurity.com/blog/driftwood-know-if-private-keys-are-sensitive/)
- Esiste un modo semplice per ignorare segreti specifici?
- Se la sorgente scansionata [supporta i numeri di riga](https://github.com/trufflesecurity/trufflehog/blob/d6375ba92172fd830abb4247cca15e3176448c5d/pkg/engine/engine.go#L358-L365), puoi aggiungere un commento `trufflehog:ignore` sulla riga contenente il segreto per ignorare quel segreto.
- Posso trovare segreti con `trufflehog:ignore` incluso?
- Passa `--no-ignore-tag` per segnalare i risultati anche quando la loro riga contiene un commento `trufflehog:ignore`. Questo è utile per rivedere risultati accettati in precedenza.
# :newspaper: Cosa c'è di nuovo nella v3?
TruffleHog v3 è una riscrittura completa in Go con molte nuove potenti funzionalità.
- Abbiamo **aggiunto oltre 700 rilevatori di credenziali che supportano la verifica attiva contro le rispettive API**.
- Abbiamo anche aggiunto il **supporto nativo per la scansione di GitHub, GitLab, Docker, filesystem, S3, GCS, Circle CI e Travis CI**.
- **Verifica istantaneamente le chiavi private** contro milioni di utenti github e **miliardi** di certificati TLS usando la nostra tecnologia [Driftwood](https://trufflesecurity.com/blog/driftwood).
- Scansiona binari, documenti e altri formati di file
- Disponibile come GitHub Action e come pre-commit hook
## Cos'è la verifica delle credenziali?
Per ogni potenziale credenziale rilevata, abbiamo implementato meticolosamente una verifica programmatica contro l'API a cui riteniamo appartenga. La verifica elimina i falsi positivi e fornisce tre stati di risultato:
- **verified**: credenziale confermata come valida e attiva tramite test API
- **unverified**: credenziale rilevata ma non confermata valida (potrebbe essere non valida, scaduta o la verifica disabilitata)
- **unknown**: verifica tentata ma fallita a causa di errori, come un errore di rete o dell'API
Ad esempio, il [rilevatore di credenziali AWS](https://github.com/trufflesecurity/trufflehog/blob/main/pkg/detectors/aws/access_keys/accesskey.go) esegue una chiamata API `GetCallerIdentity` contro l'API AWS per verificare se una credenziale AWS è attiva.
# :memo: Utilizzo
TruffleHog ha un sottocomando per ogni sorgente di dati che potresti voler scansionare:
- git
- github
- gitlab
- huggingface
- docker
- s3
- filesystem (file e directory)
- syslog
- circleci
- travisci
- gcs (Google Cloud Storage)
- postman
- jenkins
- elasticsearch
- stdin
- multi-scan
Ogni sottocomando può avere opzioni che puoi vedere con il flag `--help` fornito al sottocomando:
```
$ 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.
```
Ad esempio, per scansionare un repository `git`, inizia con
```
trufflehog git https://github.com/trufflesecurity/trufflehog.git
```
## Configurazione
TruffleHog supporta la definizione di [rilevatori regex personalizzati](#custom-regex-detector-alpha)
e di più sorgenti in un file di configurazione fornito tramite il flag `--config`.
I rilevatori regex possono essere utilizzati con qualsiasi sottocomando, mentre le sorgenti definite
nella configurazione sono riservate al solo sottocomando `multi-scan`.
Il formato di configurazione per le sorgenti è disponibile nella
[pagina di documentazione sulla configurazione delle sorgenti](https://trufflesecurity.com/docs/connect-sources) di Truffle Security.
Esempio di configurazione di una sorgente GitHub e [riferimento alle opzioni](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
```
Puoi definire più connessioni sotto la chiave `sources` (vedi sopra) e
TruffleHog analizzerà tutte le sorgenti contemporaneamente.
Per visualizzare i log di debug di una sola sorgente, aggiungi `debug: true` ad essa. Quella sorgente
scrive tutti i suoi log di debug, mentre ogni altra sorgente mantiene il livello di log normale.
Questo è utile quando una sorgente tra molte si comporta in modo anomalo:
```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
```
Per attivare i log di debug per ogni sorgente, usa invece `--log-level=5`.
## S3
La sorgente S3 supporta l'assunzione di ruoli IAM per la scansione, oltre agli utenti IAM. Questo rende più semplice per gli utenti scansionare più account AWS senza dover ricorrere a credenziali hardcoded per ciascun account.
L'identità IAM che TruffleHog utilizza inizialmente dovrà avere i privilegi `AssumeRole` come principal nella [trust policy](https://aws.amazon.com/blogs/security/how-to-use-trust-policies-with-iam-roles/) di ciascun ruolo IAM da assumere.
Per scansionare un bucket specifico utilizzando credenziali impostate localmente o i metadati dell'istanza se su un'istanza EC2:
```bash
trufflehog s3 --bucket=<bucket-name>
```
Per scansionare un bucket specifico utilizzando un ruolo assunto:
```bash
trufflehog s3 --bucket=<bucket-name> --role-arn=<iam-role-arn>
```
È possibile passare più ruoli come argomenti separati. Il seguente comando tenterà di scansionare ogni bucket che ciascun ruolo ha il permesso di elencare nell'API S3:
```bash
trufflehog s3 --role-arn=<iam-role-arn-1> --role-arn=<iam-role-arn-2>
```
### Restringere una scansione a oggetti specifici
I bucket di grandi dimensioni contengono spesso dati che non vale mai la pena scansionare, come archivi, file multimediali e artefatti di build. Due insiemi di flag tengono questi oggetti fuori da una scansione. Entrambi vengono confrontati con la chiave dell'oggetto prima che l'oggetto venga scaricato, quindi un oggetto saltato non costa alcuna richiesta GET.
Scansiona solo gli oggetti sotto uno o più prefissi di chiave:
```bash
trufflehog s3 --bucket=<bucket-name> --include-prefix=infra/ --include-prefix=services/
```
Salta gli oggetti sotto un prefisso di chiave:
```bash
trufflehog s3 --bucket=<bucket-name> --exclude-prefix=projects/archived/
```
Entrambi i flag di prefisso possono essere usati insieme per scansionare un sottoalbero escludendone una parte. Un oggetto che corrisponde a un prefisso di esclusione viene sempre saltato, anche se corrisponde anche a un prefisso di inclusione:
```bash
trufflehog s3 --bucket=<bucket-name> --include-prefix=src/ --exclude-prefix=src/vendor/
```
I prefissi vengono confrontati letteralmente, non come glob, e non sono limitati a un confine di percorso. `--include-prefix=log` corrisponde sia a `logs/app.txt` che a `logs-archive/app.txt`.
Le estensioni dei file vengono filtrate separatamente. Scrivile senza punto iniziale:
```bash
trufflehog s3 --bucket=<bucket-name> --exclude-extension=zip --exclude-extension=mp4
```
```bash
trufflehog s3 --bucket=<bucket-name> --include-extension=tf --include-extension=yaml
```
A differenza dei flag di prefisso, `--include-extension` e `--exclude-extension` non possono essere combinati, perché indicare le estensioni da scansionare esclude già tutte le altre. Usarli entrambi causa un errore all'avvio.
La corrispondenza delle estensioni non distingue tra maiuscole e minuscole, quindi `--exclude-extension=zip` salta anche `BACKUP.ZIP`. Un oggetto la cui chiave non ha alcuna estensione, come `Makefile`, non corrisponde a nessuna voce: viene saltato quando è impostato `--include-extension`, e mantenuto quando è impostato solo `--exclude-extension`.
Due cose da tenere presenti quando si usa `--include-extension`. Un dotfile conta interamente come estensione, quindi `.env` ha l'estensione `env` e qualsiasi elenco di inclusioni che ometta `env` salterà ogni file `.env` nel bucket. Poiché i file `.env` sono un luogo comune in cui si trovano i segreti, aggiungi `--include-extension=env` a meno che tu non voglia saltarli. Inoltre conta solo l'ultima estensione, quindi `backup.tar.gz` ha l'estensione `gz`: `--exclude-extension=tar.gz` non corrisponde a nulla, mentre `--exclude-extension=gz` funziona.
Questi flag si applicano anche solo alle chiavi degli oggetti, non ai file all'interno di un archivio. `--exclude-extension=mp4` salta `clip.mp4` presente nel bucket, ma non un `clip.mp4` racchiuso in `media.zip`. Escludere `zip` salta l'archivio interamente.
TruffleHog chiede a S3 di elencare solo le chiavi sotto i prefissi di inclusione, quindi un prefisso che copre una piccola parte di un grande bucket viene elencato rapidamente. I prefissi e le estensioni di esclusione vengono applicati dopo l'elencazione, quindi riducono il costo del download degli oggetti ma non quello della loro elencazione.
I prefissi e le estensioni vengono applicati insieme. Un oggetto deve superare entrambi per essere scansionato, quindi il comando seguente scansiona `src/main.tf` ma salta sia `src/bundle.zip` che `docs/guide.tf`:
```bash
trufflehog s3 --bucket=<bucket-name> --include-prefix=src/ --exclude-extension=zip
```
Questi flag restringono gli oggetti all'interno di un bucket. Per restringere quali bucket vengono scansionati, usa `--bucket` o `--ignore-bucket`, che a differenza dei flag di prefisso non possono essere usati insieme.
Codici di uscita:
- 0: Nessun errore e nessun risultato trovato.
- 1: È stato riscontrato un errore. Le sorgenti potrebbero non aver completato le scansioni.
- 183: Nessun errore riscontrato, ma sono stati trovati risultati. Viene restituito solo se viene usato il flag `--fail`.
---
[Read more](https://github.com/trufflesecurity/trufflehog)