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 cobrindo centenas de serviços e tipos de credenciais, extraídas do NoseyParker e do Kingfisher. O Titus funciona 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.

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

Por que o Titus?

Escaneamento rápido de segredos: Correspondência de regex acelerada por Hyperscan/Vectorscan quando disponível, com um 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 de CI/CD e centenas de outros serviços.
Validação de segredos em tempo real: Os 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 severidade baseada em risco: Cada achado recebe uma pontuação numérica (0–100) e um nível de severidade (info → crítico). As pontuações são ajustadas por metadados estáticos de regras, contexto de acessibilidade do código e chamadas de API em tempo real que medem o raio de impacto real de uma credencial — assim, os achados mais perigosos sempre aparecem primeiro.
Escaneamento 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 do Docker.
Múltiplas interfaces para cada fluxo de trabalho: Escaneie pela CLI, incorpore como biblioteca Go, escaneie passivamente o tráfego HTTP no Burp Suite ou escaneie páginas 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 na 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 gravados num datastore (titus.ds por predefinição) e impressos na consola.

Opções de Análise

Análise de GitHub e GitLab

Analise 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 varredura em toda a organização ou em todo o 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 de API mais altos.

Verificação de Imagens Docker / OCI

Verifique imagens de contêiner diretamente — sem daemon do docker, sem necessidade do binário docker. O Titus extrai imagens diretamente de qualquer registro OCI via HTTPS (usando credenciais de ~/.docker/config.json), ou lê imagens de um tarball local de docker save ou de um diretório de layout de imagem OCI. Em seguida, verifica os metadados do manifesto/configuração da imagem e cada arquivo regular 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`). Registries 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.

### Visualizando Resultados de Scan

Use `report` para reler os achados de um scan 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 os segredos detectados em relação às suas APIs de origem:```bash
titus scan path/to/code --validate

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

Regras de Deteção de Filtragem```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 arquivos binários 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 Office (xlsx, docx, pptx, odp, ods, odt), PDFs, notebooks Jupyter, bases de dados SQLite, email (eml, rtf) e arquivos (zip, tar, tar.gz, jar, war, ear, apk, ipa, crx, xpi, 7z). Os arquivos 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, o 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

Finding Scoring

Cada finding que o Titus produz carrega uma pontuação numérica de 0–100 e um nível de severidade:

Pontuação	Severidade
0–20	info
21–40	low
41–60	medium
61–80	high
81–100	critical

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 se sabe 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)

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 em tempo real (AWS) e verificações de permissões de repositório (PATs fine-grained do GitHub) quando `--score-scope` está habilitado.

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

## Biblioteca Go para Detecção de Segredos

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

I'll analyze the request and provide the translation. However, I notice that the actual content to translate was not included in your message — the INPUT section is empty.

Please provide the Markdown content (chunk 29 of 49) that you'd like me to translate from English to Portuguese, and I'll return only the translated text following all the rules you've specified.```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 oferece suporte à verificação de bytes e arquivos, à validação de segredos detectados e ao 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 para obter a referência completa da API, padrões de concorrência e mais exemplos.

Extensão do Burp Suite para Varredura de Segredos

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

Configuração

