Configurer un environnement de test pour Hydra

Introduction

Dans ce laboratoire, vous apprendrez à configurer un environnement de test pour Hydra en installant et en configurant un serveur OpenSSH sur votre machine virtuelle LabEx. Cet environnement contrôlé vous permettra de pratiquer en toute sécurité les techniques de craquage de mots de passe lors des exercices suivants.

Vous configurerez le serveur SSH pour activer l'authentification par mot de passe et la connexion en tant que root, ce qui est essentiel pour les tests avec Hydra. Le processus comprend la modification des fichiers de configuration, le redémarrage des services et la vérification de la configuration pour les tests de sécurité ultérieurs.

Installer un serveur SSH local

Dans cette étape, vous allez installer un serveur OpenSSH sur votre machine virtuelle LabEx. Commençons par comprendre ce qu'est SSH - il signifie Secure Shell (Shell sécurisé), qui est un protocole réseau permettant de créer un canal sécurisé entre deux ordinateurs sur un réseau non sécurisé. Cela est particulièrement important lorsque vous avez besoin d'accéder à distance à un système tout en gardant votre communication chiffrée.

Le serveur OpenSSH que nous installons est l'implémentation la plus courante du protocole SSH sur les systèmes Linux. En le configurant, nous créons un environnement contrôlé où nous pourrons tester en toute sécurité des outils de craquage de mots de passe comme Hydra plus tard dans le laboratoire. C'est similaire à la façon dont les professionnels de la sécurité testent les systèmes pour détecter les vulnérabilités dans un environnement sûr et isolé.

Tout d'abord, nous devons mettre à jour la liste de vos paquets. Cela garantit que votre système connaît les dernières versions disponibles des paquets logiciels :
```
sudo apt update
```
La commande sudo vous donne des privilèges d'administrateur, tandis que apt update met à jour la liste des paquets disponibles sur votre système.
Maintenant, installez le paquet du serveur OpenSSH. Cela téléchargera et configurera tous les composants nécessaires pour exécuter un serveur SSH :
```
sudo apt install -y openssh-server
```
Le paramètre -y répond automatiquement "oui" à toutes les invitations pendant l'installation, rendant le processus plus fluide.
Étant donné que nous travaillons dans un conteneur Docker (un environnement léger et isolé), nous devons démarrer manuellement le service SSH. Normalement, il démarrerait automatiquement, mais nous gérerons cette configuration plus tard :
```
sudo service ssh start
```
Vérifions que le serveur SSH fonctionne correctement. Cette commande vérifie l'état actuel du service SSH :
```
sudo service ssh status
```
Vous devriez voir une sortie contenant "active (running)" ce qui confirme que le service fonctionne correctement.
Enfin, vérifions que le serveur SSH écoute sur le port par défaut (22). Les ports sont comme des portes que les services utilisent pour communiquer, et SSH utilise traditionnellement le port 22 :
```
ss -tulnp | grep sshd
```
La commande ss affiche les statistiques des sockets, et nous filtrons les entrées liées à SSH. Vous devriez voir une sortie montrant sshd en écoute sur *:22 ou 0.0.0.0:22, ce qui signifie qu'il est prêt à accepter des connexions sur toutes les interfaces réseau.

Configurer le serveur SSH pour les tests

Dans cette étape, vous allez configurer le serveur SSH pour activer l'authentification par mot de passe, ce qui est nécessaire pour les tests avec Hydra dans les étapes suivantes. SSH (Secure Shell, Shell sécurisé) est un protocole permettant d'accéder de manière sécurisée à distance à des systèmes. Par défaut, les configurations SSH modernes privilégient la sécurité en désactivant l'authentification par mot de passe au profit de l'authentification basée sur des clés. Cependant, comme Hydra est un outil de craquage de mots de passe, nous devons activer temporairement l'authentification par mot de passe à des fins de test.

