GoReleaser Logo

TruffleHog

Finde durchgesickerte Anmeldedaten.

🔎 Aktuell gescannt

...und mehr

Um mehr über TruffleHog und seine Funktionen und Fähigkeiten zu erfahren, besuchen Sie unsere Produktseite.

🌐 TruffleHog Enterprise

Sind Sie daran interessiert, Git, Jira, Slack, Confluence, Microsoft Teams, Sharepoint (und mehr) kontinuierlich auf Anmeldedaten zu überwachen? Wir haben ein Enterprise-Produkt, das helfen kann! Erfahren Sie mehr unter https://trufflesecurity.com/trufflehog-enterprise.

Wir verwenden die Einnahmen aus dem Enterprise-Produkt, um weitere großartige Open-Source-Projekte zu finanzieren, von denen die gesamte Community profitieren kann.

Was ist TruffleHog 🐽

TruffleHog ist das leistungsstärkste Tool zur Erkennung, Klassifizierung, Validierung und Analyse von Geheimnissen. In diesem Zusammenhang bezieht sich Geheimnis auf eine Berechtigung, die eine Maschine verwendet, um sich bei einer anderen Maschine zu authentifizieren. Dies umfasst API-Schlüssel, Datenbankpasswörter, private Verschlüsselungsschlüssel und mehr.

Erkennung 🔍

TruffleHog kann in vielen Orten nach Geheimnissen suchen, darunter Git, Chats, Wikis, Logs, API-Testplattformen, Objektspeicher, Dateisysteme und mehr.

Klassifizierung 📁

TruffleHog klassifiziert über 800 Geheimnistypen und ordnet sie der jeweiligen Identität zu, zu der sie gehören. Handelt es sich um ein AWS-Geheimnis? Stripe-Geheimnis? Cloudflare-Geheimnis? Postgres-Passwort? SSL-Private-Key? Manchmal ist es schwer zu erkennen, also klassifiziert TruffleHog alles, was es findet.

Validierung ✅

Für jedes Geheimnis, das TruffleHog klassifizieren kann, kann es sich auch anmelden, um zu bestätigen, ob dieses Geheimnis live ist oder nicht. Dieser Schritt ist entscheidend, um zu wissen, ob eine aktive aktuelle Gefahr besteht oder nicht.

Analyse 🔬

Für die etwa 20 am häufigsten durchgesickerten Anmeldedatentypen kann TruffleHog anstelle einer einzigen Anfrage viele Anfragen senden, um alles über das Geheimnis zu erfahren. Wer hat es erstellt? Auf welche Ressourcen kann es zugreifen? Welche Berechtigungen hat es auf diesen Ressourcen?

📢 Treten Sie unserer Community bei

Haben Sie Fragen? Feedback? Springen Sie in Slack oder Discord und verbringen Sie Zeit mit uns.

Treten Sie unserer Slack-Community bei

Treten Sie dem Secret Scanning Discord bei

📺 Demo

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

# :floppy_disk: Installation

Mehrere Optionen stehen Ihnen zur Verfügung:

### MacOS-Benutzer```bash
brew install trufflehog

Docker:

_{Stellen Sie sicher, dass die Docker-Engine läuft, bevor Sie die folgenden Befehle ausführen:}

Unix```bash

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

#### &nbsp;&nbsp;&nbsp;&nbsp;Windows-Eingabeaufforderung```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 und M2 Mac```bash
docker run --platform linux/arm64 --rm -it -v "$PWD:/pwd" trufflesecurity/trufflehog:latest github --repo https://github.com/trufflesecurity/test_keys

Binäre Releases```bash

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

### Aus dem Quellcode kompilieren```bash
git clone https://github.com/trufflesecurity/trufflehog.git
cd trufflehog; go install

Verwendung des Installationsskripts```bash

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

### Installationsskript verwenden, Prüfsummensignatur überprüfen (erfordert installiertes cosign)```bash
curl -sSfL https://raw.githubusercontent.com/trufflesecurity/trufflehog/main/scripts/install.sh | sh -s -- -v -b /usr/local/bin

Verwendung des Installationsskripts zur Installation einer bestimmten Version```bash

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

# :closed_lock_with_key: Überprüfung der Artefakte

Prüfsummen werden auf alle Artefakte angewendet, und die resultierende Prüfsummendatei wird mit cosign signiert.

Sie benötigen das folgende Werkzeug, um die Signatur zu überprüfen:

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

Die Überprüfungsschritte sind wie folgt:

1. Laden Sie die gewünschten Artefaktdateien und die folgenden Dateien von der [Releases](https://github.com/trufflesecurity/trufflehog/releases)-Seite herunter.

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

2. Überprüfen Sie die Signatur:   ```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"

