titus — Scanner di segreti ad alte prestazioni. CLI, libreria Go, estensione Burp Suite ed estensione Chrome. 487 regole di rilevamento con validazione delle credenziali in tempo reale. | Kitploit

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

Per la scansione a livello di organizzazione o di utente, utilizzare 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

L'autenticazione utilizza la tua configurazione Docker / Podman esistente (`~/.docker/config.json`, `${XDG_RUNTIME_DIR}/containers/auth.json`). I registry privati che richiedono un nuovo login devono prima essere autenticati con `docker login` (o `podman login`, o `crane auth login`) — titus non richiede le 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

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

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

Per i database SQLite, Titus estrae il testo da tutte le tabelle (1000 righe per tabella per impostazione predefinita). Usa `--sqlite-row-limit` per modificare:```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 include scorer YAML per le credenziali AWS, i PAT di GitHub e i token Slack, oltre a scorer SDK basati su Go che eseguono l'enumerazione live delle policy IAM (AWS) e i controlli dei permessi dei repository (PAT fine-grained di GitHub) quando `--score-scope` è abilitato.

Consulta [docs/scoring.md](https://github.com/praetorian-inc/titus/blob/main/docs/scoring.md) per il riferimento completo: livelli di severità, tipi di modificatori, dettagli sugli scorer integrati e come scrivere i tuoi scorer YAML o Go.

## Libreria Go per il rilevamento dei segreti

Titus può essere importato come libreria Go per aggiungere il rilevamento dei segreti ai tuoi strumenti e pipeline.```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 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))

Poi carica `dist/titus-burp-1.0.0-all.jar` in Burp Suite sotto Extensions > Add.

#### Windows (Download from Releases)

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

Scarica il binario appropriato per la tua piattaforma e titus-burp-<version>.jar da Releases:
- titus-linux-amd64 o titus-linux-arm64 per Linux
- titus-darwin-amd64 o titus-darwin-arm64 per macOS
Installa il binario: ```bash mkdir -p ~/.titus cp titus- ~/.titus/titus chmod +x ~/.titus/titus
Carica il JAR in Burp Suite sotto Extensions > Add

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

### Funzionalità dell'estensione per 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 Chrome di Titus 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 Chrome di Titus con i risultati aggregati della rilevazione dei segreti" src="https://assets.kitploit.com/production/public/readmes/11969/265d972fadcc7f212944d7a1d8fd58a43446e7199d1209900e83b96a546ffb00.png" />

### Avviso di sicurezza

L'estensione per browser rimuove l'Content Security Policy e gli header 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 (accelerata 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 con SIMD. Ciò richiede CGO, la libreria C e `pkg-config` (che cgo utilizza per individuare la libreria). `make build` verifica la presenza di questi elementi e tenta di installare ciò che manca 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

Se si invoca `go build` direttamente (ad esempio, quando si incorpora Titus), passare il tag e abilitare 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 automatica del database Hyperscan

Titus serializza automaticamente ogni database Hyperscan compilato con successo
nella cache utente standard. Le istanze successive dello scanner con le stesse
regole ordinate e gli stessi flag caricano quel database invece di compilarlo di nuovo. Il file di cache
è il flusso di byte non modificato prodotto da `hs_serialize_database` di Hyperscan,
e Titus lo carica con `hs_deserialize_database`.

`TITUS_CACHE_DIR` può sovrascrivere la posizione della cache. Le scritture nella cache sono atomiche e
best-effort: una cache non disponibile o di sola lettura non impedisce la scansione. Un database
mancante, corrotto, incompatibile o con fingerprint diverso attiva la
compilazione normale e aggiorna la cache quando possibile.

I database serializzati sono specifici per architettura, funzionalità della CPU e versione di
Hyperscan. Titus rileva le voci incompatibili durante la deserializzazione e le sostituisce
con un database compilato per il runtime corrente.

## Contributing

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

## License

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

Le regole di rilevamento derivano da [NoseyParker](https://github.com/praetorian-inc/noseyparker) (Praetorian Security, Inc.) e [Kingfisher](https://github.com/mongodb/kingfisher) (MongoDB, Inc.), entrambi con licenza Apache 2.0. Vedi [NOTICE](https://github.com/praetorian-inc/titus/blob/main/NOTICE) per l'attribuzione completa.

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

titus

Più Popolari

Titus: Scanner di Segreti ad Alte Prestazioni

Indice

Perché Titus?

Installazione

Opzioni di scansione

Scansione di GitHub e GitLab

Scan a GitHub repository

Scan a GitLab project

Full URLs work too

Scansione di immagini 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

Regole di rilevamento del filtraggio```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

Assegnazione del punteggio ai finding

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)

Estensione Burp Suite per la scansione dei segreti

Configurazione

Linux / macOS (compilazione dal sorgente)```bash

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

Linux / macOS (Scarica dalle Releases)

Funzionalità dell'estensione Burp

Interfaccia dell'estensione Burp

Estensione per browser Chrome per la scansione dei segreti

Setup```bash

macOS (Homebrew)

Ubuntu/Debian

Fedora/RHEL

Or build vectorscan from source:

Build Pure-Go (senza dipendenze C)

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

Fully static binary