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 funciona como CLI, biblioteca de Go, extensión de Burp Suite y extensión de navegador Chrome — todas comparten el mismo motor de detección y conjunto de reglas.
Diseñado para ingenieros de seguridad, pentesters y equipos de 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 todo tu código base.
Descarga un binario precompilado desde la página de Releases, o compila desde el código 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, utilice 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 tasa de API más altos.
Escanee imágenes de contenedores directamente — sin daemon de docker, sin necesidad del binario docker. Titus extrae imágenes directamente de cualquier registro OCI a través de HTTPS (usando credenciales de ~/.docker/config.json), o lee imágenes desde un tarball local de docker save o 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, incluidos los archivos de capas inferiores eliminados por capas posteriores (ya que los secretos pueden permanecer recuperables desde el 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 tu configuración existente de Docker / Podman (`~/.docker/config.json`, `${XDG_RUNTIME_DIR}/containers/auth.json`). Los registros privados que necesiten 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 los resultados del escaneo
Usa `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
### Validación de secretos detectados
Pase `--validate` durante un escaneo para verificar los secretos detectados contra sus API de origen:```bash
titus scan path/to/code --validate
La validación se ejecuta de forma concurrente (4 workers 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
### Extracción de 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 comprimidos (zip, tar, tar.gz, jar, war, ear, apk, ipa, crx, xpi, 7z). Los archivos comprimidos se extraen de forma recursiva hasta límites configurables de profundidad y tamaño.```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). Utilice `--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 a 100 y un nivel de severidad:
| Puntuación | Severidad |
|---|---|
| 0–20 | info |
| 21–40 | low |
| 41–60 | medium |
| 61–80 | high |
| 81–100 | critical |
Las puntuaciones comienzan desde el base_score de la regla y se ajustan mediante modificadores — condiciones que aumentan o disminuyen la puntuación según lo que se sabe 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, PATs 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 (PATs de grano fino de GitHub) cuando `--score-scope` está habilitado.
Consulta [docs/scoring.md](https://github.com/praetorian-inc/titus/blob/main/docs/scoring.md) para la referencia completa: niveles de severidad, tipos de modificadores, detalles de los scorers integrados y cómo escribir tus propios scorers YAML o Go.
## Biblioteca Go para Detección de Secretos
Titus se puede importar como una biblioteca Go para agregar detección de secretos a tus propias herramientas y pipelines.```bash
go get github.com/praetorian-inc/titus
(no input provided)```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 el escaneo de bytes y archivos, la validación de secretos detectados y la carga de 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))
Consulta docs/library-usage.md para obtener la referencia completa de la API, los patrones de concurrencia y más ejemplos.
La extensión de Burp escanea las respuestas HTTP en busca de secretos durante el tráfico del proxy y las pruebas de penetración activas.
make install-burp
Luego cargue `dist/titus-burp-1.0.0-all.jar` en Burp Suite en Extensions > Add.
#### Windows (Descargar desde Releases)
1. Descargue `titus-windows-amd64.exe` y `titus-burp-<version>.jar` desde [Releases](../../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 lanza 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 añade una pestaña Titus a Burp con tres subpestañas:
Secrets: Todos los secretos detectados con filtrado por tipo, host y estado de validación.
Titus Burp Suite extension secrets tab showing detected API keys and credentials with validation status
Statistics: vista agregada de secretos agrupados por tipo y host.
Settings: configure las opciones de escaneo, validación y asignaciones de severidad.
Titus Burp Suite extension settings tab with scan configuration options
Al ver cualquier solicitud en Burp, aparece una pestaña Titus en el inspector de respuestas si se detectan secretos, lo que proporciona acceso rápido a los hallazgos sin cambiar a la pestaña principal de Titus.
Titus tab in Burp Suite response inspector highlighting detected secrets in HTTP responses
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 descomprimida** y selecciona el directorio `extension/`
### Características de la extensión del navegador
- Escanea JavaScript y hojas de estilo, tanto en línea como externos, en busca de claves de API y tokens
- Escanea localStorage y sessionStorage en busca de credenciales filtradas
- Captura opcional de respuestas de red para una detección integral de secretos
- Resultados mostrados en la ventana emergente y el panel
<img width="1719" height="958" alt="Ventana emergente de la extensión de Chrome de Titus 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 la extensión de Chrome de Titus 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 Content Security Policy 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. **Habilítala solo durante pruebas de seguridad activas.**
## Compilación desde el código fuente
### Compilación estándar (acelerada con Vectorscan)
Por defecto, Titus se compila con [Vectorscan](https://github.com/VectorCamp/vectorscan) (ARM) / [Hyperscan](https://github.com/intel/hyperscan) (x86) para la 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 lo que falte 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 iniciar cuando el motor acelerado esté activo.
Para instalar la biblioteca C tú mismo en lugar de depender de la instalación automática:```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 integrar 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 totalmente portátil — compila el motor en Go puro 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
#### Caché automática de base de datos de Hyperscan
Titus serializa automáticamente cada base de datos de Hyperscan compilada con éxito en la caché estándar del usuario. Las instancias posteriores del escáner con exactamente las mismas reglas ordenadas y flags cargan esa base de datos en lugar de compilarla de nuevo. El archivo de caché es el flujo de bytes sin modificar producido por `hs_serialize_database` de Hyperscan, y Titus lo carga con `hs_deserialize_database`.
`TITUS_CACHE_DIR` puede sobrescribir la ubicación de la caché. Las escrituras en la caché son atómicas y de mejor esfuerzo: una caché no disponible o de solo lectura no impide el escaneo. Una base de datos ausente, corrupta, incompatible o con una huella diferente desencadena la compilación normal y actualiza la caché cuando es posible.
Las bases de datos serializadas son específicas de la arquitectura, las características de la CPU y la versión de Hyperscan. Titus detecta entradas incompatibles durante la deserialización y las reemplaza con una base de datos compilada para el entorno de ejecución actual.
## Contribuir
¡Las contribuciones son bienvenidas! Consulta [CONTRIBUTING.md](https://github.com/praetorian-inc/titus/blob/main/CONTRIBUTING.md) para obtener pautas sobre cómo contribuir a Titus.
## Licencia
Apache License 2.0 — consulta [LICENSE](https://github.com/praetorian-inc/titus/blob/main/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.), ambos licenciados bajo Apache 2.0. Consulta [NOTICE](https://github.com/praetorian-inc/titus/blob/main/NOTICE) para obtener la atribución completa.