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
titus — Hochleistungs-Scanner für Geheimnisse. CLI, Go-Bibliothek, Burp Suite-Erweiterung und Chrome-Erweiterung. 487 Erkennungsregeln mit Live-Validierung von Anmeldeinformationen. | Kitploit
Tools/GitHubGitHub/praetorian-inc/titus
Statische AnalyseSchwachstellenscannerContainer-SicherheitWeb-Proxys & AbfangenCode-AnalysePenetrationstestsDevSecOpsSecret-ErkennungLieferkettensicherheit
GitHubpraetorian-inc/titus

titus

6677588vor 2 TagenVon Kitploit geprüft

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

Repository anzeigenWebseite
Teilen
<img width="1200" height="628" alt="Titus - hochleistungsfähiger Secrets-Scanner für Quellcode, Git-Historie und Binärdateien" src="https://assets.kitploit.com/production/public/readmes/11969/d2f6b99d686a073185db1b7299fa5f033067b057000062cf592a4ae15a796034.png" />

# Titus: Hochleistungsfähiger Secrets-Scanner

[![Go](https://img.shields.io/badge/Go-1.27.0+-00ADD8?logo=go&logoColor=white)](https://go.dev)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
[![CI](https://img.shields.io/github/actions/workflow/status/praetorian-inc/titus/ci.yml?branch=main&label=CI)](https://github.com/praetorian-inc/titus/actions)

**Titus** ist ein hochleistungsfähiger 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](https://github.com/praetorian-inc/noseyparker) und [Kingfisher](https://github.com/mongodb/kingfisher) stammen. Titus läuft als CLI, als Go-Bibliothek, als Burp-Suite-Erweiterung und als Chrome-Browser-Erweiterung – alle mit derselben Erkennungs-Engine und demselben Regelsatz.

Titus wurde für Sicherheitsingenieure, Penetrationstester und DevSecOps-Teams entwickelt und kombiniert [Hyperscan](https://github.com/intel/hyperscan)/[Vectorscan](https://github.com/VectorCamp/vectorscan)-beschleunigtes Regex-Matching mit Live-Validierung von Anmeldedaten, um geleakte Secrets in Ihrer gesamten Codebasis zu finden und zu verifizieren.

## Inhaltsverzeichnis

- [Warum Titus?](#why-titus)
- [Installation](#installation)
- [Schnellstart](#quick-start)
- [Scan-Optionen](#scanning-options)
- [Bewertung von Funden](#finding-scoring)
- [Go-Bibliothek](#go-library-for-secrets-detection)
- [Burp-Suite-Erweiterung](#burp-suite-extension-for-secret-scanning)
- [Browser-Erweiterung](#chrome-browser-extension-for-secret-scanning)
- [Aus dem Quellcode erstellen](#building-from-source)
- [Mitwirken](#contributing)
- [Lizenz](#license)

## Warum Titus?

- **Schnelles Secrets-Scanning**: Regex-Matching beschleunigt durch [Hyperscan](https://github.com/intel/hyperscan)/[Vectorscan](https://github.com/VectorCamp/vectorscan), sofern verfügbar, mit einem reinen Go-Fallback für Portabilität auf jeder Plattform.
- **Breite Abdeckung der Erkennung von Anmeldedaten**: 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 Schadensradius einer Anmeldedate messen – sodass die gefährlichsten Funde stets zuerst angezeigt werden.
- **Scanning von Container-Images**: Scannen Sie Docker- und OCI-Images direkt aus einer beliebigen Registry, einem Tarball oder einem OCI-Layout-Verzeichnis – ohne Docker-Daemon oder Binärdatei.
- **Mehrere Schnittstellen für jeden Workflow**: Scannen Sie über die CLI, betten Sie Titus als Go-Bibliothek ein, scannen Sie HTTP-Verkehr in Burp Suite passiv oder scannen Sie Webseiten in Chrome während des Application-Security-Testings.
- **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 eine vorgefertigte Binärdatei von der Seite [Releases](../../releases) herunter oder erstellen Sie sie 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
```

Die Ergebnisse werden in einen Datenspeicher (`titus.ds` standardmäßig) geschrieben und auf der Konsole ausgegeben.

### Unterbefehle

<!-- BEGIN generated: cli-subcommands -->
Titus organisiert seine Funktionalität in diese fokussierten Unterbefehle:

```bash
titus analyze # Analyze a credential on demand — detect type, validate, score, and enumerate resources
titus enum    # Enumerate remote services for secrets
titus explore # Interactively explore scan results
titus report  # Generate a report from scan results
titus rules   # Manage detection rules
titus scan    # Scan a target for secrets
titus serve   # Run as streaming server for Burp extension integration
titus version # Show version information
```
<!-- END generated: cli-subcommands -->

Jedes Unterkommando akzeptiert `--help` für seine eigenen Flags. Die Formen `titus <provider>` auf oberster Ebene, die älter sind als `titus enum <provider>`, funktionieren weiterhin, sind aber versteckt und veraltet statt Aliase, daher werden sie in der generierten Referenz statt hier aufgeführt.

<!-- BEGIN generated: cli-aliases -->
Die vollständige Referenz — jedes Unterkommando, jeder Alias und jedes Flag, einschließlich der vor `--help` verborgenen — wird in [docs/CLI.md](https://github.com/praetorian-inc/titus/blob/main/docs/CLI.md) generiert.
<!-- END generated: cli-aliases -->

## Scan-Optionen

### GitHub- & GitLab-Scanning

Scannen Sie öffentliche Repositories direkt per URL — 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 scan owner/repo --git
```

Tokens sind für öffentliche Repositories optional. Setzen Sie `GITHUB_TOKEN` oder `GITLAB_TOKEN` (oder verwenden Sie `--token`) für den Zugriff auf private Repositories und höhere API-Ratenlimits.

### Docker-/OCI-Image-Scanning

Scannen Sie Container-Images direkt — kein Docker-Daemon, keine `docker`-Binärdatei erforderlich. Titus ruft Images direkt von jeder OCI-Registry über HTTPS ab (unter Verwendung der 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 Metadaten des Image-Manifests und der Image-Konfiguration sowie jede reguläre Datei in jeder Ebene, einschließlich Dateien aus unteren Ebenen, die von späteren Ebenen 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 fordert keine Anmeldedaten an.

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

# Only findings from one repository (host-qualified as recorded, or without the host)
titus report --repo github.com/acme/api

# Repeat a selector, or combine selectors; a location matching any value is kept
titus report --namespace github.com/acme --namespace gitlab.example.com/acme --path src/config.yaml

# List the repository, namespace and path values that select current findings
titus report sources

# List every recorded source, including sources with no findings
titus report sources all
```

Sie können 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 Fund als bestätigt, verneint oder unbekannt.

### Erkennungsregeln für Filterung

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

Regeln, die mit `visible: false` markiert sind, sind Hilfsregeln, die Kontext für andere Regeln erfassen, etwa eine Client-ID, einen Kontonamen oder einen Host, und kein Geheimnis darstellen. Ihre Muster werden weiterhin ausgeführt, aber ihre Treffer werden niemals gemeldet, weder von der CLI noch von der Go-Bibliothek, selbst wenn die Regel explizit ausgewählt wird.

### Extrahieren von Geheimnissen aus Binärdateien

Titus kann Text aus binären Dateiformaten extrahieren und den Inhalt auf Geheimnisse 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
```

Zu den unterstützten Formaten gehören 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 von Titus erzeugte Finding trägt eine numerische Bewertung von 0–100 sowie eine Schweregradstufe:

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

Die 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 senken:

```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 sowie mit Go-basierten SDK-Scorern ausgeliefert, die bei aktiviertem `--score-scope` eine Live-IAM-Richtlinienaufzählung (AWS) und Berechtigungsprüfungen für Repositories (GitHub Fine-Grained PATs) durchführen.

Die vollständige Referenz finden Sie unter [docs/scoring.md](https://github.com/praetorian-inc/titus/blob/main/docs/scoring.md): Schweregradstufen, Modifikatortypen, Details zu den 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 Secrets-Erkennung in Ihre eigenen Tools und Pipelines zu integrieren.

```bash
go get github.com/praetorian-inc/titus
```

```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 = AKIADEADBEEFDEADBEEF`)
    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](https://github.com/praetorian-inc/titus/blob/main/docs/library-usage.md) für die vollständige API-Referenz, Nebenläufigkeitsmuster und weitere Beispiele.

## Burp-Suite-Erweiterung für Secret-Scanning

Die Burp-Erweiterung durchsucht HTTP-Antworten während des Proxy-Verkehrs und bei aktiven Penetrationstests nach 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
   ```
3. Laden Sie die JAR-Datei in Burp Suite unter Extensions > Add

#### Linux / macOS (Download von Releases)

1. Laden Sie die passende Binärdatei für Ihre Plattform und `titus-burp-<version>.jar` von [Releases](../../releases) herunter:
   - `titus-linux-amd64` oder `titus-linux-arm64` für Linux
   - `titus-darwin-amd64` oder `titus-darwin-arm64` für macOS
2. Installieren Sie die Binärdatei:
   ```bash
   mkdir -p ~/.titus
   cp titus-<platform> ~/.titus/titus
   chmod +x ~/.titus/titus
   ```
3. Lade die 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-Traffic automatisch, während er durch Burp fließt
- **Aktives Secret-Scanning**: Rechtsklick-Kontextmenü zum Scannen ausgewählter Anfragen
- **Deduplizierung**: dasselbe Secret wird nur einmal pro Engagement gemeldet
- **Fast-Path-Filterung**: Binärinhalte, Bilder und Nicht-Text-Antworten werden übersprungen
- **Live-Validierung von Zugangsdaten**: erkannte Secrets gegen Quell-APIs prüfen, um zu bestätigen, ob sie aktiv sind
- **Verwaltung von Fehlalarmen**: Befunde als Fehlalarme markieren, um Rauschen zu filtern
- **Schweregrad-Klassifizierung**: Befunde farblich nach Risiko codiert (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**: Klicke auf die Schaltflächen Type, Host oder Status, um nach bestimmten Werten zu filtern; nutze das Suchfeld für Text- und Regex-Abgleich
- **Massenaktionen**: Mehrere Zeilen auswählen, um sie im Batch zu validieren oder als Fehlalarm zu markieren
- **Secret Details-Panel**: Wähle einen Befund aus, um Folgendes anzuzeigen:
    - **Details**: Regelinformationen, Kategorie, vollständiger Secret-Wert, Zeitstempel der ersten Erkennung
    - **URLs**: Alle Fundorte dieses Secrets
    - **Validation**: Validierungsergebnis mit Details (z. B. AWS-Konto-ID, ARN)
    - **Request/Response**: Vollständiger HTTP-Traffic mit hervorgehobenem Secret


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

<img width="1964" height="848" alt="Titus Burp Suite extension statistics tab showing secrets by type and host" src="https://assets.kitploit.com/production/public/readmes/11969/4a3d6f997049bb8bba621ceb8511b9a41c63867a5c1e8add6065c483706ac36a.png" />

- **Summary**: Gesamtzahl eindeutiger Secrets, gescannte Hosts, Validierungsaufschlüsselung (aktiv vs. inaktiv) und Anzahl der Fehlalarme
- **Secrets by Type**: Anzahl jedes Secret-Typs mit Kategorieklassifizierung
- **Secrets by Host**: Anzahl der pro Host gefundenen Secrets

**Settings**: Konfiguration von Scan-Optionen, Validierung und Schweregrad-Zuordnungen.

Titus Burp Suite extension settings tab with scan configuration options

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


Beim Anzeigen einer 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 externes JavaScript sowie Stylesheets nach API-Schlüsseln und Tokens
- Durchsucht localStorage und sessionStorage nach offengelegten 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. Dadurch wird die Sicherheitslage der von Ihnen besuchten Websites geschwächt, 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-beschleunigtes Regex-Matching. Dies erfordert CGO, die C-Bibliothek und `pkg-config` (das cgo verwendet, um die Bibliothek zu finden). `make build` prüft dies 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
```

Beim Start siehst du `[vectorscan] N/N rules compiled for Hyperscan`, 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 eine vollständig portable, statische Binärdatei 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 eine 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 Laufzeit 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).

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

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.

    916
  • 2

    ghostlock-app

    yukonga/ghostlock-app

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

    558
  • 3

    redforge

    cybersecurity91/redforge

    Browser-seitiges Red-Team-Toolkit mit 102 Offline-Tools für Recon, Payload-Generierung, Credential-Angriffe, Krypto, Encoding und Engagement-Reporting.

    370
  • 4

    ARTEX

    baarai/artex

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

    360
  • 5

    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.

    317
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Das System der Handlung für KI-native Cybersicherheit – wo Absicht zu gesteuerter Ausführung wird, Beweise zu operativem Gedächtnis werden und jeder Einsatz den nächsten verbessert.

    289

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →