Attaque par force brute SSH avec Hydra

Introduction

Dans ce laboratoire, vous apprendrez à effectuer des attaques par force brute contre les services SSH à l'aide d'Hydra, un outil populaire de craquage de mots de passe en cybersécurité. L'exercice couvre l'installation d'Hydra, la configuration d'un serveur cible avec des informations d'identification faibles et l'exécution d'attaques à l'aide de listes de mots (wordlists) préparées.

Vous acquerrez une expérience pratique dans la configuration d'un environnement de test SSH et l'analyse des capacités de force brute d'Hydra. Ce laboratoire démontre des scénarios d'attaque réels tout en renforçant les principes du piratage éthique dans un environnement contrôlé.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL hydra(("Hydra")) -.-> hydra/HydraGroup(["Hydra"]) hydra/HydraGroup -.-> hydra/installation("Installation and Setup") hydra/HydraGroup -.-> hydra/password_creation("Password List Creation") hydra/HydraGroup -.-> hydra/username_creation("Username List Creation") hydra/HydraGroup -.-> hydra/ssh_attack("SSH Brute Force") hydra/HydraGroup -.-> hydra/output_saving("Output File Saving") hydra/HydraGroup -.-> hydra/verbose_mode("Verbose Mode Usage") hydra/HydraGroup -.-> hydra/troubleshooting("Basic Troubleshooting") subgraph Lab Skills hydra/installation -.-> lab-549926{{"Attaque par force brute SSH avec Hydra"}} hydra/password_creation -.-> lab-549926{{"Attaque par force brute SSH avec Hydra"}} hydra/username_creation -.-> lab-549926{{"Attaque par force brute SSH avec Hydra"}} hydra/ssh_attack -.-> lab-549926{{"Attaque par force brute SSH avec Hydra"}} hydra/output_saving -.-> lab-549926{{"Attaque par force brute SSH avec Hydra"}} hydra/verbose_mode -.-> lab-549926{{"Attaque par force brute SSH avec Hydra"}} hydra/troubleshooting -.-> lab-549926{{"Attaque par force brute SSH avec Hydra"}} end

Installer Hydra

Dans cette étape, nous allons installer Hydra, un puissant outil de craquage de mots de passe utilisé pour les attaques par force brute contre divers services réseau. Hydra est particulièrement utile pour les tests d'intrusion (penetration testing) car il peut systématiquement essayer différentes combinaisons de nom d'utilisateur et de mot de passe pour accéder aux systèmes sécurisés. Il prend en charge plusieurs protocoles, notamment SSH (que nous utiliserons dans ce laboratoire), FTP, HTTP, et plus encore.

Tout d'abord, ouvrez le terminal dans votre environnement de VM LabEx. Le terminal est votre interface principale pour exécuter des commandes sous Linux. Assurez-vous que vous êtes dans le répertoire de travail par défaut où nous effectuerons tout notre travail de laboratoire :
```
cd ~/project
```
Avant d'installer un nouveau logiciel, il est conseillé de mettre à jour votre liste de paquets. Cela garantit que vous obtiendrez la dernière version disponible d'Hydra et de toutes ses dépendances :
```
sudo apt update
```
Nous allons maintenant installer Hydra à l'aide du gestionnaire de paquets apt, qui gère l'installation de logiciels sur les systèmes basés sur Debian comme Ubuntu. L'option -y confirme automatiquement l'installation :
```
sudo apt install -y hydra
```
Après l'installation, vérifions qu'Hydra est correctement installé en vérifiant sa version. La commande head -n 1 affiche uniquement la première ligne de la sortie, qui contient les informations de version :
```
hydra -h | head -n 1
```
Vous devriez voir une sortie similaire à :
```
Hydra v9.2 (c) 2022 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes.
```
Hydra propose également une version d'interface graphique (GUI) pour ceux qui préfèrent les outils GUI. Bien que nous utilisions la version en ligne de commande dans ce laboratoire, vous pouvez éventuellement installer la version GUI GTK+ avec :
```
sudo apt install -y hydra-gtk
```

