Titus: Scanner di Segreti ad Alte Prestazioni

Titus è uno scanner di segreti ad alte prestazioni che rileva credenziali, chiavi API e token in codice sorgente, file e cronologia Git. È dotato di 487 regole di rilevamento che coprono centinaia di servizi e tipi di credenziali, tratte da NoseyParker e Kingfisher. Titus funziona come CLI, libreria Go, estensione Burp Suite ed estensione per browser Chrome, tutti con lo stesso motore di rilevamento e lo stesso set di regole.

Progettato per ingegneri della sicurezza, penetration tester e team DevSecOps, Titus combina il matching di espressioni regolari accelerato da Hyperscan/Vectorscan con la convalida live delle credenziali per trovare e verificare segreti compromessi in tutto il tuo codebase.

Indice

• Perché Titus?
• Installazione
• Avvio Rapido
• Opzioni di Scansione
• Punteggio dei Risultati
• Libreria Go
• Estensione Burp Suite
• Estensione per Browser
• Compilazione da Sorgente
• Contribuire
• Licenza

Perché Titus?

• Scansione veloce dei segreti: Matching di espressioni regolari accelerato da Hyperscan/Vectorscan quando disponibile, con un fallback puramente Go per la portabilità su qualsiasi piattaforma.
• Ampia copertura di rilevamento delle credenziali: 487 regole rilevano chiavi API, token e credenziali per AWS, GCP, Azure, GitHub, Slack, database, sistemi CI/CD e centinaia di altri servizi.
• Convalida live dei segreti: I segreti rilevati vengono verificati tramite le API dei rispettivi servizi per confermare se sono attivi, riducendo i falsi positivi e prioritizzando la mitigazione.
• Punteggio di gravità basato sul rischio: Ogni risultato riceve un punteggio numerico (0–100) e un livello di gravità (info → critico). I punteggi sono calibrati in base ai metadati statici delle regole, al contesto di accessibilità del codice e alle chiamate API live che misurano il reale raggio d'azione di una credenziale, in modo che i risultati più pericolosi emergano sempre per primi.
• Scansione di immagini container: Scansiona immagini Docker e OCI direttamente da qualsiasi registro, tarball o directory di layout OCI, senza necessità di demone Docker o binari aggiuntivi.
• Multipli interfacce per ogni flusso di lavoro: Scansiona da CLI, integra come libreria Go, scansiona passivamente il traffico HTTP in Burp Suite o scansiona pagine web in Chrome durante i test di sicurezza delle applicazioni.
• Estrazione da file binari: Estrae e scansiona segreti da documenti Office, PDF, archivi (zip, tar, 7z), app mobili (APK, IPA), estensioni browser e altro ancora.

Installazione

Scarica un binario precompilato dalla pagina Release o compila dal sorgente:```bash make build

Il binario sarà in `dist/titus`.

## Avvio Rapido```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

I risultati vengono scritti in un datastore (titus.ds di default) e stampati nella console.

Opzioni di Scansione

Scansione GitHub & GitLab

Scansiona repository pubblici direttamente tramite URL — non è richiesto alcun token API:```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

Per la scansione a livello di organizzazione o di utente, utilizza i sottocomandi dedicati:```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

I token sono opzionali per i repository pubblici. Imposta GITHUB_TOKEN o GITLAB_TOKEN (o usa --token) per l'accesso a repository privati e limiti di velocità API più elevati.

Scansione di immagini Docker / OCI

Scansiona le immagini dei container direttamente — nessun demone docker, nessun binario docker richiesto. Titus estrae le immagini direttamente da qualsiasi registro OCI su HTTPS (usando le credenziali da ~/.docker/config.json), o legge immagini da un tarball locale docker save o da una directory di layout di immagini OCI. Quindi scansiona i metadati del manifest/config dell'immagine e ogni file regolare in ogni layer, inclusi i file dei layer inferiori eliminati da layer successivi (poiché i segreti possono rimanere recuperabili dalla cronologia dell'immagine).```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'autenticazione utilizza la tua configurazione Docker / Podman esistente (`~/.docker/config.json`, `${XDG_RUNTIME_DIR}/containers/auth.json`). I registri privati che richiedono un nuovo accesso devono prima essere autenticati con `docker login` (o `podman login`, o `crane auth login`) — titus non richiede credenziali.

### Visualizzazione dei risultati della scansione

Usa `report` per rileggere i risultati di una scansione precedente:```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

