Aller au contenu principal

Attaques par force brute

Attaques par force brute et énumération

Notions théoriques​

1. Qu'est-ce qu'une attaque par force brute ?​

Définition

Une attaque par force brute est une méthode utilisée pour deviner un mot de passe ou une clé de chiffrement en essayant toutes les combinaisons possibles jusqu'à trouver la bonne.

attention

Cette attaque est efficace si le mot de passe est court ou simple.

Par exemple, un mot de passe comme "123456" sera facilement trouvé en quelques secondes.

2. Qu'est-ce que l'énumération ?​

Définition

L’énumération est une technique qui consiste à collecter des informations sur un système avant une attaque.

Cela peut inclure :

  • La découverte d’utilisateurs existants sur un site Web.
  • La récupération de noms de fichiers ou de répertoires cachés.
  • L’identification des services actifs sur un serveur.

Elle est souvent utilisée avant une attaque par force brute pour réduire le nombre de tentatives nécessaires.

3. Comment se protéger ?​

Pour se protéger contre ces attaques, il est recommandé de :

  • Utiliser des mots de passe longs et complexes.
  • Mettre en place une limitation du nombre de tentatives (ex. : blocage après 5 essais).
  • Activer l’authentification à deux facteurs (2FA).
  • Configurer des CAPTCHAs pour éviter les attaques automatisées.

Exemple pratique​

Nous allons voir comment un attaquant pourrait utiliser un outil pour trouver un mot de passe par force brute et comment il pourrait découvrir des utilisateurs existants sur un site.

1. Attaque par force brute sur un mot de passe​

Un attaquant peut utiliser Hydra, un outil permettant de tester des mots de passe sur un service comme SSH.

Commande pour tester des mots de passe sur un serveur SSH :

hydra -l admin -P passwords.txt ssh://192.168.1.10

Explication :

  • -l admin : Nom d'utilisateur ciblé.
  • -P passwords.txt : Liste de mots de passe à tester.
  • ssh://192.168.1.10 : Adresse du serveur cible.

Si le mot de passe est dans la liste, Hydra affichera :

[22][ssh] host: 192.168.1.10   login: admin   password: password123

2. Énumération des utilisateurs sur un site Web​

Avec WFuzz, un attaquant peut tester des noms d'utilisateur sur un formulaire de connexion.

Commande pour tester des noms d’utilisateur :

wfuzz -c -z file,users.txt --hc 403 http://site.com/login?username=FUZZ

Explication :

  • -z file,users.txt : Liste de noms d’utilisateur à tester.
  • --hc 403 : Ignore les réponses avec un code 403 (accès refusé).
  • FUZZ : Remplace FUZZ par chaque nom d’utilisateur de la liste.

Si un utilisateur existe, la réponse du serveur sera différente.

4 outils très utilisés en cybersécurité

Voici 4 outils très utilisés en cybersécurité pour tester la robustesse des systèmes et identifier les failles potentielles.

attention

Il est essentiel de les utiliser uniquement dans un cadre légal et éthique.

OutilUtilisation principale
HydraAttaque par force brute sur SSH et autres services
WFuzzÉnumération des utilisateurs et fichiers cachés
John the RipperCrackage de mots de passe chiffrés
GobusterDécouverte de répertoires cachés sur un site Web

Test de mémorisation/compréhension​


Quelle est la principale caractéristique d'une attaque par force brute ?


Pourquoi l'énumération est-elle utile avant une attaque par force brute ?


Quel outil est souvent utilisé pour les attaques par force brute sur SSH ?


Que signifie l'option `-P` dans la commande Hydra ?


Comment un site peut-il se protéger contre la force brute ?


Quel est l’objectif principal de WFuzz ?


Que signifie `FUZZ` dans la commande WFuzz ?


Pourquoi l’authentification à deux facteurs protège contre la force brute ?


Quel type de réponse HTTP peut indiquer qu'un utilisateur existe lors d'une énumération ?


Quel est le principal inconvénient d'une attaque par force brute ?


TP pour réfléchir et résoudre des problèmes​

Présentation des TP​

Ces TP pratiques sont conçus pour vous permettre d'expérimenter concrètement les concepts d'attaques par force brute et d'énumération, en vous concentrant sur l'analyse et la résolution de problèmes de sécurité. Ils s'appuient sur un environnement contrôlé et éthique, où vous agissez en tant que "red team" testant vos propres systèmes.

  1. Identifier une machine cible : Utilisez une VM Debian (par exemple, Debian 12 ou une version récente) installée spécialement pour ces essais, ou une machine Debian existante que vous utilisez déjà pour des services comme Apache, MariaDB ou d'autres. Si vous n'en avez pas, téléchargez l'ISO Debian depuis le site officiel et installez-la dans VirtualBox ou VMware avec au moins 1 Go de RAM et un disque de 20 Go. Configurez le réseau en mode "host-only" ou "NAT" pour l'isoler. Sur cette VM, installez et activez les services nécessaires selon le TP :

    • Pour SSH : sudo apt update && sudo apt install openssh-server && sudo systemctl enable --now ssh
    • Pour FTP : sudo apt update && sudo apt install vsftpd && sudo systemctl enable --now vsftpd (note : configurez /etc/vsftpd.conf pour autoriser les utilisateurs locaux si besoin)
    • Pour le serveur Web (Apache) : sudo apt update && sudo apt install apache2 && sudo systemctl enable --now apache2 (pour les TP web comme WFuzz ou Gobuster)
    • Vérifiez les ports ouverts avec sudo netstat -tuln ou ss -tuln.

  2. Créer l'utilisateur de test : Sur la machine cible Debian, créez un utilisateur dédié pour les attaques, nommé abc123 avec le mot de passe abc123. Cela simule un compte faible pour observer les vulnérabilités. Exécutez :

    sudo adduser abc123
    • Suivez les invites pour définir le mot de passe abc123 (confirmez-le deux fois). Vous pouvez ignorer les questions optionnelles (nom complet, téléphone, etc.) en appuyant sur Entrée.
    • Ajoutez l'utilisateur au groupe sudo si nécessaire pour des tests avancés : sudo usermod -aG sudo abc123.
    • Vérifiez la création : id abc123 (devrait afficher UID, GID, etc.).
attention

Important : Ces TP sont réalisés dans un cadre pédagogique et éthique. Il est interdit d’utiliser ces techniques sur des systèmes sans autorisation. Supprimez l'utilisateur abc123 après les TP (sudo deluser abc123) et réinitialisez les mots de passe. Testez uniquement sur vos propres machines.

astuce

