Attaquer plusieurs cibles avec Hydra

Introduction

Dans ce laboratoire (lab), vous apprendrez à attaquer plusieurs cibles simultanément en utilisant Hydra. Le laboratoire se concentre sur l'utilisation des capacités d'Hydra pour effectuer des tentatives de craquage de mots de passe contre une liste d'hôtes cibles.

Le laboratoire vous guide tout au long de la création d'un fichier de liste de cibles contenant des adresses IP ou des noms d'hôtes, du chargement de ce fichier dans Hydra à l'aide de l'option -M, de l'exécution d'une attaque SSH parallèle contre les cibles, et enfin, de la vérification de la sortie pour identifier les connexions réussies sur plusieurs hôtes. Cette expérience pratique vous fournira des compétences pratiques dans l'utilisation d'Hydra pour les scénarios de test de pénétration et d'audit de sécurité.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL hydra(("Hydra")) -.-> hydra/HydraGroup(["Hydra"]) hydra/HydraGroup -.-> hydra/target_ip("Target IP Specification") hydra/HydraGroup -.-> hydra/target_service("Target Service Selection") hydra/HydraGroup -.-> hydra/ssh_attack("SSH Brute Force") hydra/HydraGroup -.-> hydra/task_limit("Task Limit Configuration") hydra/HydraGroup -.-> hydra/multiple_targets("Multiple Targets Attack") hydra/HydraGroup -.-> hydra/success_detection("Login Success Detection") subgraph Lab Skills hydra/target_ip -.-> lab-550760{{"Attaquer plusieurs cibles avec Hydra"}} hydra/target_service -.-> lab-550760{{"Attaquer plusieurs cibles avec Hydra"}} hydra/ssh_attack -.-> lab-550760{{"Attaquer plusieurs cibles avec Hydra"}} hydra/task_limit -.-> lab-550760{{"Attaquer plusieurs cibles avec Hydra"}} hydra/multiple_targets -.-> lab-550760{{"Attaquer plusieurs cibles avec Hydra"}} hydra/success_detection -.-> lab-550760{{"Attaquer plusieurs cibles avec Hydra"}} end

Créer un fichier de liste de cibles

Dans cette étape, vous allez créer un fichier de liste de cibles. Ce fichier contiendra une liste d'adresses IP ou de noms d'hôtes auxquels Hydra tentera de se connecter et de craquer les mots de passe. Il s'agit d'une étape cruciale dans tout scénario de test de pénétration ou d'audit de sécurité.

Tout d'abord, comprenons ce qu'est un fichier de liste de cibles. C'est simplement un fichier texte où chaque ligne représente un hôte cible. Un hôte cible peut être une adresse IP (par exemple, 192.168.1.100) ou un nom d'hôte (par exemple, example.com).

Maintenant, créons le fichier de liste de cibles. Nous allons utiliser l'éditeur de texte nano, qui est déjà installé dans votre machine virtuelle LabEx.

Ouvrez l'éditeur nano :
```
nano ~/project/targets.txt
```
Cette commande ouvre un nouveau fichier nommé targets.txt dans le répertoire ~/project. Si le fichier n'existe pas, nano le créera.
Ajoutez les adresses IP suivantes au fichier targets.txt. Chaque adresse IP doit être sur une nouvelle ligne :
```
192.168.1.100
192.168.1.101
192.168.1.102
```
N'hésitez pas à utiliser les adresses IP de votre choix. Ce ne sont que des exemples. Dans un scénario réel, vous remplaceriez ces adresses par les adresses IP réelles des systèmes que vous êtes autorisé à tester.
Enregistrez le fichier et quittez nano. Pour ce faire, appuyez sur Ctrl+X, puis sur Y pour confirmer l'enregistrement, et enfin sur Enter pour accepter le nom de fichier.
Vérifiez que le fichier a été créé et contient le bon contenu. Vous pouvez utiliser la commande cat pour afficher le contenu du fichier :
```
cat ~/project/targets.txt
```
Vous devriez voir la liste des adresses IP que vous avez entrées.
```
192.168.1.100
192.168.1.101
192.168.1.102
```

Vous avez maintenant créé avec succès un fichier de liste de cibles nommé targets.txt dans votre répertoire ~/project. Ce fichier sera utilisé à l'étape suivante pour charger les cibles dans Hydra.

Charger les cibles avec l'option -M

Dans cette étape, vous apprendrez à charger le fichier de liste de cibles que vous avez créé à l'étape précédente dans Hydra en utilisant l'option -M. L'option -M indique à Hydra de lire la liste des hôtes cibles à partir d'un fichier. Cela est particulièrement utile lorsque vous avez un grand nombre de cibles à tester.

Avant de continuer, discutons brièvement de la syntaxe de la commande Hydra avec l'option -M. La syntaxe de base est :

hydra -M <target_file> <service> <options>

Où :

<target_file> est le chemin vers le fichier contenant la liste des hôtes cibles.
<service> est le service que vous souhaitez attaquer (par exemple, ssh, ftp, http).
<options> sont toutes les autres options que vous souhaitez utiliser, telles que le nom d'utilisateur, la liste de mots de passe, etc.

