Escá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.
<img width="1200" height="628" alt="Titus - escáner de secretos de alto rendimiento para código fuente, historial de git y archivos binarios" src="https://assets.kitploit.com/production/public/readmes/11969/d2f6b99d686a073185db1b7299fa5f033067b057000062cf592a4ae15a796034.png" />
# Titus: Escáner de secretos de alto rendimiento
[](https://go.dev)
[](LICENSE)
[](https://github.com/praetorian-inc/titus/actions)
**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](https://github.com/praetorian-inc/noseyparker) y [Kingfisher](https://github.com/mongodb/kingfisher). Titus funciona como CLI, como biblioteca de Go, como extensión de Burp Suite y como extensión de navegador para Chrome — todas compartiendo 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](https://github.com/intel/hyperscan)/[Vectorscan](https://github.com/VectorCamp/vectorscan) con la validación de credenciales en vivo para encontrar y verificar secretos filtrados en todo tu código base.
## Tabla de contenidos
- [¿Por qué Titus?](#why-titus)
- [Instalación](#installation)
- [Inicio rápido](#quick-start)
- [Opciones de escaneo](#scanning-options)
- [Puntuación de hallazgos](#finding-scoring)
- [Biblioteca de Go](#go-library-for-secrets-detection)
- [Extensión de Burp Suite](#burp-suite-extension-for-secret-scanning)
- [Extensión de navegador](#chrome-browser-extension-for-secret-scanning)
- [Compilar desde el código fuente](#building-from-source)
- [Contribuir](#contributing)
- [Licencia](#license)
## ¿Por qué Titus?
- **Escaneo de secretos rápido**: coincidencia de expresiones regulares acelerada por [Hyperscan](https://github.com/intel/hyperscan)/[Vectorscan](https://github.com/VectorCamp/vectorscan) cuando está disponible, con una alternativa 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 → crítico). Las puntuaciones se ajustan mediante metadatos estáticos de las reglas, el contexto de accesibilidad del código y llamadas a API en vivo que miden el radio de impacto real de una credencial — de modo que los hallazgos más peligrosos siempre aparecen primero.
- **Escaneo de imágenes de contenedor**: escanea imágenes Docker y OCI directamente desde cualquier registro, tarball o directorio de diseño OCI — sin necesidad de un daemon de Docker ni de binarios.
- **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 las 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](../../releases), o compílalo 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.
### Subcomandos
<!-- BEGIN generated: cli-subcommands -->
Titus organiza su funcionalidad en estos subcomandos específicos:
```bash
titus analyze # Analyze a credential on demand — detect type, validate, score, and enumerate resources
titus enum # Enumerate remote services for secrets
titus explore # Interactively explore scan results
titus report # Generate a report from scan results
titus rules # Manage detection rules
titus scan # Scan a target for secrets
titus serve # Run as streaming server for Burp extension integration
titus version # Show version information
```
<!-- END generated: cli-subcommands -->
Cada subcomando acepta `--help` para sus propias opciones. Las formas de nivel superior `titus <provider>` que preceden a `titus enum <provider>` siguen funcionando, pero están ocultas y obsoletas en lugar de ser alias, por lo que se listan en la referencia generada en lugar de aquí.
<!-- BEGIN generated: cli-aliases -->
La referencia completa — cada subcomando, alias y opción, incluidos los que están ocultos de `--help` — se genera en [docs/CLI.md](https://github.com/praetorian-inc/titus/blob/main/docs/CLI.md).
<!-- END generated: cli-aliases -->
## 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 scan 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.
### Escaneo de imágenes Docker / OCI
Escanee imágenes de contenedores directamente — sin daemon de docker, sin necesidad del binario `docker`. Titus extrae las imágenes directamente de cualquier registro OCI a través de HTTPS (usando las credenciales de `~/.docker/config.json`), o lee imágenes desde un tarball local de `docker save` o desde 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 seguir siendo recuperables del 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
# Only findings from one repository (host-qualified as recorded, or without the host)
titus report --repo github.com/acme/api
# Repeat a selector, or combine selectors; a location matching any value is kept
titus report --namespace github.com/acme --namespace gitlab.example.com/acme --path src/config.yaml
# List the repository, namespace and path values that select current findings
titus report sources
# List every recorded source, including sources with no findings
titus report sources all
```
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
```
Las reglas marcadas como `visible: false` son auxiliares que capturan contexto para otras reglas, como un ID de cliente, un nombre de cuenta o un host, en lugar de un secreto. Sus patrones siguen ejecutándose, pero sus coincidencias nunca se reportan, ni por la CLI ni por la biblioteca Go, incluso cuando la regla se selecciona explícitamente.
### Extracción de secretos de archivos binarios
Titus puede extraer texto de formatos de archivo 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 de forma predeterminada). Utilice `--sqlite-row-limit` para ajustarlo:
```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 gravedad:
| Puntuación | Gravedad |
|-------|----------|
| 0–20 | info |
| 21–40 | low |
| 41–60 | medium |
| 61–80 | high |
| 81–100 | critical |
Las puntuaciones parten del `base_score` de la regla y se ajustan mediante **modificadores**: condiciones que elevan o reducen 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 comprobaciones 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 en YAML o Go.
## Biblioteca Go para detección de secretos
Titus se puede importar como una biblioteca Go para añadir detección de secretos a tus propias herramientas y pipelines.
```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 = AKIADEADBEEFDEADBEEF`)
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](https://github.com/praetorian-inc/titus/blob/main/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
```
3. Carga el JAR en Burp Suite en Extensions > Add
#### Linux / macOS (Descargar desde Releases)
1. Descarga el binario adecuado para tu plataforma y `titus-burp-<version>.jar` desde [Releases](../../releases):
- `titus-linux-amd64` o `titus-linux-arm64` para Linux
- `titus-darwin-amd64` o `titus-darwin-arm64` para macOS
2. Instala el binario:
```bash
mkdir -p ~/.titus
cp titus-<platform> ~/.titus/titus
chmod +x ~/.titus/titus
```
3. Carga 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 a través de Burp
- **Escaneo activo de secretos**: menú contextual con clic derecho para escanear las solicitudes seleccionadas
- **Deduplicación**: el mismo secreto se reporta solo una vez por engagement
- **Filtrado de ruta rápida**: se omiten el contenido binario, las imágenes y las respuestas que no son de 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 la generación de informes
### 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**: haz clic en los botones Type, Host o Status para filtrar por valores específicos; usa el cuadro de búsqueda para coincidencias de texto y regex
- **Acciones masivas**: selecciona varias filas para validar o marcar como falso positivo en lote
- **Panel Secret Details**: selecciona 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 (p. ej., ID de cuenta de AWS, ARN)
- **Request/Response**: tráfico HTTP completo con el secreto resaltado
**Statistics**: vista agregada de los secretos agrupados por tipo y host.
<img width="1964" height="848" alt="Titus Burp Suite extension statistics tab showing secrets by type and host" src="https://assets.kitploit.com/production/public/readmes/11969/4a3d6f997049bb8bba621ceb8511b9a41c63867a5c1e8add6065c483706ac36a.png" />
- **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**: configura las opciones de escaneo, la validación y las 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*: escanea también los cuerpos de las solicitudes en busca de secretos enviados por la aplicación
- *Validation*: habilítalo 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**: personaliza los niveles de severidad por categoría de secreto
- **Actions**: borrar caché, restablecer la configuración, guardar/exportar hallazgos a JSON
Al visualizar 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 del 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. Activa el **Modo de desarrollador**
3. Haz clic en **Cargar descomprimida** y selecciona el directorio `extension/`
### Características de la extensión de navegador
- Escanea JavaScript y hojas de estilo en línea y 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 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 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 de navegador elimina las cabeceras 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. **Actívala 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 completamente portátil y estático — 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 la 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
faltante, corrupta, incompatible o con una huella digital 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 la atribución completa.