Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
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
Outils/GitHubGitHub/praetorian-inc/titus
Analyse StatiqueScanners de VulnérabilitésSécurité des ConteneursProxies Web et InterceptionAnalyse de CodeTests d'IntrusionDevSecOpsDétection de SecretsSécurité de la Chaîne Logistique
GitHubpraetorian-inc/titus

titus

6677588il y a 2 joursVérifié par Kitploit

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.

Voir le dépôtSite web
Partager
<img width="1200" height="628" alt="Titus - scanner de secrets haute performance pour le code source, l'historique git et les fichiers binaires" src="https://assets.kitploit.com/production/public/readmes/11969/d2f6b99d686a073185db1b7299fa5f033067b057000062cf592a4ae15a796034.png" />

# Titus : scanner de secrets haute performance

[![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** 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 de types d'identifiants, issues de [NoseyParker](https://github.com/praetorian-inc/noseyparker) et [Kingfisher](https://github.com/mongodb/kingfisher). Titus s'exécute en tant que CLI, bibliothèque Go, extension Burp Suite et extension de navigateur Chrome — toutes 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 d'expressions régulières accélérée par [Hyperscan](https://github.com/intel/hyperscan)/[Vectorscan](https://github.com/VectorCamp/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.

## Table des matières

- [Pourquoi Titus ?](#why-titus)
- [Installation](#installation)
- [Démarrage rapide](#quick-start)
- [Options de scan](#scanning-options)
- [Notation des résultats](#finding-scoring)
- [Bibliothèque Go](#go-library-for-secrets-detection)
- [Extension Burp Suite](#burp-suite-extension-for-secret-scanning)
- [Extension de navigateur](#chrome-browser-extension-for-secret-scanning)
- [Compilation depuis les sources](#building-from-source)
- [Contribution](#contributing)
- [Licence](#license)

## Pourquoi Titus ?

- **Scan de secrets rapide** : correspondance d'expressions régulières accélérée par [Hyperscan](https://github.com/intel/hyperscan)/[Vectorscan](https://github.com/VectorCamp/vectorscan) lorsqu'ils sont disponibles, avec une implémentation de repli en Go pur pour la portabilité sur toute 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 des secrets en direct** : les secrets détectés sont vérifiés auprès de leurs API d'origine afin de confirmer s'ils sont actifs, ce qui réduit les faux positifs et permet de prioriser 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 selon les métadonnées statiques des règles, le contexte d'accessibilité du code et des appels d'API en direct qui mesurent le rayon d'impact réel d'un identifiant — afin que 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.
- **Plusieurs interfaces 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 des 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](../../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.

### Sous-commandes

<!-- BEGIN generated: cli-subcommands -->
Titus organise ses fonctionnalités en ces sous-commandes ciblées :

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

Chaque sous-commande accepte `--help` pour ses propres options. Les formes de premier niveau `titus <provider>` qui précèdent `titus enum <provider>` fonctionnent toujours, mais elles sont masquées et obsolètes plutôt que des alias, elles sont donc répertoriées dans la référence générée plutôt qu'ici.

<!-- BEGIN generated: cli-aliases -->
La référence complète — chaque sous-commande, alias et option, y compris ceux masqués de `--help` — est générée dans [docs/CLI.md](https://github.com/praetorian-inc/titus/blob/main/docs/CLI.md).
<!-- END generated: cli-aliases -->

## Options de scan

### Scan GitHub & GitLab

Scannez directement des 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 scan owner/repo --git
```

Les jetons sont facultatifs pour les dépôts publics. Définissez `GITHUB_TOKEN` ou `GITLAB_TOKEN` (ou utilisez `--token`) pour accéder aux dépôts privés et bénéficier de 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 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 depuis une archive `docker save` locale ou un répertoire de disposition d'image OCI. Il analyse ensuite les métadonnées du manifeste et de la configuration de l'image ainsi que chaque fichier régulier de 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 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 de scan

Utilisez `report` pour relire les résultats d'un scan précédent :

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

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

Les validations s'exécutent en parallèle (4 workers par défaut, configurables avec `--validate-workers`) et marquent 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
```

Les règles marquées `visible: false` sont des assistants qui capturent le contexte pour d'autres règles, comme un ID client, un nom de compte ou un hôte, plutôt qu'un secret. Leurs motifs s'exécutent toujours, mais leurs correspondances ne sont jamais signalées, ni par la CLI ni par la bibliothèque Go, même lorsque la règle est sélectionnée explicitement.

### 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 résultats

Chaque résultat 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 justificatif d'accès :

```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 fourni 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 autorisations de dépôt (PAT à granularité fine GitHub) 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
```

```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,
        )
    }
}
```

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

Consultez [docs/library-usage.md](https://github.com/praetorian-inc/titus/blob/main/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 le scan de 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
   ```
3. Chargez le JAR dans Burp Suite sous Extensions > Add

#### Linux / macOS (Télécharger depuis Releases)

1. Téléchargez le binaire approprié pour votre plateforme et `titus-burp-<version>.jar` depuis [Releases](../../releases) :
   - `titus-linux-amd64` ou `titus-linux-arm64` pour Linux
   - `titus-darwin-amd64` ou `titus-darwin-arm64` pour macOS
2. Installez le binaire :
   ```bash
   mkdir -p ~/.titus
   cp titus-<platform> ~/.titus/titus
   chmod +x ~/.titus/titus
   ```
3. 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** : un 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 par 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 regroupés par type et par hôte.

<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** : 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 correspondances de gravité.

Titus Burp Suite extension settings tab with scan configuration options

- **Scan Settings** :
    - *Analyse passive* : analyse automatiquement tout le trafic proxy (activée 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 de 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 d'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 fenêtre contextuelle et le tableau de bord

<img width="1719" height="958" alt="Fenêtre contextuelle 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
```

### Build 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 dessus à l'exécution chaque fois que vectorscan n'est pas compilé :

```bash
# Portable pure-Go binary (no CGO, no vectorscan)
make build-pure

# Fully static binary
make build-static
```

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

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.

## Contribution

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 de [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.
Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    927
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    555
  • 3

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    360
  • 4

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    357
  • 5

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    324
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    289

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →