Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Einreichen
ToolsExploitsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

FeedsKontaktDatenschutz© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
trufflehog — Durchgesickerte Anmeldedaten finden, verifizieren und analysieren | Kitploit
Tools/GitHubGitHub/trufflesecurity/trufflehog
SchwachstellenscannerDynamische Analyse (Sandboxing)Code-AnalyseCloud-SicherheitDevSecOpsSecret-ErkennungBedrohungsanalyseLieferkettensicherheitIncident ResponseTop in DevSecOps Nr.4
27.4k2.5k302vor 1 TagVon Kitploit geprüft
Top in Secret-Erkennung Nr.2
Top in Lieferkettensicherheit Nr.19
GitHubtrufflesecurity/trufflehog

trufflehog

Durchgesickerte Anmeldedaten finden, verifizieren und analysieren

Repository anzeigenWebseite

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Das ultimative OSINT-Toolkit: Untersuchungsgraph, Konfidenzbewertung, Alias-Familien, Karte, Zeitleiste und Berichte. 49 Module, 400+ Websites, keine API-Schlüssel erforderlich.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    647
  • 3

    looking-glass

    anonghosty/looking-glass

    CSIRT-Plattform, die Shadowserver-Berichte in MongoDB einliest und sie als interaktive Karten, Analysen, Findings, Advisories und Executive-Dashboards wiedergibt.

    421
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer ist eine Open-Source-Plattform für Privileged Access Management (PAM), die DevOps- und IT-Teams bedarfsgesteuerten und sicheren Zugriff auf SSH-, RDP-, Kubernetes-, Datenbank- und RemoteApp-Endpunkte über einen Webbrowser bietet.

    389
  • 5

    ARTEX

    baarai/artex

    LLM-basierte Multi-Agenten-Plattform für autonome Penetrationstests mit Planer-/Worker-Agenten, Asset- und Explorationsgraphen, MITM-Verkehrsaufzeichnung und Schwachstellen-Retesting.

    333
  • 6

    SafeLine

    chaitin/safeline

    Selbst gehosteter WAF und Reverse Proxy, der bösartigen HTTP-Verkehr filtert, SQL-Injection, XSS und Bot-Angriffe blockiert, mit Ratenbegrenzung und dynamischer HTML/JS-Verschlüsselung.

    331

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen
<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">Finde geleakte Zugangsdaten.</p>
</p>

---

<div align="center">

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

</div>

---

# :mag_right: _Jetzt wird gescannt_

<div align="center">

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

**...und mehr**

