---

## Casos de Uso

### Pruebas de Penetración
- Validar credenciales descubiertas a través de múltiples servicios durante evaluaciones internas
- Probar patrones de reutilización de contraseñas en servicios de base de datos y archivos compartidos
- Identificar credenciales predeterminadas en infraestructura recién implementada

### Operaciones del Equipo Rojo
- Validación rápida de credenciales después de 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

### Rociado de Claves Privadas

¿Encontraste una clave privada en un sistema comprometido? Rocíala a través de la red para encontrar dónde más concede 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

### Validación de seguridad
- Probar credenciales predeterminadas en servicios recién implementados
- Validar la aplicación de la política de contraseñas en todas las plataformas
- Generar pistas de auditoría para cumplimiento y evaluaciones de seguridad

---

## Instalación

### Archivos binarios precompilados (Recomendado)

Descargar 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

---

## Inicio Rápido

### Subcomandos

Brutus organiza su funcionalidad en seis subcomandos enfocados:```bash
brutus creds    # Non-HTTP credential auditing (SSH, databases, SMB, etc.)
brutus web      # HTTP/web panel auditing (Basic Auth, form login, AI-powered)
brutus snmp     # SNMP community string testing
brutus badkeys  # Known weak/compromised SSH key testing
brutus logon    # Windows logon-screen backdoor detection (sticky keys, utilman)
brutus enum     # Account enumeration (account-existence oracles, Kerberos, Teams auth, email generation)

### 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

Con modo verbose (`-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)

---

## 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 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 5: Pruebas de Servicio Dirigidas```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

Los nombres de servicios de Nmap se asignan automáticamente a los protocolos de Brutus (p. ej., `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 identificación de servicios), debes especificar `--protocol` o dejar que Brutus realice la identificación automática 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

### 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"}

**Objetivos básicos** (identificados automáticamente con Nerva):```bash
echo "192.168.1.100:22" | brutus creds

**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** |
|---------|:-----:|:------:|:------:|:----------:|
| Único binario | ❌ | ❌ | ❌ | ✅ |
| Cero dependencias | ❌ | ❌ | ❌ | ✅ |
| Proxy SOCKS5 | ✅ | ❌ | ❌ | ✅ |
| Pipeline Nerva | ❌ | ❌ | ❌ | ✅ |
| Importación Nmap/Masscan | ❌ | ❌ | ❌ | ✅ |
| JSON Streaming | ⚠️ | ❌ | ❌ | ✅ |
| Multiplataforma | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Errores consistentes | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Desarrollo activo | ✅ | ⚠️ | ❌ | ✅ |
| Claves incorrectas integradas | ❌ | ❌ | ❌ | ✅ |
| Importación de biblioteca Go | ❌ | ❌ | ❌ | ✅ |

---

## Protocolos compatibles

Brutus soporta **27 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 |
| 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 |

### 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 |

### 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 |
| Neo4j | 7687 | Contraseña | Bases de datos gráficas |
| 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 |

### Contenedores y orquestación
| Protocolo | Puerto | Métodos de autenticación | Caso de uso |
|----------|------|--------------|----------|
| Docker | 2375/2376 | Sin autenticación | Demonios Docker expuestos |
| Kubernetes | 6443/10250 | Sin autenticación | API/kubelet K8s expuestos |

### Comunicaciones
| Protocolo | Puerto | Métodos de autenticación | Caso de uso |
|----------|------|--------------|----------|
| SMTP | 25/587 | Contraseña | Relevo de correo |
| IMAP | 143/993 | Contraseña | Acceso a buzón |
| POP3 | 110/995 | Contraseña | Acceso a buzón |

---

## Claves SSH incorrectas integradas

Despliegue de un solo binario sin necesidad de archivos de clave 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)** integradas 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"

