---

## Casi d'Uso

### Test di Penetrazione
- Validare le credenziali scoperte attraverso più servizi durante valutazioni interne
- Testare i modelli di riutilizzo delle password nei servizi di database e condivisione file
- Identificare credenziali predefinite su infrastrutture appena distribuite

### Operazioni Red Team
- Validazione rapida delle credenziali dopo dump di password o campagne di phishing
- Testare opportunità di movimento laterale attraverso i servizi di rete
- Validare credenziali compromesse in ambienti eterogenei

### Private Key Spraying

Trovata una chiave privata su un sistema compromesso? Spargila attraverso la rete per scoprire dove altro concede 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

### Convalida della sicurezza
- Testare le credenziali predefinite sui servizi appena distribuiti
- Convalidare l'applicazione delle politiche delle password su diverse piattaforme
- Generare tracce di audit per conformità e 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/

### Installazione Go```bash
go install github.com/praetorian-inc/brutus/cmd/brutus@latest

Ogni sottocomando ha alias per la rilevabilità:

| Sottocomando | Alias |
|------------|---------|
| `creds` | `services`, `defaults`, `credentials` |
| `web` | `http`, `panels` |
| `snmp` | `community` |
| `badkeys` | `keys`, `ssh-keys`, `badkey` |
| `logon` | `stickykeys`, `sticky-keys`, `utilman`, `sethc`, `winlogon`, `accessibility` |
| `enum` | *(nessuno)* |```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

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

Output JSON per l'integrazione pipeline (restituisce solo le credenziali riuscite):```
$ 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"}

#### Scenario 2: Bug Bounty Recon 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 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)'

### Importazione strumenti di scansione (Nmap & Masscan)

Brutus può importare target direttamente dai file di output di scansione di **nmap** e **masscan**, eliminando la necessità di conversione di formato o strumenti intermedi.

#### Importazione XML di Nmap (`--nmap-file`)

Importa 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

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

**Nerva URI** (output predefinito di Nerva, nessun `--json` necessario):```bash
# Nerva outputs URI-scheme lines by default
$ echo "github.com:22" | nerva
ssh://github.com:22 (20.205.243.166)

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

Brutus automaticamente:
- Analizza JSON, schema URI e formati di target bare
- Mappa i servizi ai protocolli
- Testa le credenziali predefinite appropriate
- Restituisce i risultati in formato JSON corrispondente

### Formato di output della pipeline

Brutus restituisce solo le credenziali riuscite 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"}

### Embedded Key Collection

| 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 bilanciatore di carico |
| Ceragon FibeAir | CVE-2015-0936 | mateidu | Backhaul wireless |
| Array Networks | - | sync | Appliance vAPV/vxAG |
| Quantum DXi | - | root | Appliance di deduplicazione |
| Loadbalancer.org | - | root | Bilanciatori di carico enterprise |

---

## Modalità di aggressività

Il flag globale `--mode` (`-m`) controlla l'aggressività su tutti i sottocomandi. Imposta preset di ottimizzazione delle prestazioni che bilanciano copertura e sicurezza:

| Modalità | Threads | Timeout | Rate Limit | Jitter | Retries | 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 eventuali flag CLI espliciti li sovrascrivono:```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

Schemi supportati:
- `socks5://` — Proxy SOCKS5 standard (risoluzione DNS lato client)
- `socks5h://` — SOCKS5 con risoluzione DNS remota (utile quando si puntano hostname interni)

---

## Test delle stringhe community SNMP

Il sottocomando `snmp` fornisce test dedicati delle stringhe community 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 | Uguale a cautious |
| `aggressive` | 200+ | Completa (specifiche del fornitore, 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

- **Privacy ed Etica**
  - [Privacy ed Etica](https://github.com/praetorian-inc/brutus/blob/HEAD/privacy_ethics.md)
- **Articoli e Rapporti**
  - [Articoli e Rapporti](https://github.com/praetorian-inc/brutus/blob/HEAD/articles_reports.md)```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)
        }
    }
}

**Come funziona:**

1. **Rilevamento** — Brutus sonda i target HTTP per rilevare il tipo di autenticazione (Basic Auth vs form-based)
2. **Identificazione del dispositivo** — Claude Vision analizza gli screenshot per identificare il dispositivo/applicazione
3. **Suggerimento di credenziali** — Claude suggerisce credenziali predefinite basate sui suoi dati di addestramento
4. **Ricerca web opzionale** — Perplexity (se configurato) cerca online ulteriori credenziali
5. **Test** — Verifica le credenziali trovate sul target

**Per i target con autenticazione 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
- Testa automaticamente le coppie di credenziali

**Per i target con autenticazione HTTP form-based:**
- Utilizza Chrome headless per renderizzare e fare screenshot della pagina
- Claude Vision identifica il form di login, il tipo di dispositivo e suggerisce credenziali
- Perplexity (opzionale) cerca ulteriori credenziali predefinite
- L'automazione del browser compila e invia il form

**Requisiti:**
- `ANTHROPIC_API_KEY` — **Obbligatoria** per Claude Vision (identificazione del dispositivo + suggerimento credenziali)
- `PERPLEXITY_API_KEY` — *Opzionale* per ulteriori ricerche web
- Chrome/Chromium installato (solo per autenticazione form-based)

**I protocolli non HTTP (SSH, MySQL, ecc.) non sono influenzati da `--experimental-ai`** — continuano a utilizzare il test standard delle credenziali.

---

## RDP: Rilevamento e sfruttamento 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: non sono necessarie credenziali.

**Come funziona:**

1. Si connette al target RDP e negozia una sessione non NLA
2. Cattura la bitmap della schermata di login come riferimento
3. Invia 5x il tasto Shift (il trigger per 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 l'API Claude Vision (quando `ANTHROPIC_API_KEY` è impostata)```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

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

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 interagire in tempo reale con il prompt dei comandi del backdoor:```bash
# Start interactive web terminal
brutus logon --target 10.0.0.50:3389 --web

**Implementazione tecnica:** Il supporto del protocollo RDP utilizza [IronRDP](https://github.com/Devolutions/IronRDP) (Rust) compilato in WebAssembly ed eseguito tramite [wazero](https://github.com/tetratelabs/wazero), mantenendo il design a singolo binario e zero-CGO di Brutus.

---

## Enumerazione degli account

Il sottocomando `enum` enumera quali oracoli di esistenza account funzionano per un'organizzazione (e enumera le email rispetto a essi) oppure enumera gli utenti di Active Directory, il tutto senza inviare password.

### Enumerazione degli oracoli di esistenza account

Identifica quali oracoli di esistenza account non autenticati (microsoft365, google, github, più l'oracolo di Microsoft Teams) funzionano per un'organizzazione, li convalida rispetto a un utente noto valido, quindi enumera le email candidate rispetto agli oracoli funzionanti. La ricognizione DNS TXT evidenzia gli oracoli candidati; la convalida rispetto a `--known-valid` è il punto principale. `--known-valid` è obbligatorio e l'enumerazione viene eseguita solo sugli oracoli che lo confermano:```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]

### Generazione di Email/Username

Genera indirizzi email o nomi utente da wordlist incorporate di nomi e cognomi:```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

---
### Autenticazione Microsoft Teams / Entra ID

Ottieni un token di accesso OAuth2, un token di aggiornamento e un token ID da Microsoft Entra ID (Azure AD) utilizzando il [flusso del codice del dispositivo](https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-device-code) (RFC 8628). I token risultanti possono essere utilizzati per chiamate API di Microsoft Graph, enumerazione di Teams e auditing tramite strumenti come [ROADtools](https://github.com/dirkjanm/ROADtools) o query Graph personalizzate.```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

#### Enumerazione utenti di Teams

Una volta autenticati, enumera gli utenti aziendali di Teams tramite indirizzo email. Ogni risultato è `exists`, `blocked` (il tenant proibisce la ricerca esterna ma l'utente potrebbe esistere), `not found`, o `unknown` (errore di autenticazione/trasporto). Gli account personali/Live non sono supportati — solo tenant aziendali.```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` riutilizza lo stesso generatore di nomi e cognomi ordinati per frequenza di
`enum generate`; `--format` seleziona la struttura del nome utente e `--limit` limita
la generazione ai primi N candidati (più probabili). `--domain` può essere combinato
con `-e`/`-E`.

---

## Limitazioni Note

### Rilevamento Euristico dei Tasti Bloccati

- **Falsi negativi alternati:** Il rilevamento basato solo su euristiche (`brutus logon` senza `--experimental-ai`) può produrre falsi negativi su scansioni ripetute contro lo stesso target. Dopo un rilevamento riuscito, la finestra cmd.exe rimane aperta sul server. Le connessioni successive vedono cmd.exe nel fotogramma di base e, poiché l'invio di 5x Shift non crea una nuova finestra, la differenza di pixel è minima — con un verdetto "pulito". Questo non influisce sulla modalità `--experimental-ai`, che utilizza l'analisi Vision API del fotogramma di risposta direttamente (non una differenza baseline-risposta) e identifica in modo affidabile la finestra del terminale indipendentemente dallo stato precedente.
- **Soluzione alternativa:** Usa `--experimental-ai` con `ANTHROPIC_API_KEY` impostata per un rilevamento consistente su scansioni ripetute, oppure lascia un intervallo di raffreddamento tra le scansioni per permettere alla sessione RDP di resettarsi.

### Plugin del Browser

- Richiede Chrome/Chromium installato localmente
- La modalità headless potrebbe non funzionare su tutti i sistemi
- Alcune pagine di login con molti JavaScript potrebbero richiedere più tempo di attesa