Sobald die Signatur als gültig bestätigt wurde, können Sie fortfahren und überprüfen, dass die SHA256-Summen mit dem heruntergeladenen Artefakt übereinstimmen: ```shell sha256sum --ignore-missing -c trufflehog_{version}_checksums.txt

Ersetzen Sie {version} durch die Version der heruntergeladenen Dateien

Alternativ, wenn Sie das Installationsskript verwenden, übergeben Sie die Option -v, um die Signaturprüfung durchzuführen. Dazu muss das Cosign-Binärprogramm vor der Ausführung des Installationsskripts installiert sein.

🚀 Schnellstart

1: Ein Repository nur auf verifizierte Geheimnisse scannen

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

Erwartete Ausgabe:```
🐷🔑🐷  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: Scanne eine GitHub-Organisation nur nach verifizierten Geheimnissen```bash

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

## 3: Scan a GitHub Org ohne archivierte Repositories```bash
trufflehog github --org=trufflesecurity --exclude-archived

4: Scannen Sie ein GitHub-Repo nach nur verifizierten Geheimnissen und erhalten Sie JSON-Ausgabe

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

Erwartete Ausgabe:```
{"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: Ein GitHub-Repo + seine Issues und Pull Requests scannen```bash

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

## 6: S3 bucket auf Ergebnisse mit hoher Vertrauenswürdigkeit scannen (verifiziert + unbekannt)```bash
trufflehog s3 --bucket=<bucket name> --results=verified,unknown

7: Scannen von S3-Buckets mit IAM-Rollen```bash

trufflehog s3 --role-arn=

## 8: Scanne ein Github-Repo mittels SSH-Authentifizierung in Docker```bash
docker run --rm -v "$HOME/.ssh:/root/.ssh:ro" trufflesecurity/trufflehog:latest git ssh://github.com/trufflesecurity/test_keys

9: Einzelne Dateien oder Verzeichnisse scannen```bash

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

## 10: Lokales Git-Repository scannen

Klone das Git-Repository. Zum Beispiel [test keys](https://github.com/trufflesecurity/trufflehog/blob/HEAD/[email protected]:trufflesecurity/test_keys.git) Repository.```bash
git clone [email protected]:trufflesecurity/test_keys.git

Führe trufflehog vom übergeordneten Verzeichnis (außerhalb des Git-Repos) aus.```bash trufflehog git file://test_keys --results=verified,unknown

Um vor bösartigen Git-Konfigurationen beim lokalen Scannen zu schützen (siehe CVE-2025-41390), klont TruffleHog lokale Git-Repositorys vor dem Scannen in ein temporäres Verzeichnis. Dies folgt den [Sicherheitsbest Practices von Git](https://git-scm.com/docs/git#_security). Falls Sie einen benutzerdefinierten Pfad angeben möchten, in den das Repository geklont werden soll (anstatt tmp), können Sie das Flag `--clone-path` verwenden. Wenn Sie den lokalen Klonvorgang überspringen und das Repository direkt scannen möchten (dies nur für vertrauenswürdige Repos tun), können Sie das Flag `--trust-local-git-config` verwenden.

## 11: GCS-Buckets nur nach bestätigten Geheimnissen scannen```bash
trufflehog gcs --project-id=<project-ID> --cloud-environment --results=verified

12: Scannen eines Docker-Images nur nach verifizierten Geheimnissen

Verwenden Sie das Flag --image mehrmals, um mehrere Images zu scannen.```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: Scan in CI

Setzen Sie das `--since-commit`-Flag auf Ihren Standard-Branch, in den gemerged wird (z.B. "main"). Setzen Sie das `--branch`-Flag auf den Branch-Namen Ihres PRs (z.B. "feature-1"). Abhängig von der verwendeten CI/CD-Plattform kann dieser Wert dynamisch bezogen werden (z.B. [CIRCLE_BRANCH in Circle CI](https://circleci.com/docs/variables/) und [TRAVIS_PULL_REQUEST_BRANCH in Travis CI](https://docs.travis-ci.com/user/environment-variables/)). Wenn das Repository geklont wurde und der Ziel-Branch während des CI/CD-Workflows bereits ausgecheckt ist, sollte `--branch HEAD` ausreichen. Das `--fail`-Flag gibt einen Fehlercode 183 zurück, wenn gültige Anmeldedaten gefunden werden.```bash
trufflehog git file://. --since-commit main --branch feature-1 --results=verified,unknown --fail

