Renforcer la sécurité SSH dans OpenSSH

Introduction

Dans ce laboratoire (lab), vous apprendrez des techniques essentielles pour renforcer la sécurité SSH dans OpenSSH grâce à l'authentification par clés et au durcissement de la configuration. Vous allez pratiquer le remplacement de l'authentification par mot de passe par des paires de clés sécurisées, désactiver la connexion en tant que root et modifier les ports par défaut pour atténuer les attaques de force brute.

Les exercices pratiques vous guideront dans la génération de clés cryptographiques, la configuration des autorisations de fichiers appropriées et le test de votre configuration SSH sécurisée. Vous apprendrez également les commandes clés pour gérer les services SSH et vérifier vos configurations de sécurité.

Skills Graph

Installer OpenSSH

Dans cette étape, vous allez installer le paquet du serveur OpenSSH sur votre machine virtuelle (VM) LabEx. OpenSSH (Open Secure Shell) est une implémentation gratuite et open-source du protocole SSH qui permet d'établir des communications chiffrées sécurisées entre deux hôtes non fiables sur un réseau non sécurisé. C'est l'outil standard pour l'administration à distance de serveurs et les transferts de fichiers sécurisés.

Avant de commencer, il est important de comprendre que SSH fonctionne selon un modèle client-serveur. Le serveur (que nous installons actuellement) écoute les connexions entrantes, tandis que les clients (comme le terminal de votre machine locale) se connectent à lui. Toutes les communications sont chiffrées, protégeant ainsi vos identifiants et vos données.

Étant donné que la VM LabEx utilise des conteneurs Docker où systemctl n'est pas disponible (les conteneurs Docker exécutent généralement un seul processus plutôt que des systèmes d'exploitation complets), nous utiliserons la commande service pour gérer le démon SSH. C'est une alternative plus simple à systemctl qui fonctionne bien dans les environnements conteneurisés.

Suivez ces étapes pour installer OpenSSH :

1. Tout d'abord, mettez à jour votre liste de paquets pour vous assurer d'obtenir la dernière version. Cela récupère les informations les plus récentes sur les paquets à partir des dépôts d'Ubuntu :

   sudo apt update

2. Installez le paquet du serveur OpenSSH. Le drapeau -y confirme automatiquement toutes les invitations pendant l'installation :

   sudo apt install -y openssh-server

