## Prérequis rapides - Accès administrateur à la machine distante Debian ou Ubuntu - Ouverture du port 22 TCP sur le réseau ou le pare-feu. Si vous changez de port, adaptez les commandes - Un utilisateur non-root sur le serveur, membre du groupe sudo de préférence - Sur le poste client, OpenSSH déjà présent sur Linux et macOS. Sur Windows 10 et 11, l’outil ssh est intégré --- ## 1. Installer et activer le serveur SSH (OpenSSH) sur Debian / Ubuntu Installez OpenSSH sur le serveur, activez-le au démarrage et démarrez immédiatement le service. ```bash sudo apt update sudo apt install -y openssh-server sudo systemctl enable ssh --now sudo systemctl status ssh --no-pager ``` Si un pare-feu UFW est utilisé, autorisez SSH. Le profil OpenSSH existe généralement par défaut. ```bash sudo ufw allow OpenSSH # alternative si le profil n'existe pas sudo ufw allow 22/tcp sudo ufw reload sudo ufw status ``` Test rapide côté serveur pour vérifier qu’il écoute sur le port 22. ```bash ss -tnlp | grep :22 ``` --- ## 2. Se connecter en SSH depuis un client Connexion de base avec un utilisateur non-root. ```bash ssh utilisateur@ip_ou_domaine ``` Spécifier une clé privée particulière. ```bash ssh -i ~/.ssh/id_ed25519 utilisateur@ip_ou_domaine ``` Si le serveur écoute sur un port non standard, par exemple 2222. ```bash ssh -p 2222 utilisateur@ip_ou_domaine ``` Augmenter la verbosité pour diagnostiquer un souci de connexion. ```bash ssh -vvv utilisateur@ip_ou_domaine ``` --- ## 3. Générer une paire de clés SSH sur le client Générez une clé **ed25519** moderne et protégée par une **passphrase**. ```bash ssh-keygen -t ed25519 -a 100 -C "poste-client" ``` La clé publique se trouve en général dans ce fichier. ```bash ~/.ssh/id_ed25519.pub ``` Copiez automatiquement votre clé publique vers le serveur avec ssh-copy-id. ```bash ssh-copy-id -i ~/.ssh/id_ed25519.pub utilisateur@ip_ou_domaine ``` Alternative manuelle si ssh-copy-id n’est pas disponible. ```bash cat ~/.ssh/id_ed25519.pub | ssh utilisateur@ip_ou_domaine 'mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys' ``` Activez ensuite l’agent SSH sur le client et chargez votre clé pour éviter de retaper la passphrase à chaque connexion. ```bash # Linux / macOS eval "$(ssh-agent -s)" ssh-add ~/.ssh/id_ed25519 ``` Sous Windows PowerShell. ```powershell Start-Service ssh-agent Get-Service ssh-agent | Set-Service -StartupType Automatic ssh-add $env:USERPROFILE\.ssh\id_ed25519 ``` --- ## 4. Durcir la configuration du serveur SSH Créez un fichier de configuration dédié afin d’éviter de modifier le fichier principal. Sur Debian et Ubuntu récents, les *drop-ins* dans sshd_config.d/ sont pris en charge. ```bash sudo nano /etc/ssh/sshd_config.d/10-hardening.conf ``` Exemple de paramètres recommandés. ```text Port 22 Protocol 2 PermitRootLogin no PasswordAuthentication no PubkeyAuthentication yes KbdInteractiveAuthentication no ChallengeResponseAuthentication no X11Forwarding no AllowAgentForwarding yes AllowTcpForwarding yes ClientAliveInterval 300 ClientAliveCountMax 2 MaxAuthTries 3 LoginGraceTime 30 UseDNS no # Restreindre à des comptes spécifiques si souhaité # AllowUsers adminops deployer ``` Testez la syntaxe et rechargez le service sans couper les connexions existantes. ```bash sudo sshd -t sudo systemctl reload ssh ``` Important. Ne désactivez **PasswordAuthentication** qu’après avoir confirmé que la connexion par **clé** fonctionne. Gardez une session SSH ouverte pendant vos changements pour éviter un verrouillage accidentel. --- ## 5. Configurer le client SSH avec ~/.ssh/config Créez un alias de connexion pratique côté client. ```bash mkdir -p ~/.ssh && chmod 700 ~/.ssh nano ~/.ssh/config ``` Exemple d’entrée. ```sshconfig Host prod-web HostName ip_ou_domaine User utilisateur Port 22 IdentityFile ~/.ssh/id_ed25519 IdentitiesOnly yes ``` Utilisation. ```bash ssh prod-web ``` Connexion via un bastion avec ProxyJump. ```sshconfig Host bastion HostName bastion.exemple.com User ops IdentityFile ~/.ssh/id_ed25519 Host prod-web HostName web.interne.local User deploy ProxyJump bastion ``` --- ## 6. Transférer des fichiers avec SSH Transfert avec scp. ```bash # vers le serveur scp fichier.txt utilisateur@ip_ou_domaine:/home/utilisateur/ # depuis le serveur scp utilisateur@ip_ou_domaine:/var/log/syslog ./ ``` Transfert efficace et incrémental avec rsync sur SSH. ```bash rsync -avz -e "ssh -p 22" ./site/ utilisateur@ip_ou_domaine:/var/www/site/ ``` Session SFTP interactive. ```bash sftp utilisateur@ip_ou_domaine ``` --- ## 7. Tunnels SSH (port forwarding) Tunnel local. Accéder à un service distant localisé sur le port 80 via http://localhost:8080. ```bash ssh -L 8080:localhost:80 utilisateur@ip_ou_domaine ``` Tunnel distant. Expose un service local du client vers le serveur sur 9000. ```bash ssh -R 9000:localhost:3000 utilisateur@ip_ou_domaine ``` Proxy SOCKS dynamique. ```bash ssh -D 1080 -N utilisateur@ip_ou_domaine ``` --- ## 8. Sécuriser davantage. UFW, Fail2ban et port non standard Autoriser un port alternatif si vous changez 22 vers 2222 par exemple. Attention, changer de port **ne remplace pas** l’authentification par clé. ```bash sudo ufw allow 2222/tcp sudo ufw delete allow 22/tcp sudo ufw reload ``` Installer Fail2ban et activer la *jail* sshd. Cela limite les tentatives de brute force. ```bash sudo apt install -y fail2ban sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local sudo nano /etc/fail2ban/jail.local ``` Extrait minimal à adapter. ```ini [sshd] enabled = true bantime = 1h findtime = 10m maxretry = 5 ``` Redémarrez Fail2ban. ```bash sudo systemctl restart fail2ban sudo fail2ban-client status sshd ``` --- ## 9. Vérifier l’empreinte de la clé hôte (sécurité) Au premier contact, SSH affiche l’empreinte de la clé hôte du serveur. Comparez-la avec celle mesurée **sur le serveur**. ```bash sudo ssh-keygen -l -f /etc/ssh/ssh_host_ed25519_key.pub ``` Vous pouvez aussi pré-remplir known_hosts côté client. ```bash ssh-keyscan -t ed25519 ip_ou_domaine >> ~/.ssh/known_hosts ``` --- ## 10. Dépannage. Problèmes courants et solutions Connexion refusée. Vérifiez service et pare-feu. ```bash sudo systemctl status ssh sudo ufw status ss -tnlp | grep :22 ``` Authentification qui échoue. ```bash # journal d'authentification sur Debian/Ubuntu sudo tail -f /var/log/auth.log # diagnostic côté client ssh -vvv utilisateur@ip_ou_domaine ``` Permissions trop ouvertes sur .ssh ou authorized_keys. ```bash chmod 700 ~/.ssh chmod 600 ~/.ssh/authorized_keys ``` Clé privée non utilisée. Forcez l’identité. ```bash ssh -i ~/.ssh/id_ed25519 -o IdentitiesOnly=yes utilisateur@ip_ou_domaine ``` Hôte derrière un cloud firewall. Ouvrez le port 22 dans la console du fournisseur en plus d’UFW local. Conflit de port ou service déjà utilisé. Changez le port dans le drop-in et dans UFW, puis rechargez. ```bash sudo nano /etc/ssh/sshd_config.d/10-hardening.conf sudo sshd -t && sudo systemctl reload ssh ``` --- ## 11. Bonnes pratiques récapitulatives - Utiliser des clés **ed25519** avec **passphrase**, stockées dans ~/.ssh avec permissions strictes - Désactiver l’authentification par mot de passe une fois les clés en place - Interdire la connexion root directe et utiliser sudo avec un utilisateur dédié - Restreindre éventuellement avec AllowUsers ou AllowGroups - Surveiller auth.log et activer Fail2ban - Sauvegarder vos clés privées et mettre en place une politique de rotation si nécessaire - Documenter tout changement de port et mettre à jour les règles réseau associées --- ## Annexes. Cartes mémo utiles Lister les clés côté serveur. ```bash sudo ls -l /etc/ssh/ssh_host_*_key.pub ``` Imprimer l’empreinte de la clé locale. ```bash ssh-keygen -l -f ~/.ssh/id_ed25519.pub ``` Exemple d’exécution d’une commande distante en une ligne. ```bash ssh utilisateur@ip_ou_domaine 'sudo systemctl status --no-pager ssh' ``` Exemple de multiplexage pour accélérer les connexions répétées. ```sshconfig Host * ControlMaster auto ControlPath ~/.ssh/cm-%r@%h:%p ControlPersist 5m ``` Fin du guide. Vous pouvez désormais vous connecter en SSH à vos serveurs Debian/Ubuntu, de manière fiable et sécurisée.