14: Einen Postman-Workspace scannen

Verwenden Sie die Flags --workspace-id, --collection-id, --environment mehrmals, um mehrere Ziele zu scannen.```bash trufflehog postman --token= --workspace-id=

## 15: Scannen eines Jenkins-Servers```bash
trufflehog jenkins --url https://jenkins.example.com --username admin --password admin

16: Scannen eines Elasticsearch-Servers

Lokalen Cluster scannen

Es gibt zwei Möglichkeiten, sich mit TruffleHog bei einem lokalen Cluster zu authentifizieren: (1) Benutzername und Passwort, (2) Dienst-Token.

Mit Benutzername und Passwort mit einem lokalen Cluster verbinden```bash

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

#### Mit einem Service-Token zu einem lokalen Cluster verbinden```bash
trufflehog elasticsearch --nodes 192.168.14.3 192.168.14.4 --service-token ‘AAEWVaWM...Rva2VuaSDZ’

Einen Elastic Cloud Cluster scannen

Um einen Cluster auf Elastic Cloud zu scannen, benötigen Sie eine Cloud-ID und einen API-Schlüssel.```bash trufflehog elasticsearch
--cloud-id 'search-prod:dXMtY2Vx...YjM1ODNlOWFiZGRlNjI0NA=='
--api-key 'MlVtVjBZ...ZSYlduYnF1djh3NG5FQQ=='

## 17. Scannen eines GitHub-Repositorys nach Cross-Fork-Objektverweisen und gelöschten Commits

Der folgende Befehl listet gelöschte und versteckte Commits in einem GitHub-Repository auf und scannt sie dann nach Geheimnissen. Dies ist eine Alphaversion-Funktion.```bash
trufflehog github-experimental --repo https://github.com/<USER>/<REPO>.git --object-discovery

Zusätzlich zur normalen TruffleHog-Ausgabe erstellt das Flag --object-discovery zwei Dateien in einem neuen Verzeichnis $HOME/.trufflehog: valid_hidden.txt und invalid.txt. Diese werden verwendet, um den Zustand während der Commit-Enumeration zu verfolgen und den Benutzern eine vollständige Liste aller versteckten und gelöschten Commits (valid_hidden.txt) bereitzustellen. Wenn Sie diese Dateien nach dem Scannen automatisch entfernen möchten, fügen Sie bitte das Flag --delete-cached-data hinzu.

Hinweis: Die Enumeration aller gültigen Commits in einem Repository mit dieser Methode dauert zwischen 20 Minuten und einigen Stunden, abhängig von der Größe Ihres Repositorys. Wir haben einen Fortschrittsbalken hinzugefügt, der Sie über die Dauer der Enumeration auf dem Laufenden hält. Das eigentliche Secret-Scannen läuft extrem schnell.

Für weitere Informationen zu Cross Fork Object References lesen Sie bitte unseren Blogbeitrag.

18. Hugging Face scannen

Ein Hugging Face Modell, Dataset, Space oder Bucket scannen```bash

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

### Scannen aller Modelle, Datasets, Spaces und Buckets, die zu einer Hugging Face Organisation oder einem Benutzer gehören```bash
trufflehog huggingface --org <orgname> --user <username>

(Optional) Beim Scannen einer Organisation oder eines Benutzers können Sie eine gesamte Ressourcenklasse mit --skip-all-models, --skip-all-datasets, --skip-all-spaces, --skip-all-buckets überspringen ODER eine bestimmte Ressource mit --ignore-models <model_id>, --ignore-datasets <dataset_id>, --ignore-spaces <space_id>, --ignore-buckets <bucket_id>.

Diskussion und PR-Kommentare scannen```bash

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

## 19. Scannen der stdin-Eingabe```bash
aws s3 cp s3://example/gzipped/data.gz - | gunzip -c | trufflehog stdin

❓ FAQ

