Titus: Scanner de Segredos de Alto Desempenho

Titus é um scanner de segredos de alto desempenho que detecta credenciais, chaves de API e tokens em código-fonte, arquivos e histórico do git. Ele vem com 487 regras de detecção que abrangem centenas de serviços e tipos de credenciais, extraídas do NoseyParker e do Kingfisher. O Titus é executado como CLI, biblioteca Go, extensão do Burp Suite e extensão do navegador Chrome — todos compartilhando o mesmo mecanismo de detecção e conjunto de regras.

Construído para engenheiros de segurança, testadores de penetração e equipes DevSecOps, o Titus combina correspondência de regex acelerada por Hyperscan/Vectorscan com validação ao vivo de credenciais para encontrar e verificar segredos vazados em toda a sua base de código.

Índice

• Por que Titus?
• Instalação
• Início Rápido
• Opções de Varredura
• Pontuação de Descobertas
• Biblioteca Go
• Extensão para Burp Suite
• Extensão para Navegador
• Compilação a Partir do Código Fonte
• Contribuição
• Licença

Por que Titus?

• Varredura rápida de segredos: Correspondência de regex acelerada por Hyperscan/Vectorscan quando disponível, com fallback em Go puro para portabilidade em qualquer plataforma.
• Ampla cobertura de detecção de credenciais: 487 regras detectam chaves de API, tokens e credenciais para AWS, GCP, Azure, GitHub, Slack, bancos de dados, sistemas CI/CD e centenas de outros serviços.
• Validação ao vivo de segredos: Segredos detectados são verificados junto às suas APIs de origem para confirmar se estão ativos, reduzindo falsos positivos e priorizando a remediação.
• Pontuação de gravidade baseada em risco: Cada descoberta recebe uma pontuação numérica (0–100) e um nível de gravidade (informativo → crítico). As pontuações são ajustadas por metadados estáticos das regras, contexto de acessibilidade do código e chamadas de API ao vivo que medem o raio de explosão real de uma credencial — para que as descobertas mais perigosas sempre surjam primeiro.
• Varredura de imagens de contêiner: Escaneie imagens Docker e OCI diretamente de qualquer registro, tarball ou diretório de layout OCI — sem necessidade de daemon ou binário Docker.
• Múltiplas interfaces para cada fluxo de trabalho: Escaneie pela CLI, incorpore como biblioteca Go, escaneie passivamente tráfego HTTP no Burp Suite ou escaneie páginas da web no Chrome durante testes de segurança de aplicações.
• Extração de arquivos binários: Extraia e escaneie segredos de documentos do Office, PDFs, arquivos compactados (zip, tar, 7z), aplicativos móveis (APK, IPA), extensões de navegador e muito mais.

Instalação

Baixe um binário pré-compilado da página de Releases, ou compile a partir do código fonte:```bash make build

O binário estará em `dist/titus`.

## Início 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

Os resultados são escritos em um datastore (titus.ds por padrão) e impressos no console.

Opções de Escaneamento

Escaneamento do GitHub e GitLab

Escaneie repositórios públicos diretamente por URL — não é necessário 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 varreduras em toda a organização ou por usuário, use os 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

Tokens são opcionais para repositórios públicos. Defina GITHUB_TOKEN ou GITLAB_TOKEN (ou use --token) para acesso a repositórios privados e limites de taxa mais altos da API.

Digitalização de Imagens Docker / OCI

Digitalize imagens de contêiner diretamente — sem necessidade de daemon docker, sem binário docker necessário. Titus baixa imagens diretamente de qualquer registro OCI via HTTPS (usando credenciais de ~/.docker/config.json), ou lê imagens de um tarball docker save local ou diretório de layout de imagem OCI. Em seguida, analisa os metadados do manifesto/config da imagem e todos os arquivos regulares em cada camada, incluindo arquivos de camadas inferiores excluídos por camadas posteriores (já que segredos podem permanecer recuperáveis do histórico da imagem).```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/

A autenticação usa sua configuração existente do Docker / Podman (`~/.docker/config.json`, `${XDG_RUNTIME_DIR}/containers/auth.json`). Registros privados que precisam de um novo login devem primeiro ser autenticados com `docker login` (ou `podman login`, ou `crane auth login`) — o titus não solicita credenciais.

### Visualizar Resultados da Varredura

Use o comando `report` para reler os resultados de uma varredura 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

