---

## Anwendungsfälle

### Penetrationstests
- Entdeckte Anmeldeinformationen während interner Bewertungen über mehrere Dienste hinweg validieren
- Muster der Passwortwiederverwendung über Datenbank- und Dateifreigabedienste testen
- Standard-Anmeldeinformationen auf neu bereitgestellter Infrastruktur identifizieren

### Red-Team-Operationen
- Schnelle Validierung von Anmeldeinformationen nach Passwort-Leaks oder Phishing-Kampagnen
- Möglichkeiten der lateralen Bewegung über Netzwerkdienste testen
- Kompromittierte Anmeldeinformationen über heterogene Umgebungen hinweg validieren

### Spraying von privaten Schlüsseln

Haben Sie einen privaten Schlüssel auf einem kompromittierten System gefunden? Sprayen Sie ihn über das 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

### Sicherheitsvalidierung
- Testen Sie Standard-Anmeldedaten auf neu bereitgestellten Diensten
- Überprüfen Sie die Durchsetzung von Passwortrichtlinien auf allen Plattformen
- Erstellen Sie Prüfpfade für Compliance- und Sicherheitsbewertungen

---

## Installation

### Vorgefertigte Binärdateien (Empfohlen)

Download from [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/

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

Jeder Unterbefehl hat Aliase zur Auffindbarkeit:
| Unterbefehl | Aliase |
|------------|---------|
| `creds` | `services`, `defaults`, `credentials` |
| `web` | `http`, `panels` |
| `snmp` | `community` |
| `badkeys` | `keys`, `ssh-keys`, `badkey` |
| `logon` | `stickykeys`, `sticky-keys`, `utilman`, `sethc`, `winlogon`, `accessibility` |
| `enum` | *(keine)* |```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

### Ausgabe Beispiel```
$ 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)

JSON-Ausgabe für 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"}

#### Szenario 2: Bug Bounty Recon auf einer Zieldomain```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 4: SSH-Key-Tests in der gesamten Infrastruktur```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)'

### Import von Scan-Tools (Nmap & Masscan)

Brutus kann Ziele direkt aus **nmap**- und **masscan**-Scanausgabedateien importieren, sodass keine Formatkonvertierung oder Zwischentools erforderlich sind.

#### Nmap XML Import (`--nmap-file`)

Importiert Ziele aus nmaps XML-Ausgabe (`-oX`). Nmap bietet Service-Fingerprinting, sodass Brutus erkannte Dienste automatisch dem richtigen 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

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

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

Brutus automatisch:
- JSON-, URI-Schema- und reine Zielformate parst
- Dienste Protokollen zuordnet
- Passende Standard-Anmeldeinformationen testet
- Ergebnisse im passenden JSON-Format ausgibt

### Pipeline-Ausgabeformat

Brutus gibt nur erfolgreiche Anmeldeinformationen 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"}

### Eingebettete Schlüsselsammlung

| Produkt | CVE | Standardbenutzer | Beschreibung |
|---------|-----|------------------|--------------|
| Vagrant | - | vagrant, root | HashiCorp Vagrant unsicherer Schlüssel |
| F5 BIG-IP | CVE-2012-1493 | root | Statischer SSH-Host-Schlüssel |
| ExaGrid | CVE-2016-1561 | root | Hintertür für Backup-Appliance |
| 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 setzt Leistungsoptimierungs-Voreinstellungen, die die Abdeckung gegen Sicherheit abwägen:

| Modus | Threads | Timeout | Ratenlimit | Jitter | Wiederholungen | Anwendungsfall |
|-------|---------|---------|------------|--------|----------------|----------------|
| `cautious` | 5 | 15s | 2 req/s | 500ms | 1 | Produktionsumgebungen, Sperrungen vermeiden |
| `default` | 10 | 10s | Unbegrenzt | Keine | 2 | Standardtests |
| `aggressive` | 20 | 10s | Unbegrenzt | Keine | 3 | Labor-/CTF-Umgebungen, maximale Abdeckung |

Modus-Voreinstellungen werden zuerst angewendet, danach überschreiben explizite 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

Unterstützte Schemata:
- `socks5://` — Standard-SOCKS5-Proxy (clientseitige DNS-Auflösung)
- `socks5h://` — SOCKS5 mit fernseitiger DNS-Auflösung (nützlich beim Anvisieren interner Hostnamen)

