Optimiser la vitesse d'attaque d'Hydra et les threads

Introduction

Dans ce laboratoire, vous apprendrez à optimiser les performances d'une attaque par force brute d'Hydra en ajustant les configurations de threads (fils d'exécution). Vous explorerez comment différents paramètres de threads affectent la vitesse d'attaque et l'utilisation des ressources système à travers des scénarios pratiques d'attaque SSH.

Les exercices vous guideront à travers la modification du nombre de threads, l'exécution d'attaques avec des listes de mots de passe, et l'analyse des différences de performance. Vous acquerrez une expérience pratique des capacités de traitement parallèle d'Hydra tout en comprenant l'équilibre entre l'efficacité de l'attaque et la charge du système.

Comprendre les options de threads d'Hydra

Dans cette étape, vous découvrirez les options de threads (fils d'exécution) d'Hydra et comment elles affectent la vitesse des attaques par force brute. Hydra est un outil populaire de craquage de mots de passe qui prend en charge les attaques parallélisées en utilisant plusieurs threads. Les threads permettent à Hydra d'essayer simultanément plusieurs combinaisons de mots de passe, ce qui accélère considérablement le processus de craquage par rapport à l'essai d'un seul mot de passe à la fois.

Tout d'abord, ouvrez un terminal dans votre VM LabEx et accédez au répertoire de travail par défaut :
```
cd ~/project
```
Consultons le menu d'aide d'Hydra pour comprendre les options liées aux threads :
```
hydra -h | grep -i thread
```
La commande grep -i thread filtre la sortie pour afficher uniquement les informations relatives aux threads, ce qui facilite la recherche de ce dont nous avons besoin. Vous devriez voir une sortie similaire à :
```
-t TASKS  run TASKS number of connects in parallel (default: 16)
```
L'option -t contrôle le nombre de connexions parallèles (threads) qu'Hydra utilisera. Considérez les threads comme des travailleurs - plus il y a de travailleurs, plus ils peuvent effectuer de tâches simultanément. Plus de threads signifie des attaques plus rapides, mais aussi une utilisation plus importante des ressources et du trafic réseau. Ceci est important car l'utilisation d'un trop grand nombre de threads peut surcharger votre système ou déclencher des alertes de sécurité sur le système cible.
Créons une petite liste de mots de passe de test pour démontrer le comportement des threads :
```
cat > test_passwords.txt << EOF
test1
test2
test3
test4
test5
EOF
```
Voyons maintenant comment différents nombres de threads affectent la vitesse d'attaque. Tout d'abord, essayez avec 1 thread :
```
hydra -l testuser -P test_passwords.txt 127.0.0.1 ssh -t 1 -vV
```
Remarquez comment il essaie les mots de passe un par un, avec un seul processus enfant.
Maintenant, essayez avec 4 threads :
```
hydra -l testuser -P test_passwords.txt 127.0.0.1 ssh -t 4 -vV
```
Vous verrez plusieurs processus enfants travailler simultanément, essayant différents mots de passe en parallèle. Cette exécution parallèle devrait être sensiblement plus rapide que la version à un seul thread.
Enfin, essayez avec 8 threads :
```
hydra -l testuser -P test_passwords.txt 127.0.0.1 ssh -t 8 -vV
```
Même si nous n'avons que 5 mots de passe, Hydra créera toujours 8 processus enfants, mais seulement 5 seront activement en train de travailler. Cela démontre comment le nombre de threads affecte le traitement parallèle.

Configurer une attaque SSH simple

Dans cette étape, vous allez préparer un scénario d'attaque SSH simple en utilisant Hydra. Cette démonstration vous aidera à comprendre comment fonctionnent les outils de craquage de mots de passe dans un environnement contrôlé. Nous utiliserons une liste de mots de passe complète et ciblerons un serveur SSH local s'exécutant sur votre propre machine pour des raisons de sécurité.

Tout d'abord, assurez-vous que vous êtes dans le bon répertoire de travail :
```
cd ~/project
```
Le fichier de liste de mots de passe passwords.txt a été créé avec un ensemble complet de mots de passe courants. Cette liste plus importante nous aidera à mieux démontrer l'impact des différentes configurations de threads sur les performances de l'attaque. Vérifiez que le fichier de mots de passe a été créé correctement :
```
cat passwords.txt
```
Pour ce laboratoire, nous ciblerons le serveur SSH local (127.0.0.1) qui est votre propre machine. C'est plus sûr que d'attaquer des systèmes distants. Tout d'abord, vérifiez si SSH est en cours d'exécution :
```
sudo service ssh status
```
S'il n'est pas en cours d'exécution, démarrez-le avec : sudo service ssh start

Lancer une attaque avec les threads par défaut

Dans cette étape, vous allez exécuter une attaque par force brute SSH en utilisant Hydra avec les paramètres de threads par défaut. Hydra utilise automatiquement 16 threads parallèles par défaut, ce qui signifie qu'il tentera simultanément 16 combinaisons de mots de passe différentes. Avec notre liste de mots de passe plus importante, vous pourrez observer plus clairement l'impact de la configuration des threads.

Tout d'abord, accédez à votre répertoire de travail :
```
cd ~/project
```

Lancez l'attaque Hydra contre le serveur SSH local :

hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV

Observez attentivement la sortie. Vous verrez :
- Hydra démarrant avec 16 tâches (threads)
- Chaque tentative de connexion affichée en temps réel
- La vitesse actuelle mesurée en tentatives par minute
- Une connexion réussie lorsqu'il trouve le bon mot de passe
Pour obtenir des mesures de temps précises, exécutez la commande avec l'utilitaire time :
```
time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV
```
Enregistrez ces résultats de temps avec soin. Avec notre liste de mots de passe plus importante, vous pourrez constater des différences de performances claires lorsque nous ajusterons le nombre de threads.

Augmenter le nombre de threads et comparer la vitesse

Dans cette étape, vous apprendrez comment l'ajustement du nombre de threads d'Hydra affecte les performances du craquage de mots de passe. Nous comparerons les résultats de différents paramètres de threads pour comprendre le compromis entre la vitesse et l'utilisation des ressources.

Tout d'abord, assurez-vous que vous êtes dans le bon répertoire de travail :
```
cd ~/project
```
Exécutez Hydra avec un nombre de threads augmenté (32) et mesurez le temps d'exécution :
```
time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 32
```
Maintenant, testez avec un nombre de threads encore plus élevé (64) pour voir si les performances continuent de s'améliorer :
```
time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 64
```
Analysez comment l'augmentation du nombre de threads affecte :
- La durée globale de l'attaque
- L'utilisation des ressources système (visible dans les colonnes User/System de la sortie de la commande time)
- Le taux de tentatives de connexion réseau (indiqué dans la sortie détaillée d'Hydra)

Tester l'attaque avec un nombre de threads réduit

Dans cette étape, nous allons explorer comment la réduction du nombre de threads d'Hydra affecte les performances du craquage de mots de passe. Nous allons tester avec des nombres de threads plus faibles pour comprendre l'équilibre entre la vitesse et l'utilisation des ressources.

Tout d'abord, assurez-vous que vous êtes dans le bon répertoire de travail :
```
cd ~/project
```
Exécutez Hydra avec 8 threads (la moitié de notre minimum précédent) et mesurez le temps d'exécution :
```
time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 8
```
Maintenant, testez avec seulement 4 threads pour voir la configuration pratique minimale :
```
time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 4
```
Tenez compte de ces compromis pratiques pour une utilisation dans le monde réel :
- Un nombre de threads plus élevé (16-64) pour des attaques rapides sur des systèmes puissants
- Un nombre de threads plus faible (4-8) pour la discrétion ou les environnements à ressources limitées
- L'impact sur le réseau varie en fonction du nombre de threads - plus de threads créent un trafic plus détectable

Résumé

Dans ce labo, vous avez appris à configurer la vitesse d'attaque et les paramètres de threads d'Hydra pour des attaques par force brute efficaces. Les principaux points à retenir incluent l'utilisation du paramètre -t pour contrôler les connexions parallèles et l'analyse de la façon dont le nombre de threads affecte les performances grâce à des tests pratiques avec différentes valeurs.

Vous avez également acquis une expérience pratique en configurant un scénario d'attaque SSH, en créant une liste de mots de passe et en observant la relation entre le nombre de threads, la vitesse d'attaque et l'utilisation des ressources système. Cet exercice pratique a permis de démontrer les techniques d'optimisation pour Hydra dans divers environnements de test.

Ajuster la vitesse d'attaque et les threads d'Hydra