LLI Wiki — My Digital Knowledge Base

SSH : plusieurs clés, ProxyJump et dépannage des connexions en échec

Configurer plusieurs clés SSH, un rebond ProxyJump, gérer les clés ssh-rsa anciennes et diagnostiquer les échecs de connexion.

Un recueil d'astuces OpenSSH : utiliser plusieurs clés privées, configurer la connexion par clé, convertir une clé PuTTY, les rebonds (jump host), les empreintes, les problèmes de clés ssh-rsa / ssh-dss anciennes et le dépannage des connexions en échec.

Plusieurs clés privées avec ~/.ssh/config

Utilisez un bloc Host par machine distante, chacun pointant vers sa propre clé :

Host myshortname realname.example.com
    HostName realname.example.com
    IdentityFile ~/.ssh/realname_rsa    # clé privée pour realname
    User remoteusername

Host myother realname2.example.org
    HostName realname2.example.org
    IdentityFile ~/.ssh/realname2_rsa   # autre clé privée pour realname2
    User remoteusername

Créez le dossier .ssh et appliquez les permissions habituelles :

mkdir -p ~/.ssh
chmod 700 ~/.ssh
touch ~/.ssh/config
chmod 600 ~/.ssh/config

chmod 600 ~/.ssh/id_rsa
chmod 644 ~/.ssh/id_rsa.pub
chmod 600 ~/.ssh/authorized_keys
chmod 644 ~/.ssh/known_hosts

Connexion sans mot de passe avec une paire de clés

Générez une paire de clés sur la machine A (utilisateur a) :

a@A:~> ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/a/.ssh/id_rsa):
Created directory '/home/a/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/a/.ssh/id_rsa.
Your public key has been saved in /home/a/.ssh/id_rsa.pub.

Créez ~/.ssh pour l'utilisateur b sur la machine B (il peut déjà exister), puis ajoutez la clé publique à authorized_keys. Le mot de passe de b est demandé à chaque fois :

ssh b@B mkdir -p .ssh
cat .ssh/id_rsa.pub | ssh b@B 'cat >> .ssh/authorized_keys'

Ensuite, ssh b@B fonctionne sans mot de passe. Sur B, restreignez les permissions :

chmod 700 .ssh; chmod 640 .ssh/authorized_keys

Utiliser une clé PuTTY avec OpenSSH

  1. Ouvrez PuTTYgen, cliquez sur Load et chargez votre clé privée.
  2. Allez dans Conversions > Export OpenSSH key et exportez la clé privée.
  3. Copiez-la dans ~/.ssh/id_rsa (ou id_dsa).
  4. Créez la version RFC 4716 de la clé publique :
ssh-keygen -e -f ~/.ssh/id_dsa > ~/.ssh/id_dsa_com.pub
  1. Convertissez-la au format OpenSSH :
ssh-keygen -i -f ~/.ssh/id_dsa_com.pub > ~/.ssh/id_dsa.pub

Explorateur Windows sur le dossier .ssh de WSL avec les fichiers de clés

Empreintes de clé

Empreinte MD5 d'une clé RSA :

ssh-keygen -E md5 -lf ~/.ssh/id_rsa

Empreinte SHA256 standard :

ssh-keygen -lf ~/.ssh/id_rsa

Serveur de rebond (ProxyJump)

Atteindre un serveur via un bastion :

Host bastion01
  HostName bastion01.example.com
  User remoteusername
  IdentityFile ~/.ssh/id_rsa

Host server01
  HostName server01.example.com
  User remoteusername
  ProxyJump bastion01
  IdentityFile ~/.ssh/id_rsa

En ligne de commande : ssh -J user@bastion.example.com user@server.example.com -vvv.

Clés ssh-rsa / ssh-dss anciennes refusées

Les versions récentes d'OpenSSH désactivent par défaut les signatures ssh-rsa (et ssh-dss). Pour un vieil équipement ou serveur, réactivez l'algorithme. Listez d'abord les types de clés pris en charge :

ssh -Q key

Dans ~/.ssh/config :

Host router
   #HostKeyAlgorithms +ssh-dss
   #PubkeyAcceptedKeyTypes +ssh-dss
   PubkeyAcceptedKeyTypes +ssh-rsa
   HostName 192.0.2.10
   Port 2222
   User remoteusername
   IdentityFile ~/.ssh/router_key

Ou en ligne de commande :

ssh -p 2222 -i ~/.ssh/router_key -o PubkeyAcceptedKeyTypes=+ssh-rsa remoteusername@192.0.2.10

Dépanner une connexion en échec

Déboguer côté client

ssh <serveur> -vvv

Une ligne telle que debug3: receive packet: type 51 signifie que le serveur a refusé la clé proposée (SSH_MSG_USERAUTH_FAILURE) : regardez alors côté serveur.

Consulter les journaux du serveur

Mots de passe en échec :

grep "Failed password" /var/log/auth.log

Si le fichier n'existe pas, vérifiez la configuration syslog dans /etc/rsyslog.conf. Avec journald :

journalctl _SYSTEMD_UNIT=ssh.service | egrep "Failed|Failure"
journalctl _SYSTEMD_UNIT=sshd.service | egrep "Failed|Failure"   # RHEL, CentOS

Pour plus de détails, augmentez le niveau de journalisation dans /etc/ssh/sshd_config :

SyslogFacility AUTH
SyslogFacility AUTHPRIV
LogLevel DEBUG

et vérifiez que /etc/rsyslog.conf route les messages d'authentification :

authpriv.* /var/log/secure
auth.* /var/log/secure

Puis redémarrez les deux services :

sudo systemctl restart sshd
sudo systemctl restart rsyslog

Lisez /var/log/secure sur CentOS/RHEL, /var/log/auth.log sur les autres distributions.

Cause fréquente : les permissions

sshd ignore silencieusement authorized_keys quand le répertoire personnel ou le dossier .ssh est modifiable par le groupe ou les autres. Correction :

sudo chmod g-w /home/user
sudo chmod 700 /home/user
sudo chmod 700 /home/user/.ssh
sudo chmod 600 /home/user/.ssh/authorized_keys

Il en va de même pour un compte de service dont le répertoire personnel est personnalisé : chmod 700 sur ce répertoire et sur .ssh, chmod 600 sur authorized_keys.

Références

Captures d'écran

Journal sshd en échec : permissions incorrectes sur le répertoire personnel

Mastodon LLIMastodon SocialFosstodon