// formation · Fondamentaux en informatique
SSH : connexion à distance sécurisée avec OpenSSH
- 12 chapitres
- ≈ 17 min de lecture
- Cours 6 / 7
- Accès libre
SSH (Secure Shell) est le protocole qui permet d’administrer à distance, de façon chiffrée et authentifiée, la quasi-totalité des serveurs Linux et Unix, des hyperviseurs, des pare-feu et de nombreux équipements réseau. Son implémentation de référence, OpenSSH, est développée par le projet OpenBSD et livrée par toutes les distributions Linux, par macOS et par Windows. Ce cours explique le fonctionnement du protocole, l’authentification par clé, la configuration du client et du serveur, les bastions, les tunnels et les certificats. Les sept travaux pratiques construisent un laboratoire de trois machines Debian 13, du premier échange de clés jusqu’à une autorité de certification.
À qui s’adresse ce cours : techniciens, administrateurs systèmes et réseau débutants ou autodidactes, développeurs et responsables informatiques de PME qui utilisent déjà SSH « par habitude » et veulent le maîtriser et le sécuriser. Prérequis : être à l’aise avec la ligne de commande Linux et les notions de base d’adressage IP.
Pourquoi SSH : administrer à distance sans exposer ses secrets
Avant SSH, l’administration à distance passait par Telnet, rlogin ou rsh : les identifiants et toutes les commandes circulaient en clair, lisibles par quiconque écoutait le réseau. SSH, conçu en 1995 puis normalisé par l’IETF (SSH-2, RFC 4251 à 4254), apporte trois garanties :
- la confidentialité : tout le trafic de la session est chiffré ;
- l’intégrité : toute modification d’un paquet en transit est détectée ;
- l’authentification des deux extrémités : le client vérifie l’identité du serveur grâce à sa clé d’hôte, puis le serveur vérifie celle de l’utilisateur.
Au-delà du terminal distant, SSH transporte des transferts de fichiers (scp, sftp, rsync), des dépôts Git, des tunnels vers des services internes et les commandes des outils d’automatisation comme Ansible. C’est donc un accès à privilèges par excellence : un compte SSH compromis sur un serveur, c’est souvent un attaquant installé au cœur du système d’information. Bien configurer SSH fait partie de la défense en profondeur de toute infrastructure.
OpenSSH en bref : composants et versions
OpenSSH regroupe plusieurs programmes, que l’on retrouve tout au long du cours :
ssh: le client ;scpetsftppour les fichiers ;sshd: le serveur, configuré par/etc/ssh/sshd_config;ssh-keygen: création et gestion des clés, empreintes, fichierknown_hosts, certificats ;ssh-agentetssh-add: conservation des clés déchiffrées en mémoire ;ssh-copy-id: installation d’une clé publique sur un serveur ;ssh-keyscan: collecte des clés d’hôte de serveurs.
Le projet publie environ deux versions par an. La version 10.0 (avril 2025) a supprimé l’algorithme de signature DSA, jugé trop faible, et utilise par défaut l’échange de clés hybride post-quantique mlkem768x25519-sha256, qui combine ML-KEM et X25519. Elle a aussi séparé le code d’authentification du serveur dans un programme distinct, sshd-auth, pour réduire la surface exposée avant l’authentification. À l’automne 2026, la branche courante est la 10.6 (octobre 2026, corrigée par une version 10.6p2 en novembre), qui active un algorithme de signature hybride post-quantique, ssh-mldsa44-ed25519.
Les distributions livrent souvent une version un peu plus ancienne, maintenue avec des correctifs de sécurité : Debian 13, utilisée dans les TP, fournit OpenSSH 10.0. Vérifiez toujours la version réelle avec ssh -V et consultez la page de manuel installée (man sshd_config) plutôt qu’une documentation en ligne plus récente.
Bonne pratique : appliquez sans délai les mises à jour de sécurité du paquet OpenSSH. Le service est exposé par nature et ses failles sont activement recherchées.
Le déroulement d’une connexion SSH
Une connexion SSH-2 se déroule en trois couches, que l’on peut se représenter comme un tuyau construit en trois étapes entre le client (à gauche) et le serveur (à droite) :
- Couche transport. Le client ouvre une connexion TCP (port 22 par défaut). Les deux parties échangent leur version, puis négocient les algorithmes : échange de clés, signature de la clé d’hôte, chiffrement, intégrité. L’échange de clés produit un secret partagé dont dérivent les clés de session ; le serveur signe cet échange avec sa clé d’hôte, ce qui permet au client de l’authentifier. À partir de là, tout est chiffré.
- Couche authentification de l’utilisateur. Dans ce tunnel chiffré, le client propose des méthodes : clé publique, mot de passe, clavier interactif (codes à usage unique via PAM), GSSAPI (Kerberos). Le serveur annonce les méthodes qu’il accepte et peut en exiger plusieurs successivement.
- Couche connexion. Une fois l’utilisateur authentifié, la session est multiplexée en canaux : un shell interactif, une commande, le sous-système SFTP, des redirections de ports, l’agent. Plusieurs canaux coexistent dans la même connexion.
Cette architecture explique bien des comportements observés en TP : un tunnel est simplement un canal supplémentaire, ProxyJump ouvre un canal TCP sur le bastion pour y faire passer une seconde connexion SSH complète, et le multiplexage côté client réutilise une couche transport déjà authentifiée. Les algorithmes négociés évoluent avec les versions : les chiffrements par défaut sont aujourd’hui chacha20-poly1305 et AES en mode GCM ou CTR, et les signatures RSA fondées sur SHA-1 (ssh-rsa) sont désactivées par défaut depuis OpenSSH 8.8. Un vieil équipement qui ne connaît que ces algorithmes provoque une erreur de négociation (« no matching host key type found ») : la bonne réponse est de mettre à jour l’équipement ou de restreindre l’exception à cet hôte précis dans ~/.ssh/config, jamais de réactiver globalement un algorithme obsolète.
L’option -v du client (jusqu’à -vvv) affiche chacune de ces étapes ; c’est le premier réflexe en cas d’échec.
Clés d’hôte et known_hosts : authentifier le serveur
Chaque serveur possède des paires de clés d’hôte générées à l’installation (/etc/ssh/ssh_host_ed25519_key, ssh_host_ecdsa_key, ssh_host_rsa_key). Les clés privées ne doivent être lisibles que par root : le serveur refuse de démarrer dans le cas contraire.
À la première connexion, le client ne connaît pas la clé du serveur. Il affiche son empreinte (condensé SHA-256) et demande confirmation : c’est le modèle « confiance à la première utilisation » (TOFU). Une fois acceptée, la clé est enregistrée dans ~/.ssh/known_hosts. Si elle change par la suite, le client affiche un avertissement très visible et refuse de se connecter automatiquement ; il désactive l’authentification par mot de passe pour éviter de livrer un secret à un imposteur. Les causes légitimes existent (réinstallation, nouvelle VM avec la même adresse), mais une interception est aussi possible : on vérifie toujours avant de supprimer l’ancienne entrée avec ssh-keygen -R.
Plusieurs outils encadrent ce mécanisme :
ssh-keygen -l -f /etc/ssh/ssh_host_ed25519_key.pubaffiche l’empreinte à comparer, à exécuter sur le serveur par un canal sûr (console, inventaire) ;ssh-keygen -F hôteretrouve une entrée,ssh-keygen -R hôtela supprime ;- la directive client
StrictHostKeyCheckingaccepteask(par défaut),yes(refuse toute clé inconnue),accept-new(accepte les nouvelles clés mais refuse les clés modifiées) etno(à proscrire) ; HashKnownHosts yesstocke les noms sous forme hachée, pour qu’un fichier volé ne livre pas la liste des serveurs ;ssh-keygen -Hconvertit un fichier existant ;- les marqueurs
@revoked(clé à refuser) et@cert-authority(autorité de certificats d’hôte) enrichissent le fichier.
À retenir : répondre « yes » sans vérifier l’empreinte annule la protection contre l’interception. À l’échelle d’un parc, la vraie solution consiste à distribuer les empreintes (gestion de configuration) ou à utiliser des certificats d’hôte (chapitre 11).
Authentifier l’utilisateur : mots de passe, clés et FIDO2
Le mot de passe est simple mais faible : il peut être deviné par des robots qui balayent Internet, réutilisé depuis une autre fuite ou capturé par hameçonnage. L’authentification par clé publique fonctionne autrement : l’utilisateur possède une paire de clés, la clé publique est déposée dans ~/.ssh/authorized_keys du compte sur le serveur, et le client prouve qu’il détient la clé privée en signant des données propres à la session. Aucun secret réutilisable ne transite.
Les types de clés disponibles sont, par ordre de préférence actuel :
- Ed25519 : type par défaut de
ssh-keygen, rapide, clés courtes, sans paramètre à choisir ; - ECDSA (courbes NIST) et RSA (au moins 3072 bits) pour la compatibilité avec d’anciens équipements ;
- ed25519-sk et ecdsa-sk : clés adossées à un jeton matériel FIDO2. La clé privée ne quitte jamais le jeton, chaque signature exige une présence physique et, avec l’option
verify-required, un code PIN ou une biométrie.
La clé privée stockée sur disque est chiffrée par une phrase de passe. Le serveur, lui, applique la directive StrictModes : il ignore un fichier authorized_keys si ce fichier, le répertoire ~/.ssh ou le répertoire personnel sont modifiables par d’autres que l’utilisateur (en pratique 700 pour ~/.ssh et 600 pour le fichier).
Pour exiger plusieurs facteurs, la directive serveur AuthenticationMethods enchaîne les méthodes : publickey,keyboard-interactive impose une clé puis un code à usage unique fourni par PAM. Les principes généraux sont détaillés dans l’article L’authentification multifacteur : renforcez la sécurité.
L’agent SSH et l’hygiène des clés
Saisir sa phrase de passe à chaque connexion est vite pénible, d’où la tentation de clés sans protection. L’agent résout ce dilemme : ssh-agent conserve en mémoire les clés déchiffrées et signe pour le compte du client, qui le joint par un socket désigné par la variable SSH_AUTH_SOCK. On charge une clé avec ssh-add ; l’option -t limite sa durée de présence, -c impose une confirmation à chaque usage, -l liste les clés et -D les retire toutes.
Le transfert d’agent (ssh -A ou ForwardAgent yes) rend l’agent du poste utilisable depuis le serveur distant, par exemple pour rebondir vers une autre machine. La page de manuel d’OpenSSH invite à l’activer avec prudence : toute personne capable de lire le socket sur le serveur intermédiaire (un administrateur, un attaquant ayant obtenu les droits root) peut utiliser vos clés tant que la session est ouverte. Le rebond par ProxyJump (chapitre 9) rend ce transfert inutile dans la plupart des cas.
Quelques règles d’hygiène complètent le dispositif : une clé par personne et par poste (pour révoquer un ordinateur perdu sans tout changer), un commentaire explicite (-C), jamais de clé privée copiée sur un serveur, une revue régulière des fichiers authorized_keys et le retrait immédiat des clés des personnes qui quittent l’entreprise.
Configurer le client : le fichier ~/.ssh/config
Le client lit ses paramètres dans cet ordre : options de la ligne de commande, fichier de l’utilisateur ~/.ssh/config, puis fichier système /etc/ssh/ssh_config. Règle essentielle : pour chaque directive, la première valeur obtenue est retenue (seules quelques directives comme IdentityFile s’accumulent). Les blocs spécifiques se placent donc en haut du fichier et le bloc générique Host * en bas.
Host srv01
HostName 10.10.0.30
User stagiaire
IdentityFile ~/.ssh/id_ed25519
IdentitiesOnly yes
ProxyJump bastion
Host *
ServerAliveInterval 60
ControlMaster auto
ControlPath ~/.ssh/cm-%C
ControlPersist 10m
Les directives les plus utiles en entreprise :
HostetMatch: sélection des blocs par alias (motifs avec*et négation!) ou par critères (utilisateur, hôte, résultat d’une commande) ;HostName,User,Port: destination réelle ;IdentityFileetIdentitiesOnly yes: n’utiliser que la clé désignée, ce qui évite d’atteindre la limiteMaxAuthTriesdu serveur en présentant toutes les clés de l’agent ;ProxyJump: rebond par un ou plusieurs bastions ;ControlMaster,ControlPath,ControlPersist: multiplexage de plusieurs sessions dans une connexion déjà authentifiée ;ServerAliveInterval: messages de maintien qui évitent les coupures sur les connexions inactives ;LocalForward,RemoteForward,DynamicForward: tunnels déclarés une fois pour toutes.
ssh -G alias affiche la configuration effective sans se connecter : c’est l’outil de diagnostic du fichier. Le même fichier est lu par scp, sftp, rsync, Git et Ansible, qui profitent tous des alias et des rebonds. Pour Git, voir aussi le cours Git : les fondamentaux du contrôle de version.
Configurer et durcir le serveur sshd
Le serveur lit /etc/ssh/sshd_config. Sur Debian et Ubuntu, la première ligne active de ce fichier est Include /etc/ssh/sshd_config.d/*.conf ; comme pour le client, la première valeur lue l’emporte, donc les fichiers de sshd_config.d priment sur le reste du fichier principal. On y place ses réglages, ce qui évite les conflits lors des mises à jour du paquet.
Les directives de durcissement les plus courantes (valeurs par défaut entre parenthèses) :
PermitRootLogin no(prohibit-password:rootpeut encore se connecter par clé) ;PasswordAuthentication noetKbdInteractiveAuthentication no(yes) : clés uniquement, une fois celles-ci déployées ;AllowGroupsouAllowUsers(tous autorisés) : liste blanche des comptes ;MaxAuthTries 3(6) etLoginGraceTime 30(120 secondes) ;ClientAliveIntervaletClientAliveCountMax(désactivé) : fermeture des sessions dont le client ne répond plus ;X11Forwarding no,AllowAgentForwarding no,AllowTcpForwarding nosur les serveurs qui n’en ont pas l’usage ;LogLevel VERBOSE(INFO) : journaux d’authentification plus détaillés, par exemple les clés présentées puis refusées.
Depuis la version 9.8, OpenSSH applique aussi PerSourcePenalties, activé par défaut : une adresse qui accumule les échecs d’authentification ou provoque des erreurs est temporairement refusée, ce qui freine les attaques par force brute. Pour un blocage durable et partagé, on complète avec un outil comme CrowdSec.
Deux commandes doivent devenir des réflexes avant tout rechargement : sshd -t, qui vérifie la syntaxe et les clés, et sshd -T, qui affiche la configuration effective (avec -C user=…,host=…,addr=… pour simuler une connexion et évaluer les blocs Match). On recharge ensuite avec systemctl reload ssh (le service s’appelle sshd sur Red Hat et dérivés) en gardant une session ouverte, puis on teste depuis un second terminal.
Bonne pratique : l’ANSSI publie des recommandations pour un usage sécurisé d’OpenSSH et le CIS des référentiels de configuration par distribution. Servez-vous-en comme liste de contrôle, et filtrez le port 22 pour qu’il ne soit joignable que depuis le réseau d’administration.
Bastions, rebonds et tunnels
Un bastion est le point d’entrée unique vers un réseau d’administration : seul lui est joignable depuis l’extérieur de ce réseau, il concentre la journalisation et on peut le durcir à l’extrême. Le client l’utilise avec ProxyJump (ou -J) : il ouvre une session vers le bastion, lui demande de relayer un flux TCP vers la destination, puis établit à travers ce flux une seconde session SSH, chiffrée de bout en bout. Le bastion n’a besoin d’aucune clé privée et ne voit pas le contenu des sessions. Il doit seulement autoriser le relais TCP (AllowTcpForwarding).
Un bastion bien conçu repose sur quelques principes : comptes nominatifs (jamais de compte partagé), authentification forte (clé matérielle ou second facteur via AuthenticationMethods), aucun outil d’administration installé dessus, journaux exportés vers un serveur distinct que les administrateurs du bastion ne peuvent pas modifier, et filtrage réseau qui n’autorise vers les serveurs internes que les flux SSH provenant du bastion. Pour les environnements soumis à des exigences de traçabilité, des bastions spécialisés enregistrent même le contenu des sessions.
Les redirections de ports transportent d’autres protocoles dans la session :
-L port_local:destination:port(locale) : un port s’ouvre sur le poste client et mène à une destination joignable par le serveur, typiquement une interface d’administration interne ;-R port_distant:destination:port(distante) : un port s’ouvre sur le serveur et mène à une destination joignable par le client ; par défaut il n’écoute que sur la boucle locale du serveur (GatewayPorts no) ;-D port(dynamique) : le client devient un proxy SOCKS ; l’application choisit elle-même ses destinations.
On les combine avec -N (pas de commande distante) et -f (arrière-plan). Les tunnels sont aussi une technique d’attaque, utilisée pour contourner un filtrage ou maintenir un accès : c’est pourquoi on les interdit là où ils ne servent pas et on journalise leur usage. Pour un accès permanent à tout un réseau, un VPN (WireGuard, OpenVPN) reste plus adapté qu’une collection de tunnels.
Restreindre l’accès : options des clés, Match et SFTP
Chaque ligne de authorized_keys peut commencer par des options qui limitent l’usage de la clé :
from="motif": adresses ou noms d’origine autorisés (notation CIDR acceptée) ;command="…": commande imposée ; la commande demandée par le client est ignorée mais disponible dansSSH_ORIGINAL_COMMAND;restrict: interdit en une fois redirections, transfert d’agent et de X11, terminal et~/.ssh/rc; on réautorise un élément au besoin (pty,port-forwarding) ;expiry-time="AAAAMMJJ": date d’expiration de la clé ;permitopenetpermitlisten: n’autorisent qu’une redirection précise.
Côté serveur, un bloc Match applique des réglages selon l’utilisateur, le groupe, l’adresse ou le port local (Match Group, Match Address…). Seule une partie des directives y est permise. Une ligne Match all referme un bloc conditionnel. Combiné à ChrootDirectory et ForceCommand internal-sftp, un bloc Match crée un compte de dépôt limité au transfert de fichiers et enfermé dans un répertoire, qui doit appartenir à root et n’être modifiable par personne d’autre, comme tous ses parents.
Les certificats OpenSSH
Au-delà de quelques dizaines de serveurs, distribuer des clés publiques et des empreintes devient ingérable. OpenSSH propose son propre système de certificats, plus simple qu’une PKI X.509 :
- une autorité utilisateurs signe la clé publique d’un utilisateur avec
ssh-keygen -s ca -I identifiant -n comptes -V +1d cle.pub, ce qui produitcle-cert.pub. Le serveur fait confiance à cette autorité viaTrustedUserCAKeyset accepte le certificat pour les comptes listés dans ses principals ;AuthorizedPrincipalsFilepermet de raisonner par rôles ; - une autorité hôtes signe la clé d’hôte d’un serveur avec l’option
-h; le serveur la présente grâce àHostCertificateet le client la reconnaît via une ligne@cert-authoritydansknown_hosts.
Les certificats portent une période de validité (-V), un identifiant repris dans les journaux et un numéro de série. Des certificats utilisateur courts, d’une journée par exemple, éliminent le problème des clés oubliées après un départ. La révocation passe par une liste de clés révoquées (KRL) déclarée avec RevokedKeys. ssh-keygen -L -f fichier-cert.pub affiche le contenu d’un certificat. Les clés privées des autorités sont les secrets les plus sensibles du dispositif : machine dédiée, coffre matériel ou service de signature.
Exploiter SSH au quotidien
Un accès SSH bien conçu se maintient dans le temps :
- Journalisation :
journalctl -u ssh(ou/var/log/auth.logselon la configuration) ; chaque connexion acceptée y indique l’empreinte de la clé ou l’identifiant du certificat utilisé, ce qui permet de savoir quelle clé a servi. Centralisez ces journaux dans votre SIEM ou votre outil de supervision. - Inventaire des accès : liste des clés autorisées par serveur et par compte, revue trimestrielle, suppression des clés inconnues ; une gestion de configuration (Ansible) qui déploie
authorized_keysetsshd_config.dà l’identique sur tout le parc. - Rotation : renouvellement des clés de services, durée de vie limitée pour les accès de prestataires (
expiry-timeou certificats courts). - Audit :
sshd -Tpour la configuration effective ; un outil comme Lynis pour un contrôle plus large du système. - Préparer l’avenir cryptographique : avec OpenSSH 10, l’échange de clés est déjà hybride post-quantique par défaut ; vérifiez que vos équipements anciens ne forcent pas des algorithmes obsolètes. Le contexte est présenté dans l’article Cryptographie post-quantique : calendrier, obligations et plan de migration.
À retenir : SSH est sûr par conception, mais sa sécurité réelle dépend de trois choses que seul l’administrateur maîtrise : la vérification des clés d’hôte, la protection et le suivi des clés d’utilisateurs, et une configuration serveur réduite au strict nécessaire.
Évaluation : SSH : connexion à distance sécurisée avec OpenSSH
Répondez aux questions puis vérifiez votre score. Une seule bonne réponse par question.
Pour aller plus loin sur le blog : Lynis : l’outil d’audit de sécurité Linux · FreeIPA : l’Active Directory du monde Linux · Git : le gardien incontournable des versions de code
// travaux pratiques
7 TP pour mettre en pratique
- TP01 - Préparer le laboratoire et établir la première connexion SSH
- TP02 - Authentification par clé Ed25519 et agent SSH
- TP03 - Configuration du client et rebond par un bastion
- TP04 - Durcir la configuration du serveur sshd
- TP05 - Tunnels SSH : redirection locale, distante et dynamique
- TP06 - Clés restreintes et compte SFTP chrooté
- TP07 - Mettre en place une autorité de certification SSH
// formation sur mesure
Former votre équipe sur ce sujet ?
Azur Secure anime des sessions intra-entreprise, à distance ou dans vos locaux sur la Côte d'Azur, adaptées au niveau de vos équipes.