Titus : Scanner de secrets haute performance

Titus est un scanner de secrets haute performance qui détecte les identifiants, clés d'API et jetons dans le code source, les fichiers et l'historique git. Il est livré avec 487 règles de détection couvrant des centaines de services et types d'identifiants, issues de NoseyParker et Kingfisher. Titus s'exécute en tant que CLI, bibliothèque Go, extension Burp Suite et 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 la validation d'identifiants en direct pour trouver et vérifier les secrets divulgués dans l'ensemble de votre base de code.

Pourquoi Titus ?

Scan de secrets rapide : correspondance regex accélérée par Hyperscan/Vectorscan lorsqu'ils sont disponibles, avec un repli en Go pur pour la portabilité sur n'importe quelle plateforme.
Large couverture de détection d'identifiants : 487 règles détectent les clés d'API, jetons et identifiants pour AWS, GCP, Azure, GitHub, Slack, les bases de données, les systèmes CI/CD et des centaines d'autres services.
Validation de secrets en direct : les secrets détectés sont vérifiés auprès de leurs API sources pour confirmer s'ils sont actifs, ce qui réduit les faux positifs et priorise la remédiation.
Notation de gravité basée sur le risque : chaque résultat reçoit un score numérique (0–100) et un niveau de gravité (info → critique). Les scores sont ajustés par les métadonnées statiques des règles, le contexte d'accessibilité du code et les appels API en direct qui mesurent le rayon d'impact réel d'un identifiant — ainsi les résultats les plus dangereux remontent toujours en premier.
Scan d'images de conteneurs : scannez directement les images Docker et OCI depuis n'importe quel registre, tarball ou répertoire de layout OCI — sans nécessiter de démon Docker ni de binaire.
Interfaces multiples pour chaque flux de travail : scannez depuis la CLI, intégrez en tant que bibliothèque Go, scannez passivement le trafic HTTP dans Burp Suite, ou scannez les pages web dans Chrome lors de tests de sécurité applicative.
Extraction de fichiers binaires : extrayez et scannez les secrets depuis les documents Office, PDF, archives (zip, tar, 7z), applications mobiles (APK, IPA), extensions de navigateur, et plus encore.

Installation

Téléchargez un binaire précompilé depuis la page Releases, ou compilez depuis les 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.

Options de scan

Scan GitHub & GitLab

Scannez directement les dépôts publics par URL — aucun jeton d'API requis :```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

Pour l'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 jetons sont facultatifs 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 débit d'API plus élevées.

Analyse d'images Docker / OCI

Analysez directement les images de conteneurs — aucun démon docker, aucun binaire docker requis. Titus extrait les images directement depuis n'importe quel registre OCI via HTTPS (en utilisant les identifiants de ~/.docker/config.json), ou lit les images depuis une archive docker save locale ou 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 de chaque couche, y compris les fichiers des couches inférieures supprimés par les couches supérieures (car les secrets peuvent rester récupérables depuis l'historique de l'image).```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/

L'authentification utilise votre configuration Docker / Podman existante (`~/.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.

### Consultation 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 au moment du scan avec --format :```bash titus scan path/to/code --format json

### Validation des secrets détectés

Passez `--validate` pendant une analyse pour vérifier les secrets détectés auprès de leurs API sources :```bash
titus scan path/to/code --validate

La validation s'exécute en parallèle (4 workers par défaut, configurables avec --validate-workers) et marque chaque résultat comme confirmé, infirmé ou inconnu.

Règles de détection du filtrage```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

### Extraction de secrets à partir de fichiers binaires

Titus peut extraire du texte à partir de formats de fichiers binaires et analyser le contenu à la recherche de 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'à une profondeur et des limites de taille configurables.```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

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

Notation des findings

Chaque finding produit par Titus porte un score numérique de 0 à 100 et un niveau de gravité :