---

## SNMP-Community-String-Tests

Der Unterbefehl `snmp` bietet dedizierte Tests von SNMP-v1/v2c-Community-Strings mit abgestuften Wortlisten, die durch das globale Flag `--mode` gesteuert werden:

| Modus | Strings | Abdeckung |
|-------|---------|-----------|
| `cautious` | ~25 | Gängige Strings (public, private, community, usw.) |
| `default` | ~25 | Wie bei cautious |
| `aggressive` | 200+ | Umfassend (herstellerabhängig, 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

**Der Inhalt scheint leer zu sein.**  
Wir benötigen mehr Inhalt, um fortzufahren.  
- [Zurück nach oben](#readme)  
---  
## Übersetzung  
Die Übersetzung der hier genannten Werkzeuge bezieht sich auf eine Konvertierung von einer natürlichen Sprache in eine andere. Dies trifft normalerweise nicht auf Open-Source-Cybersicherheitswerkzeuge zu, die typischerweise auf Englisch sind, aber die README bietet manchmal übersetzte Versionen oder Beschreibungen.```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)
        }
    }
}

**Wie es funktioniert:**

1. **Erkennung** — Brutus testet 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. **Anmeldeinformationsvorschläge** — Claude schlägt Standard-Anmeldeinformationen aus seinen Trainingsdaten vor
4. **Optionale Websuche** — Perplexity (falls konfiguriert) sucht online nach weiteren Anmeldeinformationen
5. **Testen** — Testet die gefundenen Anmeldeinformationen gegen das Ziel

**Für HTTP Basic Auth Ziele:**
- Testet `/` um HTTP-Header zu erfassen
- Identifiziert Gerät aus Server-Header, WWW-Authenticate-Realm etc.
- Claude schlägt wahrscheinliche Standard-Anmeldeinformationen vor
- Testet Anmeldeinformationspaare automatisch

**Für HTTP formularbasierte Auth-Ziele:**
- Verwendet headless Chrome zum Rendern und Erstellen eines Screenshots der Seite
- Claude Vision identifiziert das Login-Formular, den Gerätetyp und schlägt Anmeldeinformationen vor
- Perplexity (optional) sucht nach weiteren Standard-Anmeldeinformationen
- Browser-Automatisierung füllt und sendet das Formular ab

**Anforderungen:**
- `ANTHROPIC_API_KEY` — **Erforderlich** für Claude Vision (Geräteidentifikation + Anmeldeinformationsvorschläge)
- `PERPLEXITY_API_KEY` — *Optional* für zusätzliche Websuche-Recherche
- Chrome/Chromium installiert (nur für formularbasierte Auth)

**Nicht-HTTP-Protokolle (SSH, MySQL, etc.) werden von `--experimental-ai` nicht beeinflusst** — sie verwenden weiterhin Standard-Anmeldeinformationstests.

---

## RDP: Erkennung und Ausnutzung der Sticky Keys Hintertür

Brutus beinhaltet automatische Erkennung der **Sticky Keys Hintertür** (MITRE ATT&CK [T1546.008](https://attack.mitre.org/techniques/T1546/008/)) auf RDP-Zielen. Diese Pre-Authentifizierungsprüfung läuft auf Nicht-NLA RDP-Zielen — keine Anmeldeinformationen erforderlich.

**Wie es funktioniert:**

1. Stellt eine Verbindung zum RDP-Ziel her und handelt eine Nicht-NLA-Sitzung aus
2. Erfasst den Login-Bildschirm-Bitmap als Basislinie
3. Sendet 5x die Umschalttaste (der Sticky Keys Auslöser)
4. Erfasst den Antwort-Bitmap
5. Heuristische Analyse erkennt, ob ein Terminalfenster erschienen ist (cmd.exe, PowerShell usw.)
6. Optional Bestätigung über 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

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

Dies verbindet, löst die Hintertür aus, tippt den Befehl, drückt die Eingabetaste, wartet auf die Ausgabe und speichert einen PNG-Screenshot des Ergebnisses.

### Interaktives Web-Terminal (`--web`)

Starten Sie einen browserbasierten RDP-Viewer für die Live-Interaktion mit der Eingabeaufforderung der Hintertür:```bash
# Start interactive web terminal
brutus logon --target 10.0.0.50:3389 --web

**Technische Umsetzung:** Die RDP-Protokollunterstützung verwendet [IronRDP](https://github.com/Devolutions/IronRDP) (Rust), das zu WebAssembly kompiliert und über [wazero](https://github.com/tetratelabs/wazero) ausgeführt wird, wodurch Brutus' Zero-CGO-, Single-Binary-Design beibehalten wird.

---

## Konto-Enumeration

Der Unterbefehl `enum` ermittelt, welche Kontoexistenz-Orakel für eine Organisation funktionieren (und zählt E-Mails gegen diese auf) oder zählt Active Directory-Benutzer auf, alles ohne Passwörter zu senden.

### Kontoexistenz-Orakel-Enumeration

Identifizieren Sie, welche nicht authentifizierten Kontoexistenz-Orakel (microsoft365, google, github, plus das Microsoft Teams-Orakel) für eine Organisation funktionieren, validieren Sie sie anhand eines bekannten gültigen Benutzers, und zählen Sie dann Kandidaten-E-Mails gegen die funktionierenden Orakel auf. DNS-TXT-Recon deckt die Kandidaten-Orakel auf; die Validierung gegen `--known-valid` ist das Highlight. `--known-valid` ist erforderlich, und die Enumeration läuft nur gegen die Orakel, die es bestätigen:```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]

### Email/Username Generation

E-Mail-Adressen oder Benutzernamen aus eingebetteten Wortlisten mit Vor-/Nachnamen generieren:```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 / Entra ID Authentifizierung

Erhalten Sie ein OAuth2-Zugriffstoken, ein Aktualisierungstoken und ein ID-Token von Microsoft Entra ID (Azure AD) unter Verwendung des [device code flow](https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-device-code) (RFC 8628). Die resultierenden Token können für Microsoft Graph-API-Aufrufe, Teams-Enumeration und Auditing über Tools wie [ROADtools](https://github.com/dirkjanm/ROADtools) oder benutzerdefinierte Graph-Abfragen verwendet werden.```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

#### Teams-Benutzerenumeration

Sobald authentifiziert, enumerieren Sie Unternehmens-Teams-Benutzer anhand der E-Mail-Adresse. Jedes Ergebnis ist `exists`, `blocked` (der Mandant verbietet externe Suche, aber der Benutzer könnte existieren), `not found` oder `unknown` (Authentifizierungs-/Transportfehler). Persönliche/Live-Konten werden nicht unterstützt — nur Unternehmensmandanten.```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` verwendet denselben frequenzbasierten Generator für Vor- und Nachnamen wie
`enum generate`; `--format` wählt das Benutzernamen-Layout aus und `--limit` begrenzt
die Generierung auf die ersten N (wahrscheinlichsten) Kandidaten. `--domain` kann mit
`-e`/`-E` kombiniert werden.

---

## Bekannte Einschränkungen

### Heuristische Erkennung der Feststelltaste

- **Wechselnde Fehlalarme:** Die rein heuristische Erkennung (`brutus logon` ohne `--experimental-ai`) kann bei wiederholten Scans gegen dasselbe Ziel falsch-negative Ergebnisse liefern. Nach einer erfolgreichen Erkennung bleibt das cmd.exe-Fenster auf dem Server geöffnet. Nachfolgende Verbindungen sehen das cmd.exe im Basisrahmen, und da das fünfmalige Senden von Umschalt keine neues Fenster erzeugt, ist der Pixelunterschied minimal – was zu einem „sauberen“ Urteil führt. Dies betrifft nicht den Modus `--experimental-ai`, der die Vision-API-Analyse des Antwortrahmens direkt nutzt (kein Differenz zwischen Basis und Antwort) und das Terminalfenster unabhängig vom vorherigen Zustand zuverlässig identifiziert.
- **Workaround:** Verwenden Sie `--experimental-ai` mit gesetzter `ANTHROPIC_API_KEY` für eine konsistente Erkennung bei wiederholten Scans, oder lassen Sie zwischen den Scans eine Abkühlphase zu, damit die RDP-Sitzung zurückgesetzt wird.

### Browser-Plug-in

- Erfordert lokal installiertes Chrome/Chromium
- Der headless-Modus funktioniert möglicherweise nicht auf allen Systemen
- Einige JavaScript-lastige Anmeldeseiten erfordern möglicherweise zusätzliche Wartezeit