3. Après l'installation, vérifiez si le service SSH est en cours d'exécution. La commande status indique si le service est actif et en écoute pour les connexions :

   service ssh status

   Vous devriez voir un message indiquant que le service est actif (en cours d'exécution). S'il n'est pas en cours d'exécution, nous le démarrerons à l'étape suivante.

4. Si le service n'est pas en cours d'exécution (ce qui serait indiqué par "inactif" dans la sortie de la commande status), démarrez-le manuellement :

   service ssh start

5. Vérifiez que SSH écoute sur le port par défaut (22). La commande netstat affiche les connexions réseau et les ports en écoute, tandis que grep filtre les entrées liées à SSH :

   sudo netstat -tulnp | grep sshd

   Vous devriez voir une sortie similaire à celle-ci, indiquant que SSH écoute sur toutes les interfaces réseau (0.0.0.0) sur le port 22 :

   tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      -

Configurer l'authentification par clés

Dans cette étape, vous allez configurer l'authentification SSH basée sur les clés, qui offre une sécurité supérieure à l'authentification par mot de passe traditionnelle. Contrairement aux mots de passe qui peuvent être devinés ou obtenus par force brute, l'authentification par clés utilise une paire de clés cryptographiques - une clé privée (à garder secrète) et une clé publique (à partager avec les serveurs).

Lorsque vous vous connectez à un serveur SSH, celui-ci utilise des algorithmes mathématiques pour vérifier que vous possédez la clé privée correspondant à la clé publique qu'il a en sa possession. Cette méthode est à la fois plus sécurisée et plus pratique une fois configurée.

Créons et configurons ces clés étape par étape :

1. Tout d'abord, nous allons générer une nouvelle paire de clés SSH. Cette commande crée deux fichiers dans votre répertoire ~/.ssh :

   ssh-keygen -t rsa -b 4096 -f ~/.ssh/labex_key -N ""

   • -t rsa spécifie le type de clé (algorithme RSA)
   • -b 4096 crée une clé forte de 4096 bits
   • -f définit le nom de fichier de votre paire de clés
   • -N "" signifie qu'il n'y a pas de mot de passe (pour simplifier le laboratoire)

   Vous aurez maintenant :

   • Clé privée : ~/.ssh/labex_key (ne la partagez jamais !)
   • Clé publique : ~/.ssh/labex_key.pub (celle-ci sera partagée avec les serveurs)

2. Les autorisations de fichiers appropriées sont cruciales pour la sécurité SSH. Ces commandes garantissent que seuls vous pouvez accéder à vos clés :

   chmod 700 ~/.ssh
   chmod 600 ~/.ssh/labex_key
   chmod 644 ~/.ssh/labex_key.pub

3. Maintenant, nous allons autoriser votre clé en ajoutant la clé publique au fichier spécial authorized_keys que SSH vérifie :

   cat ~/.ssh/labex_key.pub >> ~/.ssh/authorized_keys
   chmod 600 ~/.ssh/authorized_keys

4. Ensuite, nous allons configurer le serveur SSH lui-même. Modifiez le fichier de configuration principal :

   sudo nano /etc/ssh/sshd_config

   Trouvez et modifiez ces paramètres importants :

   PubkeyAuthentication yes
   PasswordAuthentication no

   Cela indique à SSH de :

   • Autoriser l'authentification par clés (activée par défaut, mais il est bon de le confirmer)
   • Désactiver les connexions par mot de passe (ne permettant que l'accès basé sur les clés)

5. Après avoir modifié la configuration, redémarrez toujours le service SSH :

   service ssh restart

6. Enfin, vérifions que tout fonctionne. Essayez de vous connecter à votre propre machine (localhost) en utilisant votre nouvelle clé :

   ssh -i ~/.ssh/labex_key localhost

   Le drapeau -i spécifie quelle clé privée utiliser. Si cela réussit, vous vous connecterez immédiatement sans invitation de mot de passe - cela confirme que l'authentification par clés fonctionne correctement.

Désactiver la connexion en tant que root

Dans cette étape, nous allons désactiver la connexion directe en tant que root via SSH. Cela est important car le compte root dispose de tous les privilèges système, ce qui en fait une cible principale pour les hackers. En désactivant la connexion en tant que root, nous obligeons les attaquants à deviner à la fois un nom d'utilisateur et un mot de passe, rendant les attaques par force brute beaucoup plus difficiles.

Lorsque vous aurez besoin de privilèges root après ce changement, vous vous connecterez d'abord avec un compte utilisateur normal, puis vous utiliserez sudo pour les tâches administratives. Cela crée une couche de sécurité supplémentaire car les attaquants devraient compromettre deux comptes.

Modifions la configuration SSH :

1. Tout d'abord, ouvrez le fichier de configuration principal de SSH avec un éditeur de texte. Nous utiliserons nano ici, mais vous pouvez utiliser n'importe quel éditeur avec lequel vous êtes à l'aise :

   sudo nano /etc/ssh/sshd_config

2. Recherchez la ligne qui dit PermitRootLogin (généralement autour de la ligne 32). Si vous ne la trouvez pas, vous devrez l'ajouter. Modifiez ou ajoutez cette ligne pour qu'elle soit :

   PermitRootLogin no

3. Pendant que nous éditons ce fichier, définissons quelques paramètres de sécurité supplémentaires qui fonctionnent bien avec ce changement :

   StrictModes yes
   MaxAuthTries 3
   LoginGraceTime 60

   • StrictModes vérifie les autorisations de fichiers pour la sécurité
   • MaxAuthTries limite le nombre de tentatives de connexion échouées
   • LoginGraceTime définit la durée maximale d'une tentative de connexion

4. Enregistrez vos modifications dans nano en appuyant sur :

   • Ctrl+O pour écrire le fichier
   • Entrée pour confirmer
   • Ctrl+X pour quitter

5. Pour que les modifications prennent effet, redémarrez le service SSH :

   service ssh restart

6. Testons que nos modifications ont fonctionné en essayant de nous connecter en tant que root via SSH (cela devrait échouer) :

   ssh root@localhost

   Vous devriez voir une erreur comme "Permission denied (publickey)", ce qui signifie que notre mesure de sécurité fonctionne correctement. À partir de maintenant, vous devrez utiliser un compte utilisateur normal pour vous connecter.

Changer le port par défaut

Dans cette étape, nous allons modifier le port SSH par défaut, qui est le port 22, pour le remplacer par un port personnalisé (2222 dans notre exemple). Il s'agit d'une mesure de sécurité importante car de nombreux bots automatisés et attaquants recherchent des serveurs SSH sur le port standard 22. En changeant pour un port non standard, nous rendons notre serveur moins visible pour ces scans automatisés.

Avant de faire tout changement, vérifions d'abord la configuration actuelle du port SSH. Cela nous permet de comprendre la configuration existante :

sudo grep -i port /etc/ssh/sshd_config

Vous verrez généralement #Port 22 dans la sortie. Le symbole # signifie que cette ligne est commentée, donc SSH utilise actuellement le port par défaut 22.

Maintenant, nous allons éditer le fichier de configuration SSH. Nous utiliserons l'éditeur de texte nano, qui est convivial pour les débutants :

sudo nano /etc/ssh/sshd_config

À l'intérieur du fichier, recherchez la ligne contenant #Port 22. Nous devons apporter deux modifications ici :

1. Supprimez le # pour décommenter la ligne (cela active le paramètre)
2. Changez le numéro de port de 22 à 2222

La ligne modifiée devrait ressembler à ceci :

Port 2222

Après avoir effectué ce changement, enregistrez le fichier dans nano en appuyant sur :

1. Ctrl+O (pour écrire le fichier)
2. Entrée (pour confirmer le nom de fichier)
3. Ctrl+X (pour quitter l'éditeur)

Pour que les modifications prennent effet, nous devons redémarrer le service SSH :

service ssh restart

Vérifions que SSH écoute maintenant sur notre nouveau port (2222) au lieu du port par défaut :

sudo netstat -tulnp | grep ssh

La sortie devrait montrer que SSH écoute sur le port 2222. Si vous voyez toujours le port 22, vérifiez à nouveau les modifications apportées au fichier de configuration.

Enfin, testez la nouvelle configuration en vous connectant à SSH en utilisant le port personnalisé. Notez que nous devons maintenant spécifier le port avec le drapeau -p :

ssh -p 2222 -i ~/.ssh/labex_key localhost

Après avoir réussi à vous connecter, vous pouvez quitter la session SSH en appuyant sur Ctrl+D. N'oubliez pas que désormais, vous devrez toujours spécifier ce port personnalisé lorsque vous vous connecterez à votre serveur SSH.

Tester la configuration renforcée

Dans cette étape finale, nous allons vérifier toutes les mesures de renforcement de la sécurité que vous avez mises en œuvre. Le test est crucial pour garantir que votre serveur SSH est correctement configuré et sécurisé. Nous examinerons à la fois les paramètres côté serveur et les tentatives de connexion côté client.

Commençons par vérifier la configuration actuelle de SSH sur votre serveur. Cela confirme que les modifications que vous avez apportées précédemment sont actives :

1. Tout d'abord, vérifiez tous les paramètres SSH actuels :

   sudo sshd -T | grep -E 'port|permitrootlogin|passwordauthentication|pubkeyauthentication'

   La commande sshd -T affiche la configuration réelle en cours d'exécution. Nous filtrons pour les paramètres de sécurité clés. Vous devriez voir :

   port 2222
   permitrootlogin no
   passwordauthentication no
   pubkeyauthentication yes

   Cette sortie confirme que SSH fonctionne sur le port 2222, que la connexion en tant que root est désactivée, que l'authentification par mot de passe est désactivée et que l'authentification par clé publique est activée.

Maintenant, testons les connexions du point de vue du client :

2. Testez une connexion réussie avec l'authentification par clé :

   ssh -p 2222 -i ~/.ssh/labex_key localhost "echo 'Key auth successful'"

   Cette commande tente de se connecter en utilisant votre clé privée (le flag -i spécifie le fichier de clé). Si la connexion réussit, la commande exécute un simple echo sur le serveur. Vous devriez voir :

   Key auth successful

3. Testez une tentative de connexion en tant que root qui échoue :

   ssh -p 2222 root@localhost 2>&1 | grep -i "permission denied"

   Cette commande tente de se connecter en tant que root, ce qui devrait échouer car nous avons désactivé la connexion en tant que root. La commande filtre le message d'erreur attendu.

4. Testez une tentative d'authentification par mot de passe qui échoue :

   ssh -p 2222 -o PreferredAuthentications=password -o PubkeyAuthentication=no localhost 2>&1 | grep -i "permission denied"

   Ici, nous forçons l'authentification par mot de passe (désactivée dans notre configuration) pour vérifier qu'elle est correctement bloquée. Les options désactivent explicitement l'authentification par clé.

Enfin, vérifions l'état du réseau du serveur :

5. Vérifiez les connexions SSH actives :

   sudo netstat -tulnp | grep 2222

   Cette commande affiche tous les ports en écoute, filtrés pour notre port SSH personnalisé (2222). Vous devriez voir sshd répertorié en tant qu'écoutant sur ce port.

6. Vérifiez l'état du service SSH :

   service ssh status

   Cela confirme que le service SSH fonctionne correctement. La sortie devrait indiquer que le service est actif.

Résumé

Dans ce laboratoire (lab), vous avez appris à améliorer la sécurité SSH dans OpenSSH grâce à des configurations pratiques. Les exercices ont couvert l'installation du serveur OpenSSH, la vérification de son état et la mise en œuvre de l'authentification basée sur des clés avec les paramètres de permissions appropriés.

Vous avez également exploré des techniques essentielles de renforcement de la sécurité, notamment la désactivation de la connexion en tant que root et le changement du port SSH par défaut. Ces mesures réduisent efficacement la vulnérabilité aux attaques par force brute et aux scans automatisés tout en préservant la fonctionnalité du système.