GoReleaser Logo

TruffleHog

Trova credenziali trapelate.

🔎 Ora in scansione

...e altro ancora

Per saperne di più su TruffleHog e le sue funzionalità, visita la nostra pagina prodotto.

🌐 TruffleHog Enterprise

Sei interessato a monitorare continuamente Git, Jira, Slack, Confluence, Microsoft Teams, Sharepoint (e altro) per 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 progetti open source più fantastici di cui l'intera comunità può beneficiare.

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 usa per autenticarsi a un'altra macchina. Include chiavi API, password di database, chiavi private di crittografia e altro.

Scoperta 🔍

TruffleHog può cercare segreti in molti luoghi, tra cui Git, chat, wiki, log, piattaforme di test API, object store, filesystem e altro.

Classificazione 📁

TruffleHog classifica oltre 800 tipi di segreti, mappandoli all'identità specifica a cui appartengono. È un segreto AWS? Stripe? Cloudflare? Password Postgres? Chiave privata SSL? A volte è difficile capirlo a occhio, quindi TruffleHog classifica tutto ciò che trova.

Validazione ✅

Per ogni segreto che TruffleHog può classificare, può anche effettuare l'accesso per confermare se è ancora attivo o meno. Questo passaggio è fondamentale per sapere se esiste un pericolo attivo o meno.

Analisi 🔬

Per i 20 tipi di credenziali più comunemente trapelate, invece di inviare una singola richiesta per verificare se il segreto può accedere, TruffleHog può inviare molte richieste per scoprire tutto ciò che c'è da sapere sul segreto. Chi lo ha creato? A quali risorse può accedere? Quali permessi ha su quelle risorse?

📢 Unisciti alla nostra Community

Hai domande? Feedback? Entra in Slack o Discord e con noi.

Unisciti alla nostra Community Slack

Unisciti al Discord Secret Scanning

📺 Demo

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

# :floppy_disk: Installazione

Diverse opzioni sono disponibili per te:

### Utenti MacOS```bash
brew install trufflehog

Docker:

_{Assicurati che il motore Docker sia in esecuzione prima di eseguire i seguenti comandi:}

Unix```bash

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

#### &nbsp;&nbsp;&nbsp;&nbsp;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

#### &nbsp;&nbsp;&nbsp;&nbsp;M1 and M2 Mac```bash
docker run --platform linux/arm64 --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys

Rilasci binari```bash

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

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

Utilizzando lo script di installazione```bash

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

### Utilizzare lo script di installazione, verificare la firma del checksum (richiede cosign installato)```bash
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -v -b /usr/local/bin

Utilizzare lo 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

# :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.

È necessario il seguente strumento per verificare la firma:

