Introduction
Dans ce laboratoire, vous apprendrez les bases de la sécurisation de l'accès à distance à un système Linux à l'aide du protocole Secure Shell (SSH). Vous acquerrez une expérience pratique des fonctionnalités essentielles de SSH, notamment la configuration de l'authentification par clé pour une sécurité renforcée, le transfert sécurisé de fichiers entre systèmes et la création de tunnels SSH pour le transfert de ports.
Vous commencerez par configurer un conteneur Docker pour simuler un environnement de serveur distant, rendant le laboratoire plus réaliste. Vous installerez ensuite le client OpenSSH sur votre machine hôte et générerez une nouvelle paire de clés RSA à l'aide de l'utilitaire ssh-keygen. Ensuite, vous configurerez le serveur Docker pour accepter cette clé pour l'authentification, établissant une connexion sécurisée et sans mot de passe entre votre hôte et le serveur conteneurisé. Enfin, vous pratiquerez l'utilisation de la commande scp pour les transferts de fichiers sécurisés et de la commande ssh -L pour transférer un port local vers un service distant, créant ainsi efficacement un tunnel sécurisé.
Configurer le serveur SSH Docker et générer une paire de clés
Dans cette étape, vous allez configurer un conteneur Docker pour simuler un serveur SSH distant et générer une paire de clés sécurisée sur votre machine hôte. Cette approche fournit un environnement plus réaliste en séparant le client (votre hôte) du serveur (conteneur Docker).
Étant donné que Docker et le client OpenSSH sont déjà installés dans cet environnement, vous pouvez passer directement à la configuration du serveur.
Tout d'abord, assurez-vous que le service Docker est en cours d'exécution :
sudo systemctl start docker
sudo systemctl enable docker
Maintenant, créons un conteneur Docker qui servira de serveur SSH. Nous utiliserons Ubuntu comme image de base et le configurerons avec les capacités du serveur SSH. Créez un Dockerfile :
cat > Dockerfile << 'EOF'
FROM ubuntu:22.04
## Installer le serveur OpenSSH et d'autres utilitaires
RUN apt-get update && \
apt-get install -y openssh-server nginx sudo && \
apt-get clean && \
rm -rf /var/lib/apt/lists/*
## Créer un utilisateur pour l'accès SSH
RUN useradd -m -s /bin/bash sshuser && \
echo 'sshuser:password123' | chpasswd && \
usermod -aG sudo sshuser
## Configurer SSH
RUN mkdir /var/run/sshd && \
sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin no/' /etc/ssh/sshd_config && \
sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config && \
sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config
## Créer le répertoire SSH pour l'utilisateur
RUN mkdir -p /home/sshuser/.ssh && \
chown sshuser:sshuser /home/sshuser/.ssh && \
chmod 700 /home/sshuser/.ssh
## Exposer le port SSH
EXPOSE 22 80
## Démarrer le service SSH
CMD ["/usr/sbin/sshd", "-D"]
EOF
Construisez l'image Docker :
sudo docker build -t ssh-server .
Exécutez le conteneur Docker, en mappant le port 2222 de votre hôte au port 22 du conteneur :
sudo docker run -d --name ssh-lab-server -p 2222:22 -p 8080:80 ssh-server
Vérifiez que le conteneur est en cours d'exécution :
sudo docker ps
Vous devriez voir une sortie indiquant le conteneur en cours d'exécution :
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
... ssh-server "/usr/sbin/sshd -D" ... Up ... 0.0.0.0:2222->22/tcp, 0.0.0.0:8080->80/tcp ssh-lab-server
Ensuite, vous allez générer une paire de clés SSH. Les clés SSH offrent un moyen plus sécurisé de se connecter à un serveur avec SSH que l'utilisation d'un mot de passe seul. Une paire de clés se compose d'une clé privée, qui doit rester secrète, et d'une clé publique, qui peut être partagée.
Nous utiliserons la commande ssh-keygen pour créer une nouvelle paire de clés. Nous spécifierons le type de clé comme rsa et la taille de clé comme 2048 bits pour une sécurité renforcée. Le drapeau -f nous permet de spécifier un nom de fichier pour nos clés, ce qui aide à leur organisation. Nous nommerons notre clé ~/.ssh/id_rsa_lab_ssh.
Exécutez la commande suivante. Lorsque vous êtes invité à entrer une phrase de passe, appuyez simplement sur Entrée deux fois pour continuer sans en utiliser. Pour ce laboratoire, nous omettrons la phrase de passe par souci de simplicité, mais dans un scénario réel, vous devriez toujours utiliser une phrase de passe forte pour protéger votre clé privée.
ssh-keygen -t rsa -b 2048 -f ~/.ssh/id_rsa_lab_ssh
La commande générera la paire de clés et vous indiquera où les fichiers sont enregistrés.
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/labex/.ssh/id_rsa_lab_ssh
Your public key has been saved in /home/labex/.ssh/id_rsa_lab_ssh.pub
The key fingerprint is:
SHA256:... labex@...
The key's randomart image is:
+---[RSA 2048]----+
| .o*+.. |
| . =.o. . |
| . o o. . |
| o . . |
| . S |
| . . . |
| o . |
| o . |
| E . |
+----[SHA256]-----+
Pour confirmer que les fichiers de clés ont été créés, vous pouvez lister le contenu du répertoire ~/.ssh. Vous devriez voir votre nouvelle clé privée (id_rsa_lab_ssh) et votre clé publique (id_rsa_lab_ssh.pub).
ls -l ~/.ssh/id_rsa_lab_ssh*
La sortie ressemblera à ceci, montrant les deux nouveaux fichiers :
-rw------- 1 labex labex 1876 ... /home/labex/.ssh/id_rsa_lab_ssh
-rw-r--r-- 1 labex labex 401 ... /home/labex/.ssh/id_rsa_lab_ssh.pub
Vous avez maintenant installé avec succès le serveur SSH et créé une paire de clés, que vous utiliserez dans les étapes suivantes pour configurer et tester l'authentification sécurisée.
Configurer et tester l'authentification par clé SSH
Dans cette étape, vous allez configurer le serveur SSH Docker pour qu'il reconnaisse votre clé publique, vous permettant ainsi de vous connecter sans mot de passe. Ce processus implique la copie de votre clé publique dans le conteneur Docker, puis le test de la connexion.
Pour que le serveur SSH vous authentifie à l'aide de votre clé, votre clé publique doit être placée dans le fichier ~/.ssh/authorized_keys sur le serveur. Comme notre serveur s'exécute dans un conteneur Docker, nous devons copier la clé publique de votre machine hôte vers le conteneur.
Tout d'abord, copiez votre clé publique dans le conteneur Docker à l'aide de la commande docker cp :
sudo docker cp ~/.ssh/id_rsa_lab_ssh.pub ssh-lab-server:/home/sshuser/.ssh/authorized_keys
Ensuite, nous devons définir les autorisations de fichier correctes à l'intérieur du conteneur. SSH est très strict en matière de sécurité et refusera d'utiliser les clés si les autorisations sont trop ouvertes. Exécutez la commande suivante pour définir les autorisations appropriées :
sudo docker exec ssh-lab-server chown sshuser:sshuser /home/sshuser/.ssh/authorized_keys
sudo docker exec ssh-lab-server chmod 600 /home/sshuser/.ssh/authorized_keys
Une fois la clé publique ajoutée et les autorisations définies, vous êtes prêt à tester l'authentification par clé. Vous allez tenter de vous connecter en SSH au conteneur Docker en utilisant le port 2222 (que nous avons mappé au port 22 du conteneur) en tant qu'utilisateur sshuser, en spécifiant la clé privée que vous avez créée.
Utilisez la commande ssh avec le drapeau -i pour indiquer votre fichier de clé privée et -p pour spécifier le port :
ssh -i ~/.ssh/id_rsa_lab_ssh -p 2222 sshuser@localhost
Étant donné que vous vous connectez à un nouvel hôte pour la première fois, il se peut qu'on vous demande de vérifier l'authenticité de l'hôte. Tapez yes et appuyez sur Entrée.
The authenticity of host '[localhost]:2222 ([127.0.0.1]:2222)' can't be established.
ED25519 key fingerprint is SHA256:....
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '[localhost]:2222' (ED25519) to the list of known hosts.
Si tout est correctement configuré, vous serez immédiatement connecté sans qu'on vous demande de mot de passe. Vous verrez un message de bienvenue, et votre invite de commande changera pour indiquer que vous êtes maintenant à l'intérieur du conteneur Docker :
Welcome to Ubuntu 22.04.3 LTS (GNU/Linux 5.15.0-88-generic x86_64)
...
sshuser@containerid:~$
Pour quitter la session SSH et revenir à l'invite de votre terminal hôte, tapez simplement exit et appuyez sur Entrée.
exit
Une connexion réussie sans mot de passe confirme que votre authentification par clé fonctionne correctement entre votre hôte et le conteneur Docker. Cette méthode est considérablement plus sécurisée que l'authentification par mot de passe traditionnelle.
Transférer des fichiers en toute sécurité avec scp
Dans cette étape, vous apprendrez à utiliser le Secure Copy Protocol (scp) pour transférer des fichiers en toute sécurité entre des hôtes. scp s'appuie sur le protocole SSH sous-jacent, ce qui signifie qu'il bénéficie des mêmes mécanismes de chiffrement et d'authentification que vous avez déjà configurés, y compris l'authentification par clé.
Tout d'abord, créons un fichier d'exemple dans votre répertoire de travail actuel, ~/project, que nous pourrons utiliser pour le transfert. Nous le nommerons source_file.txt.
echo "This is a test file for scp." > source_file.txt
Vous pouvez vérifier que le fichier a été créé en le listant :
ls -l source_file.txt
La sortie devrait montrer votre fichier nouvellement créé :
-rw-r--r-- 1 labex labex 29 ... source_file.txt
Maintenant, vous utiliserez scp pour copier source_file.txt dans le répertoire /tmp du conteneur Docker, démontrant ainsi le transfert sécurisé de fichiers vers un serveur distant. La syntaxe de base de scp est scp -i [private_key] -P [port] [source_file] [user]@[host]:[destination_path].
Vous utiliserez le drapeau -i pour spécifier votre clé privée, -P pour spécifier le port 2222 (le port SSH de notre conteneur Docker), et transférerez le fichier vers le compte sshuser sur le conteneur :
scp -i ~/.ssh/id_rsa_lab_ssh -P 2222 source_file.txt sshuser@localhost:/tmp/destination_file.txt
Vous verrez une sortie indiquant la progression du transfert de fichiers, qui devrait être instantanée pour un petit fichier.
source_file.txt 100% 29 6.7KB/s 00:00
Pour confirmer que le fichier a été copié avec succès, connectez-vous au conteneur Docker et listez le fichier de destination :
sudo docker exec ssh-lab-server ls -l /tmp/destination_file.txt
La sortie confirmera l'existence et les détails du fichier copié :
-rw-r--r-- 1 sshuser sshuser 29 ... /tmp/destination_file.txt
Vous pouvez également vérifier que le contenu du fichier a été transféré correctement :
sudo docker exec ssh-lab-server cat /tmp/destination_file.txt
Cela devrait afficher :
This is a test file for scp.
Vous avez maintenant transféré avec succès un fichier en utilisant scp, démontrant une méthode sécurisée et pratique pour déplacer des données entre systèmes sur un réseau.
Créer un tunnel SSH pour la redirection de port avec ssh -L
Dans cette étape, vous allez découvrir l'une des fonctionnalités les plus puissantes de SSH : le tunneling, également connu sous le nom de transfert de port. Cela vous permet de transférer de manière sécurisée le trafic réseau d'un port de votre machine locale vers un port d'un serveur distant, encapsulant ainsi efficacement un protocole non chiffré au sein d'une connexion SSH sécurisée. Nous allons pratiquer le transfert de port local.
Pour démontrer cela, nous avons besoin d'un service en cours d'exécution sur un port auquel nous pouvons nous connecter. Heureusement, notre conteneur Docker a déjà Nginx installé et configuré. Nous devons démarrer le service Nginx à l'intérieur du conteneur.
Tout d'abord, démarrez le service Nginx à l'intérieur du conteneur Docker :
sudo docker exec ssh-lab-server service nginx start
Vous pouvez vérifier que Nginx s'exécute correctement à l'intérieur du conteneur :
sudo docker exec ssh-lab-server service nginx status
La sortie devrait indiquer que le service est en cours d'exécution :
* nginx is running
Maintenant, créons le tunnel SSH. Nous utiliserons la commande ssh avec le drapeau -L, qui signifie transfert de port local. La syntaxe est ssh -L [LOCAL_PORT]:[DESTINATION_HOST]:[DESTINATION_PORT] [USER]@[SERVER].
Nous allons transférer le trafic du port 9090 de notre machine locale vers le port 80 à l'intérieur du conteneur Docker. Le drapeau -N indique à SSH de ne pas exécuter de commande distante, ce qui est idéal pour simplement transférer des ports. Notez que nous utilisons le port 2222 pour nous connecter au service SSH de notre conteneur Docker.
Exécutez cette commande. Cette commande occupera votre terminal actuel et ne retournera pas d'invite. Vous devrez ouvrir un nouveau terminal pour tester le tunnel.
ssh -i ~/.ssh/id_rsa_lab_ssh -N -L 9090:localhost:80 -p 2222 sshuser@localhost
Maintenant, ouvrez un nouveau terminal en cliquant sur l'icône + dans la barre d'onglets du terminal. Dans ce nouveau terminal, vous pouvez tester le tunnel à l'aide de curl. En accédant à localhost:9090, votre requête sera tunnelisée de manière sécurisée via SSH vers le port 80 à l'intérieur du conteneur Docker.
curl http://localhost:9090
Vous devriez voir le contenu HTML de la page d'accueil par défaut de Nginx, ce qui confirme que le tunnel fonctionne.
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
body {
width: 35em;
margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif;
}
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>
<p><em>Thank you for using nginx.</em></p>
</body>
</html>
Vous avez créé avec succès un tunnel sécurisé qui transfère le trafic de votre machine hôte vers un service exécuté à l'intérieur du conteneur Docker. Pour fermer la connexion, retournez au premier terminal (celui qui exécute la commande ssh) et appuyez sur Ctrl+C. Vous pouvez ensuite fermer le second terminal.
Résumé
Dans ce laboratoire, vous avez acquis les compétences essentielles pour sécuriser l'accès à distance sur un système Linux en utilisant le protocole Secure Shell (SSH). Les objectifs clés abordés comprennent la configuration et le test de l'authentification par clé, le transfert sécurisé de fichiers avec scp, et la création d'un tunnel SSH pour le transfert de port.
Vous avez commencé par préparer l'environnement, ce qui a impliqué la mise à jour de la liste des paquets du système et l'installation des paquets openssh-server et openssh-client. Après avoir vérifié que le service SSH était actif, vous avez généré une paire de clés RSA sécurisée de 2048 bits à l'aide de la commande ssh-keygen. Cette étape fondamentale a créé les clés publique et privée nécessaires pour établir des connexions sécurisées et sans mot de passe dans les étapes suivantes.
