praetorian-inc/titusEscáner de secretos de alto rendimiento. CLI, biblioteca Go, extensión de Burp Suite y extensión de Chrome. 487 reglas de detección con validación de credenciales en vivo.
Titus es un escáner de secretos de alto rendimiento que detecta credenciales, claves de API y tokens en código fuente, archivos e historial de git. Incluye 487 reglas de detección que cubren cientos de servicios y tipos de credenciales, extraídas de NoseyParker y Kingfisher. Titus se ejecuta como CLI, como biblioteca Go, como extensión de Burp Suite y como extensión del navegador Chrome, todos compartiendo el mismo motor de detección y conjunto de reglas.
Construido para ingenieros de seguridad, probadores de penetración y equipos DevSecOps, Titus combina la coincidencia de expresiones regulares acelerada por Hyperscan/Vectorscan con validación de credenciales en vivo para encontrar y verificar secretos filtrados en toda tu base de código.
Descarga un binario precompilado desde la página de Lanzamientos, o compílalo desde la fuente:```bash make build
El binario estará en `dist/titus`.
## Inicio Rápido```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
Los resultados se escriben en un almacén de datos (titus.ds por defecto) y se imprimen en la consola.
Escanea repositorios públicos directamente por URL — no se requiere token de API:```bash
titus scan github.com/kubernetes/kubernetes
titus scan gitlab.com/gitlab-org/cli
titus scan https://github.com/org/repo titus scan https://gitlab.com/namespace/project.git
Para escaneos a nivel de organización o de usuario, utiliza los subcomandos dedicados:```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
Los tokens son opcionales para repositorios públicos. Configure GITHUB_TOKEN o GITLAB_TOKEN (o use --token) para acceder a repositorios privados y obtener límites de API más altos.
Escanee imágenes de contenedores directamente — no se requiere demonio docker, ni el binario docker. Titus obtiene imágenes directamente de cualquier registro OCI a través de HTTPS (usando credenciales de ~/.docker/config.json), o lee imágenes de un tarball local de docker save o de un directorio de diseño de imagen OCI. Luego escanea los metadatos del manifiesto/configuración de la imagen y cada archivo regular en cada capa, incluyendo archivos de capas inferiores eliminados por capas posteriores (ya que los secretos pueden permanecer recuperables del historial de la imagen).```bash
titus scan --docker alpine:latest titus scan docker://ghcr.io/owner/repo:tag
titus scan --docker ./my-app.tar
titus scan --docker ./img/
La autenticación utiliza su configuración existente de Docker / Podman (`~/.docker/config.json`, `${XDG_RUNTIME_DIR}/containers/auth.json`). Los registros privados que requieren un inicio de sesión nuevo deben autenticarse primero con `docker login` (o `podman login`, o `crane auth login`) — titus no solicita credenciales.
### Visualización de resultados de escaneo
Use `report` para volver a leer los hallazgos de un escaneo anterior:```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
También puedes controlar el formato de salida en el momento del escaneo con --format:```bash
titus scan path/to/code --format json
### Validando secretos detectados
Pase `--validate` durante un escaneo para verificar los secretos detectados contra sus APIs de origen:```bash
titus scan path/to/code --validate
La validación se ejecuta de forma concurrente (4 trabajadores por defecto, configurable con --validate-workers) y marca cada hallazgo como confirmado, denegado o desconocido.
titus rules list
titus scan path/to/code --rules-include "aws,gcp"
titus scan path/to/code --rules-exclude "kingfisher.generic"
titus scan path/to/code --rules path/to/custom-rules.yaml
titus scan path/to/code --include-noisy
### Extrayendo Secretos de Archivos Binarios
Titus puede extraer texto de formatos de archivos binarios y escanear el contenido en busca de secretos:```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
Los formatos compatibles incluyen documentos de Office (xlsx, docx, pptx, odp, ods, odt), PDFs, cuadernos de Jupyter, bases de datos SQLite, correo electrónico (eml, rtf) y archivos (zip, tar, tar.gz, jar, war, ear, apk, ipa, crx, xpi, 7z). Los archivos se extraen de forma recursiva hasta límites de profundidad y tamaño configurables.```bash
titus scan path/to/files --extract=all
--extract-max-size 10MB
--extract-max-total 100MB
--extract-max-depth 5
Para bases de datos SQLite, Titus extrae texto de todas las tablas (1000 filas por tabla por defecto). Usa `--sqlite-row-limit` para ajustar:```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
Cada hallazgo que produce Titus lleva una puntuación numérica de 0–100 y un nivel de severidad:
| Puntuación | Severidad |
|---|---|
| 0–20 | informativo |
| 21–40 | bajo |
| 41–60 | medio |
| 61–80 | alto |
| 81–100 | crítico |
Las puntuaciones parten del base_score de la regla y se ajustan mediante modificadores — condiciones que aumentan o reducen la puntuación según lo que se conoce sobre la credencial:```bash
titus scan path/to/code
titus scan path/to/code --score-scope
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 incluye scorers YAML para credenciales de AWS, PAT de GitHub y tokens de Slack, además de scorers SDK basados en Go que realizan enumeración de políticas IAM en vivo (AWS) y verificaciones de permisos de repositorio (PAT detallados de GitHub) cuando `--score-scope` está habilitado.
Consulte [docs/scoring.md](https://github.com/praetorian-inc/titus/blob/HEAD/docs/scoring.md) para obtener la referencia completa: niveles de gravedad, tipos de modificadores, detalles sobre los scorers incorporados y cómo escribir sus propios scorers YAML o Go.
## Biblioteca Go para Detección de Secretos```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 = 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 biblioteca también admite escanear bytes y archivos, validar secretos detectados y cargar reglas personalizadas:```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))
Vea docs/library-usage.md para obtener la referencia completa de la API, patrones de concurrencia y más ejemplos.
La extensión de Burp escanea las respuestas HTTP en busca de secretos durante el tráfico de proxy y las pruebas de penetración activas.
make install-burp
Then load `dist/titus-burp-1.0.0-all.jar` in Burp Suite under Extensions > Add.
#### Windows (Descargar desde Releases)
1. Descargue `titus-windows-amd64.exe` y `titus-burp-<version>.jar` desde [Releases](https://raw.githubusercontent.com/praetorian-inc/releases)
2. Cree el directorio de Titus e instale el binario: ```powershell
mkdir %USERPROFILE%\.titus
copy titus-windows-amd64.exe %USERPROFILE%\.titus\titus.exe
titus-burp-<version>.jar desde Releases:
titus-linux-amd64 o titus-linux-arm64 para Linuxtitus-darwin-amd64 o titus-darwin-arm64 para macOSLa extensión inicia un proceso titus serve en segundo plano y se comunica a través de stdin/stdout usando NDJSON. Las reglas de detección se cargan una vez al inicio.
La extensión agrega una pestaña Titus a Burp con tres sub-pestañas:
Secretos: Todos los secretos detectados con filtrado por tipo, host y estado de validación.
Pestaña de secretos de la extensión Titus para Burp Suite que muestra claves API y credenciales detectadas con estado de validación
Estadísticas: Vista agregada de secretos agrupados por tipo y host.
Configuración: Configura opciones de escaneo, validación y asignaciones de gravedad.
Pestaña de configuración de la extensión Titus para Burp Suite con opciones de configuración de escaneo
Al ver cualquier solicitud en Burp, aparece una pestaña Titus en el inspector de respuestas si se detectan secretos, proporcionando acceso rápido a los hallazgos sin cambiar a la pestaña principal de Titus.
Pestaña Titus en el inspector de respuestas de Burp Suite resaltando secretos detectados en respuestas HTTP
La extensión de Chrome escanea páginas web en busca de secretos durante las evaluaciones de seguridad de aplicaciones web.
make build-extension
1. Navega a `chrome://extensions/`
2. Habilita el **modo de desarrollador**
3. Haz clic en **Cargar descomprimido** y selecciona el directorio `extension/`
### Funciones de la extensión del navegador
- Escanea JavaScript y hojas de estilo en línea y externos en busca de claves API y tokens
- Escanea localStorage y sessionStorage en busca de credenciales filtradas
- Captura opcional de respuestas de red para detección completa de secretos
- Resultados mostrados en ventana emergente y panel de control
<img width="1719" height="958" alt="Ventana emergente de la extensión Titus de Chrome mostrando secretos detectados en una página web" src="https://assets.kitploit.com/production/public/readmes/11969/057a24e2746412ceabe1aac0292a2de463de1efee5bca2489ca34b59d8b0dc2c.png" />
<img width="1744" height="827" alt="Panel de control de la extensión Titus de Chrome con resultados agregados de detección de secretos" src="https://assets.kitploit.com/production/public/readmes/11969/265d972fadcc7f212944d7a1d8fd58a43446e7199d1209900e83b96a546ffb00.png" />
### Aviso de seguridad
La extensión del navegador elimina las cabeceras de Política de Seguridad de Contenido (CSP) y CORS de las páginas visitadas para escanear recursos externos. Esto debilita la postura de seguridad de los sitios que visitas mientras la extensión está activa. **Solo actívala durante pruebas de seguridad activas.**
## Compilación desde el código fuente
### Compilación estándar (acelerada por Vectorscan)
Por defecto, Titus compila con [Vectorscan](https://github.com/VectorCamp/vectorscan) (ARM) / [Hyperscan](https://github.com/intel/hyperscan) (x86) para coincidencia de expresiones regulares acelerada por SIMD. Esto requiere CGO, la biblioteca C y `pkg-config` (que cgo usa para localizar la biblioteca). `make build` verifica estos requisitos e intenta instalar cualquier componente faltante mediante 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
Verás [vectorscan] N/N rules compiled for Hyperscan al inicio cuando el motor acelerado esté activo.
Para instalar tú mismo la biblioteca C en lugar de confiar en la autoinstalación:```bash
brew install pkg-config vectorscan
sudo apt-get install pkg-config libhyperscan-dev
sudo dnf install pkgconf-pkg-config vectorscan-devel
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 invocas `go build` directamente (por ejemplo, al incrustar Titus), pasa la etiqueta y habilita 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
Si no puedes instalar la biblioteca C — o quieres un binario estático y completamente portátil — compila el motor puramente en Go en su lugar. Titus recurre automáticamente a él en tiempo de ejecución siempre que vectorscan no esté compilado:```bash
make build-pure
make build-static
## Contribuciones
¡Las contribuciones son bienvenidas! Consulta [CONTRIBUTING.md](https://github.com/praetorian-inc/titus/blob/HEAD/CONTRIBUTING.md) para obtener pautas sobre cómo contribuir a Titus.
## Licencia
Licencia Apache 2.0 — consulta [LICENSE](https://github.com/praetorian-inc/titus/blob/HEAD/LICENSE).
Las reglas de detección se derivan de [NoseyParker](https://github.com/praetorian-inc/noseyparker) (Praetorian Security, Inc.) y [Kingfisher](https://github.com/mongodb/kingfisher) (MongoDB, Inc.), ambas bajo la licencia Apache 2.0. Consulta [NOTICE](https://github.com/praetorian-inc/titus/blob/HEAD/NOTICE) para la atribución completa.