Ich sehe nur 🐷🔑🐷 TruffleHog. Unearth your secrets. 🐷🔑🐷 und das Programm beendet sich, was ist los?
- Das bedeutet, dass keine Geheimnisse erkannt wurden.
Warum dauert der Scan so lange, wenn ich eine GitHub-Organisation scanne?
- Unauthentifizierte GitHub-Scans haben Ratenbegrenzungen. Um Ihre Raten zu verbessern, fügen Sie das --token-Flag mit einem persönlichen Zugangstoken hinzu.
Es heißt, ein privater Schlüssel wurde verifiziert – was bedeutet das?
- Ein verifiziertes Ergebnis bedeutet, dass TruffleHog die Anmeldeinformationen bestätigt hat, indem es sie gegen die API des Dienstes getestet hat. Bei privaten Schlüsseln haben wir bestätigt, dass der Schlüssel live für SSH- oder SSL-Authentifizierung verwendet werden kann. Weitere Informationen finden Sie in unserem Driftwood-Blogbeitrag: Blogbeitrag
Gibt es eine einfache Möglichkeit, bestimmte Geheimnisse zu ignorieren?
- Wenn die gescannte Quelle Zeilennummern unterstützt, können Sie einen trufflehog:ignore-Kommentar in der Zeile mit dem Geheimnis hinzufügen, um dieses Geheimnis zu ignorieren.

📰 Was ist neu in v3?

TruffleHog v3 ist eine vollständige Neuschreibung in Go mit vielen neuen leistungsstarken Funktionen.

Wir haben über 700 Credential-Detektoren hinzugefügt, die eine aktive Verifizierung gegenüber ihren jeweiligen APIs unterstützen.
Wir haben außerdem native Unterstützung für das Scannen von GitHub, GitLab, Docker, Dateisystemen, S3, GCS, Circle CI und Travis CI hinzugefügt.
Privaten Schlüssel sofort verifizieren – gegen Millionen von GitHub-Benutzern und Milliarden von TLS-Zertifikaten mittels unserer Driftwood-Technologie.
Scannen von Binärdateien, Dokumenten und anderen Dateiformaten
Verfügbar als GitHub Action und als Pre-Commit-Hook

Was ist Credential-Verifizierung?

Für jede potenzielle Anmeldeinformation, die erkannt wird, haben wir aufwändig eine programmatische Verifizierung gegenüber der API implementiert, von der wir glauben, dass sie dazugehört. Die Verifizierung eliminiert falsch-positive Ergebnisse und liefert drei Ergebnisstatus:

verified (verifiziert): Anmeldeinformationen wurden durch API-Tests als gültig und aktiv bestätigt.
unverified (nicht verifiziert): Anmeldeinformationen wurden erkannt, aber nicht als gültig bestätigt (kann ungültig, abgelaufen oder die Verifizierung deaktiviert sein).
unknown (unbekannt): Verifizierung wurde versucht, schlug jedoch aufgrund von Fehlern wie Netzwerk- oder API-Fehlern fehl.

Beispielsweise führt der AWS-Credential-Detektor einen GetCallerIdentity-API-Aufruf gegen die AWS-API durch, um zu überprüfen, ob eine AWS-Anmeldeinformation aktiv ist.

📝 Verwendung

TruffleHog hat für jede Datenquelle, die Sie scannen möchten, einen Unterbefehl:

git
github
gitlab
huggingface
docker
s3
filesystem (Dateien und Verzeichnisse)
syslog
circleci
travisci
gcs (Google Cloud Storage)
postman
jenkins
elasticsearch
stdin
multi-scan

Jeder Unterbefehl kann Optionen haben, die Sie mit dem --help-Flag sehen können, das dem Unterbefehl übergeben wird:``` $ 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.

Zum Beispiel, um ein `git`-Repository zu scannen, beginnen Sie mit```
trufflehog git https://github.com/trufflesecurity/trufflehog.git

Konfiguration

TruffleHog unterstützt die Definition von benutzerdefinierten Regex-Detektoren und mehreren Quellen in einer Konfigurationsdatei, die über das Flag --config bereitgestellt wird. Die Regex-Detektoren können mit jedem Unterbefehl verwendet werden, während die in der Konfiguration definierten Quellen nur für den Unterbefehl multi-scan gelten.

Das Konfigurationsformat für Quellen finden Sie auf der Dokumentationsseite zur Quellenkonfiguration von Truffle Security.

