praetorian-inc/titusScanner de secrets haute performance. Interface en ligne de commande, bibliothèque Go, extension Burp Suite et extension Chrome. 487 règles de détection avec validation en direct des identifiants.
Titus est un scanner de secrets haute performance qui détecte les identifiants, les clés API et les jetons dans le code source, les fichiers et l'historique Git. Il fournit 487 règles de détection couvrant des centaines de services et de types d'identifiants, provenant de NoseyParker et Kingfisher. Titus s'utilise en CLI, en bibliothèque Go, en extension Burp Suite et en extension de navigateur Chrome — tous partageant le même moteur de détection et le même ensemble de règles.
Conçu pour les ingénieurs en sécurité, les testeurs d'intrusion et les équipes DevSecOps, Titus combine la correspondance regex accélérée par Hyperscan/Vectorscan avec une validation en direct des identifiants pour trouver et vérifier les secrets divulgués dans l'ensemble de votre codebase.
Téléchargez un binaire précompilé depuis la page Releases, ou compilez à partir des sources :```bash make build
Le binaire se trouvera dans `dist/titus`.
## Démarrage rapide```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
Les résultats sont écrits dans un datastore (titus.ds par défaut) et affichés dans la console.
Scannez directement les dépôts publics par URL — aucun jeton API requis :```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
Pour une analyse à l'échelle de l'organisation ou de l'utilisateur, utilisez les sous-commandes dédiées :```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
Les tokens sont optionnels pour les dépôts publics. Définissez GITHUB_TOKEN ou GITLAB_TOKEN (ou utilisez --token) pour l'accès aux dépôts privés et des limites de taux API plus élevées.
Analysez directement les images conteneur — aucun daemon docker, aucun binaire docker requis. Titus récupère les images directement depuis n'importe quel registre OCI via HTTPS (en utilisant les identifiants de ~/.docker/config.json), ou lit les images à partir d'une archive docker save locale ou d'un répertoire de disposition d'image OCI. Il analyse ensuite les métadonnées du manifeste/de la configuration de l'image et chaque fichier régulier dans chaque couche, y compris les fichiers des couches inférieures supprimés par des couches ultérieures (car les secrets peuvent rester récupérables à partir de l'historique de l'image).```bash
titus scan --docker alpine:latest titus scan docker://ghcr.io/owner/repo:tag
titus scan --docker ./my-app.tar
titus scan --docker ./img/
L'authentification utilise votre configuration existante Docker / Podman (`~/.docker/config.json`, `${XDG_RUNTIME_DIR}/containers/auth.json`). Les registres privés nécessitant une nouvelle connexion doivent d'abord être authentifiés avec `docker login` (ou `podman login`, ou `crane auth login`) — titus ne demande pas d'identifiants.
### Affichage des résultats d'analyse
Utilisez `report` pour relire les résultats d'une analyse précédente :```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
Vous pouvez également contrôler le format de sortie lors de l'analyse avec --format :```bash
titus scan path/to/code --format json
### Validation des secrets détectés
Utilisez `--validate` lors d'une analyse pour vérifier les secrets détectés par rapport à leurs API sources :```bash
titus scan path/to/code --validate
La validation s'exécute simultanément (4 workers par défaut, configurable avec --validate-workers) et marque chaque résultat comme confirmé, refusé ou inconnu.
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
### Extraction de secrets à partir de fichiers binaires
Titus peut extraire du texte à partir de formats de fichiers binaires et analyser le contenu pour y trouver des secrets :```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
Les formats pris en charge incluent les documents Office (xlsx, docx, pptx, odp, ods, odt), les PDF, les notebooks Jupyter, les bases de données SQLite, les e-mails (eml, rtf) et les archives (zip, tar, tar.gz, jar, war, ear, apk, ipa, crx, xpi, 7z). Les archives sont extraites de manière récursive jusqu'à des limites de profondeur et de taille configurables.```bash
titus scan path/to/files --extract=all
--extract-max-size 10MB
--extract-max-total 100MB
--extract-max-depth 5
Pour les bases de données SQLite, Titus extrait le texte de toutes les tables (1000 lignes par table par défaut). Utilisez `--sqlite-row-limit` pour ajuster :```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
Chaque découverte produite par Titus porte un score numérique de 0 à 100 et un niveau de sévérité :
| Score | Sévérité |
|---|---|
| 0–20 | info |
| 21–40 | faible |
| 41–60 | moyen |
| 61–80 | élevé |
| 81–100 | critique |
Les scores partent du base_score de la règle et sont ajustés par des modificateurs — des conditions qui augmentent ou diminuent le score en fonction de ce qui est connu sur l’identifiant :```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 est livré avec des évaluateurs YAML pour les identifiants AWS, les PAT GitHub et les tokens Slack, ainsi que des évaluateurs SDK basés sur Go qui effectuent une énumération en direct des politiques IAM (AWS) et des vérifications des permissions de dépôt (PAT GitHub granulaires) lorsque `--score-scope` est activé.
Voir [docs/scoring.md](https://github.com/praetorian-inc/titus/blob/HEAD/docs/scoring.md) pour la référence complète : niveaux de sévérité, types de modificateurs, détails des évaluateurs intégrés, et comment écrire vos propres évaluateurs YAML ou Go.
## Bibliothèque Go pour la détection de secrets
Titus peut être importé comme une bibliothèque Go pour ajouter la détection de secrets à vos propres outils et pipelines.```bash
go get github.com/praetorian-inc/titus
Please provide the Markdown content to translate.```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,
)
}
}
La bibliothèque prend également en charge l'analyse d'octets et de fichiers, la validation des secrets détectés et le chargement de règles personnalisées :```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))
Voir docs/library-usage.md pour la référence complète de l'API, les modèles de concurrence et d'autres exemples.
make install-burp
Then charge `dist/titus-burp-1.0.0-all.jar` dans Burp Suite sous Extensions > Add.
#### Windows (Téléchargement depuis Releases)
1. Téléchargez `titus-windows-amd64.exe` et `titus-burp-<version>.jar` depuis [Releases](https://raw.githubusercontent.com/praetorian-inc/releases)
2. Créez le répertoire Titus et installez le binaire : ```powershell
mkdir %USERPROFILE%\.titus
copy titus-windows-amd64.exe %USERPROFILE%\.titus\titus.exe
titus-burp-<version>.jar depuis Releases :
titus-linux-amd64 ou titus-linux-arm64 pour Linuxtitus-darwin-amd64 ou titus-darwin-arm64 pour macOSL'extension lance un processus titus serve en arrière-plan et communique via stdin/stdout en utilisant NDJSON. Les règles de détection sont chargées une fois au démarrage.
L'extension ajoute un onglet Titus dans Burp avec trois sous-onglets :
Secrets : Tous les secrets détectés avec filtrage par type, hôte et statut de validation.
Onglet des secrets de l
Statistiques : Vue agrégée des secrets regroupés par type et hôte.
Paramètres : Configurez les options d'analyse, de validation et les correspondances de sévérité.
Onglet des paramètres de l
Lorsque vous visualisez une requête dans Burp, un onglet Titus apparaît dans l'inspecteur de réponse si des secrets sont détectés, offrant un accès rapide aux résultats sans basculer vers l'onglet Titus principal.
Onglet Titus dans l
L'extension Chrome analyse les pages web à la recherche de secrets lors des évaluations de sécurité des applications web.
make build-extension
1. Accédez à `chrome://extensions/`
2. Activez le **mode développeur**
3. Cliquez sur **Charger l'extension non empaquetée** et sélectionnez le répertoire `extension/`
### Fonctionnalités de l'extension navigateur
- Analyse les JavaScript et feuilles de style internes et externes à la recherche de clés API et de jetons
- Analyse localStorage et sessionStorage à la recherche d'identifiants divulgués
- Capture facultative des réponses réseau pour une détection complète des secrets
- Résultats affichés dans la popup et le tableau de bord
<img width="1719" height="958" alt="Popup de l'extension Chrome Titus affichant des secrets détectés sur une page web" src="https://assets.kitploit.com/production/public/readmes/11969/057a24e2746412ceabe1aac0292a2de463de1efee5bca2489ca34b59d8b0dc2c.png" />
<img width="1744" height="827" alt="Tableau de bord de l'extension Chrome Titus avec les résultats agrégés de détection de secrets" src="https://assets.kitploit.com/production/public/readmes/11969/265d972fadcc7f212944d7a1d8fd58a43446e7199d1209900e83b96a546ffb00.png" />
### Avis de sécurité
L'extension navigateur supprime les en-têtes Content Security Policy et CORS des pages visitées pour analyser les ressources externes. Cela affaiblit la posture de sécurité des sites que vous visitez pendant que l'extension est active. **Activez-la uniquement lors de tests de sécurité actifs.**
## Construction à partir des sources
### Construction standard (accélérée par Vectorscan)
Par défaut, Titus compile avec [Vectorscan](https://github.com/VectorCamp/vectorscan) (ARM) / [Hyperscan](https://github.com/intel/hyperscan) (x86) pour une correspondance regex accélérée par SIMD. Cela nécessite CGO, la bibliothèque C et `pkg-config` (que cgo utilise pour localiser la bibliothèque). `make build` vérifie leur présence et tente d'installer tout ce qui manque via Homebrew / apt / dnf :```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
Vous verrez [vectorscan] N/N rules compiled for Hyperscan au démarrage lorsque le moteur accéléré est actif.
Pour installer vous-même la bibliothèque C au lieu de vous fier à l'installation automatique :```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
Si vous invoquez `go build` directement (par exemple, lors de l'incorporation de Titus), passez le tag et activez 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
Si vous ne pouvez pas installer la bibliothèque C — ou que vous souhaitez un binaire statique entièrement portable — construisez plutôt le moteur pure-Go. Titus y revient automatiquement à l'exécution chaque fois que vectorscan n'est pas compilé:```bash
make build-pure
make build-static
## Contributing
Les contributions sont les bienvenues ! Consultez [CONTRIBUTING.md](https://github.com/praetorian-inc/titus/blob/HEAD/CONTRIBUTING.md) pour les directives sur la façon de contribuer à Titus.
## License
Licence Apache 2.0 — voir [LICENSE](https://github.com/praetorian-inc/titus/blob/HEAD/LICENSE).
Les règles de détection sont dérivées de [NoseyParker](https://github.com/praetorian-inc/noseyparker) (Praetorian Security, Inc.) et [Kingfisher](https://github.com/mongodb/kingfisher) (MongoDB, Inc.), toutes deux sous licence Apache 2.0. Voir [NOTICE](https://github.com/praetorian-inc/titus/blob/HEAD/NOTICE) pour l'attribution complète.