Leçon 12 : SSH et connexion distante

SSH (Secure Shell) est le protocole indispensable pour administrer des serveurs Linux à distance. Dans cette leçon, tu vas maîtriser SSH, les clés, le transfert de fichiers et les tunnels.

1. Comprendre SSH

Qu'est-ce que SSH ?

SSH est un protocole **crypté** pour se connecter à distance à un serveur Linux. Il a remplacé les anciens protocoles insecure (telnet, rsh).

Caractéristiques

**Chiffrement** : Toutes les données sont chiffrées
**Authentification** : Mot de passe ou clés RSA/ED25519
**Tunnel** : Créer des tunnels sécurisés
**Transfert** : Fichiers via SCP/SFTP

Concepts clés

Terme	Description
SSH	Protocole
ssh	Client (commande)
sshd	Serveur (daemon)
~/.ssh/	Répertoire de config et clés

2. Installation du serveur SSH

Installer OpenSSH Server

# Debian/Ubuntu
sudo apt install openssh-server
# Démarrer le service
sudo systemctl start ssh
# Activer au boot
sudo systemctl enable ssh
# Voir le statut

sudo systemctl status ssh

Configuration

# Fichier de configuration
sudo nano /etc/ssh/sshd_config
# Options importantes
Port 22                    # Changer le port
PermitRootLogin no         # Interdire root
PasswordAuthentication yes # Auth par mot de passe

PubkeyAuthentication yes # Auth par clé

Redémarrer après modification

sudo systemctl restart ssh

3. Connexion SSH de base

Syntaxe simple

ssh utilisateur@adresse_ip
ssh user@192.168.1.100

ssh user@mondomaine.com

Options courantes

# Port personnalisé
ssh -p 2222 user@serveur
# Avec clé spécifique
ssh -i ~/.ssh/ma_cle user@serveur
# Mode verbeux (debug)
ssh -v user@serveur
# Forward agent SSH

ssh -A user@serveur

Premier accès

# Accepter la clé hôte (première connexion)
ssh user@serveur
# Réponses aux questions :
# "Are you sure you want to continue connecting (yes/no)?"

# Taper "yes"

4. Clés SSH - Configuration sécurisée

Pourquoi utiliser des clés ?

Mot de passe	Clé SSH
Vulnérable aux attaques brute force	Impossibles à pirater
À retenir	Stockée localement
Transmission sur le réseau	Jamais transmise

Générer une clé SSH

# Clé ED25519 (recommandée - moderne et sécurisée)
ssh-keygen -t ed25519 -C "mon@email.com"
# Clé RSA (legacy)
ssh-keygen -t rsa -b 4096 -C "mon@email.com"
# Avec commentaire personnalisé

ssh-keygen -t ed25519 -C "serveur-maison"

Questions lors de la génération

Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/user/.ssh/id_ed25519): 
Enter passphrase (empty for no passphrase):      # Mot de passe pour protéger la clé

Enter same passphrase again:

⚠️ **Conseil** : Utilise une passphrase pour sécuriser ta clé !

Copier la clé sur le serveur

# Méthode automatique (recommandée)
ssh-copy-id user@serveur
# Methode manuelle
cat ~/.ssh/id_ed25519.pub | ssh user@serveur "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"
# Ou avec ssh-id

ssh-copy-id -i ~/.ssh/id_ed25519.pub user@serveur

Connexion avec clé

ssh user@serveur

# Plus de mot de passe demandé !

Agent SSH

# Démarrer l'agent
eval "$(ssh-agent -s)"
# Ajouter la clé
ssh-add ~/.ssh/id_ed25519
# Ajouter avec passphrase
ssh-add
# Lister les clés chargées
ssh-add -l
# Supprimer toutes les clés

ssh-add -D

5. Fichiers de configuration SSH

~/.ssh/config

nano ~/.ssh/config

Contenu :

# Serveur personnel
Host maison
    HostName 192.168.1.100
    User pi
    Port 22
    IdentityFile ~/.ssh/id_ed25519
# Serveur cloud
Host cloud
    HostName mondomaine.com
    User admin
    Port 2222
    IdentityFile ~/.ssh/cloud_key
# GitHub
Host github.com
    HostName github.com
    User git

IdentityFile ~/.ssh/github_ed25519

Utiliser les alias

