praetorian-inc/titusScanner de segredos de alto desempenho. CLI, biblioteca Go, extensão Burp Suite e extensão Chrome. 487 regras de detecção com validação de credenciais ao vivo.
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.
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.
Analise repositórios públicos diretamente por URL — não é necessário token de API:```bash
titus scan github.com/kubernetes/kubernetes
titus scan gitlab.com/gitlab-org/cli
titus scan https://github.com/org/repo titus scan https://gitlab.com/namespace/project.git
Para 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.
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
titus scan --docker alpine:latest titus scan docker://ghcr.io/owner/repo:tag
titus scan --docker ./my-app.tar
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.
titus rules list
titus scan path/to/code --rules-include "aws,gcp"
titus scan path/to/code --rules-exclude "kingfisher.generic"
titus scan path/to/code --rules path/to/custom-rules.yaml
titus scan path/to/code --include-noisy
### 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
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
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
titus scan path/to/code
titus scan path/to/code --score-scope
titus scan path/to/code --accessibility public # no penalty for public repos titus scan path/to/code --accessibility private # -25 penalty (default for local scans)
Titus 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.
A extensão do Burp verifica respostas HTTP em busca de segredos durante o tráfego do proxy e testes de penetração ativos.
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
titus-burp-<version>.jar em Releases:
titus-linux-amd64 ou titus-linux-arm64 para Linuxtitus-darwin-amd64 ou titus-darwin-arm64 para macOSA 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.
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
Statistics: Vista agregada dos segredos agrupados por tipo e host.
Settings: Configure opções de análise, validação e mapeamentos de severidade.
Titus Burp Suite extension settings tab with scan configuration options
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
A extensão do Chrome analisa páginas web à procura de segredos durante avaliações de segurança de aplicações web.
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
brew install pkg-config vectorscan
sudo apt-get install pkg-config libhyperscan-dev
sudo dnf install pkgconf-pkg-config vectorscan-devel
git clone --depth 1 --branch vectorscan/5.4.11 https://github.com/VectorCamp/vectorscan.git cd vectorscan && cmake -B build -DCMAKE_INSTALL_PREFIX=/usr/local && cmake --build build && sudo cmake --install build
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
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
make build-pure
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.