Tout d'abord, faites une sauvegarde du fichier de configuration SSH original. C'est une bonne pratique avant de modifier le système, car cela vous permet de restaurer les paramètres originaux si nécessaire :
```
sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak
```
Ouvrez le fichier de configuration du serveur SSH pour le modifier. Nous utilisons nano, un éditeur de texte simple adapté aux débutants. Le fichier contient tous les paramètres qui contrôlent le fonctionnement de votre serveur SSH :
```
sudo nano /etc/ssh/sshd_config
```
Recherchez et modifiez les lignes suivantes (ou ajoutez-les si elles n'existent pas). Ces paramètres activent l'authentification par mot de passe et autorisent la connexion en tant que root, ce dont nous avons besoin pour notre environnement de test :
```
PasswordAuthentication yes
PermitRootLogin yes
```
Enregistrez le fichier (Ctrl+O, Entrée) et quittez nano (Ctrl+X). N'oubliez pas que les modifications ne prendront effet qu'une fois le service SSH redémarré.
Redémarrez le service SSH pour appliquer les modifications. Cela indique au système de recharger le fichier de configuration avec nos nouveaux paramètres :
```
sudo service ssh restart
```
Vérifiez que la nouvelle configuration est active. Cette commande vérifie la configuration SSH actuelle et filtre nos paramètres spécifiques pour confirmer qu'ils sont correctement activés :
```
sudo sshd -T | grep -E "passwordauthentication|permitrootlogin"
```
Vous devriez voir une sortie confirmant que les deux paramètres sont activés. Sinon, vérifiez que vous avez correctement enregistré le fichier et redémarré le service.

Créer des comptes d'utilisateurs de test

Dans cette étape, vous allez créer des comptes d'utilisateurs de test avec des mots de passe intentionnellement faibles. Ces comptes serviront de cibles lorsque nous utiliserons Hydra plus tard pour démontrer les attaques de force brute SSH. La création de tels comptes de test nous permet de simuler en toute sécurité des scénarios réels où des attaquants pourraient exploiter des identifiants faibles.

Créons trois utilisateurs de test avec des mots de passe faibles courants. Ces mots de passe sont délibérément simples car nous voulons que Hydra soit capable de les craquer lors de nos tests. Dans les systèmes réels, vous devriez toujours utiliser des mots de passe forts et complexes.

Créez trois utilisateurs de test avec des mots de passe simples (nous les utiliserons pour les tests) :
```
sudo useradd -m -s /bin/bash testuser1
echo "testuser1:password123" | sudo chpasswd

sudo useradd -m -s /bin/bash testuser2
echo "testuser2:qwerty" | sudo chpasswd

sudo useradd -m -s /bin/bash testuser3
echo "testuser3:letmein" | sudo chpasswd
```
La commande useradd crée chaque utilisateur avec un répertoire personnel (-m) et définit leur shell sur bash (-s /bin/bash). La commande chpasswd définit ensuite le mot de passe de chaque utilisateur.
Vérifiez que les utilisateurs ont été créés avec succès :
```
id testuser1
id testuser2
id testuser3
```
La commande id affiche les informations de l'utilisateur. Vous devriez voir une sortie confirmant l'existence de chaque utilisateur, y compris leur identifiant utilisateur (UID), leur identifiant de groupe (GID) et leur appartenance à des groupes. Cette étape de vérification garantit que nos comptes de test sont correctement configurés avant de poursuivre.
Vérifiez que les mots de passe ont été correctement définis en essayant de vous connecter en tant que chaque utilisateur (vous devrez entrer les mots de passe que vous venez de définir) :
```
su - testuser1
exit
su - testuser2
exit
su - testuser3
exit
```
La commande su - username vous permet de basculer sur un autre compte utilisateur. Après avoir entré chaque mot de passe, vous devriez brièvement voir le prompt de commande changer pour indiquer que vous êtes connecté en tant que cet utilisateur. La commande exit vous ramène à votre session d'origine. Cette étape confirme que les mots de passe fonctionnent comme prévu.
(Facultatif) Créez un fichier texte contenant les identifiants de test pour référence :
```
echo -e "testuser1:password123\ntestuser2:qwerty\ntestuser3:letmein" > ~/project/test_credentials.txt
```
Cela crée un fichier texte listant tous les identifiants de test au format nom_utilisateur:mot_de_passe. Bien que ce ne soit pas strictement nécessaire, avoir ce fichier de référence peut être utile lors des tests. Le paramètre -e active l'interprétation des caractères d'échappement tels que \n pour les sauts de ligne.

Démarrer le service SSH

Dans cette étape, vous allez vous assurer que le service SSH est correctement en cours d'exécution et configuré pour démarrer automatiquement. SSH (Secure Shell, Shell sécurisé) est un protocole réseau qui permet un accès distant sécurisé entre ordinateurs. Dans notre environnement de test avec Hydra, nous avons besoin que le service SSH soit en continu pour pouvoir effectuer de manière fiable des tests de craquage de mots de passe.

Tout d'abord, vérifions si le service SSH est actuellement actif. Cette commande affiche l'état actuel du démon SSH (sshd) :
```
sudo service ssh status
```
Si le service n'est pas en cours d'exécution, vous verrez "inactive (dead)" dans la sortie. Cela signifie que le service SSH est actuellement arrêté et qu'il n'accepte aucune connexion.
Si le service n'est pas en cours d'exécution, nous devons le démarrer. Cette commande initialise le démon SSH :
```
sudo service ssh start
```
Après avoir démarré le service, vérifions qu'il est correctement en cours d'exécution. La commande de statut devrait maintenant afficher une sortie différente :
```
sudo service ssh status
```
Vous devriez maintenant voir "active (running)" dans la sortie, indiquant que le service SSH est prêt à accepter des connexions.
Étant donné que nous travaillons dans un conteneur Docker (un environnement léger et isolé), nous devons nous assurer que le service SSH démarre automatiquement lorsque le conteneur redémarre. Cette ligne ajoute une commande de démarrage à votre fichier de configuration bash :
```
echo 'sudo service ssh start' >> ~/.bashrc
```
Le fichier .bashrc s'exécute automatiquement lorsque vous démarrez une nouvelle session de terminal, ce qui garantit que le service SSH démarrera toujours lorsque le conteneur redémarrera.
Enfin, vérifions que le service SSH écoute sur le bon port réseau (le port 22 est la valeur par défaut pour SSH). Cette commande affiche toutes les connexions réseau actives :
```
sudo netstat -tulnp | grep sshd
```
Vous devriez voir une sortie montrant que sshd écoute sur 0.0.0.0:22, ce qui signifie que le serveur SSH est correctement configuré pour accepter des connexions depuis n'importe quelle interface réseau sur le port SSH standard.

Vérifier l'accessibilité du serveur SSH

Dans cette étape finale, nous allons vérifier que votre serveur SSH est correctement configuré et accessible. Cela est crucial car Hydra (l'outil de craquage de mots de passe que nous utiliserons dans les laboratoires suivants) nécessite un service SSH fonctionnel pour effectuer ses tests. Nous allons effectuer plusieurs vérifications pour nous assurer que tout fonctionne comme prévu.

Tout d'abord, vérifions si le service SSH est réellement en cours d'exécution. Les services peuvent parfois échouer à démarrer ou planter de manière inattendue, c'est donc notre première vérification de base :
```
sudo service ssh status
```
La sortie devrait clairement indiquer "active (running)". Si ce n'est pas le cas, nous devrons résoudre les problèmes liés au service avant de poursuivre.
Maintenant, nous allons tester l'accès SSH local en utilisant l'un des comptes de test que nous avons créés précédemment. Cela simule la manière dont Hydra tentera de se connecter :
```
ssh testuser1@localhost
```
Lorsque vous y êtes invité, entrez le mot de passe "password123" (celui que nous avons configuré précédemment). Après vous être connecté avec succès, tapez exit pour revenir à votre session principale. Cela confirme que l'authentification par mot de passe de base fonctionne.
Testons spécifiquement l'authentification par mot de passe (car Hydra utilise principalement la force brute pour craquer les mots de passe). Nous allons forcer SSH à utiliser l'authentification par mot de passe et fournir intentionnellement un mot de passe incorrect :
```
ssh -o PreferredAuthentications=password -o PubkeyAuthentication=no testuser1@localhost
```
Entrez n'importe quel mot de passe incorrect lorsque vous y êtes invité. Le serveur devrait rejeter la connexion, ce qui est le comportement attendu que nous souhaitons voir.
Ensuite, nous allons vérifier que le serveur SSH écoute sur la bonne interface réseau et le bon port. Cela garantit que les connexions distantes (comme celles provenant d'Hydra) peuvent atteindre le service :
```
sudo netstat -tulnp | grep sshd
```
Vous devriez voir sshd écoutant sur 0.0.0.0:22, ce qui signifie qu'il accepte les connexions depuis n'importe quelle interface réseau sur le port SSH standard (22).
Enfin, examinons les journaux d'authentification pour voir nos tentatives de test enregistrées. Les journaux sont précieux pour la résolution de problèmes et pour comprendre ce qui se passe en coulisse :
```
sudo tail -n 10 /var/log/auth.log
```
Recherchez les entrées montrant votre connexion réussie (étape 2) et votre tentative échouée (étape 3). Ces journaux seront également importants lors de l'analyse des tentatives d'attaque d'Hydra plus tard.

Résumé

Dans ce laboratoire, vous avez appris à configurer un environnement de test pour Hydra en installant et en configurant un serveur OpenSSH sur une machine virtuelle (VM) LabEx. Le processus a inclus la mise à jour des paquets, l'installation du serveur SSH et la vérification de son statut d'exécution tout en configurant les paramètres d'authentification à des fins de test.

Vous avez également pratiqué la création de comptes d'utilisateurs de test pour simuler des scénarios réels et préparé l'environnement pour des tests de sécurité des mots de passe. Ce laboratoire a fourni une expérience pratique essentielle dans la configuration de serveurs SSH et la création d'environnements contrôlés pour l'expérimentation avec des outils de sécurité.