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

Introduction

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

Vous commencerez par créer un fichier credentials.txt avec des paires nom d'utilisateur:mot de passe, en utilisant un éditeur de texte comme nano. Ensuite, vous apprendrez à charger ce fichier dans Hydra à l'aide de 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.

Skills Graph

Créer un fichier d'identifiants 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é plus tard avec Hydra pour tenter de craquer les identifiants de connexion d'un service cible.

Tout d'abord, comprenons le format requis pour le fichier d'identifiants. 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 allons utiliser l'éditeur de texte nano, qui est simple et facile à utiliser.

1. Ouvrez un nouveau fichier nommé credentials.txt dans le répertoire ~/project en utilisant nano :

   nano ~/project/credentials.txt

2. Dans l'éditeur nano, ajoutez les combinaisons nom d'utilisateur/mot de passe suivantes. N'hésitez pas à les modifier ou à en ajouter vos propres combinaisons.

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

3. Pour enregistrer le fichier, appuyez sur Ctrl+O (Écrire). Nano vous demandera le nom du fichier. Appuyez simplement sur Entrée pour accepter le nom de fichier par défaut (~/project/credentials.txt).

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

Maintenant, vérifions que le fichier a été créé et contient le contenu correct.

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

   cat ~/project/credentials.txt

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

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

Vous avez maintenant créé avec succès un fichier d'identifiants qui peut être utilisé avec Hydra. Ce fichier contient une liste de noms d'utilisateur et de mots de passe potentiels que Hydra essaiera contre le service cible.

Charger les identifiants avec l'option -C

Dans cette étape, vous apprendrez à utiliser l'option -C dans Hydra pour spécifier un fichier d'identifiants contenant des combinaisons nom d'utilisateur/mot de passe. C'est un moyen plus efficace de fournir à Hydra plusieurs tentatives de connexion par rapport à la spécification séparée des noms d'utilisateur et des mots de passe.

L'option -C indique à Hydra de lire les combinaisons nom d'utilisateur et mot de passe directement à partir d'un fichier. Le fichier doit être formaté sous la forme nom d'utilisateur:mot de passe sur chaque ligne, comme vous l'avez créé à l'étape précédente.

Simulons une commande de base de Hydra en utilisant l'option -C. Nous n'allons pas réellement attaquer un service dans cette étape, mais nous allons construire la commande pour vous assurer que vous comprenez comment utiliser l'option.

Imaginez que vous voulez attaquer un service HTTP exécuté sur 127.0.0.1. La commande de base de Hydra pour utiliser le fichier d'identifiants que vous avez créé ressemblerait à ceci :

hydra -C ~/project/credentials.txt 127.0.0.1 http-get /

Décortiquons cette commande :

• hydra : C'est la commande pour exécuter l'outil Hydra.
• -C ~/project/credentials.txt : Cette option spécifie le chemin vers le fichier d'identifiants que vous avez créé à l'étape précédente. Hydra lira les combinaisons nom d'utilisateur/mot de passe à partir de ce fichier.
• 127.0.0.1 : C'est l'adresse IP cible. Dans cet exemple, il s'agit de la machine locale.
• http-get / : Cela spécifie le service à attaquer (HTTP) et le chemin à demander (/). Il s'agit d'un espace réservé et sera utilisé à l'étape suivante.

Note importante : Cette commande ne réalisera pas réellement une attaque réussie dans cette étape. Nous ne démontrons que comment utiliser l'option -C. Vous aurez besoin d'un service HTTP vulnérable en cours d'exécution pour effectuer une attaque réelle, ce qui sera abordé à l'étape suivante.

Pour vérifier que vous comprenez comment utiliser l'option -C, vérifions votre historique de commandes.

Attaquer un service HTTP avec un fichier d'identifiants

Dans cette étape, vous utiliserez Hydra pour attaquer un service HTTP simulé en utilisant le fichier d'identifiants que vous avez créé précédemment. Pour rendre cette étape possible, nous allons d'abord configurer un simple serveur HTTP qui nécessite une authentification. Ce serveur sera intentionnellement vulnérable à une attaque de force brute.