Você também pode controlar o formato de saída no momento da varredura com --format:```bash titus scan path/to/code --format json

### Validando Segredos Detectados

Passe `--validate` durante uma varredura para verificar segredos detectados em relação às suas APIs de origem:```bash
titus scan path/to/code --validate

A validação é executada simultaneamente (4 workers por padrão, configurável com --validate-workers) e marca cada descoberta como confirmada, negada ou desconhecida.

Filtrando Regras de Detecção```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

### Extraindo Segredos de Arquivos Binários

O Titus pode extrair texto de formatos de arquivo binário e escanear o conteúdo em busca de segredos:```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

Os formatos suportados incluem documentos do Office (xlsx, docx, pptx, odp, ods, odt), PDFs, notebooks Jupyter, bancos de dados SQLite, e-mails (eml, rtf) e arquivos compactados (zip, tar, tar.gz, jar, war, ear, apk, ipa, crx, xpi, 7z). Os arquivos compactados são extraídos recursivamente até limites configuráveis de profundidade e tamanho.```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 bancos de dados SQLite, Titus extrai texto de todas as tabelas (1000 linhas por tabela por padrão). Use `--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

Pontuação de Descobertas

Cada descoberta que o Titus produz carrega uma pontuação numérica de 0 a 100 e um nível de gravidade:

As pontuações começam a partir do base_score da regra e são ajustadas por modificadores — condições que aumentam ou diminuem a pontuação com base no que é conhecido sobre a 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)

O Titus vem com scorers YAML para credenciais AWS, PATs do GitHub e tokens do Slack, além de scorers SDK baseados em Go que realizam enumeração de políticas IAM ao vivo (AWS) e verificações de permissão de repositório (PATs granulares do GitHub) quando `--score-scope` está ativado.

Veja [docs/scoring.md](https://github.com/praetorian-inc/titus/blob/HEAD/docs/scoring.md) para a referência completa: níveis de severidade, tipos de modificadores, detalhes dos scorers embutidos e como escrever seus próprios scorers YAML ou Go.

## Biblioteca Go para Detecção de Segredos

O Titus pode ser importado como uma biblioteca Go para adicionar detecção de segredos às suas próprias ferramentas e pipelines.```bash
go get github.com/praetorian-inc/titus

Translate the following Kitploit tool content. This is chunk 29 of 49 from a longer Markdown document being translated in sequence. The source language is en. Target language: pt. Content type: README chunk 29/49.

CHUNK-SPECIFIC RULES:

1. Translate ONLY natural language text. NEVER translate: code blocks, shell commands, file paths, URLs, package names, technical identifiers, CVE IDs, environment variable names.
2. Preserve ALL Markdown syntax EXACTLY as-is.
3. DO NOT add introductory headings like "## Chunk N", "## Part N", "## Continued from..." or "## Translation of chunk...". DO NOT add "End of chunk N" or "Content continues..." markers.
4. DO NOT add "..." ellipsis markers to indicate omission. Translate ONLY the exact text provided, character for character in structure.
5. Chunk boundaries are intentional. Preserve structure so chunks can be concatenated seamlessly without visual artifacts.
6. Return ONLY the translated text. No preamble, no commentary, no wrapping in code blocks, no JSON/YAML/XML, no arrays, no objects, no schemas, no key/value wrappers.
7. If the chunk starts mid-paragraph, continue translating from that point. Do not add a leading newline or indent unless it exists in the source.

INPUT:

After "INPUT:", there is nothing. I suspect that the chunk content was supposed to be provided but it's missing. But as an AI, I need to respond with a translation of the chunk. Since there's no content, the translation would be empty. However, the instructions say "If the chunk starts mid-paragraph, continue translating from that point. Do not add a leading newline or indent unless it exists in the source." If the source is empty, then the translation is also empty. But the user expects a translation of the chunk they were supposed to input. Maybe the chunk is actually part of the document that is being sent in pieces, but in this interaction, the chunk content is not present. Perhaps this is a test or a mistake. I could ask for clarification, but the rules say "Do not ask questions. Do not engage in conversation." So I should output nothing? But I need to return only the translated text. If there's nothing to translate, I should output an empty string. But that would be an empty response, which might be considered a valid translation of an empty chunk. However, the prompt says "INPUT:" and then nothing, so the input text is zero-length string. The translation is also zero-length. So I'll output nothing (empty). But to be safe, I'll output a single newline? No, if the input is empty, the output should be empty, not even a newline. The rule "Preserve exact formatting: whitespace, newlines, indentation" applies, so if there is no content, I output nothing. The response will be empty. I'll just end with nothing. But the assistant message requires a string; I can return an empty string. I'll do that.

Thus, final answer: (empty string)```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,
        )
    }
}