Puoi anche controllare il formato di output al momento della scansione con --format:```bash titus scan path/to/code --format json

### Validazione dei segreti rilevati

Passa `--validate` durante una scansione per verificare i segreti rilevati rispetto alle loro API di origine:```bash
titus scan path/to/code --validate

La validazione viene eseguita contemporaneamente (4 worker predefiniti, configurabili con --validate-workers) e contrassegna ogni risultato come confermato, negato o sconosciuto.

Filtraggio delle Regole di Rilevamento```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

### Estrazione di segreti da file binari

Titus può estrarre testo da formati di file binari e scansionare il contenuto alla ricerca di segreti:```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

I formati supportati includono documenti Office (xlsx, docx, pptx, odp, ods, odt), PDF, notebook Jupyter, database SQLite, email (eml, rtf) e archivi (zip, tar, tar.gz, jar, war, ear, apk, ipa, crx, xpi, 7z). Gli archivi vengono estratti ricorsivamente fino a limiti di profondità e dimensione configurabili.```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

Per i database SQLite, Titus estrae il testo da tutte le tabelle (1000 righe per tabella per impostazione predefinita). Usa `--sqlite-row-limit` per regolare:```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

Punteggio delle scoperte

Ogni scoperta prodotta da Titus porta un punteggio numerico da 0 a 100 e un livello di gravità:

I punteggi partono dal base_score della regola e vengono regolati da modificatori — condizioni che aumentano o diminuiscono il punteggio in base a ciò che si sa sulla credenziale:```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 include valutatori YAML per credenziali AWS, PAT GitHub e token Slack, oltre a valutatori SDK basati su Go che eseguono enumerazione live delle policy IAM (AWS) e controlli dei permessi dei repository (PAT GitHub granulari) quando `--score-scope` è abilitato.

Vedi [docs/scoring.md](https://github.com/praetorian-inc/titus/blob/HEAD/docs/scoring.md) per il riferimento completo: livelli di gravità, tipi di modificatori, dettagli dei valutatori integrati e come scrivere i tuoi valutatori YAML o Go.

## Libreria Go per il Rilevamento di Segreti

Titus può essere importato come libreria Go per aggiungere il rilevamento di segreti ai tuoi strumenti e pipeline.```bash
go get github.com/praetorian-inc/titus

Una guida completa all'implementazione delle pratiche di Azure DevSecOps. Copre l'integrazione di strumenti di sicurezza come trivy e checkov, la configurazione di pipeline sicure, la gestione dei segreti e l'applicazione della conformità.

Una guida dettagliata su Azure DevSecOps

Leggi l'articolo completo su Medium o Dev.to```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 libreria supporta anche la scansione di byte e file, la validazione dei segreti rilevati e il caricamento di regole personalizzate:```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))

Vedi docs/library-usage.md per il riferimento API completo, i pattern di concorrenza e ulteriori esempi.

Estensione Burp Suite per la Scansione di Segreti

L'estensione Burp esegue la scansione delle risposte HTTP alla ricerca di segreti durante il traffico proxy e i test di penetrazione attivi.

Configurazione

Linux / macOS (Compilazione dal Sorgente)```bash

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

make install-burp

Quindi carica `dist/titus-burp-1.0.0-all.jar` in Burp Suite sotto Estensioni > Aggiungi.

#### Windows (Scarica da Rilasci)

1. Scarica `titus-windows-amd64.exe` e `titus-burp-<version>.jar` da [Rilasci](https://raw.githubusercontent.com/praetorian-inc/releases)
2. Crea la directory di Titus e installa il binario:   ```powershell
   mkdir %USERPROFILE%\.titus
   copy titus-windows-amd64.exe %USERPROFILE%\.titus\titus.exe

