OpenSSH est un serveur SSH open source utilisé pour se connecter à distance et de manière sécurisée à une machine.

Objectif : se connecter à un serveur OpenSSH à l'aide d'une paire de clés plutôt que qu'avec un simple mot de passe.

Logiciel utilisé : OpenSSH 5.3P1

Système d'exploitation : Debian 5.0, Linux 2.6.26

---

Après avoir configuré OpenSSH sur notre machine (voir l'article http://blog.moncoindunet.fr/linux/openssh-linux/configurer-et-securiser-un-serveur-openssh/) nous voulons maintenant se connecter à ce serveur en utilisant une paire de clés plutôt que d'utiliser un simple mot de passe.

La solution du certificat est plus robuste en terme de sécurité que le mot de passe, puisque bien plus difficile à obtenir (il faut obtenir deux informations au lieu d'une pour être authentifié). De plus, dans un environnement sécurisé, il sera possible de se connecter au serveur directement, sans retaper un mot de passe à chaque connexion.

1 – Génération des clés

La génération des clés privées et publiques se fait très simplement grâce au programme ssh-keygen, installé avec OpenSSH :

$ ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/home/<user>/.ssh/id_rsa):
Created directory '/home/<user>/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/<user>/.ssh/id_rsa.
Your public key has been saved in /home/<user>/.ssh/id_rsa.pub.
The key fingerprint is:
fsmdkfslmfkfmskf <user>@<host>
The key's randomart image is:
+--[ RSA 2048]----+
|          .oo=.  |


Par défaut ssh-keygen va générer des clés de type RSA 2048 bits. Le type peut être changé via l'option -t pour avoir des clés DSA par exemple.

L'utilitaire demande d'indiquer l'endroit où poser la clé : l'endroit par défaut (répertoire personnel de l'utilisateur) est très bien.

Il demande ensuite de donner une passphrase, l'équivalent d'un mot de passe mais qui peut contenir plusieurs mots (une phrase quoi). Une bonne passphrase doit contenir un nombre varié de caractère et avoir une longueur comprise entre 10 et 30 caractères. Comme nous le verrons ensuite, cette passphrase pourra être stockée pour éviter de la taper à chaque fois.

2 – Mise en place et test

Pour pouvoir se connecter à une machine  avec un utilisateur possédant une paire de clé, il faut inscrire la clé publique créée précédemment dans le fichier authorized_keys de l'utilisateur, sur la machine distante. Nous testerons ici en local :

$ cd ~/.ssh
$ cat id_rsa.pub >> authorized_keys


On peut maintenant s'assurer que la connexion fonctionne bien avec la clé :

$ /usr/local/openssh/bin/ssh -p <port> <user>@<host>


OpenSSH demandera la passphrase que nous avons spécifié lors de la génération des clés. Si elle est correcte, on est maintenant connecter à la machine, sans avoir utiliser le mot de passe de l'utilisateur.

Pour une utilisation régulière, il peut être fastidieux de retaper la passphrase à chaque fois. Pour contourner cela il existe un utilitaire qui sauvegardera les passphrase pendant la session en cours pour nous : ssh-agent.

3 – Utilisation du ssh-agent

Le principe est le suivant : plutôt que de taper la passphrase à chaque nouvelle connexion ssh, on ne va la taper qu'à l'ouverture de la session. Elle sera ensuite sauvegardée pendant tout le temps de la session et permettra d'effectuer des connexion ssh sans retaper cette passphrase. Cette application est très utile dans le cas où par exemple vous avez un serveur centralisé pour accéder à d'autres machines.

3.1 – Lancement ssh-agent

On commence par lancer ssh-agent, qui donne en sortie les variables à exporter dans l'environnement courant :

$ ssh-agent
SSH_AUTH_SOCK=/tmp/ssh-iQtjAt2073/agent.2073; export SSH_AUTH_SOCK;
SSH_AGENT_PID=2074; export SSH_AGENT_PID;
echo Agent pid 2074;


On enregistre donc ces variables :

$ SSH_AUTH_SOCK=/tmp/ssh-iQtjAt2073/agent.2073; export SSH_AUTH_SOCK;
$ SSH_AGENT_PID=2074; export SSH_AGENT_PID;


Et on vérifie qu'il y a bien une socket qui s'est ouverte :

$ netstat -lx
Active UNIX domain sockets (only servers)
Proto RefCnt Flags       Type       State         I-Node   Path
unix  2      [ ACC ]     STREAM     LISTENING     178144   /tmp/ssh-iQtjAt2073/agent.2073

C'est bon, le ssh-agent est en place. Au besoin il peut être arrêté via la commande suivante :

$ ssh-agent -k
unset SSH_AUTH_SOCK;
unset SSH_AGENT_PID;
echo Agent pid 2074 killed;


3.2 – Ajout de la clé

La mémorisation de la clé se fait via l'outil ssh-add. Cet outil va regarder les variables d'environnement chargée précédemment pour se connecter au ssh-agent que nous avons lancé. Par défaut ssh-add va charger les clés présentes dans le répertoire ~/.ssh qui ont pour nom id_dsa, id_rsa ou identity.

$ ssh-add
Enter passphrase for /home/user/.ssh/id_rsa:
Identity added: /home/user/.ssh/id_rsa (/home/user/.ssh/id_rsa)


Une fois la bonne passphrase rentée, celle-ci sera chargée en mémoire pour les prochaine connexions ssh. On vérifie :

$ ssh localhost


La connexion s'effectue avec la clé privée, mais sans demandée de passphrase.

3.3 – Lancement automatique du ssh-agent

Je vous ai présenté la version entièrement manuelle, mais elle peut bien sur être automatisée via un petit script 🙂

Le principe est le suivant : on lance ssh-agent au démarrage d'une session, à l'utilisateur ensuite de faire un ssh-add pour ajouter son identité en vue de futures connexions ssh. Plutôt que de créer un script à part, on va mettre ça dans le fichier .profile de l'utilisateur :

$ vim ~/.profile


sshEnv="$HOME/.ssh/environment"

function startAgent
{
        /usr/local/openssh/bin/ssh-agent -s | sed 's/^echo/#echo/' > $sshEnv
        if [ $? -eq 0 ]
        then
                echo "Running ssh-agent : OK !"
        else
                echo "Running ssh-agent : KO !"
                exit 1
        fi
        chmod 600 $sshEnv
        . $sshEnv
}

if [ -f $sshEnv ]
then
        . $sshEnv
        if [ `ps -ef | grep $SSH_AGENT_PID | grep -vc grep` -eq 0 ]
        then
                startAgent
        fi
else
        startAgent
fi

On recharge le profil :

$ . ~/.profile


On peut maintenant exécuter le ssh-add à la demande :

$ ssh-add
Enter passphrase for /home/user/.ssh/id_rsa:
Identity added: /home/user/.ssh/id_rsa (/home/user/.ssh/id_rsa)


Et voilà pour le format automatisé du ssh-agent !

4 – Utiliser l'authentification par clé avec PuTTY

L'authentification par clé peut également être utilisé via PuTTY, un client SSH (entre autres) très utilisé pour se connecter à un serveur OpenSSH depuis un poste tournant sous Windows. PuTTY utilise son propre format de clé, une petite manipulation est donc nécessaire pour utiliser notre clé créée précédemment. On peut aussi choisir de regénérer un clé. Dans les deux cas, il faut passer par l'application PuTTYgen, téléchargeable ici : http://the.earth.li/~sgtatham/putty/latest/x86/puttygen.exe

4.1 – Création d'une nouvelle paire de clés

L'outils PuTTYgen permet de générer une paire de clés (une clé privée et une clé publique).

Lancer puttygen.exe et, au niveau des paramètres, choisissez "SSH-2 RSA" et 2048 bits :

Cliquer ensuite sur Generate. La clé se construit en bougeant la souris dans la fenêtre, pour générer du bruit aléatoire. Une fois la clé publique générée vous pouvez mettre un commentaire et, chose très recommandée, une passphrase qui servira de mot de passe pour la clé (pour rappel, tous les caractères sont disponibles, même espace, et elle doit faire entre 10 et 30 caractères) :

Il ne reste plus qu'à sauvegarder les deux clés via Save public key et Save private key. La clé publique est à déposer sur le serveur distant, dans le fichier ~user/.ssh/authorized_keys. La clé privée sera utilisée dans lors de la création de la connexion avec PuTTY (cf 4.3).

4.2 – Conversion d'une paire de clé existante

L'outils PuTTYgen permet de convertir une paire de clé existante pour pouvoir être utilisée avec PuTTY.

Lancer puttygen.exe et, dans la barre de menu, choisir Conversion > Import key, puis sélectionner la clé privée que vous voulez convertir. PuTTYgen demandera alors la passphrase associée à la clé. Une fois la clé chargée, il ne reste qu'à sauvegarder la clé privée via Save private key : c'est ce fichier qui sera utilisé lors de la connexion avec PuTTY (cf 4.3).

4.3 – Utilisation de la clé avec PuTTY

Lors dune création de connexion avec PuTTY, il faut lui indiquer que l'on utilise une authentification par clé via le menu Connection > SSH > Auth. Il suffit de charger le fichier créé précédemment avec PuTTYgen dans Private key file for authentication :

Et voilà, le tour est joué !