Authentification SSH avec une CA

cover

Cet article décrit comment utiliser une autorité de certification SSH pour s'authentifier auprès des serveurs SSH. Ceci est particulièrement utile lorsque vous avez beaucoup de serveurs à gérer et que vous souhaitez éviter les tracas liés à la gestion d'un grand nombre de clés SSH.

L'idée de base est d'avoir une AC (Certificate Authority) qui signera les clés publiques des utilisateurs. Ensuite, les utilisateurs pourront s'authentifier auprès des serveurs en utilisant leur clé publique signée. De cette façon, vous n'avez pas à gérer les clés publiques des utilisateurs sur les serveurs, vous n'avez qu'à gérer les clés publiques de l'AC. Vous pouvez également limiter la validité des clés publiques signées à une certaine durée ou à un certain ensemble de serveurs et d'utilisateurs.

Conditions préalables

Cet article suppose que vous disposez d'une connaissance de base de SSH et que vous disposez d'un serveur SSH exécuté sur une machine Linux.

La théorie

Qu'est-ce qu'une autorité de certification SSH ?

Une autorité de certification SSH est simplement une paire de clés SSH de base (publique et privée) utilisée pour signer d'autres clés publiques SSH. La clé publique de l'AC est ensuite distribuée aux serveurs et la clé privée est gardée secrète.

Comment ça marche?

Lorsqu'un utilisateur souhaite s'authentifier auprès d'un serveur, le serveur lui demandera de fournir une clé publique. L'utilisateur fournira ensuite une clé publique signée par l'AC. Le serveur vérifiera alors la signature de la clé publique à l'aide de la clé publique de l'AC. Si la signature est valide, l'utilisateur sera authentifié.

La pratique

Générer la paire de clés CA

La première étape consiste à générer la paire de clés CA. Pour ce faire, vous pouvez utiliser la commande ssh-keygen :

ssh-keygen \
  -t rsa \
  -b 4096 \
  -f my_ssh_ca

Paramètre	Descriptif
`-t`	L'algorithme à utiliser pour générer la paire de clés.
`-b`	La taille (en bits) de la paire de clés.
`-f`	Le nom du fichier de sortie (sans les extensions).

Cela générera deux fichiers : my_ssh_ca et my_ssh_ca.pub. La première est la clé privée de l’AC et la seconde est la clé publique de l’AC.

Générer une paire de clés SSH personnelles (facultatif)

Cette étape suppose que vous disposez déjà d’une paire de clés SSH personnelle. Si ce n'est pas le cas, vous pouvez en générer un à l'aide de la commande ssh-keygen :

ssh-keygen \
  -t ed25519 \
  -b 256 \
  -f my_ssh_key

Paramètre	Descriptif
`-t`	L'algorithme à utiliser pour générer la paire de clés.
`-b`	La taille (en bits) de la paire de clés.
`-f`	Le nom du fichier de sortie (sans les extensions).

Distribuer la clé publique de l'AC

Configurer le serveur SSH

Tout d’abord, vous devez configurer le serveur SSH pour accepter la clé publique SSH de l'AC. Pour ce faire, vous devez vous authentifier auprès du serveur et devenir root. Ensuite, vous devez éditer le fichier /etc/ssh/sshd_config et ajouter la ligne suivante à la fin du fichier :

Match Address 192.168.42.*
  TrustedUserCAKeys /etc/ssh/ssh_user_ca
  AuthorizedPrincipalsFile /etc/ssh/authorized_principals/%u
  RevokedKeys /etc/ssh/revoked_keys

Paramètre	Descriptif
`Match Address 192.168.42.*`	Cette ligne permet d'appliquer la configuration suivante uniquement aux clients correspondant à l'adresse indiquée. Dans ce cas, nous souhaitons uniquement appliquer la configuration suivante aux clients qui correspondent à l'adresse `192.168.42.*`.
`TrustedUserCAKeys`	Le chemin d’accès à la clé publique SSH CA.
`AuthorizedPrincipalsFile`	Le chemin d'accès au fichier contenant la liste des principaux SSH autorisés à s'authentifier auprès des utilisateurs.
`RevokedKeys`	Le chemin d'accès au fichier contenant la liste des clés publiques SSH révoquées.

Ensuite, vous devez créer le fichier /etc/ssh/ssh_user_ca et y ajouter la clé publique de l'AC SSH :