Configurer un serveur SSH cible

Dans cette étape, nous allons configurer un serveur SSH local qui servira de cible pour le craquage de mots de passe (password cracking) dans les étapes suivantes. Cela nous permet de pratiquer les techniques de test d'intrusion (penetration testing) dans un environnement contrôlé. SSH (Secure Shell) est un protocole utilisé pour la connexion à distance sécurisée entre les ordinateurs, et nous allons configurer une version vulnérable à des fins d'apprentissage.

Tout d'abord, assurez-vous que vous êtes dans le répertoire de travail par défaut. Ceci est important car nous voulons que tous nos fichiers de laboratoire soient organisés au même endroit :
```
cd ~/project
```
Installez le paquet serveur OpenSSH. Ce logiciel transformera votre machine en un serveur SSH qui peut accepter les connexions à distance :
```
sudo apt install -y openssh-server
```
Créez un compte d'utilisateur de test dédié avec un mot de passe faible (uniquement à des fins de démonstration). Dans les scénarios réels, les mots de passe faibles comme celui-ci sont exactement ce que les attaquants recherchent :
```
sudo useradd -m testuser
echo "testuser:password123" | sudo chpasswd
```
Configurez SSH pour autoriser l'authentification par mot de passe (temporairement pour ce laboratoire). Par défaut, de nombreux systèmes désactivent l'authentification par mot de passe pour des raisons de sécurité, mais nous l'activons ici pour démontrer le fonctionnement des attaques par force brute :
```
sudo sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/' /etc/ssh/sshd_config
```
Redémarrez le service SSH pour appliquer les modifications. Les services doivent souvent être redémarrés après que les modifications de configuration prennent effet :
```
sudo service ssh restart
```
Vérifiez que le serveur SSH est en cours d'exécution. Cette commande vérifie si notre serveur SSH est correctement actif et écoute les connexions :
```
sudo service ssh status
```
Vous devriez voir une sortie indiquant que le service est actif (en cours d'exécution). Si ce n'est pas le cas, il peut y avoir eu une erreur dans les étapes précédentes qui nécessite un dépannage (troubleshooting).
Testez la connexion SSH localement. Cette vérification finale confirme que tout fonctionne avant de passer à la phase d'attaque :
```
ssh testuser@localhost -o StrictHostKeyChecking=no
```
Lorsque vous y êtes invité, entrez le mot de passe password123. Après une connexion réussie, tapez exit pour revenir à votre session principale. L'option -o StrictHostKeyChecking=no empêche SSH de vous demander de vérifier l'empreinte digitale (fingerprint) du serveur, ce qui est acceptable pour cet environnement de laboratoire.

Préparer une liste de noms d'utilisateur et de mots de passe

Dans cette étape, nous allons créer des fichiers texte contenant des noms d'utilisateur et des mots de passe potentiels qu'Hydra utilisera pour tenter l'authentification SSH. Ces fichiers sont essentiels pour les attaques par force brute basées sur un dictionnaire (dictionary-based brute-force attacks). Une attaque par dictionnaire fonctionne en essayant systématiquement toutes les combinaisons possibles de noms d'utilisateur et de mots de passe à partir de listes prédéfinies, c'est pourquoi la préparation de bonnes listes est cruciale.

Tout d'abord, assurez-vous que vous êtes dans le répertoire de travail par défaut. Cela permet de garder vos fichiers de projet organisés et facilite leur référencement ultérieur :
```
cd ~/project
```
Créez un fichier de liste de noms d'utilisateur à l'aide de l'éditeur de texte nano. Les noms d'utilisateur courants sont souvent essayés en premier lors des attaques par force brute, car de nombreux systèmes utilisent des noms d'utilisateur par défaut ou prévisibles :
```
nano usernames.txt
```
Ajoutez ces noms d'utilisateur courants (appuyez sur Ctrl+O pour enregistrer, puis sur Ctrl+X pour quitter) :
```
admin
root
testuser
user
guest
```
Créez un fichier de liste de mots de passe. Les mots de passe faibles comme ceux-ci sont fréquemment utilisés et sont souvent les premières cibles lors des tests de sécurité :
```
nano passwords.txt
```
Ajoutez ces mots de passe courants :
```
password
password123
123456
qwerty
letmein
```
Vérifiez que les fichiers ont été créés correctement en affichant leur contenu. Cette étape de confirmation garantit qu'il n'y a pas de fautes de frappe ou de problèmes de formatage dans vos listes :
```
cat usernames.txt
cat passwords.txt
```
Vous devriez voir les listes que vous avez créées affichées dans le terminal.
(Facultatif) Générez des variations de mots de passe supplémentaires à l'aide de crunch. Cet outil permet de créer des listes de mots de passe plus complètes en générant automatiquement des combinaisons basées sur des modèles spécifiés :
```
sudo apt install -y crunch
crunch 4 6 0123456789 -o num_passwords.txt
```
Cela crée des mots de passe numériques d'une longueur comprise entre 4 et 6 caractères. La commande spécifie la longueur minimale (4), la longueur maximale (6) et le jeu de caractères (chiffres 0-9).

Exécuter Hydra contre SSH

Dans cette étape, nous allons utiliser Hydra pour effectuer une attaque par force brute (brute-force attack) contre notre serveur SSH local. La force brute est une méthode consistant à essayer de nombreuses combinaisons nom d'utilisateur/mot de passe jusqu'à trouver la bonne. Nous utiliserons les listes de mots (wordlists) que nous avons préparées précédemment pour automatiser ce processus.

Tout d'abord, naviguez vers le répertoire du projet contenant vos listes de mots. Cela garantit qu'Hydra peut trouver les fichiers que nous avons créés :
```
cd ~/project
```
Maintenant, nous allons exécuter Hydra avec des paramètres spécifiques. La structure de la commande indique à Hydra ce qu'il faut attaquer et comment. Décomposons-la :
```
hydra -L usernames.txt -P passwords.txt ssh://localhost -t 4 -vV
```
Explication des paramètres :
- -L usernames.txt : Pointeur vers notre liste de noms d'utilisateur possibles
- -P passwords.txt : Spécifie notre fichier de dictionnaire de mots de passe
- ssh://localhost : Cible le service SSH sur cette machine
- -t 4 : Contrôle la vitesse en limitant à 4 tentatives simultanées
- -vV : Affiche la progression détaillée dans le terminal
Pendant l'exécution d'Hydra, il affichera chaque tentative en temps réel. Lorsqu'il trouve des informations d'identification valides (valid credentials), elles apparaîtront clairement dans la sortie comme ceci :
```
[22][ssh] host: localhost   login: testuser   password: password123
```
(Facultatif) Pour conserver un enregistrement permanent des résultats, nous pouvons les enregistrer dans un fichier. Ceci est utile pour la documentation ou une analyse plus approfondie :
```
hydra -L usernames.txt -P passwords.txt ssh://localhost -t 4 -o results.txt
```
Une fois l'analyse terminée, vous pouvez afficher les résultats enregistrés avec :
```
cat results.txt
```

Résumé

Dans ce labo, vous avez appris à mener une attaque par force brute (brute force attack) sur SSH en utilisant Hydra, un outil puissant de craquage de mots de passe (password-cracking tool). L'exercice a couvert l'installation d'Hydra, la configuration d'un serveur SSH pour les tests et la création de listes ciblées de noms d'utilisateur/mots de passe.

Vous avez pratiqué l'exécution d'attaques basées sur un dictionnaire (dictionary-based attacks) et l'analyse des résultats, démontrant comment des informations d'identification faibles (weak credentials) peuvent être exploitées. Cette expérience pratique souligne le besoin critique de mots de passe forts et de méthodes d'authentification sécurisées en cybersécurité.