praetorian-inc/titusHochleistungs-Scanner für Geheimnisse. CLI, Go-Bibliothek, Burp Suite-Erweiterung und Chrome-Erweiterung. 487 Erkennungsregeln mit Live-Validierung von Anmeldeinformationen.
Titus ist ein leistungsstarker Geheimnis-Scanner, der Anmeldeinformationen, API-Schlüssel und Token in Quellcode, Dateien und Git-Verlauf erkennt. Er enthält 487 Erkennungsregeln, die Hunderte von Diensten und Anmeldeinformationstypen abdecken, übernommen von NoseyParker und Kingfisher. Titus ist als CLI, Go-Bibliothek, Burp Suite-Erweiterung und Chrome-Browsererweiterung verfügbar – alle nutzen dieselbe Erkennungsengine und denselben Regelsatz.
Entwickelt für Sicherheitsingenieure, Penetrationstester und DevSecOps-Teams, kombiniert Titus Hyperscan/Vectorscan-beschleunigtes Regex-Matching mit Live-Validierung von Anmeldeinformationen, um durchgesickerte Geheimnisse in Ihrer gesamten Codebasis zu finden und zu überprüfen.
Laden Sie ein vorgefertigtes Binary von der Releases-Seite herunter oder erstellen Sie es aus dem Quellcode:```bash make build
Die Binärdatei befindet sich unter `dist/titus`.
## Schnellstart```bash
# Scan a file for secrets
titus scan path/to/file.txt
# Scan a directory for leaked credentials
titus scan path/to/directory
# Scan a public GitHub repository (no token needed)
titus scan github.com/org/repo
# Scan a public GitLab project (no token needed)
titus scan gitlab.com/namespace/project
# Scan git history for secrets in past commits
titus scan --git path/to/repo
# Scan a Docker / OCI image (pulled from a registry — no docker daemon required)
titus scan --docker alpine:latest
# Validate detected secrets against source APIs
titus scan path/to/code --validate
Ergebnisse werden in einen Datenspeicher (standardmäßig titus.ds) geschrieben und auf der Konsole ausgegeben.
Öffentliche Repositories direkt per URL scannen — kein API-Token erforderlich:```bash
titus scan github.com/kubernetes/kubernetes
titus scan gitlab.com/gitlab-org/cli
titus scan https://github.com/org/repo titus scan https://gitlab.com/namespace/project.git
Für unternehmensweite oder benutzerweite Scans verwenden Sie die dedizierten Unterbefehle:```bash
# Scan all public repos in a GitHub org
titus github --org kubernetes
# Scan all repos in a GitHub org with a token (private repos + higher rate limits)
titus github --org kubernetes --token $GITHUB_TOKEN
# Scan all repos for a GitHub user
titus github --user octocat
# Scan all projects in a GitLab group
titus gitlab scan --group mygroup --token $GITLAB_TOKEN
# Scan a single repo with git history (finds deleted secrets)
titus github owner/repo --git
Tokens are optional for public repositories. Set GITHUB_TOKEN or GITLAB_TOKEN (or use --token) for private repository access and higher API rate limits.
Scan container images directly — no docker daemon, no docker binary required. Titus pulls images straight from any OCI registry over HTTPS (using credentials from ~/.docker/config.json), or reads images from a local docker save tarball or OCI image layout directory. It then scans image manifest/config metadata and every regular file in every layer, including lower-layer files deleted by later layers (since secrets can remain recoverable from image history).```bash
titus scan --docker alpine:latest titus scan docker://ghcr.io/owner/repo:tag
titus scan --docker ./my-app.tar
titus scan --docker ./img/
Die Authentifizierung verwendet Ihre vorhandene Docker-/Podman-Konfiguration (`~/.docker/config.json`, `${XDG_RUNTIME_DIR}/containers/auth.json`). Private Registrierungen, die eine erneute Anmeldung erfordern, sollten zuerst mit `docker login` (oder `podman login` oder `crane auth login`) authentifiziert werden — titus fragt nicht nach Anmeldeinformationen.
### Anzeigen von Scan-Ergebnissen
Verwenden Sie `report`, um Ergebnisse eines vorherigen Scans erneut auszulesen:```bash
# Human-readable summary of detected secrets
titus report
# JSON output for programmatic processing
titus report --format json
# SARIF output for CI/CD integration with GitHub Advanced Security
titus report --format sarif
# Report from a specific datastore
titus report --datastore path/to/titus.ds
Sie können das Ausgabeformat auch beim Scannen mit --format steuern:```bash
titus scan path/to/code --format json
### Validierung erkannter Geheimnisse
Verwenden Sie `--validate` während eines Scans, um erkannte Geheimnisse gegen ihre Quell-APIs zu überprüfen:```bash
titus scan path/to/code --validate
Die Validierung läuft parallel (4 Worker standardmäßig, konfigurierbar mit --validate-workers) und markiert jedes Ergebnis als bestätigt, abgelehnt oder unbekannt.
titus rules list
titus scan path/to/code --rules-include "aws,gcp"
titus scan path/to/code --rules-exclude "kingfisher.generic"
titus scan path/to/code --rules path/to/custom-rules.yaml
titus scan path/to/code --include-noisy
### Geheimnisse aus Binärdateien extrahieren
Titus kann Text aus Binärdateiformaten extrahieren und den Inhalt nach Geheimnissen durchsuchen:```bash
# Extract and scan all supported binary formats
titus scan path/to/files --extract=all
# Target specific formats
titus scan path/to/files --extract=xlsx,docx,pdf,zip
Unterstützte Formate umfassen Office-Dokumente (xlsx, docx, pptx, odp, ods, odt), PDFs, Jupyter-Notebooks, SQLite-Datenbanken, E-Mails (eml, rtf) und Archive (zip, tar, tar.gz, jar, war, ear, apk, ipa, crx, xpi, 7z). Archive werden rekursiv bis zu einer konfigurierbaren Tiefe und Größenbegrenzung extrahiert.```bash
titus scan path/to/files --extract=all
--extract-max-size 10MB
--extract-max-total 100MB
--extract-max-depth 5
Bei SQLite-Datenbanken extrahiert Titus Text aus allen Tabellen (standardmäßig 1000 Zeilen pro Tabelle). Verwende `--sqlite-row-limit` zum Anpassen:```bash
# Full dump of all SQLite tables (no row limit)
titus scan path/to/files --extract=all --sqlite-row-limit 0
# Custom row limit per table
titus scan path/to/files --extract=all --sqlite-row-limit 5000
Jeder Befund, den Titus erstellt, trägt eine numerische Punktzahl von 0–100 und einen Schweregrad:
| Punktzahl | Schweregrad |
|---|---|
| 0–20 | info |
| 21–40 | niedrig |
| 41–60 | mittel |
| 61–80 | hoch |
| 81–100 | kritisch |
Die Punktzahlen beginnen mit dem base_score der Regel und werden durch Modifikatoren angepasst – Bedingungen, die die Punktzahl erhöhen oder senken, basierend auf dem, was über die Anmeldeinformationen bekannt ist:```bash
titus scan path/to/code
titus scan path/to/code --score-scope
titus scan path/to/code --accessibility public # no penalty for public repos titus scan path/to/code --accessibility private # -25 penalty (default for local scans)
Titus wird mit YAML-Scorern für AWS-Anmeldeinformationen, GitHub-PATs und Slack-Token sowie Go-basierten SDK-Scorern ausgeliefert, die bei aktiviertem `--score-scope` eine Live-IAM-Richtlinienaufzählung (AWS) und Repository-Berechtigungsprüfungen (GitHub feingranulare PATs) durchführen.
Siehe [docs/scoring.md](https://github.com/praetorian-inc/titus/blob/HEAD/docs/scoring.md) für die vollständige Referenz: Schweregradstufen, Änderungsarten, Details zu integrierten Scorern und wie Sie Ihre eigenen YAML- oder Go-Scorer schreiben.
## Go-Bibliothek zur Geheimniserkennung
Titus kann als Go-Bibliothek importiert werden, um Ihren eigenen Tools und Pipelines eine Geheimniserkennung hinzuzufügen.```bash
go get github.com/praetorian-inc/titus
WARNUNG: Die Versionskontrolle gilt ab 2022/11/02 noch als experimentell.
Die Ergebnisse werden zur Versionskontrolle auf eine Remote-Freigabe kopiert. Dies kann eine große ZIP-Datei sein, die den gesamten Projektordner nachbildet, oder eine vollständige Kopie des Projektordners. Die Erstellung von ZIP-Dateien wird nativ unterstützt. Um reine Ordnerkopien zu konfigurieren, verwenden Sie robocopy (seit Windows Vista integriert) oder rsync.
Beispiele für Kopierbefehle:```go package main
import ( "fmt" "log"
"github.com/praetorian-inc/titus"
)
func main() { // Initialize the secrets scanner with default rules scanner, err := titus.NewScanner() if err != nil { log.Fatal(err) } defer scanner.Close()
// Scan a string for API keys, tokens, and credentials
matches, err := scanner.ScanString(`aws_access_key_id = AKIAIOSFODNN7EXAMPLE`)
if err != nil {
log.Fatal(err)
}
for _, match := range matches {
fmt.Printf("%s (rule: %s) at line %d\n",
match.RuleName, match.RuleID,
match.Location.SourceSpan.Start.Line,
)
}
}
Die Bibliothek unterstützt auch das Scannen von Bytes und Dateien, die Validierung erfasster Geheimnisse und das Laden benutzerdefinierter Regeln:```go
// Scan a file for leaked credentials
matches, err := scanner.ScanFile("/path/to/config.json")
// Enable validation to check if detected secrets are live
scanner, err := titus.NewScanner(titus.WithValidation())
// Load custom detection rules for organization-specific secrets
rules, err := titus.LoadRulesFromFile("/path/to/rules.yaml")
scanner, err := titus.NewScanner(titus.WithRules(rules))
Siehe docs/library-usage.md für die vollständige API-Referenz, Nebenläufigkeitsmuster und weitere Beispiele.
Die Burp-Erweiterung durchsucht HTTP-Antworten nach Geheimnissen während des Proxy-Datenverkehrs und aktiven Penetrationstests.
make install-burp
Laden Sie dann `dist/titus-burp-1.0.0-all.jar` in Burp Suite unter Erweiterungen > Hinzufügen.
#### Windows (Download von Releases)
1. Laden Sie `titus-windows-amd64.exe` und `titus-burp-<version>.jar` von [Releases](https://raw.githubusercontent.com/praetorian-inc/releases) herunter.
2. Erstellen Sie das Titus-Verzeichnis und installieren Sie die Binärdatei: ```powershell
mkdir %USERPROFILE%\.titus
copy titus-windows-amd64.exe %USERPROFILE%\.titus\titus.exe
titus-burp-<version>.jar von Releases herunter:
titus-linux-amd64 oder titus-linux-arm64 für Linuxtitus-darwin-amd64 oder titus-darwin-arm64 für macOSDie Erweiterung startet einen titus serve-Prozess im Hintergrund und kommuniziert über stdin/stdout mittels NDJSON. Erkennungsregeln werden einmalig beim Start geladen.
Die Erweiterung fügt einen Titus-Reiter in Burp mit drei Unterreitern hinzu:
Geheimnisse: Alle erkannten Geheimnisse mit Filterung nach Typ, Host und Validierungsstatus.
Titus Burp Suite Erweiterung Reiter Geheimnisse mit erkannten API-Schlüsseln und Anmeldeinformationen und Validierungsstatus
Statistiken: Aggregierte Ansicht der Geheimnisse, gruppiert nach Typ und Host.
Einstellungen: Konfiguration von Scan-Optionen, Validierung und Schweregradzuordnungen.
Titus Burp Suite Erweiterung Reiter Einstellungen mit Scan-Konfigurationsoptionen
Beim Betrachten einer beliebigen Anfrage in Burp erscheint ein Titus-Reiter im Antwortinspektor, falls Geheimnisse erkannt wurden, und bietet schnellen Zugriff auf die Ergebnisse, ohne zum Haupt-Titus-Reiter wechseln zu müssen.
Titus Reiter im Burp Suite Antwortinspektor mit hervorgehobenen Geheimnissen in HTTP-Antworten
Die Chrome-Erweiterung scannt Webseiten während Sicherheitsbewertungen von Webanwendungen auf Geheimnisse.
make build-extension
1. Navigiere zu `chrome://extensions/`
2. Aktiviere den **Entwicklermodus**
3. Klicke auf **Entpackte Erweiterung laden** und wähle das Verzeichnis `extension/`
### Funktionen der Browser-Erweiterung
- Scannt inline und externe JavaScript- und Stylesheet-Dateien auf API-Schlüssel und Tokens
- Scannt localStorage und sessionStorage auf durchgesickerte Anmeldeinformationen
- Optionales Erfassen von Netzwerkantworten für eine umfassende Erkennung von Geheimnissen
- Ergebnisse werden im Popup und im Dashboard angezeigt
<img width="1719" height="958" alt="Titus Chrome-Erweiterungs-Popup, das erkannte Geheimnisse auf einer Webseite anzeigt" src="https://assets.kitploit.com/production/public/readmes/11969/057a24e2746412ceabe1aac0292a2de463de1efee5bca2489ca34b59d8b0dc2c.png" />
<img width="1744" height="827" alt="Titus Chrome-Erweiterungs-Dashboard mit aggregierten Ergebnissen der Geheimniserkennung" src="https://assets.kitploit.com/production/public/readmes/11969/265d972fadcc7f212944d7a1d8fd58a43446e7199d1209900e83b96a546ffb00.png" />
### Sicherheitshinweis
Die Browser-Erweiterung entfernt Content Security Policy- und CORS-Header von besuchten Seiten, um externe Ressourcen zu scannen. Dies schwächt die Sicherheitslage der von Ihnen besuchten Websites, während die Erweiterung aktiv ist. **Nur während aktiven Sicherheitstests aktivieren.**
## Aus dem Quellcode erstellen
### Standard-Build (Vectorscan-beschleunigt)
Standardmäßig kompiliert Titus mit [Vectorscan](https://github.com/VectorCamp/vectorscan) (ARM) / [Hyperscan](https://github.com/intel/hyperscan) (x86) für SIMD-beschleunigtes Regex-Matching. Dies erfordert CGO, die C-Bibliothek und `pkg-config` (welches CGO verwendet, um die Bibliothek zu finden). `make build` prüft auf diese und versucht, fehlende Komponenten über Homebrew / apt / dnf zu installieren:```bash
# Build the CLI binary with vectorscan acceleration (outputs to dist/titus)
make build
# Build the Burp Suite extension JAR
make build-burp
# Build the Chrome browser extension
make build-extension
# Run unit tests
make test
# Run integration tests
make integration-test
Sie werden [vectorscan] N/N rules compiled for Hyperscan beim Start sehen, wenn die beschleunigte Engine aktiv ist.
Um die C-Bibliothek selbst zu installieren, anstatt auf die automatische Installation zu vertrauen:```bash
brew install pkg-config vectorscan
sudo apt-get install pkg-config libhyperscan-dev
sudo dnf install pkgconf-pkg-config vectorscan-devel
git clone --depth 1 --branch vectorscan/5.4.11 https://github.com/VectorCamp/vectorscan.git cd vectorscan && cmake -B build -DCMAKE_INSTALL_PREFIX=/usr/local && cmake --build build && sudo cmake --install build
Wenn Sie `go build` direkt aufrufen (z. B. beim Einbetten von Titus), übergeben Sie das Tag und aktivieren Sie CGO:```bash
# macOS (Homebrew) — adjust PKG_CONFIG_PATH to your installed version
CGO_ENABLED=1 PKG_CONFIG_PATH="$(brew --prefix vectorscan)/lib/pkgconfig" \
go build -tags vectorscan -o dist/titus ./cmd/titus
# Linux (system-installed)
CGO_ENABLED=1 go build -tags vectorscan -o dist/titus ./cmd/titus
Wenn Sie die C-Bibliothek nicht installieren können – oder eine vollständig portable, statische Binärdatei wünschen – bauen Sie stattdessen die reine Go-Engine. Titus greift zur Laufzeit automatisch darauf zurück, wenn vectorscan nicht eingebunden ist.```bash
make build-pure
make build-static
## Mitwirken
Beiträge sind willkommen! Siehe [CONTRIBUTING.md](https://github.com/praetorian-inc/titus/blob/HEAD/CONTRIBUTING.md) für Richtlinien zur Mitarbeit an Titus.
## Lizenz
Apache Lizenz 2.0 — siehe [LICENSE](https://github.com/praetorian-inc/titus/blob/HEAD/LICENSE).
Erkennungsregeln stammen von [NoseyParker](https://github.com/praetorian-inc/noseyparker) (Praetorian Security, Inc.) und [Kingfisher](https://github.com/mongodb/kingfisher) (MongoDB, Inc.), beide lizenziert unter Apache 2.0. Siehe [NOTICE](https://github.com/praetorian-inc/titus/blob/HEAD/NOTICE) für die vollständige Quellenangabe.