1. Créer un simple serveur HTTP avec authentification de base :

   Nous allons utiliser le module http.server intégré à Python pour créer un simple serveur HTTP qui nécessite une authentification. Tout d'abord, créez un fichier nommé webserver.py dans votre répertoire ~/project :

   nano ~/project/webserver.py

   Collez le code Python suivant dans le fichier :

   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 base64 encoded
               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 simple serveur HTTP qui nécessite une authentification de base. Le nom d'utilisateur correct est admin et le mot de passe est password. La chaîne encodée en base64 YWRtaW46cGFzc3dvcmQ= représente admin:password.

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

2. Lancer le serveur HTTP :

   Exécutez le script Python pour démarrer le serveur HTTP :

   python3 ~/project/webserver.py

   Le serveur démarrera et écoutera sur le port 8000. Gardez cette fenêtre de terminal ouverte, car le serveur doit être en cours d'exécution pour l'attaque Hydra.

3. Attaquer le service HTTP avec Hydra :

   Ouvrez une nouvelle fenêtre de terminal. Maintenant, utilisez Hydra pour attaquer le service HTTP en utilisant le fichier d'identifiants que vous avez créé à la première étape :

   hydra -C ~/project/credentials.txt 127.0.0.1 http-get /

   Hydra essaiera chaque combinaison nom d'utilisateur/mot de passe du fichier credentials.txt contre le service HTTP. Il tentera d'accéder au chemin racine /.

   Vous devriez voir des sorties de Hydra indiquant qu'il essaie différentes combinaisons nom d'utilisateur/mot de passe. Si Hydra trouve avec succès les identifiants corrects (admin:password), il les affichera dans la sortie.

   Exemple de sortie (attaque réussie) :

   Hydra v9.1 (c) 2020 by van Hauser/THC - Use freely but carefully.
   ...
   [http-get] 1 of 1 target
   [http-get] Trying login: admin/password
   ...
   [http-get] host: 127.0.0.1   login: admin   password: password
   ...
   1 target completed, 1 valid password found

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

4. Arrêter le serveur HTTP :

   Dans la fenêtre de terminal où le script webserver.py est en cours d'exécution, appuyez sur Ctrl+C pour arrêter le serveur.

Vous avez maintenant utilisé avec succès Hydra pour attaquer un service HTTP en utilisant un fichier d'identifiants.

Vérifier que la sortie correspond aux identifiants

Dans cette étape, vous vérifierez 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 garantit que Hydra identifie correctement les combinaisons de connexion valides.

Dans l'étape précédente, vous devriez avoir vu une sortie de Hydra similaire à celle-ci :

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

Cette sortie indique que Hydra a trouvé avec succès le nom d'utilisateur admin et le mot de passe password.

Maintenant, vérifions que ces identifiants se trouvent à la fois dans le fichier credentials.txt et le script webserver.py.

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

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

   cat ~/project/credentials.txt

   Assurez-vous que le fichier contient la ligne admin:password.

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

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

   cat ~/project/webserver.py

   Assurez-vous que le fichier contient la ligne elif auth == 'Basic YWRtaW46cGFzc3dvcmQ=': ## admin:password base64 encoded. Cette ligne confirme que le serveur attend le nom d'utilisateur admin et le mot de passe password (encodé en base64).

En vérifiant que les identifiants trouvés par Hydra correspondent aux identifiants à la fois dans le fichier credentials.txt et le script webserver.py, vous pouvez être sûr que Hydra fonctionne correctement et identifie les combinaisons de connexion valides.

Résumé

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

Le laboratoire a également introduit le concept initial de l'utilisation de l'option -C dans Hydra pour charger ces identifiants afin d'effectuer des tentatives de connexion plus efficacement, bien que la mise en œuvre complète de cette option ne soit pas détaillée dans l'extrait fourni.