Linux / macOS (Compilar a partir do Código-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 (Download from Releases)

1. Baixe `titus-windows-amd64.exe` e `titus-burp-<version>.jar` em [Releases](../../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

Carregue o JAR no Burp Suite em Extensions > Add

Linux / macOS (Download from Releases)

Baixe o binário apropriado para a sua plataforma e o titus-burp-<version>.jar em Releases:
- titus-linux-amd64 ou titus-linux-arm64 para Linux
- titus-darwin-amd64 ou titus-darwin-arm64 para macOS
Instale o binário: ```bash mkdir -p ~/.titus cp titus- ~/.titus/titus chmod +x ~/.titus/titus
Carregue o JAR no Burp Suite em Extensions > Add

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

Funcionalidades da Extensão Burp

Deteção passiva de segredos: analisa automaticamente o tráfego de proxy à medida que flui através do Burp
Deteção ativa de segredos: menu de contexto com clique direito para analisar pedidos selecionados
Desduplicação: o mesmo segredo é reportado apenas uma vez por engagement
Filtragem de caminho rápido: conteúdo binário, imagens e respostas não textuais são ignorados
Validação de credenciais em tempo real: verifica os segredos detetados contra as APIs de origem para confirmar se estão ativos
Gestão de falsos positivos: marca achados como falsos positivos para filtrar ruído
Classificação de severidade: achados codificados por cores de acordo com o risco (Alto/Médio/Baixo)
Exportação: guarda os achados em JSON para relatórios

Interface da Extensão Burp

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

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

Titus Burp Suite extension secrets tab showing detected API keys and credentials with validation status

Estado de validação: Mostra se os segredos foram verificados (Active/Inactive/Unknown)
Filtragem: Clique nos botões Type, Host ou Status para filtrar por valores específicos; use a caixa de pesquisa para correspondência de texto e regex
Ações em massa: Selecione várias linhas para validar ou marcar como falso positivo em lote
Painel Secret Details: Selecione um achado para ver:
- Details: Informação da regra, categoria, valor completo do segredo, timestamp da primeira deteção
- URLs: Todos os locais onde este segredo foi encontrado
- Validation: Resultado da validação com detalhes (por exemplo, ID de conta AWS, ARN)
- Request/Response: Tráfego HTTP completo com o segredo destacado

Statistics: Vista agregada dos segredos agrupados por tipo e host.

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

Summary: Total de segredos únicos, hosts analisados, detalhe de validação (ativos vs inativos) e contagem de falsos positivos
Secrets by Type: Contagem de cada tipo de segredo com classificação por categoria
Secrets by Host: Número de segredos encontrados por host

Settings: Configure opções de análise, validação e mapeamentos de severidade.

Titus Burp Suite extension settings tab with scan configuration options

Scan Settings:
- Passive scanning: Analisa automaticamente todo o tráfego de proxy (ativado por predefinição)
- Request body scanning: Analisa também os corpos dos pedidos à procura de segredos enviados pela aplicação
- Validation: Ative para verificar segredos contra as APIs de origem (faz pedidos de saída e pode acionar alertas)
Scan Parameters: Threads de trabalho, tamanho máximo de ficheiro, comprimento do excerto de contexto
Severity Configuration: Personalize os níveis de severidade por categoria de segredo
Actions: Limpar cache, repor definições, guardar/exportar achados para JSON

Ao visualizar qualquer pedido no Burp, aparece um separador Titus no inspetor de respostas se forem detetados segredos, proporcionando acesso rápido aos achados sem mudar para o separador principal do Titus.

Titus tab in Burp Suite response inspector highlighting detected secrets in HTTP responses

Extensão do Navegador Chrome para Deteção de Segredos

A extensão do Chrome analisa páginas web à procura de segredos durante avaliações de segurança de aplicações web.

Configuração```bash

make build-extension

1. Navegue até `chrome://extensions/`
2. Ative o **Modo de desenvolvedor**
3. Clique em **Carregar sem compactação** e selecione o diretório `extension/`

### Recursos da Extensão de Navegador

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

<img width="1719" height="958" alt="Popup da extensão Titus para Chrome mostrando segredos detectados em uma página web" src="https://assets.kitploit.com/production/public/readmes/11969/057a24e2746412ceabe1aac0292a2de463de1efee5bca2489ca34b59d8b0dc2c.png" />

<img width="1744" height="827" alt="Painel da extensão Titus para Chrome com resultados agregados de detecção de segredos" src="https://assets.kitploit.com/production/public/readmes/11969/265d972fadcc7f212944d7a1d8fd58a43446e7199d1209900e83b96a546ffb00.png" />

### Aviso de Segurança

A extensão de navegador remove os cabeçalhos Content Security Policy e CORS das páginas visitadas para examinar recursos externos. Isso enfraquece a postura de segurança dos sites que você visita enquanto a extensão estiver 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). `make build` verifica esses itens e tenta instalar o que estiver faltando 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 motor 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 o 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

Build em Go puro (sem dependências C)

Se você não pode instalar a biblioteca C — ou quer um binário totalmente portátil e estático — compile o motor em Go puro. O Titus recorre automaticamente 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

#### Cache automático do banco de dados Hyperscan

O Titus serializa automaticamente cada banco de dados Hyperscan compilado com sucesso
para o cache padrão do usuário. Instâncias posteriores do scanner com exatamente as mesmas
regras ordenadas e flags carregam esse banco de dados em vez de compilá-lo novamente. O arquivo de cache
é o fluxo de bytes não modificado produzido pelo `hs_serialize_database` do Hyperscan,
e o Titus o carrega com `hs_deserialize_database`.

`TITUS_CACHE_DIR` pode substituir o local do cache. As gravações no cache são atômicas e
de melhor esforço: um cache indisponível ou somente leitura não impede a verificação. Um
banco de dados ausente, corrompido, incompatível ou com impressão digital diferente aciona
a compilação normal e atualiza o cache quando possível.

Bancos de dados serializados são específicos para arquitetura, recursos de CPU e versão do
Hyperscan. O Titus detecta entradas incompatíveis durante a desserialização e as substitui
por um banco de dados compilado para o ambiente de execução atual.

## Contribuindo

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

## Licença

Apache License 2.0 — consulte [LICENSE](https://github.com/praetorian-inc/titus/blob/main/LICENSE).

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

Ler mais

titus v1.2.8

Categorias