Titus: Hochleistungs-Secrets-Scanner

Titus ist ein Hochleistungs-Secrets-Scanner, der Anmeldedaten, API-Schlüssel und Tokens in Quellcode, Dateien und der Git-Historie erkennt. Er wird mit 487 Erkennungsregeln ausgeliefert, die Hunderte von Diensten und Anmeldedatentypen abdecken und aus NoseyParker und Kingfisher stammen. Titus läuft als CLI, Go-Bibliothek, Burp-Suite-Erweiterung und Chrome-Browser-Erweiterung — alle teilen dieselbe Erkennungs-Engine und denselben Regelsatz.

Entwickelt für Sicherheitsingenieure, Penetrationstester und DevSecOps-Teams, kombiniert Titus Hyperscan/Vectorscan-beschleunigtes Regex-Matching mit Live-Validierung von Anmeldedaten, um geleakte Secrets in Ihrer gesamten Codebasis zu finden und zu verifizieren.

Warum Titus?

Schnelles Secrets-Scannen: Regex-Matching beschleunigt durch Hyperscan/Vectorscan, sofern verfügbar, mit einem reinen Go-Fallback für Portabilität auf jeder Plattform.
Breite Abdeckung der Anmeldedatenerkennung: 487 Regeln erkennen API-Schlüssel, Tokens und Anmeldedaten für AWS, GCP, Azure, GitHub, Slack, Datenbanken, CI/CD-Systeme und Hunderte weiterer Dienste.
Live-Validierung von Secrets: Erkannte Secrets werden gegen ihre Quell-APIs geprüft, um zu bestätigen, ob sie aktiv sind, wodurch Fehlalarme reduziert und die Behebung priorisiert werden.
Risikobasierte Schweregradbewertung: Jeder Fund erhält eine numerische Bewertung (0–100) und eine Schweregradstufe (info → kritisch). Die Bewertungen werden durch statische Regel-Metadaten, den Kontext der Code-Zugänglichkeit und Live-API-Aufrufe abgestimmt, die den tatsächlichen Auswirkungsradius einer Anmeldedatei messen — sodass die gefährlichsten Funde immer zuerst auftauchen.
Scannen von Container-Images: Scannen Sie Docker- und OCI-Images direkt aus jeder Registry, jedem Tarball oder OCI-Layout-Verzeichnis — kein Docker-Daemon oder Binary erforderlich.
Mehrere Schnittstellen für jeden Workflow: Scannen Sie über die CLI, betten Sie es als Go-Bibliothek ein, scannen Sie HTTP-Verkehr passiv in Burp Suite oder scannen Sie Webseiten in Chrome während des Anwendungssicherheitstests.
Extraktion aus Binärdateien: Extrahieren und scannen Sie Secrets aus Office-Dokumenten, PDFs, Archiven (zip, tar, 7z), mobilen Apps (APK, IPA), Browser-Erweiterungen und mehr.

Installation

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 (titus.ds standardmäßig) geschrieben und auf der Konsole ausgegeben.

Scan-Optionen

GitHub- & GitLab-Scanning

Öffentliche Repositories direkt per URL scannen — kein API-Token erforderlich:```bash

Scan a GitHub repository

titus scan github.com/kubernetes/kubernetes

Scan a GitLab project

titus scan gitlab.com/gitlab-org/cli

Full URLs work too

titus scan https://github.com/org/repo titus scan https://gitlab.com/namespace/project.git

Für organisationsweite 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 sind für öffentliche Repositories optional. Setze GITHUB_TOKEN oder GITLAB_TOKEN (oder verwende --token) für den Zugriff auf private Repositories und höhere API-Ratenlimits.

Docker / OCI Image Scanning

Scanne Container-Images direkt — kein Docker-Daemon, keine docker-Binärdatei erforderlich. Titus zieht Images direkt aus jeder OCI-Registry über HTTPS (unter Verwendung von Anmeldedaten aus ~/.docker/config.json) oder liest Images aus einem lokalen docker save-Tarball oder einem OCI-Image-Layout-Verzeichnis. Anschließend scannt es die Image-Manifest-/Konfigurationsmetadaten und jede reguläre Datei in jeder Schicht, einschließlich Dateien aus unteren Schichten, die durch spätere Schichten gelöscht wurden (da Secrets aus der Image-Historie wiederherstellbar bleiben können).```bash

Pull from a registry and scan

titus scan --docker alpine:latest titus scan docker://ghcr.io/owner/repo:tag

Scan an image saved to a tarball:

docker save my-app:latest -o my-app.tar

podman save my-app:latest -o my-app.tar

titus scan --docker ./my-app.tar

Scan an OCI image layout directory:

docker buildx build --output type=oci,dest=./img/ .