Um mehr über TruffleHog und seine Funktionen und Möglichkeiten zu erfahren, besuche unsere [Produktseite](https://trufflesecurity.com/trufflehog?gclid=CjwKCAjwouexBhAuEiwAtW_Zx5IW87JNj97Ci7heFnA5ar6-DuNzT2Y5nIl9DuZ-FOUqx0Qg3vb9nxoClcEQAvD_BwE).

</div>

# :globe_with_meridians: TruffleHog Enterprise

Möchtest du **Git, Jira, Slack, Confluence, Microsoft Teams, Sharepoint (und mehr)** kontinuierlich auf Zugangsdaten überwachen? Wir haben ein Enterprise-Produkt, das dir dabei helfen kann! Erfahre 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 profitiert.

</div>

# Was ist TruffleHog 🐽

TruffleHog ist das leistungsstärkste Tool für **Discovery, Classification, Validation** und **Analysis** von Secrets. In diesem Kontext bezeichnet ein Secret eine Zugangsdatenkombination, mit der sich eine Maschine gegenüber einer anderen Maschine authentifiziert. Dazu gehören API-Schlüssel, Datenbankpasswörter, private Verschlüsselungsschlüssel und mehr.

## Discovery 🔍

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

## Classification 📁

TruffleHog klassifiziert über 800 Secret-Typen und ordnet sie der jeweiligen spezifischen Identität zu, zu der sie gehören. Handelt es sich um ein AWS-Secret? Ein Stripe-Secret? Ein Cloudflare-Secret? Ein Postgres-Passwort? Einen privaten SSL-Schlüssel? Manchmal ist das auf den ersten Blick schwer zu erkennen, deshalb klassifiziert TruffleHog alles, was es findet.

## Validation ✅

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

## Analysis 🔬

Für die rund 20 am häufigsten geleakten Zugangsdatentypen sendet TruffleHog nicht nur eine Anfrage, um zu prüfen, ob sich das Secret anmelden kann, sondern viele Anfragen, um alles über das Secret zu erfahren. Wer hat es erstellt? Auf welche Ressourcen kann es zugreifen? Welche Berechtigungen hat es auf diesen Ressourcen?

# :loudspeaker: Tritt unserer Community bei

Fragen? Feedback? Komm in Slack oder Discord und verbringe Zeit mit uns.

Tritt unserer [Slack-Community](https://join.slack.com/t/trufflehog-community/shared_invite/zt-pw2qbi43-Aa86hkiimstfdKH9UCpPzQ) bei

Tritt dem [Secret Scanning Discord](https://discord.gg/8Hzbrnkr7E) bei

# :tv: Demo

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

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

# :floppy_disk: Installation

Es stehen mehrere Optionen zur Verfügung:

### MacOS-Benutzer

```bash
brew install trufflehog
```

### Docker:

<sub><i>_Stellen Sie sicher, dass die Docker-Engine läuft, bevor Sie die folgenden Befehle ausführen:_</i></sub>

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

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

#### &nbsp;&nbsp;&nbsp;&nbsp;Windows-Eingabeaufforderung

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

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

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

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

### Installationsskript verwenden

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

### Installationsskript verwenden, Checksummen-Signatur verifizieren (erfordert installiertes cosign)

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

### Installationsskript zum Installieren einer bestimmten Version verwenden

```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: Überprüfung der Artefakte

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

Sie benötigen das folgende Tool zur Überprüfung der Signatur:

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

Die Überprüfungsschritte sind wie folgt:

1. Laden Sie die gewünschten Artefaktdateien sowie 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"
   ```

3. Sobald die Signatur als gültig bestätigt wurde, können Sie fortfahren und überprüfen, ob die SHA256-Summen mit dem heruntergeladenen Artefakt übereinstimmen:

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

Ersetze `{version}` durch die Version der heruntergeladenen Dateien

Alternativ kannst du, wenn du das Installationsskript verwendest, die Option `-v` übergeben, um die Signaturprüfung durchzuführen.
Dies erfordert, dass die Cosign-Binärdatei vor der Ausführung des Installationsskripts installiert wurde.

# :rocket: Schnellstart

## 1: Ein Repo nur nach verifizierten Secrets scannen

Befehl:

```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: Eine GitHub-Organisation nur nach verifizierten Secrets scannen

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

## 3: Eine GitHub-Organisation scannen, archivierte Repositories ausgeschlossen

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

## 4: Ein GitHub-Repo nur nach verifizierten Secrets scannen und JSON-Ausgabe erhalten

Befehl:

```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 kann mit `--sarif` anstelle von `--json` auch [SARIF](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html) ausgeben. Die GitHub-Codeüberprüfung versteht SARIF nativ, sodass beim Hochladen Funde inline in Pull-Request-Diffs und im Sicherheits-Tab des Repositorys angezeigt und als neu/behoben über Scans hinweg verfolgt werden, anstatt bei jedem Lauf denselben Fund erneut zu melden – siehe den Abschnitt [TruffleHog Github Action](#octocat-trufflehog-github-action) weiter unten, wie man ihn hochlädt. Beachte, dass SARIF-Ergebnisse im Gegensatz zu den anderen Ausgabeformaten für den gesamten Scan im Speicher gepuffert und erst am Ende ausgegeben werden, da SARIF ein einzelnes JSON-Dokument statt eines Streams erfordert – das ist für typische Scans in Ordnung, aber Scans mit einer sehr großen Anzahl von Ergebnissen verbrauchen entsprechend mehr Speicher.

## 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: Einen S3-Bucket nach Ergebnissen mit hoher Konfidenz scannen (verifiziert + unbekannt)

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

## 7: S3-Buckets mit IAM-Rollen scannen

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

## 8: Scannen eines GitHub-Repos mit 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: Ein lokales Git-Repo scannen

Klonen Sie das Git-Repo. Zum Beispiel das [test keys](https://github.com/trufflesecurity/trufflehog/blob/main/git%40github.com%3Atrufflesecurity/test_keys.git) Repo.
```bash
git clone [email protected]:trufflesecurity/test_keys.git
```

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

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

## 11: GCS-Buckets nur nach verifizierten Secrets scannen

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

## 12: Ein Docker-Image nur auf verifizierte Secrets scannen

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 Flag `--since-commit` auf Ihren Standard-Branch, in den die Leute mergen (z. B. "main"). Setzen Sie das Flag `--branch` auf den Branch-Namen Ihres PRs (z. B. "feature-1"). Je nach verwendeter 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 Repo geklont und der Ziel-Branch während des CI/CD-Workflows bereits ausgecheckt ist, sollte `--branch HEAD` ausreichen. Das Flag `--fail` 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=<postman api token> --workspace-id=<workspace id>
```

## 15: Einen Jenkins-Server scannen

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

## 16: Einen Elasticsearch-Server scannen

### Einen lokalen Cluster scannen

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

#### Verbindung zu einem lokalen Cluster mit Benutzername und Passwort herstellen

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

#### Verbindung zu einem lokalen Cluster mit einem Service-Token herstellen

```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. Ein GitHub-Repository auf Cross-Fork-Objekt-Referenzen und gelöschte Commits scannen

Der folgende Befehl zählt gelöschte und versteckte Commits in einem GitHub-Repository auf und scannt sie anschließend auf Secrets. Dies ist ein Alpha-Release-Feature.

```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 Status während der Commit-Aufzählung zu verfolgen sowie um 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**: Das Aufzählen aller gültigen Commits in einem Repository mit dieser Methode dauert je nach Größe Ihres Repositorys zwischen 20 Minuten und einigen Stunden. Wir haben eine Fortschrittsanzeige hinzugefügt, damit Sie auf dem Laufenden bleiben, wie lange die Aufzählung dauern wird. Der eigentliche Secret-Scan läuft extrem schnell.

Weitere Informationen zu Cross Fork Object References finden Sie in [unserem Blogbeitrag](https://trufflesecurity.com/blog/anyone-can-access-deleted-and-private-repo-data-github).

## 18. Hugging Face scannen

### Ein Hugging Face Model, Dataset, Space oder Bucket scannen

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

### Alle Modelle, Datasets, Spaces und Buckets scannen, 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>`.

### Diskussions- und PR-Kommentare scannen

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

## 19. stdin-Eingabe scannen

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

# :question: FAQ

- Ich sehe nur `🐷🔑🐷  TruffleHog. Unearth your secrets. 🐷🔑🐷` und das Programm beendet sich, was hat das zu bedeuten?
  - Das bedeutet, dass keine Secrets erkannt wurden
- Warum dauert der Scan lange, wenn ich eine GitHub-Org scanne
  - Nicht authentifizierte GitHub-Scans unterliegen Rate-Limits. Um deine Rate-Limits zu verbessern, füge das `--token`-Flag mit einem Personal Access Token hinzu
- Es heißt, ein privater Schlüssel wurde verifiziert, was bedeutet das?
  - Ein verifiziertes Ergebnis bedeutet, dass TruffleHog bestätigt hat, dass die Anmeldedaten gültig sind, 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 findest du in unserem Driftwood-Blogbeitrag [Blog post](https://trufflesecurity.com/blog/driftwood-know-if-private-keys-are-sensitive/)
- Gibt es eine einfache Möglichkeit, bestimmte Secrets zu ignorieren?
  - Wenn die gescannte Quelle [Zeilennummern unterstützt](https://github.com/trufflesecurity/trufflehog/blob/d6375ba92172fd830abb4247cca15e3176448c5d/pkg/engine/engine.go#L358-L365), kannst du einen `trufflehog:ignore`-Kommentar in der Zeile hinzufügen, die das Secret enthält, um dieses Secret zu ignorieren.
- Kann ich Secrets finden, die `trufflehog:ignore` enthalten?
  - Übergib `--no-ignore-tag`, um Ergebnisse auch dann zu melden, wenn ihre Zeile einen `trufflehog:ignore`-Kommentar enthält. Dies ist nützlich, um zuvor akzeptierte Funde zu überprüfen.

# :newspaper: Was ist neu in v3?

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

- Wir haben **über 700 Detektoren für Anmeldedaten hinzugefügt, die eine aktive Verifizierung gegen ihre 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.
- **Verifiziere private Schlüssel sofort** gegen Millionen von GitHub-Nutzern und **Milliarden** von TLS-Zertifikaten mit unserer [Driftwood](https://trufflesecurity.com/blog/driftwood)-Technologie.
- Scanne Binärdateien, Dokumente und andere Dateiformate
- Verfügbar als GitHub Action und als Pre-Commit-Hook

## Was ist Anmeldedaten-Verifizierung?

Für jede potenzielle Anmeldedaten, die erkannt wird, haben wir mühsam eine programmatische Verifizierung gegen die API implementiert, zu der sie unserer Meinung nach gehört. Die Verifizierung eliminiert Fehlalarme und liefert drei Ergebnisstatus:

- **verified**: Anmeldedaten durch API-Test als gültig und aktiv bestätigt
- **unverified**: Anmeldedaten erkannt, aber nicht als gültig bestätigt (möglicherweise ungültig, abgelaufen oder Verifizierung deaktiviert)  
- **unknown**: Verifizierung versucht, aber aufgrund von Fehlern fehlgeschlagen, z. B. einem Netzwerk- oder API-Fehler

Beispielsweise führt der [AWS-Anmeldedaten-Detektor](https://github.com/trufflesecurity/trufflehog/blob/main/pkg/detectors/aws/access_keys/accesskey.go) einen `GetCallerIdentity`-API-Aufruf gegen die AWS-API aus, um zu verifizieren, ob eine AWS-Anmeldedaten aktiv ist.

# :memo: Verwendung

TruffleHog hat einen Unterbefehl für jede Datenquelle, die du scannen möchtest:

- 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 du mit dem `--help`-Flag anzeigen kannst, das dem Unterbefehl übergeben wird:

```
$ 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.
```

Um beispielsweise ein `git`-Repository zu scannen, beginne mit

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

## Konfiguration

TruffleHog unterstützt das Definieren von [benutzerdefinierten Regex-Detektoren](#custom-regex-detector-alpha)
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 ist auf Truffle Securitys
[Dokumentationsseite zur Quellenkonfiguration](https://trufflesecurity.com/docs/connect-sources) zu finden.

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

Du kannst mehrere Verbindungen unter dem Schlüssel `sources` definieren (siehe oben), und
TruffleHog wird alle Quellen gleichzeitig scannen.

Um Debug-Logs für nur eine Quelle zu sehen, füge `debug: true` zu ihr hinzu. Diese Quelle
schreibt alle ihre Debug-Logs, und jede andere Quelle behält das normale Log-Level bei.
Dies ist nützlich, wenn sich eine Quelle von vielen fehlerhaft verhält:

```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
```

Um Debug-Logs für jede Quelle zu aktivieren, verwenden Sie stattdessen `--log-level=5`.

## S3

Die S3-Quelle unterstützt neben IAM-Benutzern auch das Annehmen von IAM-Rollen zum Scannen. Dadurch können Benutzer mehrere AWS-Konten einfacher scannen, ohne für jedes Konto auf fest codierte Anmeldeinformationen angewiesen zu sein.

Die IAM-Identität, die TruffleHog zunächst verwendet, muss `AssumeRole`-Berechtigungen als Principal in der [Trust-Richtlinie](https://aws.amazon.com/blogs/security/how-to-use-trust-policies-with-iam-roles/) jeder anzunehmenden IAM-Rolle besitzen.

Um einen bestimmten Bucket mit lokal gesetzten Anmeldeinformationen oder Instanzmetadaten (falls 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=<bucket-name> --role-arn=<iam-role-arn>
```

Mehrere Rollen können als separate Argumente übergeben werden. Der folgende Befehl versucht, jeden Bucket zu scannen, für den jede Rolle in der S3-API Auflistungsberechtigungen besitzt:

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

### Einen Scan auf bestimmte Objekte eingrenzen

Große Buckets enthalten oft Daten, die es nicht wert sind, gescannt zu werden, wie etwa Archive, Medien und Build-Artefakte. Zwei Gruppen von Flags halten diese Objekte aus einem Scan heraus. Beide werden mit dem Objektschlüssel abgeglichen, bevor das Objekt heruntergeladen wird, sodass ein übersprungenes Objekt keine GET-Anfrage kostet.

Nur die Objekte unter einem oder mehreren Schlüsselpräfixen scannen:

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

Objekte unter einem Schlüsselpräfix überspringen:

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

Beide Präfix-Flags können zusammen verwendet werden, um einen Teilbaum zu scannen und dabei einen Teil davon auszulassen. Ein Objekt, das einem Ausschluss-Präfix entspricht, wird immer übersprungen, selbst wenn es auch einem Einschluss-Präfix entspricht:

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

Präfixe werden wörtlich abgeglichen, nicht als Globs, und sie sind nicht auf eine Pfadgrenze beschränkt. `--include-prefix=log` stimmt sowohl mit `logs/app.txt` als auch mit `logs-archive/app.txt` überein.

Dateiendungen werden separat gefiltert. Schreiben Sie sie ohne führenden Punkt:

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

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

Anders als bei den Präfix-Flags können `--include-extension` und `--exclude-extension` nicht kombiniert werden, da das Benennen der zu scannenden Erweiterungen bereits alle anderen ausschließt. Die Verwendung beider führt beim Start zu einem Fehler.

Der Abgleich von Erweiterungen ist unabhängig von Groß- und Kleinschreibung, sodass `--exclude-extension=zip` auch `BACKUP.ZIP` überspringt. Ein Objekt, dessen Schlüssel überhaupt keine Erweiterung hat, wie etwa `Makefile`, entspricht keinem Eintrag: Es wird übersprungen, wenn `--include-extension` gesetzt ist, und beibehalten, wenn nur `--exclude-extension` gesetzt ist.

Zwei Dinge sind bei der Verwendung von `--include-extension` zu beachten. Eine Dotfile zählt als vollständige Erweiterung, sodass `.env` die Erweiterung `env` hat und jede Include-Liste, die `env` auslässt, jede `.env`-Datei im Bucket überspringt. Da `.env`-Dateien ein häufiger Ort für Secrets sind, fügen Sie `--include-extension=env` hinzu, es sei denn, Sie möchten sie überspringen. Und nur die letzte Erweiterung zählt, sodass `backup.tar.gz` die Erweiterung `gz` hat: `--exclude-extension=tar.gz` entspricht nichts, während `--exclude-extension=gz` funktioniert.

Diese Flags gelten außerdem nur für Objektschlüssel, nicht für Dateien innerhalb eines Archivs. `--exclude-extension=mp4` überspringt `clip.mp4` im Bucket, aber nicht ein `clip.mp4`, das in `media.zip` gepackt ist. Das Ausschließen von `zip` überspringt das Archiv vollständig.

TruffleHog fordert S3 auf, nur die Schlüssel unter den Include-Präfixen aufzulisten, sodass ein Präfix, der einen kleinen Teil eines großen Buckets abdeckt, schnell aufgelistet wird. Exclude-Präfixe und -Erweiterungen werden nach dem Auflisten angewendet, sodass sie die Kosten für das Herunterladen von Objekten senken, nicht aber die Kosten für deren Auflistung.

---

[Read more](https://github.com/trufflesecurity/trufflehog)
Tool herunterladen