Maintenant, construisons une commande de base Hydra pour charger les cibles à partir du fichier targets.txt que nous avons créé précédemment. Pour cet exemple, nous utiliserons le service ssh. Nous spécifierons également un nom d'utilisateur et une liste de mots de passe (nous créerons une liste de mots de passe factice à des fins de démonstration).

Créez un fichier de liste de mots de passe factice :
```
echo "password" > ~/project/passwords.txt
```
Cette commande crée un fichier nommé passwords.txt dans le répertoire ~/project et y ajoute le mot "password". Dans un scénario réel, vous utiliseriez une liste de mots de passe plus complète.
Maintenant, exécutez la commande Hydra pour charger les cibles à partir du fichier targets.txt et tenter de craquer le mot de passe SSH pour l'utilisateur root en utilisant le fichier passwords.txt :
```
hydra -L ~/project/users.txt -P ~/project/passwords.txt -M ~/project/targets.txt ssh
```
Remarque : Cette commande échouera probablement car vous n'avez probablement pas de serveurs SSH en cours d'exécution sur les adresses IP de votre fichier targets.txt, et même si vous en aviez, vous n'auriez probablement pas les bonnes informations d'identification. Cette étape vise principalement à démontrer comment charger des cibles à partir d'un fichier.

Pour éviter les erreurs, créons un fichier users.txt avec un nom d'utilisateur susceptible d'exister sur la plupart des systèmes.
```
echo "root" > ~/project/users.txt
```
Maintenant, relancez la commande Hydra :
```
hydra -L ~/project/users.txt -P ~/project/passwords.txt -M ~/project/targets.txt ssh
```
Vous verrez probablement des erreurs liées au refus de connexion ou aux informations d'identification incorrectes. Cela est prévu. L'essentiel est que Hydra tente de se connecter aux cibles répertoriées dans le fichier targets.txt.

La sortie montrera Hydra tentant de se connecter à chaque adresse IP de votre fichier targets.txt. Il essaiera le nom d'utilisateur "root" et le mot de passe "password" pour chaque cible. Étant donné que ces informations sont probablement incorrectes, les tentatives échoueront.

Dans cette étape, vous avez appris avec succès à charger des cibles à partir d'un fichier en utilisant l'option -M dans Hydra. Il s'agit d'une compétence fondamentale pour effectuer des attaques de craquage de mots de passe à grande échelle.

Exécuter une attaque SSH en parallèle

Dans cette étape, vous apprendrez à exécuter une attaque SSH en parallèle en utilisant Hydra. L'exécution d'attaques en parallèle accélère considérablement le processus de craquage, en particulier lorsqu'il s'agit de multiples cibles. Hydra vous permet de spécifier le nombre de tâches parallèles à exécuter en utilisant l'option -t.

L'option -t contrôle le nombre de connexions parallèles que Hydra établira. Un nombre plus élevé de threads peut accélérer l'attaque, mais il peut également imposer une charge supplémentaire sur les systèmes cibles et votre propre système. Il est important de trouver un équilibre adapté à votre situation spécifique.

Modifions la commande Hydra précédente pour exécuter l'attaque SSH avec un nombre spécifié de threads.

Exécutez la commande Hydra suivante pour exécuter l'attaque SSH avec 4 threads :
```
hydra -L ~/project/users.txt -P ~/project/passwords.txt -t 4 -M ~/project/targets.txt ssh
```
Dans cette commande, l'option -t 4 indique à Hydra d'utiliser 4 threads parallèles. Cela signifie que Hydra tentera de se connecter à 4 cibles différentes simultanément.

Encore une fois, vous verrez probablement des erreurs liées au refus de connexion ou aux informations d'identification incorrectes. Cela est prévu. Le but de cette étape est de démontrer comment utiliser l'option -t pour exécuter des attaques en parallèle.

La sortie montrera Hydra tentant de se connecter aux adresses IP de votre fichier targets.txt, mais cette fois-ci avec 4 connexions simultanées.
Expérimentez avec différentes valeurs pour l'option -t. Essayez d'augmenter le nombre de threads pour voir comment cela affecte la vitesse de l'attaque. Soyez attentif aux ressources de votre système et des systèmes cibles. Un bon point de départ est de doubler le nombre de threads :
```
hydra -L ~/project/users.txt -P ~/project/passwords.txt -t 8 -M ~/project/targets.txt ssh
```
Observez la sortie et notez tout changement de performance.

Considérations importantes :

Utilisation des ressources : L'augmentation du nombre de threads augmente l'utilisation du processeur et du réseau sur votre système. Surveillez les ressources de votre système pour vous assurer de ne pas le surcharger.
Charge du système cible : L'exécution de trop de threads peut submerger les systèmes cibles, les faisant potentiellement planter ou devenir inaccessibles. Respectez les systèmes cibles et évitez d'utiliser un nombre excessif de threads.
Détection : L'exécution d'attaques avec un grand nombre de threads peut vous rendre plus facilement détectable par les systèmes de détection d'intrusion (IDS).