Beispiel für eine GitHub-Quellenkonfiguration und Optionsreferenz:```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

Sie können mehrere Verbindungen unter dem `sources`-Schlüssel definieren (siehe oben), und TruffleHog wird alle Quellen gleichzeitig scannen.

## S3

Die S3-Quelle unterstützt das Annehmen von IAM-Rollen für das Scannen zusätzlich zu IAM-Benutzern. Dies erleichtert es Benutzern, mehrere AWS-Konten zu scannen, ohne auf fest codierte Anmeldeinformationen für jedes Konto angewiesen zu sein.

Die IAM-Identität, die TruffleHog zunächst verwendet, muss `AssumeRole`-Berechtigungen als Prinzipal in der [Vertrauensrichtlinie](https://aws.amazon.com/blogs/security/how-to-use-trust-policies-with-iam-roles/) jeder IAM-Rolle haben, die angenommen werden soll.

Um einen bestimmten Bucket mit lokal festgelegten Anmeldeinformationen oder Instanzmetadaten (wenn auf einer EC2-Instanz) zu scannen:```bash
trufflehog s3 --bucket=<bucket-name>

Um einen bestimmten Bucket mit einer angenommenen Rolle zu scannen:```bash trufflehog s3 --bucket= --role-arn=

Mehrere Rollen können als separate Argumente übergeben werden. Der folgende Befehl versucht, jeden Bucket zu scannen, den jede Rolle in der S3-API auflisten darf:```bash
trufflehog s3 --role-arn=<iam-role-arn-1> --role-arn=<iam-role-arn-2>

Exit Codes:

0: Keine Fehler und keine Ergebnisse gefunden.
1: Ein Fehler ist aufgetreten. Quellen haben möglicherweise keine vollständigen Scans durchgeführt.
183: Keine Fehler aufgetreten, aber Ergebnisse gefunden. Wird nur zurückgegeben, wenn das Flag --fail verwendet wird.

:octocat: TruffleHog Github Action

Allgemeine Verwendung```

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

Im obigen Beispiel-Konfiguration scannen wir nach Live-Secrets in allen Pull-Requests und Pushes auf `main`. Es werden nur Code-Änderungen in den referenzierten Commits gescannt. Wenn Sie einen gesamten Branch scannen möchten, lesen Sie bitte den Abschnitt „Erweiterte Verwendung“ weiter unten.

### Flaches Klonen

Wenn Sie TruffleHog in einen eigenständigen Workflow integrieren und kein anderes CI/CD-Tool neben TruffleHog verwenden, empfehlen wir die Verwendung von [Flachem Klonen](https://git-scm.com/docs/git-clone#Documentation/git-clone.txt---depthltdepthgt), um Ihren Workflow zu beschleunigen. Hier ist ein Beispiel, wie das geht:```
...
      - 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
...

Je nach Ereignistyp (push oder PR) berechnen wir die Anzahl der vorhandenen Commits. Dann addieren wir 2, damit wir auf einen Basiscommit vor unseren Codeänderungen verweisen können. Wir übergeben diesen ganzzahligen Wert an das fetch-depth-Flag in der checkout-Aktion zusätzlich zum relevanten Branch. Jetzt sollte unser Checkout-Prozess viel kürzer sein.

Canary-Erkennung

TruffleHog erkennt statisch https://canarytokens.org/.

Erweiterte Nutzung```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:

Wenn Sie bestimmte `base`- und `head`-Referenzen angeben möchten, können Sie das `base`-Argument (`--since-commit`-Flag in der TruffleHog CLI) und das `head`-Argument (`--branch`-Flag in der TruffleHog CLI) verwenden. Wir empfehlen die Verwendung dieser Argumente nur für sehr spezifische Anwendungsfälle, bei denen das Standardverhalten nicht funktioniert.

#### Erweiterte Nutzung: Ganzen Branch scannen```
- name: scan-push
        uses: trufflesecurity/trufflehog@main
        with:
          base: ""
          head: ${{ github.ref_name }}
          extra_args: --results=verified,unknown

TruffleHog GitLab CI