cat my_ssh_ca.pub > /etc/ssh/ssh_user_ca

Pour l'instant, nous n'avons aucune clé publique SSH CA à révoquer, il nous suffit donc de créer un fichier vide pour le paramètre RevokedKeys :

touch /etc/ssh/revoked_keys

Enfin, nous devons créer le répertoire /etc/ssh/authorized_principals pour stocker la liste des principaux SSH autorisés à s'authentifier auprès des utilisateurs :

mkdir /etc/ssh/authorized_principals

Configurer l'authentification basée sur le principal

A titre d'exemple, nous allons configurer le serveur SSH pour me permettre de m'authentifier auprès de l'utilisateur wabbit. Pour ce faire, nous devons créer le fichier /etc/ssh/authorized_principals/wabbit et y ajouter la ligne suivante :

wabbit_ops

Cela me permettra de m'authentifier auprès de l'utilisateur wabbit en utilisant le principal wabbit_ops. Attention, un principal n'est pas un nom d'utilisateur, c'est juste un nom qui servira à identifier l'utilisateur ou un rôle. Vous pouvez utiliser le nom de votre choix, mais il est préférable d'utiliser un nom facile à retenir.

Appliquer la configuration

Une fois la configuration effectuée, vous devez redémarrer le serveur SSH pour appliquer les modifications :

systemctl restart sshd

Configurer le client SSH

Maintenant que le serveur SSH est configuré, nous devons configurer le client SSH pour qu'il utilise l'autorité de certification SSH pour s'authentifier auprès du serveur SSH.

Signez la clé publique SSH personnelle

Tout d’abord, nous devons signer la clé publique SSH personnelle à l’aide de la clé privée CA. Pour ce faire, nous devons utiliser la commande ssh-keygen :

ssh-keygen \
  -s my_ssh_ca \
  -I lunik@my_server \
  -n wabbit_ops \
  -V +1d \
  my_ssh_key.pub

Paramètre	Descriptif
`-s`	Le chemin d'accès à la clé privée de l'autorité de certification.
`-I`	L'identité de la clé publique signée. Ceci est utilisé pour identifier la clé publique signée. C'est une bonne idée d'utiliser le nom d'utilisateur, le nom d'hôte et le nom du serveur. Cela n'a aucun impact sur l'authentification.
`-n`	Le principal autorisé lors de l’authentification.
`-V`	Durée de validité de la clé publique signée.
`my_ssh_key.pub`	Le chemin d’accès à la clé publique à signer.

Cela générera un fichier my_ssh_key-cert.pub qui contient la clé publique signée.

Pour vérifier la signature de la clé publique signée, vous pouvez utiliser la commande ssh-keygen :

ssh-keygen \
  -L \
  -f my_ssh_key-cert.pub

Paramètre	Descriptif
`-L`	Vérifiez la signature de la clé publique.
`-f`	Le chemin d'accès à la clé publique à vérifier.

Cela imprimera le résultat suivant :

my_ssh_key-cert.pub:
        Type: ssh-ed25519-cert-v01@openssh.com user certificate
        Public key: ED25519-CERT SHA256:Nbe7SXv788c0t3g8D8GQ/5dwHXX4zXtoaEC7r97h5oM
        Signing CA: RSA SHA256:jitBsmIydxjgdW7DttD9piKIWmb4RPQQ7i7wfQ+M4Vg (using rsa-sha2-512)
        Key ID: "lunik@my_server"
        Serial: 0
        Valid: from 2023-09-19T19:13:00 to 2023-09-20T19:14:07
        Principals: 
                wabbit_ops
        Critical Options: (none)
        Extensions: 
                permit-X11-forwarding
                permit-agent-forwarding
                permit-port-forwarding
                permit-pty
                permit-user-rc

S'authentifier sur le serveur SSH

Maintenant que le client SSH est configuré, nous pouvons nous authentifier auprès du serveur SSH à l'aide de la clé publique signée. Pour ce faire, nous devons utiliser la commande ssh :

ssh \
  -i my_ssh_key \
  wabbit@my_server

Paramètre	Descriptif
`-i`	Le chemin d’accès à la clé privée à utiliser pour s’authentifier.
`wabbit@mon_serveur`	Le nom d'utilisateur et le nom d'hôte du serveur SSH.