Dans cette étape, vous avez appris avec succès à exécuter des attaques SSH en parallèle en utilisant Hydra avec l'option -t. Il s'agit d'une technique cruciale pour accélérer les attaques de craquage de mots de passe.

Vérifier la sortie pour plusieurs hôtes

Dans cette étape, vous apprendrez à interpréter la sortie de Hydra lorsqu'il attaque plusieurs hôtes. La sortie de Hydra fournit des informations précieuses sur le succès ou l'échec des tentatives d'attaque.

Lorsque Hydra réussit à craquer un mot de passe, il affichera les informations d'identification au format suivant :

[<service>] host: <host>  login: <username>   password: <password>

Par exemple :

[ssh] 192.168.1.100:22 login: root   password: password

Cela indique que Hydra a réussi à craquer le mot de passe SSH de l'utilisateur root sur l'hôte 192.168.1.100, et que le mot de passe est password.

Lorsque Hydra échoue à craquer un mot de passe, il affichera généralement un message d'erreur tel que "Login failed" (Connexion échouée) ou "Invalid credentials" (Informations d'identification invalides).

Analysons la sortie des étapes précédentes.

Relancez la commande Hydra de l'étape précédente :

hydra -L ~/project/users.txt -P ~/project/passwords.txt -t 4 -M ~/project/targets.txt ssh

Examinez la sortie. Vous verrez probablement une série de messages "Login failed" ou "Invalid credentials" pour chaque hôte cible. Cela est dû au fait que le nom d'utilisateur et le mot de passe que vous utilisez sont probablement incorrects.

La sortie pourrait ressembler à ceci :

Hydra v9.6 (c) 2024 by van Hauser/THC - use freely but only for legal purposes.
Hydra starting at 2024-10-27 10:00:00
[DATA] 1 task, 3 servers, 1 userfiles, 1 passfiles -> max 1 task per 1 server, overall 1 task per attack
[DATA] attacking ssh://192.168.1.100:22
[STATUS][ssh] 192.168.1.100:22 - Login failed for user 'root'
[DATA] attacking ssh://192.168.1.101:22
[STATUS][ssh] 192.168.1.101:22 - Login failed for user 'root'
[DATA] attacking ssh://192.168.1.102:22
[STATUS][ssh] 192.168.1.102:22 - Login failed for user 'root'
Hydra finished.

Si Hydra réussissait à craquer un mot de passe, vous verriez une ligne similaire à l'exemple ci-dessus, indiquant les informations d'identification réussies.

Pour mieux illustrer une connexion réussie, créons un scénario où Hydra a plus de chances de réussir. Cela nécessite un serveur SSH vulnérable. Comme nous n'en avons pas à disposition, nous modifierons le fichier targets.txt pour pointer vers localhost et tenter de nous connecter en tant qu'utilisateur actuel. Cela échouera probablement toujours, mais c'est le plus proche que nous puissions arriver d'un scénario "réussi" sans une cible vulnérable dédiée.

Tout d'abord, ajoutez 127.0.0.1 à votre fichier targets.txt :
```
echo "127.0.0.1" >> ~/project/targets.txt
```
Maintenant, essayez de craquer le mot de passe SSH de l'utilisateur actuel (labex) sur localhost. Vous devrez connaître le mot de passe de l'utilisateur labex. Si vous ne l'avez pas défini, vous pouvez essayer de laisser la liste de mots de passe vide, ce qui tentera un mot de passe nul.
```
hydra -l labex -P ~/project/passwords.txt -t 4 -M ~/project/targets.txt ssh
```
Remarque : Cela échouera probablement toujours à moins que vous n'ayez un mot de passe très simple pour l'utilisateur labex ou que vous ayez autorisé la connexion SSH sans mot de passe.

Même si l'attaque échoue, le point clé est de comprendre comment interpréter la sortie de Hydra. Recherchez les lignes indiquant des connexions réussies et prêtez attention aux messages d'erreur pour comprendre pourquoi les attaques échouent.

Dans cette étape, vous avez appris à vérifier la sortie de Hydra lorsqu'il attaque plusieurs hôtes et à interpréter les résultats. Il s'agit d'une compétence cruciale pour comprendre le succès ou l'échec de vos tentatives de craquage de mots de passe.

Résumé

Dans ce laboratoire, vous avez appris à créer un fichier de liste de cibles contenant des adresses IP ou des noms d'hôtes, ce qui est essentiel pour les tests de pénétration et les audits de sécurité. Vous avez utilisé l'éditeur de texte nano pour créer un fichier targets.txt dans le répertoire ~/project, en ajoutant plusieurs adresses IP cibles, chacune sur une nouvelle ligne. La commande cat a ensuite été utilisée pour vérifier le contenu du fichier.

Le laboratoire a également abordé la manière de charger le fichier de liste de cibles créé dans Hydra en utilisant l'option -M. Cela permet à Hydra de cibler efficacement plusieurs hôtes simultanément, rationalisant le processus de craquage de mots de passe.