Beispielverwendung```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"'

Im obigen Beispielpipeline durchsuchen wir alle Repository-Verzeichnisse und -Dateien nach Live-Geheimnissen. Dieser Job wird nur ausgeführt, wenn die Pipeline-Quelle ein Merge-Request-Ereignis ist, was bedeutet, dass er ausgelöst wird, wenn ein neuer Merge-Request erstellt wird.

## Pre-Commit-Hook

TruffleHog kann in einem Pre-Commit-Hook verwendet werden, um zu verhindern, dass Anmeldeinformationen auslaufen, bevor sie Ihren Computer verlassen.

Weitere Informationen finden Sie in der [Pre-Commit-Hook-Dokumentation](https://github.com/trufflesecurity/trufflehog/blob/HEAD/PreCommit.md).

## Benutzerdefinierter Regex-Detektor (Alpha)

TruffleHog unterstützt die Erkennung und Überprüfung benutzerdefinierter regulärer Ausdrücke.
Für die Erkennung ist mindestens ein **regulärer Ausdruck** und ein **Schlüsselwort** erforderlich.
Ein **Schlüsselwort** ist ein fester, wörtlicher String-Bezeichner, der in oder um den zu erkennenden Regex herum vorkommt. Um maximale Flexibilität bei der Überprüfung zu ermöglichen, wird ein Webhook verwendet, der die Übereinstimmungen des regulären Ausdrucks enthält.

TruffleHog sendet eine JSON-POST-Anfrage mit den Regex-Übereinstimmungen an einen konfigurierten Webhook-Endpunkt. Wenn der Endpunkt mit einem `200 OK`-Antwortstatuscode antwortet, gilt das Geheimnis als verifiziert. Wenn die Überprüfung aufgrund von Netzwerk-/API-Fehlern fehlschlägt, wird das Ergebnis als unbekannt markiert.

Benutzerdefinierte Detektoren unterstützen verschiedene Filtermechanismen: Entropie, Regex, die auf die gesamte Übereinstimmung abzielen, Regex, die auf das erfasste Geheimnis abzielen, und ausgeschlossene Wortlisten, die gegen das Geheimnis geprüft werden (erfasste Gruppe, falls vorhanden, gesamte Übereinstimmung, falls keine Erfassungsgruppe vorhanden ist). Beachten Sie, dass wenn Ihr benutzerdefinierter Detektor mehrere `regex`-Sets hat (in diesem Beispiel `hogID` und `hogToken`), die Filter auf jeden Regex angewendet werden. [Hier](https://github.com/trufflesecurity/trufflehog/blob/HEAD/examples/generic_with_filters.yml) ist ein Beispiel für einen benutzerdefinierten Detektor, der diese Filter verwendet.

**Hinweis:** Diese Funktion ist Alpha und kann sich ändern.

### Beispiel für einen Regex-Detektor
[Hier](https://github.com/trufflesecurity/trufflehog/blob/HEAD/pkg/custom_detectors/CUSTOM_DETECTORS.md) erfahren Sie, wie Sie einen benutzerdefinierten Regex-Detektor mit einem Verifizierungsserver einrichten.

## Generische JWT-Erkennung

TruffleHog unterstützt die Erkennung und Überprüfung einer Teilmenge der generischen JWTs, die es findet.
Insbesondere, wenn ein JWT Public-Key-Kryptografie anstelle von HMAC verwendet und der öffentliche Schlüssel abgerufen werden kann, kann TruffleHog bestimmen, ob der JWT live ist oder nicht.

## :mag: Analysieren

TruffleHog unterstützt die Durchführung einer tiefergehenden Analyse einer Anmeldeinformation, um ihre Berechtigungen und die Ressourcen, auf die sie Zugriff hat, anzuzeigen.```bash
trufflehog analyze

❤️ Mitwirkende

Dieses Projekt existiert dank all der Menschen, die beitragen. [Mitwirken].

💻 Mitwirken

Beiträge sind sehr willkommen! Bitte lies zuerst unsere Richtlinien für Beiträge.

Wir nehmen keine Beiträge mehr zu TruffleHog v2 an, aber dieser Code ist im v2-Branch verfügbar.

Hinzufügen neuer Secret-Detektoren

Wir haben einige Dokumentation und Werkzeuge veröffentlicht, um mit dem Hinzufügen neuer Secret-Detektoren zu beginnen. Lass uns die Erkennung gemeinsam verbessern!

Verwendung als Bibliothek

Derzeit befindet sich trufflehog in intensiver Entwicklung und es können keine Garantien für die Stabilität der öffentlichen APIs zu diesem Zeitpunkt gegeben werden.

Lizenzänderung

Seit v3.0 wird TruffleHog unter einer AGPL-3-Lizenz veröffentlicht, enthalten in LICENSE. TruffleHog v3.0 verwendet keine der vorherigen Codebasis, aber es wurde darauf geachtet, die Abwärtskompatibilität der Befehlszeilenschnittstelle zu erhalten. Die Arbeiten vor dieser Veröffentlichung sind weiterhin unter der GPL 2.0 in der Historie dieses Repositorys und den vorherigen Paketveröffentlichungen und Tags verfügbar. Eine ausgefüllte CLA ist erforderlich, damit wir zukünftige Beiträge annehmen können.

trufflehog v3.97.0

Kategorien