Titus: Escáner de secretos de alto rendimiento

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.

¿Por qué Titus?

Escaneo de secretos rápido: coincidencia de expresiones regulares acelerada por Hyperscan/Vectorscan cuando está disponible, con un fallback en Go puro para portabilidad en cualquier plataforma.
Amplia cobertura de detección de credenciales: 487 reglas detectan claves de API, tokens y credenciales de AWS, GCP, Azure, GitHub, Slack, bases de datos, sistemas CI/CD y cientos de servicios más.
Validación de secretos en vivo: los secretos detectados se verifican contra sus API de origen para confirmar si están activos, lo que reduce los falsos positivos y prioriza la remediación.
Puntuación de severidad basada en riesgo: cada hallazgo recibe una puntuación numérica (0–100) y un nivel de severidad (info → critical). Las puntuaciones se ajustan mediante metadatos estáticos de las reglas, contexto de accesibilidad del código y llamadas a API en vivo que miden el radio de impacto real de una credencial — para que los hallazgos más peligrosos siempre aparezcan primero.
Escaneo de imágenes de contenedores: escanea imágenes Docker y OCI directamente desde cualquier registro, tarball o directorio de layout OCI — sin necesidad de un daemon o binario de Docker.
Múltiples interfaces para cada flujo de trabajo: escanea desde la CLI, intégralo como biblioteca de Go, escanea pasivamente el tráfico HTTP en Burp Suite o escanea páginas web en Chrome durante pruebas de seguridad de aplicaciones.
Extracción de archivos binarios: extrae y escanea secretos de documentos de Office, PDFs, archivos comprimidos (zip, tar, 7z), aplicaciones móviles (APK, IPA), extensiones de navegador y más.

Instalación

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.

Opciones de escaneo

Escaneo de GitHub y GitLab

Escanea repositorios públicos directamente por URL — no se requiere token de 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

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.

Escaneo de imágenes Docker / OCI

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

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/

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.

Reglas de detección de filtrado```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

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

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

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

Puntuación de hallazgos

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

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

Extensión de Burp Suite para el Escaneo de Secretos

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.

Configuración

Linux / macOS (Compilar desde el Código Fuente)```bash

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

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

Cargue el JAR en Burp Suite en Extensions > Add

Linux / macOS (Descargar desde Releases)

Descargue el binario adecuado para su plataforma y titus-burp-<version>.jar desde Releases:
- titus-linux-amd64 o titus-linux-arm64 para Linux
- titus-darwin-amd64 o titus-darwin-arm64 para macOS
Instale el binario: ```bash mkdir -p ~/.titus cp titus- ~/.titus/titus chmod +x ~/.titus/titus
Cargue el JAR en Burp Suite en Extensions > Add

La 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.

Características de la extensión de Burp

Escaneo pasivo de secretos: escanea automáticamente el tráfico del proxy a medida que fluye por Burp
Escaneo activo de secretos: menú contextual al hacer clic derecho para escanear las solicitudes seleccionadas
Deduplicación: el mismo secreto se reporta solo una vez por compromiso
Filtrado de ruta rápida: se omiten el contenido binario, las imágenes y las respuestas que no son texto
Validación de credenciales en vivo: verifica los secretos detectados contra las API de origen para confirmar si están activos
Gestión de falsos positivos: marca los hallazgos como falsos positivos para filtrar el ruido
Clasificación de severidad: hallazgos codificados por colores según el riesgo (Alto/Medio/Bajo)
Exportación: guarda los hallazgos en JSON para su reporte

Interfaz de la extensión de Burp

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

Estado de validación: muestra si los secretos han sido verificados (Activo/Inactivo/Desconocido)
Filtrado: haga clic en los botones Type, Host o Status para filtrar por valores específicos; use el cuadro de búsqueda para coincidencias de texto y expresiones regulares
Acciones masivas: seleccione varias filas para validar o marcar como falso positivo en lote
Panel Secret Details: seleccione un hallazgo para ver:
- Details: información de la regla, categoría, valor completo del secreto, marca de tiempo de primera detección
- URLs: todas las ubicaciones donde se encontró este secreto
- Validation: resultado de la validación con detalles (por ejemplo, ID de cuenta de AWS, ARN)
- Request/Response: tráfico HTTP completo con el secreto resaltado

Statistics: vista agregada de secretos agrupados por tipo y host.

Titus Burp Suite extension statistics tab showing secrets by type and host

Summary: total de secretos únicos, hosts escaneados, desglose de validación (activos vs inactivos) y recuento de falsos positivos
Secrets by Type: recuento de cada tipo de secreto con clasificación por categoría
Secrets by Host: número de secretos encontrados por host

Settings: configure las opciones de escaneo, validación y asignaciones de severidad.

Titus Burp Suite extension settings tab with scan configuration options

Scan Settings:
- Passive scanning: escanea automáticamente todo el tráfico del proxy (habilitado por defecto)
- Request body scanning: también escanea los cuerpos de las solicitudes en busca de secretos enviados por la aplicación
- Validation: habilítelo para verificar los secretos contra las API de origen (realiza solicitudes salientes y puede activar alertas)
Scan Parameters: hilos de trabajo, tamaño máximo de archivo, longitud del fragmento de contexto
Severity Configuration: personalice los niveles de severidad por categoría de secreto
Actions: borrar caché, restablecer la configuración, guardar/exportar hallazgos a JSON

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

Extensión de navegador Chrome para el escaneo de secretos

La extensión de Chrome escanea páginas web en busca de secretos durante las evaluaciones de seguridad de aplicaciones web.

Configuración```bash

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

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

Compilación en Go puro (sin dependencias de C)

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

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

make build-pure

Fully static binary

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.

titus v1.2.8

Categorías