3. Carica il JAR in Burp Suite sotto Estensioni > Aggiungi

Linux / macOS (Scarica dalle Release)

1. Scarica il binario appropriato per la tua piattaforma e titus-burp-<version>.jar dalle Release:
   • titus-linux-amd64 o titus-linux-arm64 per Linux
   • titus-darwin-amd64 o titus-darwin-arm64 per macOS
2. Installa il binario: ```bash mkdir -p ~/.titus cp titus- ~/.titus/titus chmod +x ~/.titus/titus
   root@kitploit:~

3. Carica il JAR in Burp Suite tramite Estensioni > Aggiungi

L'estensione avvia un processo titus serve in background e comunica tramite stdin/stdout utilizzando NDJSON. Le regole di rilevamento vengono caricate una volta all'avvio.

Funzionalità dell'estensione Burp

• Scansione passiva dei segreti: analizza automaticamente il traffico proxy mentre fluisce attraverso Burp
• Scansione attiva dei segreti: menu contestuale con clic destro per scansionare le richieste selezionate
• Deduplicazione: lo stesso segreto viene segnalato una sola volta per incarico
• Filtro rapido: contenuti binari, immagini e risposte non testuali vengono saltati
• Validazione live delle credenziali: controlla i segreti rilevati rispetto alle API di origine per confermare se sono attivi
• Gestione dei falsi positivi: contrassegna i risultati come falsi positivi per filtrare il rumore
• Classificazione della gravità: risultati con codice colore in base al rischio (Alto/Medio/Basso)
• Esportazione: salva i risultati in JSON per reportistica

Interfaccia dell'estensione Burp

L'estensione aggiunge una scheda Titus a Burp con tre sottoschede:

Segreti: tutti i segreti rilevati con filtraggio per tipo, host e stato di validazione.

Scheda segreti dell

• Stato di validazione: mostra se i segreti sono stati controllati (Attivo/Inattivo/Sconosciuto)
• Filtraggio: clicca sui pulsanti Tipo, Host o Stato per filtrare per valori specifici; usa la casella di ricerca per corrispondenze testuali e regex
• Azioni in blocco: seleziona più righe per validare o contrassegnare come falso positivo in batch
• Pannello Dettagli segreto: seleziona un risultato per visualizzare:
  • Dettagli: informazioni sulla regola, categoria, valore completo del segreto, timestamp della prima visione
  • URL: tutte le posizioni in cui è stato trovato questo segreto
  • Validazione: risultato della validazione con dettagli (es. ID account AWS, ARN)
  • Richiesta/Risposta: traffico HTTP completo con il segreto evidenziato

Statistiche: vista aggregata dei segreti raggruppati per tipo e host.

• Riepilogo: totale segreti unici, host scansionati, ripartizione della validazione (attivi vs inattivi) e conteggio falsi positivi
• Segreti per Tipo: conteggio di ciascun tipo di segreto con classificazione per categoria
• Segreti per Host: numero di segreti trovati per host

Impostazioni: configura le opzioni di scansione, validazione e mapping della gravità.

Scheda impostazioni dell

• Impostazioni di scansione:
  • Scansione passiva: scansiona automaticamente tutto il traffico proxy (abilitato per impostazione predefinita)
  • Scansione corpo richiesta: scansiona anche i corpi delle richieste per i segreti inviati dall'applicazione
  • Validazione: abilita per controllare i segreti rispetto alle API di origine (effettua richieste in uscita e potrebbe attivare avvisi)
• Parametri di scansione: thread di lavoro, dimensione massima file, lunghezza snippet contestuale
• Configurazione gravità: personalizza i livelli di gravità per categoria di segreto
• Azioni: cancella cache, reimposta impostazioni, salva/esporta risultati in JSON

Quando si visualizza una richiesta in Burp, una scheda Titus appare nell'ispezione della risposta se vengono rilevati segreti, fornendo accesso rapido ai risultati senza passare alla scheda principale Titus.

Scheda Titus nell

Estensione del browser Chrome per la scansione dei segreti

L'estensione Chrome scansiona le pagine web alla ricerca di segreti durante le valutazioni di sicurezza delle applicazioni web.

Configurazione```bash

make build-extension

1. Vai su `chrome://extensions/`
2. Abilita la **Modalità sviluppatore**
3. Fai clic su **Carica decompresso** e seleziona la directory `extension/`

### Funzionalità dell'estensione del browser

- Analizza JavaScript e fogli di stile inline ed esterni alla ricerca di chiavi API e token
- Analizza localStorage e sessionStorage alla ricerca di credenziali trapelate
- Acquisizione opzionale delle risposte di rete per una rilevazione completa dei segreti
- Risultati visualizzati nel popup e nella dashboard

<img width="1719" height="958" alt="Popup dell'estensione Titus Chrome che mostra i segreti rilevati su una pagina web" src="https://assets.kitploit.com/production/public/readmes/11969/057a24e2746412ceabe1aac0292a2de463de1efee5bca2489ca34b59d8b0dc2c.png" />

<img width="1744" height="827" alt="Dashboard dell'estensione Titus Chrome con risultati aggregati di rilevazione dei segreti" src="https://assets.kitploit.com/production/public/readmes/11969/265d972fadcc7f212944d7a1d8fd58a43446e7199d1209900e83b96a546ffb00.png" />

### Avviso di sicurezza

L'estensione del browser rimuove le intestazioni Content Security Policy e CORS dalle pagine visitate per analizzare le risorse esterne. Ciò indebolisce la postura di sicurezza dei siti che visiti mentre l'estensione è attiva. **Abilitala solo durante test di sicurezza attivi.**

## Compilazione dal sorgente

### Build standard (accelerato con Vectorscan)

Per impostazione predefinita, Titus viene compilato con [Vectorscan](https://github.com/VectorCamp/vectorscan) (ARM) / [Hyperscan](https://github.com/intel/hyperscan) (x86) per il matching regex accelerato via SIMD. Questo richiede CGO, la libreria C e `pkg-config` (che cgo utilizza per individuare la libreria). `make build` verifica la loro presenza e tenta di installare eventuali componenti mancanti tramite 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

Vedrai [vectorscan] N/N rules compiled for Hyperscan all'avvio quando il motore accelerato è attivo.

Per installare la libreria C da solo invece di affidarti all'installazione automatica:```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

Se invochi `go build` direttamente (ad esempio, quando incorpori Titus), passa il tag e abilita 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 Pure-Go (nessuna dipendenza C)

Se non puoi installare la libreria C — o desideri un binario completamente portatile e statico — compila invece il motore in puro Go. Titus passa automaticamente a esso in runtime ogni volta che vectorscan non è compilato:```bash

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

make build-pure

Fully static binary

make build-static

## Contributing

I contributi sono benvenuti! Vedi [CONTRIBUTING.md](https://github.com/praetorian-inc/titus/blob/HEAD/CONTRIBUTING.md) per le linee guida su come contribuire a Titus.

## License

Licenza Apache 2.0 — vedi [LICENSE](https://github.com/praetorian-inc/titus/blob/HEAD/LICENSE).

Le regole di rilevamento sono derivate da [NoseyParker](https://github.com/praetorian-inc/noseyparker) (Praetorian Security, Inc.) e [Kingfisher](https://github.com/mongodb/kingfisher) (MongoDB, Inc.), entrambe concesse in licenza sotto Apache 2.0. Vedi [NOTICE](https://github.com/praetorian-inc/titus/blob/HEAD/NOTICE) per l'attribuzione completa.