ssh maison        # Au lieu de ssh pi@192.168.1.100

scp fichier maison:/home/pi/

Permissions

chmod 700 ~/.ssh
chmod 600 ~/.ssh/config
chmod 600 ~/.ssh/id_ed25519

chmod 644 ~/.ssh/id_ed25519.pub

6. Transfert de fichiers

SCP - Copy

# Copier vers le serveur
scp fichier.txt user@serveur:/home/user/
scp -r dossier/ user@serveur:/home/user/
# Copier depuis le serveur
scp user@serveur:/home/user/fichier.txt ./
scp -r user@serveur:/home/user/dossier/ ./
# Options utiles
scp -P 2222 fichier.txt user@serveur:/dossier/  # Port
scp -C fichier.txt user@serveur:/dossier/      # Compression
scp -v fichier.txt user@serveur:/dossier/      # Verbeux

scp -p fichier.txt user@serveur:/dossier/ # Préserver dates

SFTP - Transfert interactif

sftp user@serveur
# Commandes SFTP
ls              # Lister
cd dossier      # Changer dossier
pwd             # Dossier actuel
put fichier.txt # Envoyer
get fichier.txt # Télécharger
get -r dossier/ # Télécharger dossier
rm fichier      # Supprimer
mkdir dossier   # Créer dossier

exit # Quitter

RSYNC - Synchronisation

# Synchroniser local vers distant
rsync -avz dossier/ user@serveur:/home/user/backup/
# Synchroniser avec suppression
rsync -avz --delete dossier/ user@serveur:/backup/
# Exclure des fichiers
rsync -avz --exclude='*.log' dossier/ user@serveur:/backup/
#dry-run (simulation)

rsync -avzn dossier/ user@serveur:/backup/

7. Port Forwarding (Tunnel SSH)

Local Port Forwarding

Accéder à un service du serveur comme si localement.

ssh -L [port_local]:[destination]:[port_destination] user@serveur

Exemples pratiques

# Accéder au serveur web du serveur (port 80)
ssh -L 8080:localhost:80 user@serveur
# → http://localhost:8080 sur ta machine
# Accéder à MySQL sur le serveur
ssh -L 3306:localhost:3306 user@serveur
# Accéder à un service sur un autre serveur

ssh -L 9000:autre-serveur:80 user@serveur

Remote Port Forwarding

Exposer un service local vers internet via le serveur.

ssh -R 8080:localhost:80 user@serveur

Dynamic Port Forwarding (SOCKS Proxy)

# Créer un proxy SOCKS
ssh -D 1080 user@serveur
# Configurer le navigateur

# SOCKS Proxy: localhost:1080

8. SSH Bastion (Jump Host)

Se connecter via un serveur bastion

# Direct via le bastion
ssh -J user@bastion.com user@serveur-distant
# Avec clé spécifique
ssh -J -i ~/.ssh/bastion_key user@bastion.com user@serveur-interne
# Configuration dans ~/.ssh/config
Host serveur-distant
    HostName 192.168.1.50
    User admin

ProxyJump user@bastion.com

9. Sécurité SSH

Meilleures pratiques

# 1. Désactiver root login
# Dans /etc/ssh/sshd_config:
PermitRootLogin no
# 2. Changer le port par défaut
Port 2222
# 3. Utiliser only key authentication
PasswordAuthentication no
# 4. Limiter les utilisateurs
AllowUsers user1 user2
# 5. Fail2ban (anti-bruteforce)

sudo apt install fail2ban

Authentification à deux facteurs

# Installer Google Authenticator
sudo apt install libpam-google-authenticator
# Configurer /etc/pam.d/sshd
# Ajouter: auth required pam_google_authenticator.so
# Activer dans /etc/ssh/sshd_config
ChallengeResponseAuthentication yes

AuthenticationMethods password,publickey

10. Exercices pratiques

Exercice 1 : Configurer clé SSH

# Générer une clé
ssh-keygen -t ed25519 -C "mon-serveur"
# Copier sur le serveur
ssh-copy-id user@serveur
# Se connecter sans mot de passe

ssh user@serveur

Exercice 2 : Tunnel vers MySQL

# Créer le tunnel
ssh -L 3306:localhost:3306 user@serveur
# Se connecter localement

mysql -h localhost -u root -p

Exercice 3 : Transfert de backup