- [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 [rilasci](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"

Una volta confermata la validità della firma, puoi procedere a verificare che gli hash 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 usando 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.

🚀 Avvio Rapido

1: Scansiona un repository solo per segreti verificati

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

Risultato atteso:```
🐷🔑🐷  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 un'Org GitHub solo per segreti verificati```bash

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

## 3: Scansiona un'organizzazione GitHub escludendo i repository archiviati```bash
trufflehog github --org=trufflesecurity --exclude-archived

4: Scansiona un repository GitHub solo per segreti verificati e ottieni output JSON

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

Risultato previsto:```
{"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}
...

5: Analizza un repository GitHub + le sue Issues e Pull Requests```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: Scansiona i bucket S3 utilizzando i ruoli IAM```bash

trufflehog s3 --role-arn=

## 8: Scansiona 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 file o directory individuali```bash

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

## 10: Scansiona un repository git locale

Clona il repository git. Per esempio il repository [test keys](https://github.com/trufflesecurity/trufflehog/blob/HEAD/[email protected]:trufflesecurity/test_keys.git).```bash
git clone [email protected]:trufflesecurity/test_keys.git

Esegui trufflehog dalla directory padre (fuori dal repository git).```bash trufflehog git file://test_keys --results=verified,unknown

Per proteggersi da configurazioni git dannose durante la scansione locale (vedi CVE-2025-41390), TruffleHog clona i repository git locali in una directory temporanea prima della scansione. Questo segue le [best practice di sicurezza di Git](https://git-scm.com/docs/git#_security). Se si desidera specificare un percorso personalizzato per clonare il repository (invece di tmp), è possibile utilizzare il flag `--clone-path`. Se si desidera saltare il processo di clonazione locale e scansionare direttamente il repository (fallo solo per repository fidati), è possibile utilizzare il flag `--trust-local-git-config`.

## 11: Scansiona i bucket GCS solo per segreti verificati```bash
trufflehog gcs --project-id=<project-ID> --cloud-environment --results=verified

12: Scansiona un'immagine Docker solo per 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 si effettuano i merge (ad es.: "main"). Imposta il flag `--branch` sul nome del branch della tua PR (ad es.: "feature-1"). A seconda della piattaforma CI/CD che usi, questo valore può essere recuperato dinamicamente (ad es.: [CIRCLE_BRANCH su Circle CI](https://circleci.com/docs/variables/) e [TRAVIS_PULL_REQUEST_BRANCH su Travis CI](https://docs.travis-ci.com/user/environment-variables/)). Se il repository viene clonato e il branch di destinazione è già estratto durante il flusso di lavoro 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: Scansiona un workspace Postman

Usa i flag --workspace-id, --collection-id, --environment più volte per scansionare più target.```bash trufflehog postman --token= --workspace-id=

## 15: Scansionare un server Jenkins```bash
trufflehog jenkins --url https://jenkins.example.com --username admin --password admin

16: Eseguire una scansione su un server Elasticsearch

Scansionare un cluster locale

Ci sono 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’

Scansiona un cluster Elastic Cloud

Per scansionare un cluster su Elastic Cloud, avrai bisogno di 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 per riferimenti a oggetti cross-fork e commit eliminati

Il comando seguente enumera i commit eliminati e nascosti su un repository GitHub e poi li analizza alla ricerca di segreti. Questa è una funzionalità in versione alpha.```bash
trufflehog github-experimental --repo https://github.com/<USER>/<REPO>.git --object-discovery

Oltre all'output normale 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, oltre a 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 dai 20 minuti a qualche ora, a seconda delle dimensioni del repository. Abbiamo aggiunto una barra di avanzamento per tenerti aggiornato sulla durata dell'enumerazione. L'effettiva scansione dei segreti è estremamente veloce.

Per maggiori informazioni sui Cross Fork Object References, consulta il nostro articolo del blog.

18. Scansiona Hugging Face

Scansiona un modello, dataset, spazio o bucket Hugging Face```bash

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

### Scansiona tutti i Modelli, Dataset, Spazi e Bucket appartenenti a un'Organizzazione o Utente Hugging Face```bash
trufflehog huggingface --org <orgname> --user <username>

(Opzionalmente) Quando si scansiona un'organizzazione o un utente, è possibile saltare un'intera classe di risorse con --skip-all-models, --skip-all-datasets, --skip-all-spaces, --skip-all-buckets OPPURE una risorsa particolare con --ignore-models <model_id>, --ignore-datasets <dataset_id>, --ignore-spaces <space_id>, --ignore-buckets <bucket_id>.

Scansione dei commenti di discussione e delle PR```bash

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

## 19. Scansiona input da stdin```bash
aws s3 cp s3://example/gzipped/data.gz - | gunzip -c | trufflehog stdin

❓ FAQ

Tutto ciò che vedo è 🐷🔑🐷 TruffleHog. Unearth your secrets. 🐷🔑🐷 e il programma esce, che succede?
- Significa che non sono stati rilevati segreti
Perché la scansione richiede molto tempo quando scansiono un'organizzazione GitHub?
- Le scansioni GitHub non autenticate hanno limiti di frequenza. Per migliorare i tuoi limiti, includi il flag --token con un token di accesso personale
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 in tempo reale per l'autenticazione SSH o SSL. Dai un'occhiata al nostro post sul blog Driftwood per saperne di più Post sul blog
Esiste un modo semplice per ignorare segreti specifici?
- Se la fonte scansionata supporta i numeri di riga, allora puoi aggiungere un commento trufflehog:ignore sulla riga contenente il segreto per ignorare quel segreto.

📰 Novità 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 rispetto alle loro 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 utilizzando la nostra tecnologia Driftwood.
Scansiona binari, documenti e altri formati di file
Disponibile come GitHub Action e hook pre-commit

Cos'è la verifica delle credenziali?

Per ogni potenziale credenziale rilevata, abbiamo implementato meticolosamente la verifica programmatica rispetto all'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 (può essere non valida, scaduta o verifica disabilitata)
unknown: Verifica tentata ma fallita a causa di errori, come un guasto di rete o API

Ad esempio, il rilevatore di credenziali AWS esegue una chiamata API GetCallerIdentity all'API AWS per verificare se una credenziale AWS è attiva.

📝 Utilizzo

TruffleHog ha un sottocomando per ogni origine 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 [] [ ...]

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. --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 [...] Show help.

git []

Find credentials in git repositories.

github [] Find credentials in GitHub repositories.

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

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

filesystem [] [...] Find credentials in a filesystem.

s3 [] Find credentials in S3 buckets.

gcs [] Find credentials in GCS buckets.

syslog --format=FORMAT [] Scan syslog

circleci --token=TOKEN Scan CircleCI

docker [] Scan Docker Image

travisci --token=TOKEN Scan TravisCI

postman [] Scan Postman

elasticsearch [] Scan Elasticsearch

jenkins --url=URL [] Scan Jenkins

huggingface [] Find credentials in HuggingFace datasets, models and spaces.

stdin Find credentials from stdin.

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

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

analyze Analyze API keys for fine-grained permissions information.

Per 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 e multiple 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 solo per il sottocomando multi-scan.

Il formato di configurazione per le sorgenti può essere trovato nella pagina di documentazione sulla configurazione delle sorgenti di Truffle Security.

Esempio di configurazione sorgente GitHub e riferimento alle opzioni:```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.

## S3

La sorgente S3 supporta l'assunzione di ruoli IAM per l'analisi oltre agli utenti IAM. Questo facilita l'analisi di più account AWS senza dover fare affidamento su credenziali hardcoded per ciascun account.

L'identità IAM che TruffleHog utilizza inizialmente deve disporre dei privilegi `AssumeRole` come principale nella [trust policy](https://aws.amazon.com/blogs/security/how-to-use-trust-policies-with-iam-roles/) di ciascun ruolo IAM da assumere.

Per analizzare un bucket specifico utilizzando credenziali impostate localmente o 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= --role-arn=

È possibile passare più ruoli come argomenti separati. Il seguente comando tenterà di scansionare ogni bucket per cui ogni ruolo ha i permessi di elencare nell'API S3:```bash
trufflehog s3 --role-arn=<iam-role-arn-1> --role-arn=<iam-role-arn-2>

Codici di uscita:

0: Nessun errore e nessun risultato trovato.
1: È stato riscontrato un errore. Alcune fonti potrebbero non aver completato le scansioni.
183: Nessun errore riscontrato, ma sono stati trovati risultati. Verrà restituito solo se viene utilizzato il flag --fail.

:octocat: TruffleHog Github Action

Utilizzo generale```

on: push: branches: - main pull_request:

jobs: test: runs-on: ubuntu-latest steps: - name: Checkout code uses: actions/checkout@v4 with: fetch-depth: 0 - name: Secret Scanning uses: trufflesecurity/trufflehog@main with: extra_args: --results=verified,unknown

Nell'esempio di configurazione sopra, stiamo cercando segreti attivi in tutte le PR e i Push al branch `main`. Vengono scansionate solo le modifiche al codice nei commit referenziati. Se desideri scansionare un intero branch, consulta la sezione "Utilizzo avanzato" di seguito.

### Clonazione superficiale

Se stai integrando TruffleHog in un flusso di lavoro autonomo e non stai eseguendo nessun altro strumento CI/CD insieme a TruffleHog, allora ti consigliamo di utilizzare la [Clonazione superficiale](https://git-scm.com/docs/git-clone#Documentation/git-clone.txt---depthltdepthgt) per velocizzare il tuo flusso di lavoro. Ecco un esempio di come farlo:```
...
      - shell: bash
        run: |
          if [ "${{ github.event_name }}" == "push" ]; then
            echo "depth=$(($(jq length <<< '${{ toJson(github.event.commits) }}') + 2))" >> $GITHUB_ENV
            echo "branch=${{ github.ref_name }}" >> $GITHUB_ENV
          fi
          if [ "${{ github.event_name }}" == "pull_request" ]; then
            echo "depth=$((${{ github.event.pull_request.commits }}+2))" >> $GITHUB_ENV
            echo "branch=${{ github.event.pull_request.head.ref }}" >> $GITHUB_ENV
          fi
      - uses: actions/checkout@v3
        with:
          ref: ${{env.branch}}
          fetch-depth: ${{env.depth}}
      - uses: trufflesecurity/trufflehog@main
        with:
          extra_args: --results=verified,unknown
...

A seconda del tipo di evento (push o PR), calcoliamo il numero di commit presenti. Quindi aggiungiamo 2, in modo da poter fare riferimento a un commit base prima delle nostre modifiche al codice. Passiamo quel valore intero al flag fetch-depth nell'azione di checkout insieme al branch pertinente. Ora il nostro processo di checkout dovrebbe essere molto più breve.

Rilevamento dei canarini

TruffleHog rileva staticamente https://canarytokens.org/.

Utilizzo avanzato```yaml

name: TruffleHog uses: trufflesecurity/trufflehog@main with:
Repository path
path:
Start scanning from here (usually main branch).
base:
Scan commits until here (usually dev branch).
head: # optional
Extra args to be passed to the trufflehog cli.
extra_args: --log-level=2 --results=verified,unknown
Scan with a specific TruffleHog version (default: latest).
version:
Docker image to pull. Override to use a registry mirror (default: ghcr.io/trufflesecurity/trufflehog).
image:

Se desideri specificare riferimenti `base` e `head` specifici, puoi utilizzare l'argomento `base` (flag `--since-commit` nella CLI di TruffleHog) e l'argomento `head` (flag `--branch` nella CLI di TruffleHog). Raccomandiamo di utilizzare questi argomenti solo per casi d'uso molto specifici, in cui il comportamento predefinito non funziona.

#### Utilizzo avanzato: Scansiona l'intero ramo```
- name: scan-push
        uses: trufflesecurity/trufflehog@main
        with:
          base: ""
          head: ${{ github.ref_name }}
          extra_args: --results=verified,unknown

TruffleHog GitLab CI

Esempio di Utilizzo```yaml

stages:

security

security-secrets: stage: security allow_failure: false image: alpine:latest variables: SCAN_PATH: "." # Set the relative path in the repo to scan before_script: - apk add --no-cache git curl jq - curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -b /usr/local/bin script: - trufflehog filesystem "$SCAN_PATH" --results=verified,unknown --fail --json | jq rules: - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'

Nell'esempio di pipeline sopra, stiamo cercando segreti attivi in tutte le directory e file del repository. Questo job viene eseguito solo quando l'origine della pipeline è un evento di merge request, il che significa che viene attivato quando viene creata una nuova merge request.

## Pre-commit Hook

TruffleHog può essere utilizzato in un hook pre-commit per impedire che le credenziali vengano divulgate prima ancora di lasciare il tuo computer.

Consulta la [documentazione dell'hook pre-commit](https://github.com/trufflesecurity/trufflehog/blob/HEAD/PreCommit.md) per maggiori informazioni.

## Rilevatore Regex Personalizzato (alpha)

TruffleHog supporta il rilevamento e la verifica di espressioni regolari personalizzate. Per il rilevamento, è necessaria almeno una **espressione regolare** e una **parola chiave**. Una **parola chiave** è un identificatore di stringa letterale fissa che appare all'interno o intorno alla regex da rilevare. Per consentire la massima flessibilità nella verifica, viene utilizzato un webhook contenente le corrispondenze dell'espressione regolare.

TruffleHog invierà una richiesta JSON POST contenente le corrispondenze della regex a un endpoint webhook configurato. Se l'endpoint risponde con un codice di stato `200 OK`, il segreto è considerato verificato. Se la verifica fallisce a causa di errori di rete/API, il risultato viene contrassegnato come sconosciuto.

I rilevatori personalizzati supportano alcuni meccanismi di filtraggio diversi: entropia, regex mirata all'intera corrispondenza, regex mirata al segreto catturato ed elenchi di parole escluse controllate rispetto al segreto (gruppo catturato se presente, intera corrispondenza se il gruppo di cattura non è presente). Nota che se il tuo rilevatore personalizzato ha più `regex` impostate (in questo esempio `hogID` e `hogToken`), i filtri vengono applicati a ciascuna regex. [Qui](https://github.com/trufflesecurity/trufflehog/blob/HEAD/examples/generic_with_filters.yml) è un esempio di un rilevatore personalizzato che utilizza questi filtri.

**NB:** Questa funzionalità è alpha e soggetta a modifiche.

### Esempio di Rilevatore Regex

[Qui](https://github.com/trufflesecurity/trufflehog/blob/HEAD/pkg/custom_detectors/CUSTOM_DETECTORS.md) viene spiegato come configurare un rilevatore regex personalizzato con server di verifica.

## Rilevamento JWT Generico

TruffleHog supporta il rilevamento e la verifica di un sottoinsieme di JWT generici che trova. Nello specifico, se un JWT utilizza la crittografia a chiave pubblica anziché HMAC e la chiave pubblica può essere ottenuta, TruffleHog può determinare se il JWT è attivo o meno.

## :mag: Analizza

TruffleHog supporta l'esecuzione di un'analisi più approfondita di una credenziale per visualizzare i suoi permessi e le risorse a cui ha accesso.```bash
trufflehog analyze

❤️ Contributori

Questo progetto esiste grazie a tutte le persone che contribuiscono. [Contribuisci].

💻 Contribuire

I contributi sono molto benvenuti! Si prega di consultare le nostre linee guida per i contributi per prima cosa.

Non accettiamo più contributi a TruffleHog v2, ma quel codice è disponibile nel branch v2.

Aggiungere nuovi rilevatori di segreti

Abbiamo pubblicato della documentazione e strumenti per iniziare ad aggiungere nuovi rilevatori di segreti. Miglioriamo il rilevamento insieme!

Utilizzo come libreria

Attualmente, trufflehog è in pieno sviluppo e non possono essere fornite garanzie sulla stabilità delle API pubbliche al momento.

Cambiamento di licenza

Dalla v3.0, TruffleHog è rilasciato sotto licenza AGPL 3, inclusa in LICENSE. TruffleHog v3.0 non utilizza alcuna parte del codice precedente, ma è stata prestata attenzione per preservare la compatibilità all'indietro nell'interfaccia a riga di comando. Il lavoro precedente a questa versione è ancora disponibile con licenza GPL 2.0 nella storia di questo repository e nelle precedenti versioni e tag del pacchetto. È richiesto un CLA completato per accettare contributi futuri.

trufflehog v3.97.0

Categorie