SSH : Commandes et gestion des clés

Posté en
ssh

SSH (Secure Shell) est un protocole réseau cryptographique qui permet d’accéder de manière sécurisée à un ordinateur distant. L’authentification par clés SSH est plus sécurisée que l’authentification par mot de passe et permet des connexions automatisées sans saisie de mot de passe.

Principe de fonctionnement

SSH utilise la cryptographie asymétrique avec une paire de clés :

  • Clé privée : stockée sur votre ordinateur local (jamais partagée)
  • Clé publique : copiée sur le serveur distant dans ~/.ssh/authorized_keys

Lorsque vous vous connectez, le serveur vérifie que vous possédez la clé privée correspondant à la clé publique sans jamais transmettre la clé privée sur le réseau.

Génération d’une paire de clés SSH

Commande de base

ssh-keygen -t ed25519 -C "votre_email@example.com"

Options détaillées :

  • -t ed25519 : spécifie le type d’algorithme (Ed25519, plus sécurisé et rapide)
  • -C "commentaire" : ajoute un commentaire pour identifier la clé (généralement votre email)

Alternative avec RSA

ssh-keygen -t rsa -b 4096 -C "votre_email@example.com"

Options :

  • -t rsa : utilise l’algorithme RSA (plus ancien mais universellement supporté)
  • -b 4096 : taille de la clé en bits (minimum 2048, recommandé 4096)

Processus interactif

# Emplacement de sauvegarde (appuyez sur Entrée pour accepter le chemin par défaut)
Enter file in which to save the key (/home/utilisateur/.ssh/id_ed25519):

# Saisie d’une passphrase (fortement recommandé)
Enter passphrase (empty for no passphrase):
Enter same passphrase again:

Fichiers générés

  • ~/.ssh/id_ed25519 : clé privée (permissions 600)
  • ~/.ssh/id_ed25519.pub : clé publique (permissions 644)

Options avancées de génération

Option Description Exemple
-f Spécifier le nom du fichier -f ~/.ssh/id_serveur1
-N Définir la passphrase en ligne -N "ma_passphrase"
-q Mode silencieux -q
-o Format OpenSSH (recommandé) -o
-a Nombre de tours KDF -a 100

Exemple complet

# Générer une clé Ed25519 avec nom personnalisé et passphrase
ssh-keygen -t ed25519 -f ~/.ssh/id_github -C "github@example.com" -N "ma_passphrase_securisee"

Copie de la clé publique sur le serveur

Méthode automatique (recommandée)

ssh-copy-id utilisateur@serveur.example.com

Cette commande :

  1. Se connecte au serveur distant
  2. Crée le répertoire ~/.ssh si nécessaire
  3. Ajoute votre clé publique dans ~/.ssh/authorized_keys
  4. Configure les permissions correctement

Spécifier une clé particulière

ssh-copy-id -i ~/.ssh/id_rsa.pub utilisateur@serveur.example.com

Spécifier un port différent

ssh-copy-id -i ~/.ssh/id_ed25519.pub -p 2222 utilisateur@serveur.example.com

Méthode manuelle

# 1. Afficher le contenu de la clé publique
cat ~/.ssh/id_ed25519.pub

# 2. Se connecter au serveur
ssh utilisateur@serveur.example.com

# 3. Créer le répertoire .ssh si nécessaire
mkdir -p ~/.ssh

# 4. Ajouter la clé publique
echo "votre_cle_publique" >> ~/.ssh/authorized_keys

# 5. Définir les permissions correctes
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys

Copie en une seule commande

cat ~/.ssh/id_ed25519.pub | ssh utilisateur@serveur.example.com "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys"

Connexion SSH avec clés

Connexion simple

ssh utilisateur@serveur.example.com

Spécifier une clé privée

ssh -i ~/.ssh/id_rsa utilisateur@serveur.example.com

Connexion avec port personnalisé

ssh -p 2222 utilisateur@serveur.example.com