Para SNMP, el modo también controla la profundidad de la lista de palabras incorporada (consulte [Pruebas de Cadenas de Comunidad SNMP](#snmp-community-string-testing)).

---

## Soporte de Proxy SOCKS5

La bandera `--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

---

## Integración como biblioteca

Para desarrolladores que construyen 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

│   │   │   │   ├── 0xSSRF-Toolkit.pdf
│   │   │   │   └── SSRFmap.pdf
``````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)
        }
    }
}

**Cómo funciona:**

1. **Detección** — Brutus sondea objetivos HTTP para detectar el tipo de autenticación (Basic Auth vs. basada en formularios)
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. **Prueba** — Prueba las credenciales descubiertas contra el objetivo

**Para objetivos con HTTP Basic Auth:**
- Sonda `/` para capturar encabezados HTTP
- Identifica el dispositivo a partir del encabezado Server, el realm de WWW-Authenticate, etc.
- Claude sugiere posibles credenciales predeterminadas
- Prueba pares de credenciales automáticamente

**Para objetivos con autenticación basada en formularios HTTP:**
- Usa Chrome sin cabeza 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 llena y envía el formulario

**Requisitos:**
- `ANTHROPIC_API_KEY` — **Obligatorio** para Claude Vision (identificación del dispositivo + sugerencias de credenciales)
- `PERPLEXITY_API_KEY` — *Opcional* para investigación web adicional
- Chrome/Chromium instalado (solo para autenticación basada en formularios)

**Los protocolos no HTTP (SSH, MySQL, etc.) no se ven afectados por `--experimental-ai`** — continúan usando pruebas de credenciales estándar.

---

## RDP: Detección y explotación del backdoor de teclas de accesibilidad

Brutus incluye detección automática del **backdoor de teclas de accesibilidad** (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 referencia
3. Envía 5 pulsaciones de la tecla Shift (el disparador de teclas de accesibilidad)
4. Captura el mapa de bits de 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

**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.

Esto se conecta, activa la puerta trasera, escribe el comando, presiona Enter, espera la salida y guarda una captura de pantalla PNG del resultado.

### Terminal Web Interactiva (`--web`)```bash
# Start interactive web terminal
brutus logon --target 10.0.0.50:3389 --web

**Implementación técnica:** El soporte del protocolo RDP utiliza [IronRDP](https://github.com/Devolutions/IronRDP) (Rust) compilado a WebAssembly y ejecutado mediante [wazero](https://github.com/tetratelabs/wazero), manteniendo el diseño zero-CGO, single-binary de Brutus.

---

## Enumeración de Cuentas

El subcomando `enum` enumera qué oráculos de existencia de cuentas funcionan para una organización (y enumera correos electrónicos contra ellos) o enumera usuarios de Active Directory, todo sin enviar contraseñas.

### Enumeración de Oráculos de Existencia de Cuentas

Identifica qué oráculos de existencia de cuentas no autenticados (microsoft365, google, github, más el oráculo de Microsoft Teams) funcionan para una organización, valídelos contra un usuario conocido-válido, luego enumere correos electrónicos candidatos contra los oráculos que funcionan. El reconocimiento DNS TXT revela los oráculos candidatos; la validación contra `--known-valid` es el titular. `--known-valid` es requerido, y la enumeración se ejecuta solo contra los oráculos que lo confirman:```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]

### Generación de correos electrónicos/nombres de usuario

Genera direcciones de correo electrónico o nombres de usuario a partir de listas de palabras de nombres y apellidos incrustadas:```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

### Microsoft Teams / Autenticación de Entra ID

Obtén un token de acceso OAuth2, un token de actualización y un token de ID de Microsoft Entra ID (Azure AD) mediante el [flujo de código de dispositivo](https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-device-code) (RFC 8628). Los tokens resultantes se pueden usar para realizar llamadas a Microsoft Graph API, enumeración de Teams y auditoría a través de herramientas como [ROADtools](https://github.com/dirkjanm/ROADtools) o consultas personalizadas de Graph.```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

#### Enumeración de usuarios de Teams

Una vez autenticado, enumera los usuarios corporativos de Teams por dirección de correo electrónico. Cada resultado es `exists`, `blocked` (el inquilino prohíbe la búsqueda externa pero el usuario puede existir), `not found` o `unknown` (fallo de autenticación/transporte). Las cuentas Personal/Live no son compatibles — solo inquilinos 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 el mismo generador de nombres/apellidos ordenados por frecuencia que `enum generate`; `--format` selecciona el diseño de nombre de usuario y `--limit` limita la generación a los primeros N candidatos (los más probables). `--domain` puede combinarse con `-e`/`-E`.

---

## Limitaciones Conocidas

### Detección Heurística de Sticky Keys

- **Falsos negativos alternantes:** La detección solo heurística (`brutus logon` sin `--experimental-ai`) puede producir falsos negativos en escaneos repetidos contra el mismo objetivo. Tras una detección exitosa, la ventana de cmd.exe permanece abierta en el servidor. Las conexiones posteriores ven el cmd.exe en el marco de referencia (baseline), y dado que enviar 5 veces Shift no crea una nueva ventana, la diferencia de píxeles es mínima, lo que resulta en un veredicto "limpio". Esto no afecta al modo `--experimental-ai`, que utiliza el análisis de la API Vision directamente sobre el cuadro de respuesta (no una diferencia baseline-vs-respuesta) e identifica de manera confiable la ventana de terminal independientemente del estado anterior.
- **Solución alternativa:** Utilice `--experimental-ai` con `ANTHROPIC_API_KEY` configurada para una detección consistente en escaneos repetidos, o permita un tiempo de espera entre escaneos para que la sesión RDP se reinicie.

### Plugin del Navegador

- Requiere Chrome/Chromium instalado localmente
- El modo sin interfaz gráfica (headless) puede no funcionar en todos los sistemas
- Algunas páginas de inicio de sesión con mucho JavaScript pueden requerir tiempo de espera adicional