# Créer une archive
tar -czf backup.tar.gz ~/Documents/
# Transférer vers le serveur
scp backup.tar.gz user@serveur:/backup/
# Nettoyer local

rm backup.tar.gz

11. Tableau résumé

Commande	Description
`ssh user@serveur`	Connexion basique
`ssh-keygen`	Générer clé
`ssh-copy-id`	Copier clé
`scp`	Copier fichiers
`sftp`	Transfert interactif
`rsync`	Synchronisation
`ssh -L`	Port forwarding local
`ssh -R`	Port forwarding remote
`ssh -J`	Jump host

Maîtrise SSH pour administrer tes serveurs comme un pro ! 🔐

Complément: OpenSSL et clés SSH

Introduction

Quand on travaille avec Linux, la sécurité des communications et des données est un sujet central. openssl est la boîte à outils reine pour la cryptographie sous Linux : générér des clés, créer des certificats, calculer des hashs, chiffrer des fichiers. ssh-keygen est son pendant spécialisé pour les clés SSH. Dans cette leçon, vous apprendrez à utiliser ces deux outils pour sécuriser vos échanges.

Générer des clés SSH avec ssh-keygen

ssh-keygen crée les paires de clés (publique/privée) utilisées pour l'authentification SSH sans mot de passe. Le principe : vous gardez la clé privée au chaud, et vous partagez la clé publique avec les serveurs distants.

Questions posées lors de la génération :

Emplacement : valider le chemin par défaut (~/.ssh/id_ed25519) ou en indiquer un autre

Passphrase : fortement recommandée — elle chiffre la clé privée sur le disque

La passphrase — protection de la clé privée

Sans passphrase, quiconque accède à votre clé privée peut l'utiliser. Avec une passphrase, elle est chiffrée sur le disque :

Le fichier known_hosts

Lors de la première connexion SSH à un serveur, son fingerprint est enregistré dans ~/.ssh/known_hosts :

Clés SSH pourplusieurs connexions

On peut créer des clés dédiées pour différents environnements :

Contenu du fichier ~/.ssh/config :

Calculer des hashs avec openssl

openssl dgst calcule l'empreinte (hash) d'un fichier — utile pour vérifier l'intégrité d'un téléchargement :

Vérifier l'intégrité avec shasum

En complément de openssl, sha256sum / sha512sum sont souvent préinstallées :

Générer des données aléatoires

openssl rand génère des octets pseudo-aléatoires — utile pour des mots de passe ou des clés de session :

Chiffrer et déchiffrer des fichiers avec openssl

openssl enc permet de chiffrer un fichier avec un mot de passe (AES-256-CBC par défaut) :

Créer un certificat SSL auto-signé

Pour tester un serveur web en HTTPS sans passer par une autorité de certification :

Vérifier un certificat SSL distant

Pour inspecter le certificat d'un site web depuis le terminal :

Conversions de format

openssl peut convertir des clés et certificats entre différents formats :

Générer un CSR (Certificate Signing Request)

Pour obtenir un certificat signé par une autorité (Let's Encrypt, DigiCert…), il faut d'abord créer un CSR :

Agent SSH — ne taper sa passphrase qu'une fois

ssh-agent garde les clés déchiffrées en mémoire pour la session :

SSHFP — fingerprint DNS pour SSH

SSHFP est un enregistrement DNS qui permet à SSH de vérifier automatiquement l'authenticité du serveur :

Résumé

ssh-keygen -t ed25519 = clé SSH moderne recommandée

ssh-copy-id user@serveur = copier la clé publique sur un serveur

~/.ssh/config = définir des alias et clés par serveur

ssh-agent = retenir la passphrase pour la session

ssh-keygen -R serveur = retirer un serveur du known_hosts

openssl dgst -sha256 fichier = calculer un hash SHA-256

sha256sum -c hashes.txt = vérifier l'intégrité de fichiers

openssl rand -base64 32 = générer des données aléatoires

openssl enc -aes-256-cbc -salt -in f.txt -out f.enc = chiffrer un fichier

openssl req -x509 -key key.pem -out cert.pem -days 365 = certificat auto-signé

openssl s_client -connect site:443 = inspecter le certificat d'un serveur

Toujours chmod 600 sur les clés privées, chmod 700 sur ~/.ssh