skopeo copy docker://my-app:latest oci:./img:latest

titus scan --docker ./img/

Die Authentifizierung verwendet Ihre vorhandene Docker-/Podman-Konfiguration (`~/.docker/config.json`, `${XDG_RUNTIME_DIR}/containers/auth.json`). Private Registries, die eine neue Anmeldung erfordern, sollten zuerst mit `docker login` (oder `podman login` oder `crane auth login`) authentifiziert werden — titus fragt nicht nach Anmeldedaten.

### Anzeigen von Scan-Ergebnissen

Verwenden Sie `report`, um die Ergebnisse eines vorherigen Scans erneut zu lesen:```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

Du kannst das Ausgabeformat auch zur Scanzeit mit --format steuern:```bash titus scan path/to/code --format json

### Erkannte Secrets validieren

Übergeben Sie `--validate` während eines Scans, um erkannte Secrets gegen ihre Quell-APIs zu prüfen:```bash
titus scan path/to/code --validate

Die Validierung läuft parallel (standardmäßig 4 Worker, konfigurierbar mit --validate-workers) und markiert jeden Befund als bestätigt, verneint oder unbekannt.

Erkennungsregeln filtern```bash

List all available detection rules

titus rules list

Scan with only specific rules (e.g., AWS and GCP credentials)

titus scan path/to/code --rules-include "aws,gcp"

Exclude rules by pattern

titus scan path/to/code --rules-exclude "kingfisher.generic"

Use a custom rules file for organization-specific secrets

titus scan path/to/code --rules path/to/custom-rules.yaml

Opt in to rules marked noisy: true (high false-positive rate, off by default)

titus scan path/to/code --include-noisy

### Extrahieren von Secrets aus Binärdateien

Titus kann Text aus Binärdateiformaten extrahieren und die Inhalte auf Secrets scannen:```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 konfigurierbaren Tiefen- und Größenbeschränkungen entpackt.```bash

Tune extraction limits for large codebases

titus scan path/to/files --extract=all
--extract-max-size 10MB
--extract-max-total 100MB
--extract-max-depth 5

Für SQLite-Datenbanken extrahiert Titus Text aus allen Tabellen (standardmäßig 1000 Zeilen pro Tabelle). Verwenden Sie `--sqlite-row-limit`, um dies anzupassen:```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

Bewertung von Findings

Jedes Finding, das Titus erzeugt, trägt eine numerische Bewertung von 0–100 und eine Schweregradstufe:

Bewertung	Schweregrad
0–20	info
21–40	low
41–60	medium
61–80	high
81–100	critical

Bewertungen beginnen beim base_score der Regel und werden durch Modifikatoren angepasst — Bedingungen, die die Bewertung basierend auf dem, was über die Credential bekannt ist, erhöhen oder verringern:```bash

Score findings using static rule metadata only (no network calls)

titus scan path/to/code

Score findings AND make live API calls to verify credential blast radius

(calls AWS STS/IAM and GitHub API for supported credential types)

titus scan path/to/code --score-scope

Override the accessibility context (default: auto-detected from git remote)

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-Tokens geliefert, plus Go-basierten SDK-Scorern, die bei aktiviertem `--score-scope` eine Live-IAM-Richtlinien-Enumeration (AWS) und Repository-Berechtigungsprüfungen (GitHub Fine-Grained PATs) durchführen.