Mode verbeux (débogage)

ssh -v utilisateur@serveur.example.com
ssh -vv utilisateur@serveur.example.com # Plus de détails
ssh -vvv utilisateur@serveur.example.com # Maximum de détails

Configuration SSH (~/.ssh/config)

Créer un fichier de configuration

Le fichier ~/.ssh/config permet de simplifier les connexions en définissant des alias et des paramètres par défaut.

Exemple de configuration

# Serveur personnel
Host monserveur
    HostName 192.168.1.100
    User admin
    Port 22
    IdentityFile ~/.ssh/id_ed25519

# Serveur de production
Host prod
    HostName prod.example.com
    User deployer
    Port 2222
    IdentityFile ~/.ssh/id_prod
    ForwardAgent yes

# GitHub
Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_github

# Configuration par défaut pour tous les hôtes
Host *
    ServerAliveInterval 60
    ServerAliveCountMax 3
    Compression yes

Utilisation avec la configuration

# Au lieu de :
ssh -p 2222 -i ~/.ssh/id_prod deployer@prod.example.com

# Vous tapez simplement :
ssh prod

Paramètres de configuration utiles

Paramètre Description Valeur exemple
HostName Nom d’hôte ou IP réel 192.168.1.100
User Nom d’utilisateur admin
Port Port SSH 22
IdentityFile Chemin vers la clé privée ~/.ssh/id_rsa
ForwardAgent Transfert de l’agent SSH yes
ServerAliveInterval Intervalle keep-alive (secondes) 60
Compression Activer la compression yes
StrictHostKeyChecking Vérification stricte des hôtes ask

Gestion de l’agent SSH (ssh-agent)

L’agent SSH conserve vos clés privées déverrouillées en mémoire, évitant de ressaisir la passphrase à chaque connexion.

Démarrer l’agent

eval "$(ssh-agent -s)"

Ajouter une clé à l’agent

ssh-add ~/.ssh/id_ed25519

Ajouter toutes les clés par défaut

ssh-add

Lister les clés chargées

ssh-add -l

Supprimer toutes les clés de l’agent

ssh-add -D

Définir une durée de vie

# Ajouter une clé qui expirera après 1 heure
ssh-add -t 3600 ~/.ssh/id_ed25519

Gestion des clés existantes

Lister les clés disponibles

ls -la ~/.ssh/

Afficher l’empreinte d’une clé

# Format MD5
ssh-keygen -l -E md5 -f ~/.ssh/id_ed25519.pub

# Format SHA256 (par défaut)
ssh-keygen -lf ~/.ssh/id_ed25519.pub

Changer la passphrase d’une clé

ssh-keygen -p -f ~/.ssh/id_ed25519

Extraire la clé publique d’une clé privée

ssh-keygen -y -f ~/.ssh/id_ed25519 > ~/.ssh/id_ed25519.pub

Convertir une clé au format OpenSSH

ssh-keygen -p -m RFC4716 -f ~/.ssh/id_rsa

Tester la connexion SSH

# Test simple
ssh -T git@github.com

# Test avec une clé spécifique
ssh -T -i ~/.ssh/id_github git@github.com

Permissions importantes

Permissions correctes pour la sécurité :

Fichier/Répertoire Permission Commande
~/.ssh/ 700 (drwx——) chmod 700 ~/.ssh
~/.ssh/id_* (clé privée) 600 (-rw——-) chmod 600 ~/.ssh/id_ed25519
~/.ssh/id_*.pub (clé publique) 644 (-rw-r–r–) chmod 644 ~/.ssh/id_ed25519.pub
~/.ssh/authorized_keys 600 (-rw——-) chmod 600 ~/.ssh/authorized_keys
~/.ssh/config 600 (-rw——-) chmod 600 ~/.ssh/config
~/.ssh/known_hosts 644 (-rw-r–r–) chmod 644 ~/.ssh/known_hosts

Corriger toutes les permissions en une fois

chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_*
chmod 644 ~/.ssh/*.pub
chmod 600 ~/.ssh/authorized_keys
chmod 600 ~/.ssh/config

Commandes utiles supplémentaires

Copier des fichiers via SSH (SCP)

# Copier vers le serveur
scp fichier.txt utilisateur@serveur.example.com:/chemin/destination/

# Copier depuis le serveur
scp utilisateur@serveur.example.com:/chemin/fichier.txt ./

# Copier un répertoire
scp -r dossier/ utilisateur@serveur.example.com:/destination/

Transfert de fichiers avec SFTP

# Connexion SFTP
sftp utilisateur@serveur.example.com

# Commandes SFTP courantes :
put fichier.txt # Upload
get fichier.txt # Download
ls # Lister fichiers distants
lls # Lister fichiers locaux
pwd # Répertoire distant
lpwd # Répertoire local
exit # Quitter

Tunnel SSH (Port Forwarding)

# Forward local (accéder à un service distant via localhost)
ssh -L 8080:localhost:80 utilisateur@serveur.example.com

# Forward distant (exposer un service local sur le serveur distant)
ssh -R 8080:localhost:3000 utilisateur@serveur.example.com

# Dynamic forward (proxy SOCKS)
ssh -D 1080 utilisateur@serveur.example.com

Exécuter une commande à distance

# Commande simple
ssh utilisateur@serveur.example.com "ls -la"

# Commandes multiples
ssh utilisateur@serveur.example.com "cd /var/log && tail -n 20 syslog"

# Script distant
ssh utilisateur@serveur.example.com "bash -s" < script_local.sh

Dépannage

Problèmes courants

Erreur : Permission denied (publickey)

Solutions :

  • Vérifier que la clé publique est bien dans ~/.ssh/authorized_keys sur le serveur
  • Vérifier les permissions (700 pour .ssh, 600 pour authorized_keys)
  • Vérifier que le bon fichier de clé privée est utilisé
  • Utiliser ssh -v pour voir les détails de connexion

Erreur : WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!

Solution :

# Supprimer l'ancienne clé d'hôte
ssh-keygen -R serveur.example.com

Erreur : Bad owner or permissions

Solution :

# Corriger les permissions
chmod 600 ~/.ssh/config
chmod 600 ~/.ssh/id_*
chmod 700 ~/.ssh

Vérifier la configuration SSH du serveur

# Vérifier si l'authentification par clé est activée
sudo grep "PubkeyAuthentication" /etc/ssh/sshd_config

# Doit afficher : PubkeyAuthentication yes

Bonnes pratiques de sécurité

Recommandations

  • Utilisez toujours une passphrase pour protéger vos clés privées
  • Privilégiez Ed25519 (plus rapide et plus sécurisé que RSA)
  • Utilisez des clés différentes pour différents services (GitHub, serveurs, etc.)
  • Changez régulièrement vos clés (tous les 1-2 ans)
  • Sauvegardez vos clés privées dans un endroit sécurisé (coffre-fort chiffré)
  • Ne partagez jamais votre clé privée
  • Désactivez l'authentification par mot de passe sur les serveurs publics
  • Utilisez ssh-agent pour éviter de ressaisir la passphrase
  • Auditez régulièrement les clés dans authorized_keys
  • Surveillez les logs SSH : /var/log/auth.log

Résumé des commandes essentielles

Action Commande
Générer une clé Ed25519 ssh-keygen -t ed25519 -C "email@example.com"
Copier la clé sur le serveur ssh-copy-id user@serveur.com
Se connecter ssh user@serveur.com
Ajouter clé à l'agent ssh-add ~/.ssh/id_ed25519
Lister les clés de l'agent ssh-add -l
Afficher empreinte ssh-keygen -lf ~/.ssh/id_ed25519.pub
Changer passphrase ssh-keygen -p -f ~/.ssh/id_ed25519
Test connexion GitHub ssh -T git@github.com

Related Posts