Score	Gravité
0–20	info
21–40	low
41–60	medium
61–80	high
81–100	critical

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 le credential :```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 est livré avec des scoreurs YAML pour les identifiants AWS, les PAT GitHub et les jetons Slack, ainsi que des scoreurs 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 à granularité fine) lorsque `--score-scope` est activé.

Consultez [docs/scoring.md](https://github.com/praetorian-inc/titus/blob/main/docs/scoring.md) pour la référence complète : niveaux de gravité, types de modificateurs, détails des scoreurs intégrés et comment écrire vos propres scoreurs YAML ou Go.

## Bibliothèque Go pour la détection de secrets

Titus peut être importé en tant que bibliothèque Go pour ajouter la détection de secrets à vos propres outils et pipelines.```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,
    )
}

}

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.

Extension Burp Suite pour l'analyse des secrets

L'extension Burp analyse les réponses HTTP à la recherche de secrets pendant le trafic proxy et les tests d'intrusion actifs.

Configuration

Linux / macOS (Compilation depuis les sources)```bash

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

make install-burp

Ensuite, chargez `dist/titus-burp-1.0.0-all.jar` dans Burp Suite sous Extensions > Add.

#### Windows (Téléchargement depuis les Releases)

1. Téléchargez `titus-windows-amd64.exe` et `titus-burp-<version>.jar` depuis [Releases](../../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

Chargez le JAR dans Burp Suite sous Extensions > Add

Linux / macOS (Téléchargement depuis les Releases)

Téléchargez le binaire approprié pour votre plateforme et titus-burp-<version>.jar depuis Releases :
- titus-linux-amd64 ou titus-linux-arm64 pour Linux
- titus-darwin-amd64 ou titus-darwin-arm64 pour macOS
Installez le binaire : ```bash mkdir -p ~/.titus cp titus- ~/.titus/titus chmod +x ~/.titus/titus
Chargez le JAR dans Burp Suite sous Extensions > Add

L'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 seule fois au démarrage.

Fonctionnalités de l'extension Burp

Analyse passive des secrets : analyse automatiquement le trafic proxy au fur et à mesure qu'il transite par Burp
Analyse active des secrets : menu contextuel par clic droit pour analyser les requêtes sélectionnées
Déduplication : le même secret n'est signalé qu'une seule fois par engagement
Filtrage rapide : le contenu binaire, les images et les réponses non textuelles sont ignorés
Validation des identifiants en direct : vérifie les secrets détectés auprès des API sources pour confirmer s'ils sont actifs
Gestion des faux positifs : marquez les résultats comme faux positifs pour filtrer le bruit
Classification de gravité : résultats codés par couleur selon le risque (Élevé/Moyen/Faible)
Export : enregistrez les résultats au format JSON pour le reporting

Interface de l'extension Burp

L'extension ajoute un onglet Titus à Burp avec trois sous-onglets :

Secrets : Tous les secrets détectés avec filtrage par type, hôte et statut de validation.

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

Statut de validation : Indique si les secrets ont été vérifiés (Actif/Inactif/Inconnu)
Filtrage : Cliquez sur les boutons Type, Host ou Status pour filtrer par valeurs spécifiques ; utilisez la zone de recherche pour la correspondance textuelle et par regex
Actions groupées : Sélectionnez plusieurs lignes pour valider ou marquer comme faux positif en lot
Panneau Secret Details : Sélectionnez un résultat pour afficher :
- Details : Informations sur la règle, catégorie, valeur complète du secret, horodatage de première détection
- URLs : Tous les emplacements où ce secret a été trouvé
- Validation : Résultat de la validation avec détails (par ex., ID de compte AWS, ARN)
- Request/Response : Trafic HTTP complet avec le secret mis en évidence

Statistics : Vue agrégée des secrets groupés par type et par hôte.

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