Siehe [docs/scoring.md](https://github.com/praetorian-inc/titus/blob/main/docs/scoring.md) für die vollständige Referenz: Schweregradstufen, Modifikatorarten, Details zu integrierten Scorern und wie Sie Ihre eigenen YAML- oder Go-Scorer schreiben.

## Go-Bibliothek zur Erkennung von Secrets

Titus kann als Go-Bibliothek importiert werden, um die Erkennung von Secrets in Ihre eigenen Tools und Pipelines zu integrieren.```bash
go get github.com/praetorian-inc/titus

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 außerdem das Scannen von Bytes und Dateien, die Validierung erkannter Secrets 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.

Burp Suite Extension für Secret Scanning

Die Burp-Erweiterung scannt HTTP-Antworten während des Proxy-Verkehrs und bei aktiven Penetrationstests auf Secrets.

Einrichtung

Linux / macOS (aus dem Quellcode erstellen)```bash

Build the CLI and Burp extension JAR, install CLI to ~/.titus/

make install-burp

Dann lade `dist/titus-burp-1.0.0-all.jar` in Burp Suite unter Extensions > Add.

#### Windows (Download von Releases)

1. Lade `titus-windows-amd64.exe` und `titus-burp-<version>.jar` von [Releases](../../releases) herunter
2. Erstelle das Titus-Verzeichnis und installiere die Binärdatei:   ```powershell
   mkdir %USERPROFILE%\.titus
   copy titus-windows-amd64.exe %USERPROFILE%\.titus\titus.exe

Laden Sie das JAR in Burp Suite unter Extensions > Add

Linux / macOS (Download von Releases)

Laden Sie die passende Binärdatei für Ihre Plattform und titus-burp-<version>.jar von Releases herunter:
- titus-linux-amd64 oder titus-linux-arm64 für Linux
- titus-darwin-amd64 oder titus-darwin-arm64 für macOS
Installieren Sie die Binärdatei: ```bash mkdir -p ~/.titus cp titus- ~/.titus/titus chmod +x ~/.titus/titus
Laden Sie das JAR in Burp Suite unter Extensions > Add

Die Erweiterung startet einen titus serve-Prozess im Hintergrund und kommuniziert über stdin/stdout mittels NDJSON. Erkennungsregeln werden einmalig beim Start geladen.

Funktionen der Burp-Erweiterung

Passives Secret-Scanning: scannt Proxy-Verkehr automatisch, während er durch Burp fließt
Aktives Secret-Scanning: Kontextmenü per Rechtsklick zum Scannen ausgewählter Anfragen
Deduplizierung: dasselbe Secret wird nur einmal pro Engagement gemeldet
Fast-Path-Filterung: binäre Inhalte, Bilder und Nicht-Text-Antworten werden übersprungen
Live-Anmeldedaten-Validierung: erkannte Secrets gegen Quell-APIs prüfen, um zu bestätigen, ob sie aktiv sind
False-Positive-Verwaltung: Befunde als False Positives markieren, um Rauschen zu filtern
Schweregrad-Klassifizierung: Befunde farbcodiert nach Risiko (Hoch/Mittel/Niedrig)
Export: Befunde als JSON für die Berichterstellung speichern

Oberfläche der Burp-Erweiterung

Die Erweiterung fügt Burp einen Titus-Tab mit drei Untertabs hinzu:

Secrets: Alle erkannten Secrets mit Filterung nach Typ, Host und Validierungsstatus.

Titus Burp Suite extension secrets tab showing detected API keys and credentials with validation status

Validierungsstatus: Zeigt an, ob Secrets geprüft wurden (Aktiv/Inaktiv/Unbekannt)
Filterung: Klicken Sie auf die Schaltflächen Type, Host oder Status, um nach bestimmten Werten zu filtern; verwenden Sie das Suchfeld für Text- und Regex-Übereinstimmungen
Massenaktionen: Mehrere Zeilen auswählen, um sie in Stapelverarbeitung zu validieren oder als False Positive zu markieren
Secret Details-Bereich: Wählen Sie einen Befund aus, um Folgendes anzuzeigen:
- Details: Regelinformationen, Kategorie, vollständiger Secret-Wert, Zeitstempel der ersten Erkennung
- URLs: Alle Orte, an denen dieses Secret gefunden wurde
- Validierung: Validierungsergebnis mit Details (z. B. AWS-Konto-ID, ARN)
- Request/Response: Vollständiger HTTP-Verkehr mit hervorgehobenem Secret

Statistiken: Aggregierte Ansicht der Secrets, gruppiert nach Typ und Host.

Titus Burp Suite extension statistics tab showing secrets by type and host

Zusammenfassung: Gesamtzahl eindeutiger Secrets, gescannte Hosts, Validierungsaufschlüsselung (aktiv vs. inaktiv) und Anzahl der False Positives
Secrets nach Typ: Anzahl jedes Secret-Typs mit Kategorieklassifizierung
Secrets nach Host: Anzahl der pro Host gefundenen Secrets

Einstellungen: Konfigurieren Sie Scan-Optionen, Validierung und Schweregrad-Zuordnungen.

Titus Burp Suite extension settings tab with scan configuration options

Scan-Einstellungen:
- Passives Scannen: Alle Proxy-Verkehr automatisch scannen (standardmäßig aktiviert)
- Request-Body-Scanning: Auch Request-Bodies nach Secrets scannen, die von der Anwendung gesendet werden
- Validierung: Aktivieren, um Secrets gegen Quell-APIs zu prüfen (führt ausgehende Anfragen aus und kann Alarme auslösen)
Scan-Parameter: Worker-Threads, maximale Dateigröße, Länge des Kontextausschnitts
Schweregrad-Konfiguration: Schweregrade pro Secret-Kategorie anpassen
Aktionen: Cache leeren, Einstellungen zurücksetzen, Befunde als JSON speichern/exportieren

Beim Anzeigen einer beliebigen Anfrage in Burp erscheint ein Titus-Tab im Response Inspector, wenn Secrets erkannt werden, und bietet schnellen Zugriff auf Befunde, ohne zum Haupt-Titus-Tab wechseln zu müssen.

Titus tab in Burp Suite response inspector highlighting detected secrets in HTTP responses

Chrome-Browser-Erweiterung für Secret-Scanning

Die Chrome-Erweiterung scannt Webseiten während Sicherheitsbewertungen von Webanwendungen nach Secrets.

Einrichtung```bash

make build-extension

1. Navigieren Sie zu `chrome://extensions/`
2. Aktivieren Sie den **Entwicklermodus**
3. Klicken Sie auf **Entpackte Erweiterung laden** und wählen Sie das Verzeichnis `extension/` aus

### Funktionen der Browser-Erweiterung

- Durchsucht Inline- und externe JavaScript- und Stylesheet-Dateien nach API-Schlüsseln und Tokens
- Durchsucht localStorage und sessionStorage nach preisgegebenen Anmeldedaten
- Optionale Erfassung 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 extension popup showing detected secrets on a web page" src="https://assets.kitploit.com/production/public/readmes/11969/057a24e2746412ceabe1aac0292a2de463de1efee5bca2489ca34b59d8b0dc2c.png" />

<img width="1744" height="827" alt="Titus Chrome extension dashboard with aggregated secret detection results" 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, solange die Erweiterung aktiv ist. **Aktivieren Sie sie nur während aktiver Sicherheitstests.**

## 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-beschleunigten Regex-Abgleich. Dies erfordert CGO, die C-Bibliothek und `pkg-config` (das cgo verwendet, um die Bibliothek zu finden). `make build` prüft auf diese und versucht, alles Fehlende ü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

Du siehst [vectorscan] N/N rules compiled for Hyperscan beim Start, wenn die beschleunigte Engine aktiv ist.

Um die C-Bibliothek selbst zu installieren, anstatt sich auf die automatische Installation zu verlassen:```bash

macOS (Homebrew)

brew install pkg-config vectorscan

Ubuntu/Debian

sudo apt-get install pkg-config libhyperscan-dev

Fedora/RHEL

sudo dnf install pkgconf-pkg-config vectorscan-devel

Or build vectorscan from source:

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 (zum Beispiel 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

Pure-Go-Build (keine C-Abhängigkeiten)

Wenn Sie die C-Bibliothek nicht installieren können – oder ein vollständig portables, statisches Binary wünschen – bauen Sie stattdessen die Pure-Go-Engine. Titus greift zur Laufzeit automatisch darauf zurück, wann immer vectorscan nicht einkompiliert ist:```bash

Portable pure-Go binary (no CGO, no vectorscan)

make build-pure

Fully static binary

make build-static

#### Automatischer Hyperscan-Datenbank-Cache

Titus serialisiert jede erfolgreich kompilierte Hyperscan-Datenbank automatisch
in den Standard-Benutzercache. Spätere Scanner-Instanzen mit exakt denselben
geordneten Regeln und Flags laden diese Datenbank, anstatt sie erneut zu
kompilieren. Die Cache-Datei ist der unveränderte Byte-Stream, der von Hyperscans
`hs_serialize_database` erzeugt wird, und Titus lädt sie mit
`hs_deserialize_database`.

`TITUS_CACHE_DIR` kann den Cache-Speicherort überschreiben. Cache-Schreibvorgänge
sind atomar und erfolgen nach bestem Bemühen: Ein nicht verfügbarer oder
schreibgeschützter Cache verhindert das Scannen nicht. Eine fehlende,
beschädigte, inkompatible oder anders gefingerprintete Datenbank löst die
normale Kompilierung aus und aktualisiert den Cache, wenn möglich.

Serialisierte Datenbanken sind architektur-, CPU-feature- und
Hyperscan-versionsspezifisch. Titus erkennt inkompatible Einträge während der
Deserialisierung und ersetzt sie durch eine für die aktuelle Laufzeitumgebung
kompilierte Datenbank.

## Mitwirken

Beiträge sind willkommen! Siehe [CONTRIBUTING.md](https://github.com/praetorian-inc/titus/blob/main/CONTRIBUTING.md) für
Richtlinien zur Mitarbeit an Titus.

## Lizenz

Apache License 2.0 — siehe [LICENSE](https://github.com/praetorian-inc/titus/blob/main/LICENSE).

Erkennungsregeln sind von [NoseyParker](https://github.com/praetorian-inc/noseyparker)
(Praetorian Security, Inc.) und [Kingfisher](https://github.com/mongodb/kingfisher)
(MongoDB, Inc.) abgeleitet, beide unter Apache 2.0 lizenziert. Siehe
[NOTICE](https://github.com/praetorian-inc/titus/blob/main/NOTICE) für die vollständige Attribution.

titus v1.2.8

Kategorien