titus — Hochleistungs-Scanner für Geheimnisse. CLI, Go-Bibliothek, Burp Suite-Erweiterung und Chrome-Erweiterung. 487 Erkennungsregeln mit Live-Validierung von Anmeldeinformationen. | Kitploit

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

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

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

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

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

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

// 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))

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

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

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

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

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

titus

Beliebteste

Titus: Hochleistungs-Secrets-Scanner

Inhaltsverzeichnis

Warum Titus?

Installation

Scan-Optionen

GitHub- & GitLab-Scanning

Scan a GitHub repository

Scan a GitLab project

Full URLs work too

Docker / OCI Image Scanning

Pull from a registry and scan

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

Scan an OCI image layout directory:

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

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

Erkennungsregeln filtern```bash

List all available detection rules

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

Exclude rules by pattern

Use a custom rules file for organization-specific secrets

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

Tune extraction limits for large codebases

Bewertung von Findings

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

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

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

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

Burp Suite Extension für Secret Scanning

Einrichtung

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

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

Linux / macOS (Download von Releases)

Funktionen der Burp-Erweiterung

Oberfläche der Burp-Erweiterung

Chrome-Browser-Erweiterung für Secret-Scanning

Einrichtung```bash

macOS (Homebrew)

Ubuntu/Debian

Fedora/RHEL

Or build vectorscan from source:

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

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

Fully static binary