Installer un serveur OpenSSH sur une distribution Linux

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

Objectif : installer un serveur OpenSSH pas à pas à partir des sources officielles pour se connecter à la machine depuis un client.

Logiciel utilisé : OpenSSH 5.6p1

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


 

1 – Installer un serveur OpenSSH

1.1 – Pré requis

OpenSSH demande un certain nombre de pré requis avant d'être installé.

Premièrement, deux outils indispensables à la compilation des sources : make et gcc. Nous aurons également besoin de gnupg pour vérifier le package. Sous Debian j'utilise apt-get pour installer ces packages :

# apt-get install make gcc gnupg

Ensuite, OpenSSH requiert deux librairies : celle de zlib et celle d'openssl. Celle d'OpenSSL peut être installée en même temps que l'application du même nom (cf. l'article http://blog.moncoindunet.fr/linux/installer-openssl-sous-linux/). Ces deux librairies sont disponibles via l'apt-get de Debian :

# apt-get install zlib1g-dev libssl-dev

Enfin, on récupère la dernière version d'OpenSSH sur notre machine. Je vous invite à récupérer la dernière version du package ainsi que la signature sur l'un des nombreux miroirs disponibles à cette adresse : http://www.openssh.com/portable.html

# wget http://ftp.crans.org/pub/OpenBSD/OpenSSH/portable/openssh-5.6p1.tar.gz
# wget http://ftp.crans.org/pub/OpenBSD/OpenSSH/portable/openssh-5.6p1.tar.gz.asc

Les pré requis sont en place, on va maintenant vérifier l'authenticité du package téléchargé.

1.2 – Vérifier le package

Avant d'aller plus loin, il faut s'assurer que le package est authentique, c'est à dire qu'il n'a pas été détourné par un tiers.

L'authenticité du package se vérifie grâce au programme gnupg, qui va vérifier la signature du package (fichier openssh*.asc) avec une des clés publique présente sur le site d'OpenSSH.

On va donc récupérer dans un premier temps la clé publique :

$ wget http://ftp.crans.org/pub/OpenBSD/OpenSSH/portable/DJM-GPG-KEY.asc

Et on va l'importer dans gnupg et vérifier le package :

$ gpg --import DJM-GPG-KEY.asc
gpg: clé 86FF9C48: clé publique « Damien Miller (Personal Key) <djm@mindrot.org> » importée
gpg:        Quantité totale traitée: 1
gpg:                       importée: 1
$ gpg --verify openssh-5.6p1.tar.gz.asc openssh-5.6p1.tar.gz
gpg: Signature faite le lun 23 aoû 2010 05:24:54 CEST avec la clé DSA ID 86FF9C48
gpg: Bonne signature de « Damien Miller (Personal Key) <djm@mindrot.org> »
gpg: ATTENTION: Cette clé n'est pas certifiée avec une signature de confiance !
gpg:            Rien ne dit que la signature appartient à son propriétaire.
Empreinte de clé principale: 3981 992A 1523 ABA0 79DB  FC66 CE8E CB03 86FF 9C48

Le "ATTENTION" indique simplement que la clé utlisée n'est pas certifiée par un tiers de confiance. Si vous n'avez pas confiance, vous pouvez toujours contacter la personne par téléphone pour s'assurer avec elle que vous possédez bien sa clé … (sisi !)

1.3 – Compilation et installation

Une fois le package d'OpenSSH récupéré on le décompresse dans le répertoire /usr/local/src :

# tar xvzf openssh-5.6p1.tar.gz -C /usr/local/src
# cd /usr/local/src/openssh-5.6p1/

Avant de passer à l'installation, il faut créer un utilisateur sshd ainsi que le répertoire /var/empty qui seront utilisés pour la séparation des privilèges, activée par défaut. Cette méthode permet d'avoir un processus non privilégié qui se situe entre le client et le processus père lors de la phase d'authentification.

# mkdir /var/empty
# chown root: /var/empty
# chmod 755 /var/empty
# groupadd sshd
# useradd -r -g sshd -c 'sshd privsep' -d /var/empty -s /bin/false sshd

On peut maintenant configurer, compiler et installer en spécifiant deux options :

  • --prefix : chemin d'installation
  • --with-ssl-dir : emplacement d'OpenSSL (si installé à partir des sources)
  • --datarootdir : emplacement des pages de manuels, docs, etc.

# ./configure --prefix=/usr/local/openssh --with-ssl-dir=/usr/local/ssl --datarootdir=/usr/share
# make
# make install

Voilà, c'est installé !

1.4 – Modification du PATH

Afin de pouvoir utiliser les commandes fournies par OpenSSH (comme ssh) sans avoir à retaper toute l'arborescence, nous allons modifier la variable PATH des utilisateurs :

# echo -e "openssh=/usr/local/openssh/bin\nPATH=\$PATH:\$openssh" >> /etc/profile
# . /etc/profile

2 – Démarrage et tests

2.1 – Démarrage

On peut maintenant démarrer le serveur OpenSSH :

# /usr/local/openssh/sbin/sshd -f /usr/local/openssh/etc/sshd_config

