Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
titus — 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. | Kitploit
Ferramentas/GitHubGitHub/praetorian-inc/titus
Análise EstáticaScanners de VulnerabilidadesSegurança de ContêineresProxies Web e InterceptaçãoAnálise de CódigoTestes de PenetraçãoDevSecOpsDetecção de SegredosSegurança da Cadeia de Suprimentos
GitHubpraetorian-inc/titus

titus

6677588há 2 diasRevisado pelo Kitploit

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.

Ver RepositórioSite
Compartilhar
<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

[![Go](https://img.shields.io/badge/Go-1.27.0+-00ADD8?logo=go&logoColor=white)](https://go.dev)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
[![CI](https://img.shields.io/github/actions/workflow/status/praetorian-inc/titus/ci.yml?branch=main&label=CI)](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.
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    916
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    558
  • 3

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    370
  • 4

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    360
  • 5

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    317
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    289

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →