Attaquer les services Telnet avec Hydra

Introduction

Dans ce laboratoire, vous apprendrez à mener des attaques par force brute contre les services Telnet en utilisant Hydra, un outil polyvalent de craquage de mots de passe. Vous configurerez un environnement Telnet vulnérable et utiliserez Hydra pour démontrer comment des informations d'identification faibles peuvent être exploitées.

Ce laboratoire couvre la configuration du serveur Telnet, la création d'informations d'identification de test et l'exécution d'attaques Hydra pour mettre en évidence les risques de sécurité. Grâce à une pratique concrète, vous comprendrez pourquoi Telnet est non sécurisé et apprendrez l'importance d'utiliser des alternatives chiffrées.

Skills Graph

Installer un serveur Telnet local

Dans cette étape, vous installerez un serveur Telnet sur votre VM LabEx afin de créer un environnement de test local. Telnet est l'un des plus anciens protocoles réseau, permettant l'accès à distance aux systèmes. Cependant, il transmet toutes les données (y compris les mots de passe) en texte clair sans chiffrement, ce qui le rend très peu sûr pour une utilisation dans le monde réel, mais parfait pour l'apprentissage des concepts de test de sécurité.

1. Tout d'abord, mettez à jour votre liste de paquets pour vous assurer d'obtenir les dernières versions. C'est une bonne pratique avant d'installer un nouveau logiciel :

sudo apt update

2. Installez le paquet serveur Telnet (xinetd). Xinetd est un super-serveur qui gère les connexions Telnet. L'option -y confirme automatiquement toutes les invites lors de l'installation :

sudo apt install -y xinetd telnetd

3. Créez le fichier de configuration Telnet à l'emplacement /etc/xinetd.d/telnet. Nous utiliserons nano, un éditeur de texte simple fourni avec la plupart des systèmes Linux :

sudo nano /etc/xinetd.d/telnet

4. Ajoutez la configuration suivante (appuyez sur Ctrl+O pour enregistrer, puis sur Ctrl+X pour quitter). Cette configuration active le service Telnet et définit les paramètres de base. La ligne disable = no est particulièrement importante car elle active le service :

service telnet
{
        disable         = no
        flags           = REUSE
        socket_type     = stream
        wait            = no
        user            = root
        server          = /usr/sbin/in.telnetd
        log_on_failure  += USERID
}

5. Redémarrez le service xinetd pour appliquer les modifications. Les services doivent souvent être redémarrés après des modifications de configuration :

sudo service xinetd restart

6. Vérifiez que le service Telnet est en cours d'exécution. Le port 23 est le port par défaut pour Telnet. La commande netstat affiche les connexions réseau actives et les ports d'écoute :

sudo netstat -tulnp

Vous devriez voir une sortie similaire à celle-ci, indiquant que le service Telnet est à l'écoute sur le port 23 :

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      22/sshd: /usr/sbin/
tcp        0      0 0.0.0.0:3001            0.0.0.0:*               LISTEN      -
tcp        0      0 0.0.0.0:3002            0.0.0.0:*               LISTEN      -
tcp        0      0 127.0.0.11:38203        0.0.0.0:*               LISTEN      -
tcp6       0      0 :::22                   :::*                    LISTEN      22/sshd: /usr/sbin/
tcp6       0      0 :::23                   :::*                    LISTEN      1620/xinetd
udp        0      0 0.0.0.0:3001            0.0.0.0:*                           -
udp        0      0 127.0.0.11:54421        0.0.0.0:*                           -

Configurer Telnet avec des comptes de test

Dans cette étape, vous créerez des comptes de test qui seront utilisés pour la démonstration de l'attaque par force brute Hydra. Ces comptes représentent des informations d'identification faibles courantes que l'on trouve dans les systèmes réels, ce qui nous permet de démontrer en toute sécurité comment les attaquants exploitent les mauvaises pratiques en matière de mots de passe.

1. Tout d'abord, créez trois comptes d'utilisateur de test à l'aide de la commande useradd. L'option -m garantit que les répertoires personnels sont créés pour chaque utilisateur :

sudo useradd -m user1
sudo useradd -m user2
sudo useradd -m user3

2. Définissez maintenant des mots de passe simples pour ces comptes. Nous utilisons des mots de passe faibles courants (« password », « 123456 », « qwerty ») pour simuler les vulnérabilités du monde réel. La commande chpasswd modifie en toute sécurité les mots de passe sans invites interactives :

echo "user1:password" | sudo chpasswd
echo "user2:123456" | sudo chpasswd
echo "user3:qwerty" | sudo chpasswd

3. Vérifiez que les comptes ont été créés avec succès en vérifiant le fichier de mots de passe du système. La commande grep filtre nos utilisateurs de test dans /etc/passwd, qui stocke toutes les informations des comptes d'utilisateur :

grep -E 'user1|user2|user3' /etc/passwd

Vous devriez voir une sortie similaire à :

user1:x:5001:5001::/home/user1:/bin/sh
user2:x:5002:5003::/home/user2:/bin/sh
user3:x:5003:5004::/home/user3:/bin/sh

4. Créez des fichiers d'informations d'identification pour l'attaque Hydra dans votre répertoire de projet. Ces fichiers texte serviront d'entrée à Hydra pour les combinaisons de nom d'utilisateur et de mot de passe lors de la tentative de force brute :

cd ~/project
echo -e "user1\nuser2\nuser3" > usernames.txt
echo -e "password\n123456\nqwerty" > passwords.txt

5. Vérifiez que les fichiers d'informations d'identification contiennent les informations correctes. La commande cat affiche le contenu du fichier : nous vérifions les deux fichiers pour garantir une mise en forme appropriée pour les exigences d'Hydra :

cat usernames.txt && cat passwords.txt

Vous devriez voir :

user1
user2
user3
password
123456
qwerty

Charger les fichiers de noms d'utilisateur et de mots de passe

Dans cette étape, vous préparerez les fichiers d'informations d'identification qu'Hydra utilisera pour l'attaque par force brute. Ces fichiers contiennent les noms d'utilisateur et les mots de passe que nous avons créés à l'étape précédente. Les attaques par force brute fonctionnent en essayant systématiquement toutes les combinaisons possibles d'informations d'identification jusqu'à ce que la bonne soit trouvée. Avoir des fichiers d'informations d'identification bien organisés rend ce processus plus efficace.

1. Tout d'abord, vérifiez que les fichiers d'informations d'identification existent dans votre répertoire de projet. Ceci est important car Hydra a besoin de ces fichiers pour effectuer l'attaque :

cd ~/project
ls -l usernames.txt passwords.txt

Vous devriez voir une sortie similaire à :

-rw-r--r-- 1 labex labex 12 May  1 10:00 passwords.txt
-rw-r--r-- 1 labex labex 12 May  1 10:00 usernames.txt

2. Affichez le contenu des deux fichiers pour confirmer qu'ils sont correctement formatés. Chaque nom d'utilisateur et mot de passe doit figurer sur une ligne distincte, car Hydra les lit ligne par ligne :

echo "Usernames:" && cat usernames.txt
echo "Passwords:" && cat passwords.txt

Sortie attendue :

Usernames:
user1
user2
user3
Passwords:
password
123456
qwerty

3. Créez un fichier d'informations d'identification combiné à des fins de test. Ce fichier combiné affiche les paires nom d'utilisateur-mot de passe côte à côte, ce qui permet de vérifier qu'elles sont correctement mises en correspondance :

paste usernames.txt passwords.txt > credentials.txt
cat credentials.txt

Cela affichera :

user1   password
user2   123456
user3   qwerty

4. Installez Hydra s'il n'est pas déjà présent (bien qu'il devrait être préinstallé dans la VM LabEx). Hydra est l'outil que nous utiliserons pour effectuer l'attaque par force brute contre le service Telnet :

sudo apt install -y hydra hydra-gtk

5. Vérifiez qu'Hydra est installé et vérifiez sa version. Comprendre la version est utile lors du dépannage ou de la recherche de fonctionnalités spécifiques :

hydra -h | head -n 5

Vous devriez voir la sortie d'aide d'Hydra commençant par :

Hydra v9.2 (c) 2022 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes.

Syntax: hydra [[[-l LOGIN|-L FILE] [-p PASS|-P FILE]] | [-C FILE]] [-e nsr] [-o FILE] [-t TASKS] [-M FILE [-T TASKS]] [-w TIME] [-W TIME] [-f] [-s PORT] [-x MIN:MAX:CHARSET] [-c TIME] [-ISOuvVd46] [-m MODULE_OPT] [service://server[:PORT][/OPT]]

Exécuter une attaque Hydra sur le service Telnet

Dans cette étape, vous utiliserez Hydra pour effectuer une attaque par force brute contre votre serveur Telnet local en utilisant les fichiers d

Vérifier la sortie de l'attaque Telnet

Dans cette étape, vous analyserez les résultats de votre attaque par force brute Hydra contre le service Telnet pour comprendre quelles informations d'identification ont été compromises. Hydra teste plusieurs combinaisons nom d'utilisateur/mot de passe par rapport au service, et le fichier de sortie contient toutes les connexions réussies ainsi que les tentatives infructueuses.

1. Tout d'abord, accédez à votre répertoire de projet où Hydra a enregistré ses résultats et affichez le fichier de sortie complet :

cd ~/project
cat hydra_results.txt

Un exemple de sortie montre le format des connexions réussies. Chaque ligne contient le protocole (telnet), l'adresse IP cible et les informations d'identification piratées :

[23][telnet] host: 127.0.0.1   login: user1   password: password
[23][telnet] host: 127.0.0.1   login: user2   password: 123456

2. Pour filtrer uniquement les tentatives de connexion réussies à partir de fichiers de sortie potentiellement volumineux, utilisez grep pour rechercher les lignes contenant "login:" :

grep "login:" hydra_results.txt

3. Vérifiez les comptes compromis en tentant une connexion Telnet manuelle avec les informations d'identification découvertes. Cela confirme les conclusions d'Hydra et démontre comment un attaquant utiliserait des informations d'identification volées :

telnet 127.0.0.1

À l'invite de connexion, entrez :

user1
password

Une connexion réussie affichera le message de bienvenue du serveur et l'invite de commande :

Welcome to LabEx Telnet Server
user1@localhost:~$

Tapez exit pour quitter la session Telnet une fois les tests terminés.

4. Créez un rapport de synthèse professionnel des comptes compromis à des fins de documentation. Cela crée un nouveau fichier avec les résultats formatés et le nombre :

echo "Compromised Accounts:" > attack_summary.txt
grep "login:" hydra_results.txt >> attack_summary.txt
echo -e "\nTotal compromised: $(grep -c "login:" hydra_results.txt)" >> attack_summary.txt
cat attack_summary.txt

Résumé

Dans ce labo, vous avez appris à configurer un environnement de serveur Telnet vulnérable en utilisant xinetd et des informations d'identification faibles à des fins de tests de sécurité. Le processus comprenait la configuration du service Telnet sur le port 23 et la création de comptes de test avec des mots de passe intentionnellement faibles pour démontrer les vulnérabilités d'authentification.

L'exercice a mis en évidence les risques de sécurité liés à l'utilisation de protocoles non chiffrés comme Telnet et l'importance cruciale de la mise en œuvre de politiques de mots de passe robustes. Grâce à une démonstration pratique avec Hydra, vous avez observé avec quelle facilité les attaques par force brute peuvent compromettre les systèmes dotés de mécanismes d'authentification faibles.