Scanner 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.
<img width="1200" height="628" alt="Titus - scanner de segredos de alto desempenho para código-fonte, histórico do git e arquivos binários" src="https://assets.kitploit.com/production/public/readmes/11969/d2f6b99d686a073185db1b7299fa5f033067b057000062cf592a4ae15a796034.png" />
# Titus: Scanner de Segredos de Alto Desempenho
[](https://go.dev)
[](LICENSE)
[](https://github.com/praetorian-inc/titus/actions)
**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 cobrem centenas de serviços e tipos de credenciais, extraídas do [NoseyParker](https://github.com/praetorian-inc/noseyparker) e do [Kingfisher](https://github.com/mongodb/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](https://github.com/intel/hyperscan)/[Vectorscan](https://github.com/VectorCamp/vectorscan) com validação de credenciais em tempo real para encontrar e verificar segredos vazados em toda a sua base de código.
## Índice
- [Por que Titus?](#why-titus)
- [Instalação](#installation)
- [Início Rápido](#quick-start)
- [Opções de Varredura](#scanning-options)
- [Pontuação de Achados](#finding-scoring)
- [Biblioteca Go](#go-library-for-secrets-detection)
- [Extensão do Burp Suite](#burp-suite-extension-for-secret-scanning)
- [Extensão de Navegador](#chrome-browser-extension-for-secret-scanning)
- [Compilando a partir do Código-Fonte](#building-from-source)
- [Contribuindo](#contributing)
- [Licença](#license)
## Por que Titus?
- **Varredura de segredos rápida**: correspondência de regex acelerada por [Hyperscan](https://github.com/intel/hyperscan)/[Vectorscan](https://github.com/VectorCamp/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 das 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.
- **Varredura de imagens de contêiner**: escaneie imagens Docker e OCI diretamente de qualquer registry, 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, faça varredura passiva de 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](../../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.
### Subcomandos
<!-- BEGIN generated: cli-subcommands -->
O Titus organiza a sua funcionalidade nestes subcomandos focados:
```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 aceita `--help` para suas próprias flags. As formas de nível superior `titus <provider>` que antecedem `titus enum <provider>` ainda funcionam, mas são ocultas e obsoletas em vez de aliases, portanto são listadas na referência gerada em vez de aqui.
<!-- BEGIN generated: cli-aliases -->
A referência completa — cada subcomando, alias e flag, incluindo os ocultos de `--help` — é gerada em [docs/CLI.md](https://github.com/praetorian-inc/titus/blob/main/docs/CLI.md).
<!-- END generated: cli-aliases -->
## Opções de Varredura
### Varredura de GitHub e GitLab
Escaneie repositórios públicos diretamente por URL — nenhum token de API é necessário:
```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 em todos os usuários, 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 scan 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 API mais altos.
### Verificação de Imagens Docker / OCI
Verifique imagens de contêiner diretamente — sem daemon 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 gerado por `docker save` ou de um diretório de layout de imagem OCI. Em seguida, ele 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 a partir 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 da Varredura
Use `report` para reler os achados 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
# 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
```
Também é possível 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
```
Regras marcadas como `visible: false` são auxiliares que capturam contexto para outras regras, como um ID de cliente, nome de conta ou host, em vez de um segredo. Os seus padrões continuam a ser executados, mas as suas correspondências nunca são reportadas, nem pela CLI nem pela biblioteca Go, mesmo quando a regra é selecionada explicitamente.
### Extrair Segredos de Ficheiros Binários
O Titus consegue extrair texto de formatos de ficheiros binários e analisar 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, e-mail (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, 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
```
## Pontuação de Achados
Cada achado 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)
```
O Titus vem com scorers YAML para credenciais AWS, PATs do GitHub e tokens do Slack, além de scorers baseados em SDK 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 em 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
```
```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,
)
}
}
```
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](https://github.com/praetorian-inc/titus/blob/main/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 de 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 (Baixar em 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
```
3. Carregue o JAR no Burp Suite em Extensions > Add
#### Linux / macOS (Baixar em Releases)
1. Baixe o binário apropriado para sua plataforma e o `titus-burp-<version>.jar` em [Releases](../../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-<platform> ~/.titus/titus
chmod +x ~/.titus/titus
```
3. Carregue o JAR no Burp Suite em Extensions > Add
A extensão inicia um processo `titus serve` em segundo plano e comunica via stdin/stdout usando NDJSON. As regras de detecção são carregadas uma vez na inicialização.
### Recursos da Extensão do Burp
- **Varredura passiva de segredos**: verifica automaticamente o tráfego de proxy à medida que flui pelo Burp
- **Varredura ativa de segredos**: menu de contexto com botão direito para verificar requisições selecionadas
- **Deduplicação**: o mesmo segredo é reportado apenas uma vez por engajamento
- **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 detectados junto às APIs de origem para confirmar se estão ativos
- **Gerenciamento de falsos positivos**: marca achados como falsos positivos para filtrar ruído
- **Classificação de severidade**: achados codificados por cor conforme o risco (Alto/Médio/Baixo)
- **Exportação**: salva achados em JSON para relatórios
### Interface da Extensão do Burp
A extensão adiciona uma aba **Titus** ao Burp com três sub-abas:
**Secrets**: Todos os segredos detectados com filtragem por tipo, host e status de validação.
Aba secrets da extensão Titus para Burp Suite mostrando chaves de API e credenciais detectadas com status de validação
- **Status 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 busca 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 visualizar:
- **Details**: Informações da regra, categoria, valor completo do segredo, timestamp da primeira detecção
- **URLs**: Todos os locais onde este segredo foi encontrado
- **Validation**: Resultado da validação com detalhes (ex.: ID da conta AWS, ARN)
- **Request/Response**: Tráfego HTTP completo com o segredo destacado
**Statistics**: Visão agregada dos segredos agrupados por tipo e host.
<img width="1964" height="848" alt="Aba statistics da extensão Titus para Burp Suite mostrando segredos por tipo e host" src="https://assets.kitploit.com/production/public/readmes/11969/4a3d6f997049bb8bba621ceb8511b9a41c63867a5c1e8add6065c483706ac36a.png" />
- **Summary**: Total de segredos únicos, hosts verificados, detalhamento de validação (ativos vs inativos) e contagem de falsos positivos
- **Secrets by Type**: Contagem de cada tipo de segredo com classificação de categoria
- **Secrets by Host**: Número de segredos encontrados por host
**Settings**: Configure opções de varredura, validação e mapeamentos de severidade.
Aba settings da extensão Titus para Burp Suite com opções de configuração de varredura
- **Scan Settings**:
- *Varredura passiva*: Verifica automaticamente todo o tráfego de proxy (habilitado por padrão)
- *Varredura do corpo da requisição*: Também verifica os corpos das requisições em busca de segredos enviados pela aplicação
- *Validação*: Habilite para verificar segredos junto às APIs de origem (faz requisições de saída e pode disparar alertas)
- **Scan Parameters**: Threads de trabalho, tamanho máximo de arquivo, comprimento do trecho de contexto
- **Severity Configuration**: Personalize os níveis de severidade por categoria de segredo
- **Actions**: Limpar cache, redefinir configurações, salvar/exportar achados em JSON
Ao visualizar qualquer requisição no Burp, uma aba **Titus** aparece no inspetor de respostas se segredos forem detectados, proporcionando acesso rápido aos achados sem alternar para a aba principal do Titus.
Aba Titus no inspetor de respostas do Burp Suite destacando segredos detectados 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 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
- Verifica JavaScript e folhas de estilo inline e externos em busca de chaves de API e tokens
- Verifica 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 verificar 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 é compilado 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 mecanismo acelerado estiver ativo.
Para instalar a biblioteca C manualmente 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 habilite 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 consegue 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 no 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 fingerprint diferente aciona a compilação normal e atualiza o cache quando possível.
Bancos de dados serializados são específicos de 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 obter 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 obter a atribuição completa.