Outil de test d'identifiants rapide et sans dépendances en Go. Force brute sur SSH, MySQL, PostgreSQL, Redis, MongoDB, SMB et plus de 20 protocoles. Alternative à Hydra avec intégration native du 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 toi, Brutus ? » — Les derniers mots avant que les identifiants ne tombent.</em>
</p>
<p align="center">
<strong>Outil moderne de test d'identifiants en Go pur</strong>
</p>
<p align="center">
<a href="#installation">Installation</a> •
<a href="#quick-start">Démarrage rapide</a> •
<a href="#pipeline-integration">Pipeline</a> •
<a href="#supported-protocols">Protocoles</a> •
<a href="#account-enumeration">Énumération</a> •
<a href="#socks5-proxy-support">Proxy</a> •
<a href="#library-integration">Bibliothèque</a>
</p>
---
## Aperçu
Brutus est un outil de test d'authentification multi-protocoles conçu pour combler une lacune critique dans l'outillage de sécurité offensive : la validation efficace des identifiants sur divers services réseau. Alors que les outils axés sur HTTP sont nombreux, les testeurs d'intrusion et les opérateurs red team rencontrent fréquemment des bases de données, SSH, SMB et d'autres services réseau qui nécessitent des capacités de test d'authentification spécialement conçues.
Développé en Go sous forme de binaire unique sans dépendances externes, Brutus s'intègre parfaitement avec [Nerva](https://github.com/praetorian-inc/nerva) pour la découverte automatisée de services, permettant aux opérateurs d'identifier et de tester rapidement les vecteurs d'authentification sur des plages réseau entières.
**Fonctionnalités clés :**
- **Zéro dépendance :** Binaire unique, multiplateforme (Linux, Windows, macOS)
- **43 protocoles :** SSH, RDP, MySQL, PostgreSQL, MSSQL, Oracle, Redis, SMB, LDAP, WinRM, SNMP, HTTP Basic Auth, MQTT, et plus encore
- **Prise en charge du proxy SOCKS5 :** Acheminez tout le trafic via un proxy SOCKS5 avec `--proxy`
- **Modes d'agressivité :** `--mode cautious|default|aggressive` pour ajuster la couverture par rapport à la sécurité
- **Intégration pipeline :** Prise en charge native des workflows Nerva, naabu, nmap et masscan
- **Clés compromises intégrées :** Collection intégrée de clés SSH connues (Vagrant, F5, ExaGrid, etc.)
- **Énumération de comptes :** énumération par oracle d'existence de compte, énumération d'utilisateurs Kerberos, génération d'e-mails, authentification par code d'appareil Microsoft Teams/Entra ID
- **Bibliothèque Go :** Importez directement dans vos outils d'automatisation de sécurité
- **Prêt pour la production :** Limitation de débit, mise en pool des connexions et gestion complète des erreurs
---
## Pourquoi Brutus ?
Les outils traditionnels comme **THC Hydra** ont bien servi la communauté de la sécurité, mais ils s'accompagnent de frictions importantes : chaînes de dépendances complexes, problèmes de compilation spécifiques à chaque plateforme et aucune intégration native avec les workflows de reconnaissance modernes.
**Brutus** est spécialement conçu pour la sécurité offensive moderne :
- **Déploiement véritablement sans dépendance :** Téléchargez un binaire unique et exécutez-le. Pas de `libssh-dev`, pas de `libmysqlclient-dev`, pas d'erreurs de compilation. Fonctionne de manière identique sur Linux, macOS et Windows.
- **Intégration pipeline native :** Brutus parle JSON et s'intègre directement avec [Nerva](https://github.com/praetorian-inc/nerva), [naabu](https://github.com/projectdiscovery/naabu), [nmap](https://nmap.org) et [masscan](https://github.com/robertdavidgraham/masscan). Acheminez les services découverts directement vers le test d'identifiants sans conversion de format ni script.
- **Renseignement intégré :** Les clés SSH compromises connues (Vagrant, F5 BIG-IP, ExaGrid, etc.) sont compilées dans le binaire. Utilisez `brutus badkeys` pour les tester contre des cibles SSH.
- **Conception axée bibliothèque :** Importez Brutus directement dans vos outils de sécurité Go. Créez une automatisation personnalisée sans recourir à des processus externes.
```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
```
---
## Cas d'utilisation
### Tests d'intrusion
- Valider les identifiants découverts sur plusieurs services lors d'évaluations internes
- Tester les schémas de réutilisation de mots de passe sur les services de bases de données et de partage de fichiers
- Identifier les identifiants par défaut sur les infrastructures nouvellement déployées
### Opérations Red Team
- Validation rapide des identifiants après des fuites de mots de passe ou des campagnes de phishing
- Tester les opportunités de déplacement latéral sur les services réseau
- Valider les identifiants compromis dans des environnements hétérogènes
### Pulvérisation de clés privées
Vous avez trouvé une clé privée sur un système compromis ? Pulvérisez-la sur le réseau pour découvrir où elle accorde également l'accès :
```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
```
Ce pipeline découvre tous les services SSH, les identifie avec Nerva et teste la clé compromise contre des noms d'utilisateur courants—révélant des opportunités de mouvement latéral en quelques secondes.
### Test des panneaux d'administration web
Découvrez les services HTTP et testez les identifiants à l'aide d'une détection assistée par IA ou de listes d'identifiants manuelles :
```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
```
### Validation de sécurité
- Tester les identifiants par défaut sur les services nouvellement déployés
- Valider l'application de la politique de mots de passe sur toutes les plateformes
- Générer des pistes d'audit pour la conformité et les évaluations de sécurité
---
## Installation
### Binaires précompilés (recommandé)
Téléchargez depuis [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
```
### Installation via Go
```bash
go install github.com/praetorian-inc/brutus/cmd/brutus@latest
```
---
## Démarrage rapide
### Sous-commandes
<!-- BEGIN generated: cli-subcommands -->
Brutus organise ses fonctionnalités en ces sous-commandes ciblées :
```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 -->
Certaines sous-commandes portent des alias pour faciliter la découverte :
| Sous-commande | Alias |
| --- | --- |
| `badkeys` | `keys`, `ssh-keys`, `badkey` |
| `creds` | `services`, `defaults`, `credentials` |
| `snmp` | `community` |
| `web` | `http`, `panels` |
La référence complète — chaque sous-commande, alias et option, y compris celles masquées de `--help` — est générée dans [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
```
### Utilisation de 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
```
### Exemple de sortie
```
$ 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)
```
Avec le mode verbeux (`-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)
```
Sortie JSON pour l'intégration du pipeline (affiche uniquement les identifiants valides) :
```
$ 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"}
```
---
## Intégration au pipeline
Brutus s'intègre de manière transparente avec **[Nerva](https://github.com/praetorian-inc/nerva)** et **[naabu](https://github.com/projectdiscovery/naabu)** pour une reconnaissance réseau complète.
### Scénarios concrets
#### Scénario 1 : Analyse d'un réseau d'entreprise /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 '.'
```
#### Scénario 2 : Reconnaissance de bug bounty sur un domaine cible
```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
```
#### Scénario 3 : Chasse aux bases de données lors d'un audit interne
```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
```
#### Scénario 4 : Test de clés SSH sur l'infrastructure
```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)'
```
#### Scénario 5 : Test ciblé de service
```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
```
### Importation des résultats d'outils de scan (Nmap & Masscan)
Brutus peut importer des cibles directement depuis les fichiers de sortie de scan **nmap** et **masscan**, éliminant ainsi le besoin de conversion de format ou d'outils intermédiaires.
#### Importation XML Nmap (`--nmap-file`)
Importez des cibles depuis la sortie XML de nmap (`-oX`). Nmap fournit l'empreinte des services, donc Brutus mappe automatiquement les services détectés vers le protocole correct :
```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
```
Les noms de services Nmap sont automatiquement mappés aux protocoles Brutus (par exemple, `ms-wbt-server` → `rdp`, `microsoft-ds` → `smb`). TLS est détecté à partir de l'attribut `tunnel="ssl"` de nmap. Seuls les ports ouverts sur les hôtes actifs sont importés.
#### Import JSON Masscan (`--masscan-file`)
Importez des cibles depuis la sortie JSON de masscan (`-oJ`). Comme masscan est uniquement un scanner de ports (sans empreinte de service), vous devez soit spécifier `--protocol`, soit laisser Brutus effectuer une empreinte automatique avec 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
```
#### Combinaison avec d'autres workflows
Les options `--nmap-file` et `--masscan-file` fonctionnent avec toutes les sous-commandes et sont mutuellement exclusives avec `--target`, `--targets-file` et 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"
```
### Format d'entrée du pipeline
Brutus accepte plusieurs formats d'entrée depuis 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** (sortie Nerva par défaut, aucun `--json` nécessaire) :
```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
```
**Cibles nues** (auto-identifiées avec Nerva) :
```bash
echo "192.168.1.100:22" | brutus creds
```
Brutus automatiquement :
- Analyse les formats JSON, de schéma d'URI et de cible brute
- Associe les services aux protocoles
- Teste les identifiants par défaut appropriés
- Produit les résultats au format JSON correspondant
### Format de sortie du pipeline
Brutus produit uniquement les identifiants valides au format JSONL (un objet JSON par ligne) :
```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"}
```
**Remarque :** Les tentatives d'authentification échouées ne sont pas incluses dans la sortie JSON. Le champ `key` apparaît (avec la valeur `true`) lorsque l'authentification a utilisé une clé SSH au lieu d'un mot de passe. Le champ `llm_suggested` apparaît (avec la valeur `true`) lorsque les identifiants ont été suggérés par le système d'IA (`--experimental-ai`).
---
## Comparaison
| Fonctionnalité | Hydra | Medusa | Ncrack | **Brutus** |
|---------|:-----:|:------:|:------:|:----------:|
| Binaire unique | ❌ | ❌ | ❌ | ✅ |
| Zéro dépendance | ❌ | ❌ | ❌ | ✅ |
| Proxy SOCKS5 | ✅ | ❌ | ❌ | ✅ |
| Pipeline Nerva | ❌ | ❌ | ❌ | ✅ |
| Import Nmap/Masscan | ❌ | ❌ | ❌ | ✅ |
| Streaming JSON | ⚠️ | ❌ | ❌ | ✅ |
| Multiplateforme | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Erreurs cohérentes | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Développement actif | ✅ | ⚠️ | ❌ | ✅ |
| Clés compromises intégrées | ❌ | ❌ | ❌ | ✅ |
| Import de bibliothèque Go | ❌ | ❌ | ❌ | ✅ |
---
## Protocoles pris en charge
Brutus prend en charge **43 protocoles** :
### Services réseau
| Protocole | Port | Méthodes d'authentification | Cas d'usage |
|----------|------|--------------|----------|
| SSH | 22 | Mot de passe, clés privées | Serveurs, équipements réseau |
| FTP | 21 | Mot de passe | Serveurs de fichiers, appareils NAS |
| rsync | 873 | Secrets de module, anonyme | Synchronisation de fichiers |
| Telnet | 23 | Mot de passe | Systèmes hérités, appareils IoT |
| VNC | 5900 | Mot de passe | Bureaux à distance |
| RDP | 3389 | NLA/CredSSP, mot de passe | Serveurs Windows, postes de travail |
| SNMP | 161 | Chaîne de communauté | Équipements réseau, imprimantes |
| IPMI | 623/udp | RMCP | BMC / gestion hors bande |
| OPC UA | 4840 | Jeton de nom d'utilisateur, anonyme | ICS/SCADA |
### Services web
| Protocole | Port | Méthodes d'authentification | Cas d'usage |
|----------|------|--------------|----------|
| HTTP | 80 | Authentification basique | Panneaux d'administration (Grafana, Jenkins, etc.) |
| HTTPS | 443 | Authentification basique | Panneaux d'administration sécurisés |
| Navigateur | 80/443 | Formulaire | Connexion Microsoft/Entra via navigateur |
### Infrastructure d'entreprise
| Protocole | Port | Méthodes d'authentification | Cas d'usage |
|----------|------|--------------|----------|
| SMB | 445 | Mot de passe, NTLM | Réseaux Windows, partages de fichiers |
| LDAP | 389/636 | Bind DN | Active Directory, identité |
| WinRM | 5985/5986 | NTLM | Gestion à distance Windows |
### Bases de données
| Protocole | Port | Méthodes d'authentification | Cas d'usage |
|----------|------|--------------|----------|
| MySQL | 3306 | Mot de passe | Applications web |
| PostgreSQL | 5432 | Mot de passe | Applications modernes |
| MSSQL | 1433 | Mot de passe | Applications d'entreprise |
| MongoDB | 27017 | Mot de passe | Backends NoSQL |
| Redis | 6379 | Mot de passe | Mise en cache, sessions |
| Memcached | 11211 | SASL, anonyme | Mise en cache |
| Neo4j | 7687 | Mot de passe | Bases de données de graphes |
| Cassandra | 9042 | Mot de passe | Bases de données distribuées |
| CouchDB | 5984 | HTTP Basic | Stockages de documents |
| Elasticsearch | 9200 | HTTP Basic | Moteurs de recherche |
| InfluxDB | 8086 | HTTP Basic | Données de séries temporelles |
| Oracle | 1521 | Mot de passe | Bases de données d'entreprise |
| DB2 | 50000 | Mot de passe | Bases de données d'entreprise |
| Firebird | 3050 | Mot de passe | Bases de données embarquées |
### Conteneurs et orchestration
| Protocole | Port | Méthodes d'authentification | Cas d'usage |
|----------|------|--------------|----------|
| Docker | 2375/2376 | Non authentifié | Démons Docker exposés |
| Kubernetes | 6443/10250 | Non authentifié | API K8s/kubelet exposés |
### Communications
| Protocole | Port | Méthodes d'authentification | Cas d'usage |
|----------|------|--------------|----------|
| SMTP | 25/587 | Mot de passe | Relais de messagerie |
| IMAP | 143/993 | Mot de passe | Accès aux boîtes aux lettres |
| POP3 | 110/995 | Mot de passe | Accès aux boîtes aux lettres |
| ActiveMQ | 61616 | Mot de passe | Courtiers OpenWire |
| SIP | 5060/5061 | Digest | VoIP |
| TURN | 3478 | Mot de passe | Relais TURN |
| ZooKeeper | 2181 | Digest, anonyme | Coordination |
| NATS | 4222 | Mot de passe, anonyme | Messagerie |
| XMPP | 5222 | SASL PLAIN | Chat |
| MQTT | 1883/8883 | Mot de passe, anonyme | Courtiers IoT |
| AMQP | 5672/5671 | SASL PLAIN | RabbitMQ |
| Kafka | 9092 | SASL/PLAIN | Courtiers |
| SOCKS5 | 1080 | Authentification proxy SOCKS5 | Proxys |
---
## Clés SSH compromises intégrées
Déploiement en binaire unique sans fichier de clé externe nécessaire. Chaque clé est associée à son nom d'utilisateur par défaut pour une correspondance intelligente des identifiants, et le suivi des CVE permet des requêtes de conformité.
Brutus embarque les collections de clés **[rapid7/ssh-badkeys](https://github.com/rapid7/ssh-badkeys)** et **[Vagrant](https://github.com/hashicorp/vagrant)** intégrées dans le binaire :
```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"
```
### Collecte de clés intégrées
| Produit | CVE | Utilisateur par défaut | Description |
|---------|-----|--------------|-------------|
| Vagrant | - | vagrant, root | Clé non sécurisée HashiCorp Vagrant |
| F5 BIG-IP | CVE-2012-1493 | root | Clé d'hôte SSH statique |
| ExaGrid | CVE-2016-1561 | root | Backdoor d'appliance de sauvegarde |
| Monroe DASDEC | CVE-2013-0137 | root | Systèmes d'alerte d'urgence |
| Barracuda | CVE-2014-8428 | cluster | VM de répartiteur de charge |
| Ceragon FibeAir | CVE-2015-0936 | mateidu | Liaison sans fil |
| Array Networks | - | sync | Appliances vAPV/vxAG |
| Quantum DXi | - | root | Appliances de déduplication |
| Loadbalancer.org | - | root | Répartiteurs de charge d'entreprise |
---
## Modes d'agressivité
Le flag global `--mode` (`-m`) contrôle l'agressivité sur toutes les sous-commandes. Il définit des préréglages de réglage des performances qui équilibrent la couverture par rapport à la sécurité :
| Mode | Threads | Timeout | Limite de débit | Jitter | Tentatives | Cas d'usage |
|------|---------|---------|------------|--------|---------|----------|
| `cautious` | 5 | 15s | 2 req/s | 500ms | 1 | Environnements de production, éviter les verrouillages |
| `default` | 10 | 10s | Illimité | Aucun | 2 | Tests standard |
| `aggressive` | 20 | 10s | Illimité | Aucun | 3 | Environnements de labo/CTF, couverture maximale |
Les préréglages de mode sont appliqués en premier, puis tout flag CLI explicite les remplace :
```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
```
Pour SNMP, le mode contrôle également la profondeur de la wordlist intégrée (voir [Test des chaînes de communauté SNMP](#snmp-community-string-testing)).
---
## Prise en charge du proxy SOCKS5
L'option `--proxy` achemine toutes les connexions via un proxy SOCKS5. Cela fonctionne pour tous les protocoles et sous-commandes :
```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
```
Schémas pris en charge :
- `socks5://` — Proxy SOCKS5 standard (résolution DNS côté client)
- `socks5h://` — SOCKS5 avec résolution DNS distante (utile pour cibler des noms d'hôtes internes)
---
## Test des chaînes de communauté SNMP
La sous-commande `snmp` fournit un test dédié des chaînes de communauté SNMP v1/v2c avec des listes de mots à plusieurs niveaux contrôlées par le drapeau global `--mode` :
| Mode | Chaînes | Couverture |
|------|---------|----------|
| `cautious` | ~25 | Chaînes courantes (public, private, community, etc.) |
| `default` | ~25 | Identique à cautious |
| `aggressive` | 200+ | Complète (spécifiques aux fournisseurs, SCADA, caméras IP, stockage, etc.) |
```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
```
## Intégration de bibliothèque
Pour les développeurs qui créent des outils d'automatisation de la sécurité, Brutus peut également être importé en tant que bibliothèque 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)
}
}
}
```
---
## Expérimental : Détection d'identifiants assistée par IA
> **⚠️ Fonctionnalité expérimentale :** Les fonctionnalités d'IA nécessitent des clés d'API externes et sont en cours de développement actif.
### Le flag `--experimental-ai`
Le flag `--experimental-ai` active la détection automatique d'identifiants pour les services 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
```
**Fonctionnement :**
1. **Détection** — Brutus sonde les cibles HTTP pour détecter le type d'authentification (Basic Auth vs basée sur formulaire)
2. **Identification de l'appareil** — Claude Vision analyse les captures d'écran pour identifier l'appareil/l'application
3. **Suggestions d'identifiants** — Claude suggère des identifiants par défaut à partir de ses données d'entraînement
4. **Recherche web optionnelle** — Perplexity (si configuré) recherche des identifiants supplémentaires en ligne
5. **Test** — Teste les identifiants découverts contre la cible
**Pour les cibles HTTP Basic Auth :**
- Sonde `/` pour capturer les en-têtes HTTP
- Identifie l'appareil à partir de l'en-tête Server, du realm WWW-Authenticate, etc.
- Claude suggère des identifiants par défaut probables
- Teste automatiquement les paires d'identifiants
**Pour les cibles HTTP à authentification par formulaire :**
- Utilise Chrome en mode headless pour rendre et capturer la page
- Claude Vision identifie le formulaire de connexion, le type d'appareil et suggère des identifiants
- Perplexity (optionnel) recherche des identifiants par défaut supplémentaires
- L'automatisation du navigateur remplit et soumet le formulaire
**Prérequis :**
- `ANTHROPIC_API_KEY` — **Requis** pour Claude Vision (identification de l'appareil + suggestions d'identifiants)
- `PERPLEXITY_API_KEY` — *Optionnel* pour la recherche web supplémentaire
- Chrome/Chromium installé (pour l'authentification par formulaire uniquement)
**Les protocoles non-HTTP (SSH, MySQL, etc.) ne sont pas affectés par `--experimental-ai`** — ils continuent d'utiliser le test d'identifiants standard.
---
## RDP : Détection et exploitation de la backdoor Sticky Keys
Brutus inclut la détection automatique de la **backdoor sticky keys** (MITRE ATT&CK [T1546.008](https://attack.mitre.org/techniques/T1546/008/)) sur les cibles RDP. Cette vérification de pré-authentification s'exécute sur les cibles RDP non-NLA — aucun identifiant requis.
**Fonctionnement :**
1. Se connecte à la cible RDP et négocie une session non-NLA
2. Capture le bitmap de l'écran de connexion comme référence
3. Envoie 5x la touche Shift (le déclencheur des sticky keys)
4. Capture le bitmap de réponse
5. Une analyse heuristique détecte si une fenêtre de terminal est apparue (cmd.exe, PowerShell, etc.)
6. Confirme optionnellement via l'API Claude Vision (lorsque `ANTHROPIC_API_KEY` est défini)
```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
```
**Mode détection uniquement :** La sous-commande `logon` exécute la détection des portes dérobées sticky keys et utilman sans force brute :
```bash
# Detection only (no brute force)
brutus logon --target 10.0.0.50:3389
```
**Sortie de détection :**
```
[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.
```
### Exécution de commandes via backdoor (`--exec`)
Une fois une backdoor détectée, exécutez une commande sur le système distant via l'invite de commande pré-authentification :
```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 \
```
---
[Read more](https://github.com/praetorian-inc/brutus)