Summary : Total des secrets uniques, hôtes analysés, répartition de la validation (actifs vs inactifs) et nombre de faux positifs
Secrets by Type : Nombre de chaque type de secret avec classification par catégorie
Secrets by Host : Nombre de secrets trouvés par hôte

Settings : Configurez les options d'analyse, la validation et les mappages de gravité.

Titus Burp Suite extension settings tab with scan configuration options

Scan Settings :
- Analyse passive : Analyse automatiquement tout le trafic proxy (activé par défaut)
- Analyse du corps des requêtes : Analyse également les corps de requêtes pour les secrets envoyés par l'application
- Validation : Activez pour vérifier les secrets auprès des API sources (effectue des requêtes sortantes et peut déclencher des alertes)
Scan Parameters : Threads de travail, taille maximale de fichier, longueur de l'extrait de contexte
Severity Configuration : Personnalisez les niveaux de gravité par catégorie de secret
Actions : Vider le cache, réinitialiser les paramètres, enregistrer/exporter les résultats au format JSON

Lors de la consultation d'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.

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

Extension de navigateur Chrome pour l'analyse des secrets

L'extension Chrome analyse les pages web à la recherche de secrets lors des évaluations de sécurité des applications web.

Configuration```bash

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

- Analyse le JavaScript et les feuilles de style en ligne 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 le popup et le tableau de bord

<img width="1719" height="958" alt="Popup de l'extension Chrome Titus affichant les 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 de navigateur supprime les en-têtes Content Security Policy et CORS des pages visitées afin d'analyser les ressources externes. Cela affaiblit la posture de sécurité des sites que vous visitez tant que l'extension est active. **Activez-la uniquement pendant des tests de sécurité actifs.**

## Compilation depuis les sources

### Compilation standard (accélérée par Vectorscan)

Par défaut, Titus se 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 élément manquant 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 compter sur l'installation automatique :```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

Si vous invoquez `go build` directement (par exemple, lors de l'intégration 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

Compilation en Go pur (sans dépendances C)

Si vous ne pouvez pas installer la bibliothèque C — ou si vous souhaitez un binaire entièrement portable et statique — compilez plutôt le moteur en Go pur. Titus bascule automatiquement vers celui-ci à l'exécution lorsque vectorscan n'est pas compilé :```bash

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

make build-pure

Fully static binary

make build-static

#### Cache de base de données Hyperscan automatique

Titus sérialise automatiquement chaque base de données Hyperscan compilée avec succès dans le cache utilisateur standard. Les instances de scanner ultérieures avec exactement les mêmes règles ordonnées et les mêmes indicateurs chargent cette base de données au lieu de la recompiler. Le fichier de cache est le flux d'octets non modifié produit par `hs_serialize_database` de Hyperscan, et Titus le charge avec `hs_deserialize_database`.

`TITUS_CACHE_DIR` peut remplacer l'emplacement du cache. Les écritures dans le cache sont atomiques et au mieux : un cache indisponible ou en lecture seule n'empêche pas l'analyse. Une base de données manquante, corrompue, incompatible ou avec une empreinte différente déclenche une compilation normale et actualise le cache lorsque cela est possible.

Les bases de données sérialisées sont spécifiques à l'architecture, aux fonctionnalités du CPU et à la version de Hyperscan. Titus détecte les entrées incompatibles lors de la désérialisation et les remplace par une base de données compilée pour l'environnement d'exécution actuel.

## Contribuer

Les contributions sont les bienvenues ! Consultez [CONTRIBUTING.md](https://github.com/praetorian-inc/titus/blob/main/CONTRIBUTING.md) pour les directives sur la façon de contribuer à Titus.

## Licence

Apache License 2.0 — voir [LICENSE](https://github.com/praetorian-inc/titus/blob/main/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.), tous deux sous licence Apache 2.0. Voir [NOTICE](https://github.com/praetorian-inc/titus/blob/main/NOTICE) pour l'attribution complète.

Lire plus

titus v1.2.8

Catégories