On vérifie que le processus est lancé :

# ps -ef | grep sshd
root      1946     1  0 20:31 ?        00:00:00 /usr/local/openssh/sbin/sshd

Et que le port 22 est en écoute :

# netstat -tlnp
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      1946/sshd

2.2 – Test

Une fois le serveur OpenSSH installé et démarré, il ne nous reste plus qu'à vérifier que l'on peut se connecter depuis un poste client :

# ssh localhost

3 – Démarrage automatique

3.1 – Création du script

Installer un serveur OpenSSH c'est bien, mais qu'il démarre tout seul lors du prochain redémarrage de la machine, c'est mieux !

La première étape est la création d'un petit script shell que l'on utilisera pour démarrer, arrêter ou vérifier le statut du serveur. On positionnera ce script avec les autres scripts de démarrage dans /etc/init.d.

$ vim /etc/init.d/sshd

#!/usr/bin/ksh

daemon="sshd"
conf="/usr/local/openssh/etc/sshd_config"
cmd="/usr/local/openssh/sbin/sshd"

case $1 in
        "start")
                $cmd -f $conf
                if [[ $? == 0 ]]
                then
                        echo "$daemon is running now"
                        exit 0
                else
                        echo "failed of running $daemon !!!"
                        exit 1
                fi
        ;;
        "stop")
                kill -TERM `cat /var/run/${daemon}.pid`
                if [[ $? == 0 ]]
                then
                        echo "$daemon is stopped"
                        exit 0
                else
                        echo "failed of stopping $daemon !!!"
                        exit 1
                fi
        ;;
        "status")
                if [[ -f /var/run/${daemon}.pid ]] && [[ `ps -ef | grep $cmd | grep -vc grep` -ge 1 ]]
                then
                        echo "$daemon is running"
                        exit 0
                else
                        echo "$daemon is stopped"
                        exit 1
                fi
        ;;
        "reload")
                kill -HUP `cat /var/run/${daemon}.pid`
                if [[ $? == 0 ]]
                then
                        echo "$daemon is reloaded"
                        exit 0
                else
                        echo "failed of reloading $daemon !!!"
                        exit 1
                fi
        ;;
        *)
                echo "Usage : $0 start|stop|reload|status"
                exit 1
        ;;
esac

On positionne les droits d'exécution sur le fichier, pour le propriétaire uniquement (en l'occurence, root) :

# chmod 755 /etc/init.d/sshd

Le script s'utilisera de la façon suivante :

# /etc/init.d/sshd
Usage : /etc/init.d/sshd start|stop|reload|status

3.2 – Lancement automatique du script

Pour démarrer et arrêter automatiquement le serveur OpenSSH, il faut créer des liens vers le script créé précédemment dans les différents niveaux d'exécution. Pour cela nous utiliserons le programme update-rc.d qui créera les liens correspondants aux niveaux demandés : (les liens pourraient tout aussi bien être créés à la main, c'est juste plus long)

$ update-rc.d sshd defaults
 Adding system startup for /etc/init.d/sshd ...
   /etc/rc0.d/K20sshd -> ../init.d/sshd
   /etc/rc1.d/K20sshd -> ../init.d/sshd
   /etc/rc6.d/K20sshd -> ../init.d/sshd
   /etc/rc2.d/S20sshd -> ../init.d/sshd
   /etc/rc3.d/S20sshd -> ../init.d/sshd
   /etc/rc4.d/S20sshd -> ../init.d/sshd
   /etc/rc5.d/S20sshd -> ../init.d/sshd

Dorénavant le serveur OpenSSH s'arrêtera et démarrera proprement lors du redémarrage du système.

4 – Erreurs rencontrées

Message lors du configure :

configure: error: no acceptable C compiler found in $PATH

Solution : installer un compilateur C comme gcc. Sous Debian :

# apt-get install gcc


Message lors du configure :

configure: error: *** zlib.h missing - please install first or check config.log ***

Solution : installer les librairies zlib. Sous Debian il existe le package zlib1g-dev :

# apt-get install zlib1g-dev


Message lors du configure :

configure: error: *** OpenSSL headers missing - please install first or check config.log ***

Solution : installer les librairies openssl. Sous Debian il existe le paquet libssl-dev :

# apt-get install libssl-dev


Message lors du make :

-bash: /usr/bin/make: Aucun fichier ou répertoire de ce type

Solution : installer make. Sous Debian il existe le paquet make :

# apt-get install make


Message lors du make install :

Privilege separation user sshd does not exist
make: [check-config] Erreur 255 (ignorée)

Solution : créer l'utilisateur et le groupe sshd :

# groupadd sshd
# useradd -g sshd -c 'sshd privsep' -d /var/empty -s /bin/false sshd

2 pensées sur “Installer un serveur OpenSSH sur une distribution Linux”

  1. Principalement parce que ça me permets d’écrire des notes indépendantes de la distribution Linux (en entreprise, je vois plus souvent RedHat ou d’autres Unix que Debian …)
    Et accessoirement, parce que je suis pas un grand fan des paquets tout faits pour les applications serveurs 🙂

Laisser un commentaire