titus — Scanner 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. | Kitploit

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

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

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

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

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

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

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

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

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

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

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

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

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

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

titus

Populaires

Titus : Scanner de secrets haute performance

Table des matières

Pourquoi Titus ?

Installation

Options de scan

Scan GitHub & GitLab

Scan a GitHub repository

Scan a GitLab project

Full URLs work too

Analyse d'images Docker / OCI

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

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

Notation des 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)

Extension Burp Suite pour l'analyse des secrets

Configuration

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

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

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

Fonctionnalités de l'extension Burp

Interface de l'extension Burp

Extension de navigateur Chrome pour l'analyse des secrets

Configuration```bash

macOS (Homebrew)

Ubuntu/Debian

Fedora/RHEL

Or build vectorscan from source:

Compilation en Go pur (sans dépendances C)

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

Fully static binary