A biblioteca também suporta a varredura de bytes e arquivos, validação de segredos detectados e carregamento de regras 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))

Consulte [docs/library-usage.md](https://github.com/praetorian-inc/titus/blob/HEAD/docs/library-usage.md) para a referência completa da API, padrões de concorrência e mais exemplos.

## Extensão Burp Suite para Varredura de Segredos

A extensão Burp analisa respostas HTTP em busca de segredos durante o tráfego de proxy e testes de penetração ativos.

### Configuração

#### Linux / macOS (Compilação a partir da fonte)```bash
# Build the CLI and Burp extension JAR, install CLI to ~/.titus/
make install-burp

Em seguida, carregue dist/titus-burp-1.0.0-all.jar no Burp Suite em Extensions > Add.

Windows (Baixar dos Releases)

1. Baixe titus-windows-amd64.exe e titus-burp-<version>.jar do Releases
2. Crie o diretório Titus e instale o binário: ```powershell mkdir %USERPROFILE%.titus copy titus-windows-amd64.exe %USERPROFILE%.titus\titus.exe
   root@kitploit:~

3. Carregue o JAR no Burp Suite em Extensions > Add

Linux / macOS (Baixar dos Releases)

1. Baixe o binário apropriado para sua plataforma e titus-burp-<version>.jar dos Releases:
   • titus-linux-amd64 ou titus-linux-arm64 para Linux
   • titus-darwin-amd64 ou titus-darwin-arm64 para macOS
2. Instale o binário: ```bash mkdir -p ~/.titus cp titus- ~/.titus/titus chmod +x ~/.titus/titus
   root@kitploit:~

3. Carregue o JAR no Burp Suite em Extensões > Adicionar

A extensão inicia um processo titus serve em segundo plano e comunica-se através de stdin/stdout usando NDJSON. As regras de deteção são carregadas uma vez no início.

Funcionalidades da Extensão Burp

• Varredura passiva de segredos: verifica automaticamente o tráfego do proxy à medida que flui pelo Burp
• Varredura ativa de segredos: menu de contexto com clique direito para verificar requisições selecionadas
• Dedupicação: o mesmo segredo é reportado apenas uma vez por compromisso
• Filtragem rápida: conteúdo binário, imagens e respostas não textuais são ignorados
• Validação de credenciais em tempo real: verifica segredos detetados contra APIs de origem para confirmar se estão ativos
• Gestão de falsos positivos: marcar descobertas como falsos positivos para filtrar ruído
• Classificação de gravidade: descobertas codificadas por cores conforme o risco (Alto/Médio/Baixo)
• Exportação: salvar descobertas em JSON para relatórios

Interface da Extensão Burp

A extensão adiciona um separador Titus no Burp com três sub-separadores:

Segredos: Todos os segredos detetados com filtragem por tipo, anfitrião e estado de validação.

Separador de segredos da extensão Titus Burp Suite mostrando chaves de API e credenciais detetadas com estado de validação

• Estado de validação: Mostra se os segredos foram verificados (Ativo/Inativo/Desconhecido)
• Filtragem: Clique nos botões Tipo, Anfitrião ou Estado para filtrar por valores específicos; use a caixa de pesquisa para correspondência de texto e regex
• Ações em lote: Selecione várias linhas para validar ou marcar como falso positivo em lote
• Painel de Detalhes do Segredo: Selecione uma descoberta para ver:
  • Detalhes: Informação da regra, categoria, valor completo do segredo, timestamp da primeira visualização
  • URLs: Todos os locais onde este segredo foi encontrado
  • Validação: Resultado da validação com detalhes (ex.: ID da conta AWS, ARN)
  • Requisição/Resposta: Tráfego HTTP completo com o segredo realçado

Estatísticas: Vista agregada de segredos agrupados por tipo e anfitrião.

• Resumo: Total de segredos únicos, anfitriões verificados, divisão de validação (ativo vs inativo) e contagem de falsos positivos
• Segredos por Tipo: Contagem de cada tipo de segredo com classificação de categoria
• Segredos por Anfitrião: Número de segredos encontrados por anfitrião

Configurações: Configure opções de varredura, validação e mapeamentos de gravidade.

Separador de configurações da extensão Titus Burp Suite com opções de configuração de varredura

• Configurações de Varredura:
  • Varredura passiva: Verificar automaticamente todo o tráfego do proxy (ativado por padrão)
  • Varredura do corpo da requisição: Também verificar corpos de requisições para segredos enviados pela aplicação
  • Validação: Ativar para verificar segredos contra APIs de origem (faz requisições de saída e pode acionar alertas)
• Parâmetros de Varredura: Threads de trabalho, tamanho máximo de ficheiro, comprimento do snippet de contexto
• Configuração de Gravidade: Personalizar níveis de gravidade por categoria de segredo
• Ações: Limpar cache, redefinir configurações, guardar/exportar descobertas para JSON

Ao visualizar qualquer requisição no Burp, um separador Titus aparece no inspetor de resposta se forem detetados segredos, fornecendo acesso rápido às descobertas sem mudar para o separador Titus principal.

Separador Titus no inspetor de resposta do Burp Suite realçando segredos detetados em respostas HTTP

Extensão do Navegador Chrome para Varredura de Segredos

A extensão do Chrome verifica páginas web em busca de segredos durante avaliações de segurança de aplicações web.

Configuração```bash

make build-extension

1. Navegue para `chrome://extensions/`
2. Ative o **Modo de desenvolvedor**
3. Clique em **Carregar descompactado** e selecione o diretório `extension/`

### Funcionalidades da Extensão do Navegador

- Escaneia JavaScript e folhas de estilo inline e externos em busca de chaves e tokens de API
- Escaneia localStorage e sessionStorage em busca de credenciais vazadas
- Captura opcional de respostas de rede para detecção abrangente de segredos
- Resultados exibidos em popup e painel

<img width="1719" height="958" alt="Titus Chrome extension popup showing detected secrets on a web page" src="https://assets.kitploit.com/production/public/readmes/11969/057a24e2746412ceabe1aac0292a2de463de1efee5bca2489ca34b59d8b0dc2c.png" />

<img width="1744" height="827" alt="Titus Chrome extension dashboard with aggregated secret detection results" src="https://assets.kitploit.com/production/public/readmes/11969/265d972fadcc7f212944d7a1d8fd58a43446e7199d1209900e83b96a546ffb00.png" />

### Aviso de Segurança

A extensão do navegador remove os cabeçalhos Content Security Policy e CORS das páginas visitadas para escanear recursos externos. Isso enfraquece a postura de segurança dos sites que você visita enquanto a extensão está ativa. **Ative apenas durante testes de segurança ativos.**

## Compilando a partir do Código Fonte

### Compilação Padrão (acelerada por Vectorscan)

Por padrão, o Titus compila com [Vectorscan](https://github.com/VectorCamp/vectorscan) (ARM) / [Hyperscan](https://github.com/intel/hyperscan) (x86) para correspondência de regex acelerada por SIMD. Isso requer CGO, a biblioteca C e `pkg-config` (que o cgo usa para localizar a biblioteca). O comando `make build` verifica esses requisitos e tenta instalar qualquer item faltante via 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

Você verá [vectorscan] N/N rules compiled for Hyperscan na inicialização quando o mecanismo acelerado estiver ativo.

Para instalar a biblioteca C por conta própria em vez de depender da instalação 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

Se você invocar `go build` diretamente (por exemplo, ao incorporar Titus), passe a tag e ative o 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

Compilação Puramente em Go (sem dependências C)

Se você não pode instalar a biblioteca C — ou deseja um binário totalmente portátil e estático — compile o mecanismo puramente em Go. O Titus automaticamente recorre a ele em tempo de execução sempre que o vectorscan não estiver compilado:```bash

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

make build-pure

Fully static binary

make build-static

## Contribuindo

Contribuições são bem-vindas! Veja [CONTRIBUTING.md](https://github.com/praetorian-inc/titus/blob/HEAD/CONTRIBUTING.md) para diretrizes sobre como contribuir para o Titus.

## Licença

Licença Apache 2.0 — veja [LICENSE](https://github.com/praetorian-inc/titus/blob/HEAD/LICENSE).

As regras de detecção são derivadas de [NoseyParker](https://github.com/praetorian-inc/noseyparker) (Praetorian Security, Inc.) e [Kingfisher](https://github.com/mongodb/kingfisher) (MongoDB, Inc.), ambos licenciados sob Apache 2.0. Veja [NOTICE](https://github.com/praetorian-inc/titus/blob/HEAD/NOTICE) para atribuição completa.