Conseil : Documentez vos observations (IP de la cible, résultats des scans, temps d'attaque) dans un fichier Markdown pour analyser les patterns de vulnérabilités.

TP avec Medusa​

Objectif : Comprendre et expérimenter les attaques par force brute sur des services réseau avec Medusa dans un environnement de test contrôlé.

Matériel requis :

  • Une machine virtuelle avec Kali Linux (attaquant)
  • Une machine virtuelle Debian configurée comme cible (voir présentation des TP pour l'installation et la configuration des services)
  • Un éditeur de texte et un terminal

1. Introduction​

1.1. Présentation du TP​

Dans ce TP, vous allez apprendre à :

  • Effectuer une attaque par force brute sur un service SSH avec Medusa.
  • Tester une attaque sur un service FTP pour énumérer des identifiants.
  • Analyser les résultats et comprendre les limites de ces attaques.
Présentation de Medusa

Medusa est un outil de brute force en ligne de commande, rapide et modulaire, conçu pour tester la sécurité des services réseau en tentant de deviner des identifiants (noms d'utilisateur et mots de passe).

Similaire à Hydra, Medusa supporte de nombreux protocoles (SSH, FTP, HTTP, Telnet, etc.) et est particulièrement apprécié pour sa vitesse et sa capacité à gérer plusieurs cibles simultanément. Il est couramment utilisé en pentesting pour évaluer la robustesse des authentifications distantes.

Principales commandes Medusa​

1. Attaque de base sur un service (ex: SSH)​
medusa -h 192.168.1.100 -u abc123 -P /usr/share/wordlists/rockyou.txt -M ssh
  • -h : hôte cible
  • -u : nom d'utilisateur à tester
  • -P : fichier contenant les mots de passe à tester
  • -M : module/protocole ciblé (ex: ssh)
  • -n : numéro du port (ex: 2222)
2. Utiliser une liste d'utilisateurs et de mots de passe​
medusa -H hosts.txt -U users.txt -P passwords.txt -M ftp
  • -H : fichier contenant les hôtes cibles
  • -U : liste d'utilisateurs
  • -P : liste de mots de passe
  • -M : module/protocole (ex: ftp)
3. Spécifier le nombre de threads (accélère l'attaque)​
medusa -h 192.168.1.100 -U users.txt -P passwords.txt -M ssh -t 10
  • -t 10 : utilise 10 threads simultanés
4. Attaque sur un formulaire HTTP (ex: login Web)​
medusa -h 192.168.1.100 -U users.txt -P passwords.txt -M http -m DIR:/login.php -T
  • -M http : module HTTP
  • -m DIR:/login.php : chemin du formulaire
  • -T : utilise les threads pour accélérer
5. Afficher les modules disponibles (protocoles supportés)​
medusa -M
6. Afficher l’aide complète​
medusa -d

Exemple simple​

medusa -h 192.168.1.100 -u abc123 -P rockyou.txt -M ssh -n 2222

Medusa tente de se connecter en SSH à la machine 192.168.1.100 avec l’utilisateur "abc123" et les mots de passe du fichier rockyou.txt sur le port 2222.

2. Préparation de l’environnement​

2.1. Lancer les machines virtuelles​
  1. Démarrer Kali Linux (machine attaquante).
  2. Démarrer la VM Debian (machine cible, avec SSH et FTP activés comme indiqué dans la présentation des TP).
  3. Identifier l’adresse IP de la cible en exécutant la commande suivante sur la VM Debian : 
    ip addr show eth0
    Notez l’adresse IP affichée (ex: 192.168.1.100).
Une solution

3. Installation et configuration de Medusa​

3.1. Vérifier la présence de Medusa​
  1. Sur Kali Linux, ouvrez un terminal et exécutez : 
    medusa -d
  2. Si l'aide s’affiche, Medusa est installé. Sinon, installez-le avec : 
    sudo apt update && sudo apt install medusa
3.2. Préparer les listes de mots​
  1. Vérifiez la disponibilité d’une wordlist par défaut : 
    ls /usr/share/wordlists/rockyou.txt
  2. Si le fichier n'existe pas, décompressez-le (il est souvent compressé) : 
    sudo gunzip /usr/share/wordlists/rockyou.txt.gz
Une solution

4. Attaque par force brute sur SSH avec Medusa​

4.1. Présentation de Medusa​

Medusa est un outil modulaire pour des attaques par force brute sur des protocoles réseau, optimisé pour la vitesse et la parallélisation.

4.2. Objectif​

Nous allons essayer de trouver un mot de passe SSH en testant une liste de mots de passe courants sur l'utilisateur abc123.

4.3. Étapes​
Étape 1 : Vérifier que SSH est actif sur la cible​

Sur Kali Linux, exécutez :

nmap -p 22 192.168.1.100

Si le port 22/tcp open apparaît, SSH est activé.

Étape 2 : Lancer une attaque par force brute avec Medusa​

Exécutez la commande suivante :

medusa -h 192.168.1.100 -u abc123 -P /usr/share/wordlists/rockyou.txt -M ssh

Explication des options :

  • -h 192.168.1.100 : Hôte cible.
  • -u abc123 : Nom d’utilisateur ciblé.
  • -P /usr/share/wordlists/rockyou.txt : Liste de mots de passe à tester.
  • -M ssh : Module SSH.
remarque

Si vous avez besoin de préciser un numéro de port (par exemple 2222), il suffit d'ajouter l'option :

  • -n : numéro du port (ex: 2222)

et d'exécuter la commande suivante :

medusa -h 192.168.1.100 -u abc123 -P /usr/share/wordlists/rockyou.txt -M ssh -n 2222
astuce

Si c'est trop long, vous pouvez ajouter l'option -t 16 pour tester 16 mots de passe silmutanément (au lieu de 4 par défaut).

Étape 3 : Analyser les résultats​

Medusa affiche les succès comme :

ACCOUNT FOUND: [ssh] Host: 192.168.1.100 User: abc123 Password: abc123 [1]

Testez la connexion :

ssh abc123@192.168.1.100
Une solution

5. Attaque par force brute sur FTP avec Medusa​

5.1. Objectif​

Tester une attaque sur le service FTP pour identifier des identifiants valides.

5.2. Étapes​
Étape 1 : Vérifier que FTP est actif​
nmap -p 21 192.168.1.100

Cherchez 21/tcp open ftp.

Étape 2 : Lancer l'attaque​
medusa -h 192.168.1.100 -U users.txt -P /usr/share/wordlists/rockyou.txt -M ftp

Créez users.txt si nécessaire :

echo -e "abc123\nanonymous\nftp" > users.txt
Étape 3 : Analyser les résultats​

Recherchez les comptes trouvés et testez avec :

ftp 192.168.1.100
Une solution

6. Questions de réflexion​

  1. Pourquoi Medusa est-il plus rapide que d'autres outils comme Hydra dans certains scénarios ?
  2. Quels sont les risques d'une attaque par force brute sur un service comme FTP ?
  3. Comment détecter une tentative d'attaque par force brute dans les logs d'un serveur ?
  4. Quelles sont les différences entre les modules de Medusa et comment choisir le bon ?
  5. Pourquoi est-il crucial de combiner la force brute avec d'autres techniques d'énumération ?

7. Conclusion et bonnes pratiques​

  • Les attaques par force brute avec Medusa mettent en évidence les faiblesses des mots de passe faibles et des services exposés.
  • Pour contrer ces attaques : implémentez des verrouillages de compte, utilisez des mots de passe forts, activez l'authentification à deux facteurs (2FA), et surveillez les connexions échouées.
  • Dans un cadre professionnel, testez régulièrement vos systèmes avec des outils comme Medusa pour renforcer la sécurité.

8. Pour aller plus loin​

  • Testez Medusa sur HTTP avec un formulaire de login (ex: installez DVWA sur la VM Debian).
  • Comparez les performances de Medusa et Hydra sur la même cible en mesurant le temps d'exécution.
  • Expérimentez avec des listes d'utilisateurs personnalisées basées sur une énumération préalable (ex: via Gobuster).
  • Configurez Fail2Ban sur la VM Debian pour observer le blocage automatique des attaques.

TP avec John the Ripper​

Objectif : Comprendre et expérimenter l'utilisation de John the Ripper pour cracker des mots de passe chiffrés, en explorant les concepts d'attaques par dictionnaire et par force brute abordés dans la séance de cours sur les attaques par force brute et l'énumération.

Matériel requis​

  • Une machine virtuelle avec Kali Linux (machine attaquante)
  • Un éditeur de texte (comme nano ou vim) et un terminal
  • Un accès à Internet pour télécharger des ressources publiques

1. Introduction​

1.1. Présentation du TP​

Dans ce TP, vous allez apprendre à :

  • Utiliser John the Ripper pour cracker des hashs de mots de passe.
  • Comparer les approches par dictionnaire et par force brute.
  • Analyser les résultats pour en tirer des enseignements sur la sécurité des mots de passe.
attention

⚠️ Important : Ce TP est réalisé dans un cadre pédagogique et éthique. L'utilisation de ces techniques sur des systèmes ou données sans autorisation explicite est strictement interdite.

Présentation de John the Ripper

John the Ripper (souvent abrégé en John) est un outil open-source de craquage de mots de passe, principalement utilisé pour tester la robustesse des mots de passe :

  • Casser des mots de passe hachés
  • Tester la sécurité des mots de passe
  • Réaliser des attaques par dictionnaire, brute force ou règles personnalisées

Principales commandes de John the Ripper​

1. Détection automatique du type de hash​
john --format=auto hash.txt

John essaie de détecter automatiquement le type de hash contenu dans le fichier hash.txt.

2. Lancer une attaque simple (mode par défaut)​
john hash.txt

John utilise son mode par défaut (souvent une attaque par dictionnaire avec des règles) pour tenter de casser les mots de passe.

3. Utiliser un fichier de dictionnaire (wordlist)​
john --wordlist=rockyou.txt hash.txt

Utilise le fichier rockyou.txt pour effectuer une attaque par dictionnaire.

4. Spécifier un format de hash​
john --format=raw-md5 hash.txt

Permet de forcer le format du hash s’il n’est pas détecté automatiquement.

5. Voir les mots de passe trouvés​
john --show hash.txt

Affiche les mots de passe déjà craqués et stockés dans le fichier .pot de John.

6. Reprendre une session interrompue​
john --restore

Reprend une session de craquage précédemment interrompue.

7. Lister les formats de hash supportés​
john --list=formats

Affiche tous les formats de hachage que John peut gérer.

Outils associés​

  • unshadow : combine /etc/passwd et /etc/shadow pour créer un fichier exploitable par John.
  • zip2john, rar2john, pdf2john, etc. : extraient les hashs de fichiers protégés pour les casser avec John.

Exemple simple d'utilisation​

unshadow passwd.txt shadow.txt > hash.txt
john --wordlist=rockyou.txt hash.txt
john --show hash.txt

2. Préparation de l’environnement​

2.1. Démarrer Kali Linux​

Lancez votre machine virtuelle Kali Linux et ouvrez un terminal pour exécuter les commandes nécessaires.

2.2. Télécharger une liste de mots pour le cracking​

Vous aurez besoin d'une liste de mots (wordlist) pour tester les attaques par dictionnaire. Téléchargez une wordlist publique depuis un dépôt accessible.

Commande à exécuter dans le terminal :

wget https://github.com/danielmiessler/SecLists/raw/master/Passwords/Common-Credentials/10-million-password-list-top-10000.txt -O wordlist.txt

Cette commande télécharge une liste de 10 000 mots de passe courants et la sauvegarde sous le nom wordlist.txt dans le répertoire courant.

Une solution

3. Création d’un fichier de hashs à cracker​

3.1. Générer des hashs de mots de passe​

Pour ce TP, vous allez créer un fichier contenant des hashs de mots de passe au format MD5 brut, simulant une fuite de données. Exécutez les commandes suivantes dans le terminal pour générer un fichier hashes.txt :

echo -n "secret" | md5sum | awk '{print "user1:" $1}' > hashes.txt
echo -n "admin123" | md5sum | awk '{print "user2:" $1}' >> hashes.txt
echo -n "welcome" | md5sum | awk '{print "user3:" $1}' >> hashes.txt

Explication :

  • echo -n supprime le saut de ligne pour éviter de fausser le hash.
  • md5sum calcule le hash MD5 du mot de passe.
  • awk '{print "userX:" $1}' formate la sortie avec un nom d'utilisateur suivi du hash.
Une solution

4. Cracking des hashs avec John the Ripper​

4.1. Attaque par dictionnaire​

Utilisez John the Ripper pour tenter de cracker les hashs en utilisant la wordlist téléchargée.

Commande à exécuter :

john --wordlist=wordlist.txt --format=raw-md5 hashes.txt

Explication :

  • --wordlist=wordlist.txt indique la liste de mots à tester.
  • --format=raw-md5 spécifie que les hashs sont au format MD5 brut.
  • hashes.txt est le fichier cible contenant les hashs.
Une solution
4.2. Attaque par force brute​

Si certains mots de passe ne sont pas dans la wordlist, tentez une attaque par force brute.

Commande à exécuter :

john --format=raw-md5 hashes.txt

Explication :

  • Sans --wordlist, John passe en mode force brute, essayant toutes les combinaisons possibles.
  • Cette méthode est plus lente mais exhaustive.
Une solution
4.3. Analyse des résultats​

Affichez les mots de passe crackés pour confirmer les résultats.

Commande à exécuter :

john --show hashes.txt
Une solution

5. Questions de réflexion​

  1. Pourquoi les mots de passe courts ou courants sont-ils vulnérables aux attaques par dictionnaire ?
  2. Quelle est la principale différence entre une attaque par dictionnaire et une attaque par force brute en termes de temps et d’efficacité ?
  3. Comment la longueur et la complexité d’un mot de passe influencent-elles la durée du cracking ?
  4. Quels mécanismes pourraient empêcher ou ralentir le cracking des hashs avec John the Ripper ?
  5. Pourquoi est-il dangereux de stocker des hashs sans protection supplémentaire (comme un sel) ?

6. Conclusion et bonnes pratiques​

  • Ce TP démontre la puissance de John the Ripper pour cracker des mots de passe chiffrés, soulignant la nécessité de choisir des mots de passe robustes.
  • Les bonnes pratiques incluent l’utilisation de mots de passe longs (au moins 12 caractères), combinant lettres majuscules, minuscules, chiffres et symboles, ainsi que l’activation de l’authentification à deux facteurs.
  • La protection des fichiers de hashs avec des sels et des algorithmes de hachage modernes (comme bcrypt) est essentielle pour réduire les risques.

7. Pour aller plus loin​

  • Testez John the Ripper avec d’autres formats de hashs (SHA-1, SHA-256) en adaptant --format.
  • Expérimentez avec des wordlists plus grandes ou personnalisées.
  • Explorez l’outil Hashcat pour comparer ses performances avec John the Ripper.
  • Simulez une attaque sur un fichier de hashs réels (générés éthiquement) pour évaluer leur robustesse.
  • Recherchez des techniques avancées de cracking, comme les attaques par rainbow tables ou les attaques par dictionnaire optimisées.

TP avec Hydra et WFuzz​

Objectif : Comprendre et expérimenter les attaques par force brute et énumération sur un environnement de test.

Matériel requis :

  • Une machine virtuelle avec Kali Linux (attaquant)
  • Une machine virtuelle Debian configurée comme cible (avec SSH et Apache activés, voir présentation des TP)
  • Un éditeur de texte et un terminal

1. Introduction​

1.1. Présentation du TP​

Dans ce TP, vous allez apprendre à :

  • Effectuer une attaque par force brute sur un service SSH avec Hydra.
  • Réaliser une énumération d’utilisateurs sur un site Web avec WFuzz.
  • Comprendre les mécanismes de protection contre ces attaques.
attention

⚠️ Important : Ce TP est réalisé dans un cadre pédagogique et éthique. Il est interdit d’utiliser ces techniques sur des systèmes sans autorisation.

Présentation d'Hydra

Hydra (ou THC-Hydra) est un outil de brute force en ligne, utilisé pour tester la sécurité de services réseau en tentant de deviner des identifiants (nom d'utilisateur et mot de passe).

Contrairement à John the Ripper qui travaille principalement sur des hashs locaux, Hydra attaque des services distants (SSH, FTP, HTTP, etc.).

Il est largement utilisé en pentesting pour évaluer la robustesse des mécanismes d'authentification sur des protocoles variés.

Principales commandes Hydra​

1. Attaque de base sur un service (ex: SSH)​
hydra -l root -P /chemin/vers/wordlist.txt ssh://192.168.1.10
  • -l root : nom d'utilisateur à tester
  • -P : fichier contenant les mots de passe à tester
  • ssh:// : protocole ciblé
2. Utiliser une liste d'utilisateurs et de mots de passe​
hydra -L users.txt -P passwords.txt ftp://192.168.1.10
  • -L : liste d'utilisateurs
  • -P : liste de mots de passe
  • ftp:// : protocole ciblé
3. Spécifier le nombre de threads (accélère l'attaque)​
hydra -L users.txt -P passwords.txt -t 8 ssh://192.168.1.10
  • -t 8 : utilise 8 threads simultanés
4. Attaque sur un formulaire HTTP (ex: page de login Web)​
hydra -L users.txt -P passwords.txt 192.168.1.10 http-post-form "/login.php:user=^USER^&pass=^PASS^:F=Identifiants invalides"
  • http-post-form : type de requête
  • /login.php : chemin de la page
  • ^USER^ et ^PASS^ : variables remplacées par les valeurs testées
  • F=... : texte d’échec dans la réponse du serveur
5. Afficher les modules disponibles (protocoles supportés)​
hydra -U
6. Afficher l’aide complète​
hydra -h

Exemple simple​

hydra -l admin -P rockyou.txt ssh://192.168.1.100

Hydra tente de se connecter en SSH à la machine 192.168.1.100 avec l’utilisateur "admin" et les mots de passe du fichier rockyou.txt.

Présentation de WFuzz

Présentation de WFuzz​

WFuzz est un outil de fuzzing Web en ligne de commande, principalement utilisé pour :

  • découvrir des ressources cachées,
  • tester des formulaires,
  • détecter des vulnérabilités (comme les injections SQL, XSS)
  • ou brute-forcer des paramètres HTTP.

Il fonctionne en injectant des valeurs dynamiques dans les requêtes HTTP (URL, en-têtes, paramètres POST, cookies, etc.) et en analysant les réponses du serveur.

astuce

WFuzz est particulièrement utile pour :

  • Découvrir des fichiers et répertoires cachés
  • Tester des formulaires ou des API
  • Détecter des comportements anormaux ou vulnérabilités

Principales commandes WFuzz​

1. Fuzzing d’URL (découverte de répertoires/fichiers)​
wfuzz -w wordlist.txt --sc 200 http://site.com/FUZZ
  • -w wordlist.txt : fichier contenant les mots à injecter
  • FUZZ : mot-clé remplacé par chaque mot de la wordlist
  • --sc 200 : ne montre que les réponses avec le code HTTP 200
2. Fuzzing d’un paramètre GET​
wfuzz -w payloads.txt --sc 200 http://site.com/page.php?id=FUZZ
3. Fuzzing d’un formulaire POST​
wfuzz -w passwords.txt -d "username=admin&password=FUZZ" --sc 200 http://site.com/login.php
  • -d : données POST
  • FUZZ : injecté dans le champ password
4. Fuzzing avec plusieurs points d’injection​
wfuzz -w users.txt -w passwords.txt -d "user=FUZZ1&pass=FUZZ2" --sc 302 http://site.com/login.php
  • FUZZ1 et FUZZ2 : injection multiple avec plusieurs wordlists
5. Fuzzing d’un en-tête HTTP (ex : User-Agent)​
wfuzz -w agents.txt -H "User-Agent: FUZZ" http://site.com/
  • -H : permet de modifier les en-têtes HTTP
6. Afficher uniquement certaines tailles de réponse​
wfuzz -w wordlist.txt --hl 0 http://site.com/FUZZ
  • --hl : filtre les réponses par longueur (ici, cache celles de taille 0)
7. Utiliser des cookies​
wfuzz -w wordlist.txt -b "PHPSESSID=abc123" http://site.com/FUZZ
  • -b : ajoute un cookie à la requête

Exemple simple​

wfuzz -w /usr/share/wordlists/dirb/common.txt --sc 200 http://example.com/FUZZ

Cette commande teste les chemins contenus dans common.txt et affiche ceux qui retournent un code 200 (OK).

2. Préparation de l’environnement​

2.1. Lancer les machines virtuelles​
  1. Démarrer Kali Linux (machine attaquante).
  2. Démarrer la VM Debian (machine cible, avec SSH et Apache activés comme indiqué dans la présentation des TP).
  3. Identifier l’adresse IP de la cible en exécutant la commande suivante sur la VM Debian : 
    ip addr show eth0
    Notez l’adresse IP affichée (ex: 192.168.1.100).

3. Attaque par force brute sur SSH avec Hydra​

3.1. Présentation de Hydra​

Hydra est un outil permettant d’effectuer des attaques par force brute sur divers protocoles (SSH, FTP, HTTP, etc.).

3.2. Objectif​

Nous allons essayer de trouver un mot de passe SSH en testant une liste de mots de passe courants.

3.3. Étapes​
Étape 1 : Vérifier que SSH est actif sur la cible​

Sur Kali Linux, exécutez :

nmap -p 22 192.168.1.100

Si le port 22/tcp open apparaît, cela signifie que SSH est activé.

Étape 2 : Lancer une attaque par force brute avec Hydra​

Exécutez la commande suivante :

hydra -l abc123 -P /usr/share/wordlists/rockyou.txt ssh://192.168.1.100

Explication des options :

  • -l abc123 : Nom d’utilisateur ciblé.
  • -P /usr/share/wordlists/rockyou.txt : Liste de mots de passe à tester.
  • ssh://192.168.1.100 : Adresse IP de la cible.
Étape 3 : Analyser les résultats​

Si Hydra trouve un mot de passe valide, il affichera :

[22][ssh] host: 192.168.1.100   login: abc123   password: abc123

Essayez de vous connecter avec :

ssh abc123@192.168.1.100

4. Énumération d’utilisateurs sur un site Web avec WFuzz​

4.1. Présentation de WFuzz​

WFuzz est un outil permettant de tester différentes valeurs dans une requête HTTP, utile pour découvrir des utilisateurs, fichiers cachés, etc.

4.2. Objectif​

Nous allons essayer de trouver des noms d’utilisateurs valides sur un formulaire de connexion. (Si vous n'avez pas de formulaire prêt, créez un simple fichier /var/www/html/login.php sur la VM Debian avec un formulaire basique : <form method="GET"><input name="username"><input name="password" type="password"><input type="submit"></form>.)

4.3. Étapes​
Étape 1 : Identifier une page de connexion​

Sur votre navigateur, entrez :

http://192.168.1.100/login.php

Observez le formulaire (ou la page d'accueil Apache si pas de login).

Étape 2 : Lancer WFuzz pour tester des utilisateurs​

Exécutez la commande suivante :

wfuzz -c -z file,/usr/share/wordlists/names.txt --hc 403 http://192.168.1.100/login.php?username=FUZZ&password=test

Explication des options :

  • -z file,/usr/share/wordlists/names.txt : Liste de noms d’utilisateur à tester.
  • --hc 403 : Ignore les réponses avec un code 403 (accès refusé).
  • FUZZ : Remplacé par chaque nom dans la liste.
Étape 3 : Analyser les résultats​

Si un utilisateur existe, la réponse HTTP sera différente (ex: 200 OK).

5. Questions de réflexion​

  1. Pourquoi une attaque par force brute est-elle plus efficace sur des mots de passe courts ?
  2. Quels sont les indices qui permettent de détecter une attaque par énumération ?
  3. Quels mécanismes de protection peuvent être mis en place contre la force brute et l’énumération ?
  4. Pourquoi est-il important d’utiliser un mot de passe unique pour chaque service ?
  5. Comment l’authentification à deux facteurs (2FA) empêche-t-elle ces attaques ?

6. Conclusion et bonnes pratiques​

  • Les attaques par force brute et énumération sont courantes et peuvent être utilisées pour compromettre des systèmes mal protégés.
  • Les protections efficaces incluent : limitation des tentatives, verrouillage de compte, 2FA, CAPTCHA.
  • Dans un cadre professionnel, il est essentiel de tester la sécurité de ses propres systèmes pour identifier et corriger les vulnérabilités.

TP avec Gobuster​

Objectif : Explorer l’utilisation de Gobuster pour découvrir des répertoires et fichiers cachés sur un serveur Web en se concentrant sur l’analyse d’un serveur cible pour identifier des ressources potentiellement sensibles.

Matériel requis​

  • Une machine virtuelle avec Kali Linux (machine attaquante)
  • Une machine virtuelle Debian configurée comme cible (avec Apache activé, voir présentation des TP)
  • Un éditeur de texte et un terminal
  • Un accès à Internet pour télécharger des ressources publiques si nécessaire

1. Introduction​

1.1. Présentation du TP​

Ce TP vous permettra de :

  • Configurer et utiliser Gobuster pour effectuer une énumération de répertoires et fichiers sur un serveur Web.
  • Interpréter les résultats pour détecter des ressources cachées ou mal protégées.
  • Réfléchir aux implications de sécurité liées à l’exposition de telles ressources.
attention

⚠️ Important : Ce TP est réalisé dans un cadre pédagogique et éthique. L'utilisation de ces techniques sur des systèmes ou données sans autorisation explicite est strictement interdite.

Présentation de Gobuster

Gobuster est un outil de brute force orienté Web, écrit en Go, utilisé principalement pour :

  • Découvrir des répertoires et fichiers cachés sur des serveurs Web (via HTTP/S)
  • Résoudre des sous-domaines (via DNS)
  • Explorer des chemins dans des buckets S3 ou des serveurs virtuels

Il est rapide, simple à utiliser, et très efficace pour l’énumération de contenu Web.

Principales commandes de Gobuster​

1. Recherche de répertoires et fichiers (mode dir)​
gobuster dir -u http://site.com -w wordlist.txt
  • dir : mode de recherche de dossiers/fichiers
  • -u : URL cible
  • -w : fichier de wordlist
2. Spécifier les extensions de fichiers à tester​
gobuster dir -u http://site.com -w wordlist.txt -x php,html,txt
  • -x : extensions à ajouter aux mots (ex : admin.php, admin.html…)
3. Filtrer par codes de réponse HTTP​
gobuster dir -u http://site.com -w wordlist.txt -s 200,204,301,302
  • -s : affiche uniquement les réponses avec les codes spécifiés
4. Recherche de sous-domaines (mode dns)​
gobuster dns -d exemple.com -w subdomains.txt
  • dns : mode de brute force DNS
  • -d : domaine cible
  • -w : liste de sous-domaines à tester
5. Recherche de virtual hosts (mode vhost)​
gobuster vhost -u http://192.168.1.10 -w vhosts.txt
  • vhost : teste des noms d’hôtes virtuels
  • -u : IP ou domaine cible
6. Limiter le nombre de threads (par défaut : 10)​
gobuster dir -u http://site.com -w wordlist.txt -t 20
  • -t : nombre de threads simultanés
7. Ignorer les erreurs SSL (utile pour HTTPS avec certificats invalides)​
gobuster dir -u https://site.com -w wordlist.txt -k
  • -k : ignore les erreurs de certificat

Exemple simple​

gobuster dir -u http://example.com -w /usr/share/wordlists/dirb/common.txt -x php,html

Cette commande teste des chemins comme /admin.php, /login.html sur le site example.com à l’aide de la wordlist common.txt.

2. Préparation de l’environnement​

2.1. Démarrer les machines virtuelles​
  1. Lancez la machine virtuelle Kali Linux, qui servira de plateforme d’attaque.
  2. Lancez la machine virtuelle Debian, qui sera la cible (avec Apache activé comme indiqué dans la présentation des TP).
  3. Sur la VM Debian, exécutez la commande suivante dans un terminal pour déterminer son adresse IP : 
    ip addr show eth0
    Notez l’adresse IP affichée, par exemple 192.168.1.100.
2.2. Vérifier la connectivité et le serveur Web​
  1. Depuis Kali Linux, ouvrez un terminal et testez la connectivité avec la cible en utilisant : 
    ping 192.168.1.100
    Si des réponses sont reçues, la connexion est fonctionnelle. Appuyez sur Ctrl+C pour arrêter.
  2. Ouvrez un navigateur sur Kali Linux et accédez à http://192.168.1.100. Confirmez que la page d’accueil d'Apache s’affiche (par défaut, "It works!").
Une solution

3. Installation et configuration de Gobuster​

3.1. Vérifier la présence de Gobuster​
  1. Sur Kali Linux, ouvrez un terminal et exécutez : 
    gobuster --version
  2. Si une version s’affiche (par exemple, v3.1.0), Gobuster est installé. Sinon, installez-le avec : 
    sudo apt update && sudo apt install gobuster
3.2. Préparer une liste de mots pour l’énumération​
  1. Vérifiez la disponibilité d’une liste de mots (wordlist) par défaut sur Kali Linux en exécutant : 
    ls /usr/share/wordlists/dirb/common.txt
  2. Si le fichier existe, il sera utilisé pour ce TP. Sinon, téléchargez une liste publique depuis GitHub avec : 
    wget https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/common.txt -O common.txt
Une solution

4. Énumération de répertoires avec Gobuster​

4.1. Lancer une analyse de répertoires​
  1. Exécutez la commande suivante pour scanner le serveur Web de la VM Debian : 
    gobuster dir -u http://192.168.1.100 -w /usr/share/wordlists/dirb/common.txt
    • dir : Mode d’énumération des répertoires.
    • -u http://192.168.1.100 : URL cible.
    • -w /usr/share/wordlists/dirb/common.txt : Chemin de la wordlist.
4.2. Observer les résultats​
  1. Gobuster affiche les répertoires et fichiers découverts avec leur code de statut HTTP. Par exemple : 
    /index.html (Status: 200) [Size: 1234]
    /admin (Status: 301) [Size: 324] [--> http://192.168.1.100/admin/]
    /cgi-bin (Status: 301) [Size: 325] [--> http://192.168.1.100/cgi-bin/]
  2. Notez les chemins intéressants pour une exploration ultérieure (sur une installation Debian standard, vous verrez des répertoires par défaut comme /cgi-bin).
Une solution

5. Exploration manuelle des ressources découvertes​

5.1. Accéder aux chemins trouvés​
  1. Ouvrez un navigateur sur Kali Linux.
  2. Testez les URLs découvertes, telles que :
    • http://192.168.1.100/admin
    • http://192.168.1.100/cgi-bin
    • http://192.168.1.100/index.html
5.2. Analyser le contenu​
  1. Examinez chaque page pour identifier son contenu (par exemple, formulaires, fichiers, interfaces).
  2. Notez toute information sensible ou fonctionnalité exposée (créez un fichier test dans un répertoire pour simuler une fuite).
Une solution

6. Questions de réflexion​

  1. Quels types de répertoires ou fichiers découverts pourraient compromettre la sécurité d’un serveur Web ?
  2. Comment la découverte de ressources cachées facilite-t-elle une attaque par force brute ultérieure ?
  3. Quelles mesures un administrateur peut-il prendre pour bloquer l’énumération par Gobuster ?
  4. En quoi l’énumération diffère-t-elle d’une attaque par force brute en termes d’objectif et de méthode ?
  5. Pourquoi tester ses propres systèmes avec des outils comme Gobuster est-il une pratique recommandée ?

7. Conclusion et recommandations​

  • Ce TP illustre la puissance de Gobuster pour révéler des ressources cachées, mettant en lumière les risques d’une mauvaise configuration serveur.
  • Pour sécuriser un serveur, limitez l’accès aux répertoires sensibles (via .htaccess ou permissions), désactivez le listage de répertoires, et surveillez les logs d’accès.
  • Effectuer des tests réguliers avec des outils d’énumération aide à identifier et corriger les failles avant leur exploitation.

8. Pour aller plus loin​

  • Expérimentez avec une wordlist plus large, comme /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt.
  • Ajoutez des extensions spécifiques dans Gobuster avec -x (par exemple, -x bak,conf,sql) pour chercher des fichiers de sauvegarde ou de configuration.
  • Comparez Gobuster à WFuzz sur la même cible pour évaluer leurs différences en termes de vitesse et de résultats.
  • Configurez un serveur Web local avec des répertoires cachés et testez la capacité de Gobuster à les détecter.