Leçon 74 : openssl et ssh-keygen — Cryptographie et clés SSH

Introduction

Quand on travaille avec Linux, la sécurité des communications et des données est un sujet central. openssl est la boîte à outils reine pour la cryptographie sous Linux : générér des clés, créer des certificats, calculer des hashs, chiffrer des fichiers. ssh-keygen est son pendant spécialisé pour les clés SSH. Dans cette leçon, vous apprendrez à utiliser ces deux outils pour sécuriser vos échanges.

Générer des clés SSH avec ssh-keygen

ssh-keygen crée les paires de clés (publique/privée) utilisées pour l'authentification SSH sans mot de passe. Le principe : vous gardez la clé privée au chaud, et vous partagez la clé publique avec les serveurs distants.

# Générer une clé RSA 4096 bits (recommandé)
ssh-keygen -t rsa -b 4096 -C "david@hinni-swiss.com"

# Générer une clé Ed25519 (moderne, plus compacte)
ssh-keygen -t ed25519 -C "david@hinni-swiss.com"

# Générer une clé avec un nom personnalisé
ssh-keygen -t ed25519 -f ~/.ssh/cle_prod -C "serveur-prod"

# Générer une clé RSA avec une phrase de passe (passphrase)
ssh-keygen -t rsa -b 4096 -f ~/.ssh/cle_backup

Questions posées lors de la génération :

Emplacement : valider le chemin par défaut (~/.ssh/id_ed25519) ou en indiquer un autre
Passphrase : fortement recommandée — elle chiffre la clé privée sur le disque

Types de clés disponibles

Type	Options	Recommandation
`rsa`	`-t rsa -b 4096`	Compatible partout, validé par la plupart des serveurs
`ed25519`	`-t ed25519`	Recommandé : rapide, sécurisé, clé courte
`ecdsa`	`-t ecdsa -b 256`	Alternative moderne, moins compatible
`rsa` (ancienne)	`-t rsa -b 2048`	À éviter, longueur insuffisante

La passphrase — protection de la clé privée

Sans passphrase, quiconque accède à votre clé privée peut l'utiliser. Avec une passphrase, elle est chiffrée sur le disque :

# Chiffrer une clé existante avec une nouvelle passphrase
ssh-keygen -p -f ~/.ssh/id_ed25519

# Retirer la passphrase (déconseillé)
ssh-keygen -p -N "" -f ~/.ssh/id_ed25519

# Vérifier le fingerprint d'une clé
ssh-keygen -lf ~/.ssh/id_ed25519.pub

# Afficher la clé publique
cat ~/.ssh/id_ed25519.pub

# Copier la clé publique sur un serveur distant
ssh-copy-id user@srv001.example.com

# Ou manuellement :
cat ~/.ssh/id_ed25519.pub | ssh user@srv001.example.com "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"

Le fichier known_hosts

Lors de la première connexion SSH à un serveur, son fingerprint est enregistré dans ~/.ssh/known_hosts :

# Voir les entrées known_hosts (hashées)
cat ~/.ssh/known_hosts

# Lister les fingerprints connus
ssh-keygen -lf ~/.ssh/known_hosts

# Supprimer un serveur du known_hosts (après changement de clé serveur)
ssh-keygen -R srv001.example.com

# Connexion avec fingerprint en mode détaillé
ssh -vvv user@srv001.example.com

Clés SSH pour多个 connexions

On peut créer des clés dédiées pour différents environnements :

# Clé pour le travail
ssh-keygen -t ed25519 -f ~/.ssh/cle_travail -C "david@travail"

# Clé pour le serveur de production
ssh-keygen -t ed25519 -f ~/.ssh/cle_prod -C "prod@srv001"

# Fichier ~/.ssh/config pour automatiser
nano ~/.ssh/config

Contenu du fichier ~/.ssh/config :

# Config pour le serveur de travail
Host srv-travail
    HostName 192.168.1.100
    User david
    Port 22
    IdentityFile ~/.ssh/cle_travail
    IdentitiesOnly yes

# Config pour le serveur de prod
Host srv-prod
    HostName prod.example.com
    User admin
    Port 2222
    IdentityFile ~/.ssh/cle_prod
    IdentitiesOnly yes

# Alias court
Host github
    HostName github.com
    User git
    IdentityFile ~/.ssh/cle_travail
    IdentitiesOnly yes

Calculer des hashs avec openssl

openssl dgst calcule l'empreinte (hash) d'un fichier — utile pour vérifier l'intégrité d'un téléchargement :

# Hash SHA-256 (recommandé)
openssl dgst -sha256 fichier.tar.gz

# Hash SHA-512
openssl dgst -sha512 fichier.tar.gz

# Hash MD5 (déconseillé, juste pour compatibilité)
openssl dgst -md5 fichier.tar.gz

# Vérifier un hash téléchargé
# 1. Télécharger le fichier et sa somme .sha256
# 2. Vérifier :
openssl dgst -sha256 fichier.tar.gz

Vérifier l'intégrité avec shasum

En complément de openssl, sha256sum / sha512sum sont souvent préinstallées :

# Calculer un hash
sha256sum fichier.tar.gz
# a3f8b2c1...  fichier.tar.gz

# Vérifier un hash (le fichier hashes.txt contient les empreintes)
sha256sum -c hashes.txt

# Générer un fichier de hash pour distribuer
sha256sum fichier.tar.gz > fichier.tar.gz.sha256

# Vérification
sha256sum -c fichier.tar.gz.sha256

Générer des données aléatoires

openssl rand génère des octets pseudo-aléatoires — utile pour des mots de passe ou des clés de session :

# Générer 32 octets en hexadécimal (64 caractères)
openssl rand -hex 32

# Générer 32 octets en base64 (environ 44 caractères)
openssl rand -base64 32

# Générer un mot de passe de 20 caractères
openssl rand -base64 20

# Générer des données brutes (32 octets)
openssl rand -out /tmp/aleatoire.bin 32

# Vérifier le contenu
hexdump -C /tmp/aleatoire.bin

Chiffrer et déchiffrer des fichiers avec openssl

openssl enc permet de chiffrer un fichier avec un mot de passe (AES-256-CBC par défaut) :

# Chiffrer un fichier (AES-256-CBC)
openssl enc -aes-256-cbc -salt -in fichier.txt -out fichier.enc

# Déchiffrer
openssl enc -aes-256-cbc -d -in fichier.enc -out fichier_decrypted.txt

# Chiffrer avec un mot de passe en ligne de commande (pour scripts)
openssl enc -aes-256-cbc -salt -in backup.tar -out backup.tar.enc -pass pass:MonMotDePasse

# Utiliser un fichier comme mot de passe
openssl enc -aes-256-cbc -salt -in fichier.txt -out fichier.enc -pass file:/root/.encrypt_pass

Créer un certificat SSL auto-signé

Pour tester un serveur web en HTTPS sans passer par une autorité de certification :

# Générer une clé privée RSA
openssl genrsa -out server.key 2048

# Créer un certificat auto-signé (valide 365 jours)
openssl req -new -x509 -key server.key -out server.crt -days 365

# Questions posées :
# - Country Name: CH
# - State: Bern
# - Locality: Tavannes
# - Organization: Hinni Swiss
# - Common Name: monserveur.local (important!)

# Afficher le certificat
openssl x509 -in server.crt -text -noout

# Vérifier la clé privée
openssl rsa -in server.key -check

# Tester avec openssl s_client
echo | openssl s_client -connect localhost:443 -servername monserveur.local

Vérifier un certificat SSL distant

Pour inspecter le certificat d'un site web depuis le terminal :

# Voir le certificat d'un site
echo | openssl s_client -connect github.com:443 -servername github.com 2>/dev/null | openssl x509 -noout -text

# Afficher juste les infos essentielles
echo | openssl s_client -connect github.com:443 2>/dev/null | openssl x509 -noout -dates -subject

# Vérifier l'expiration d'un certificat
echo | openssl s_client -connect google.com:443 2>/dev/null | openssl x509 -noout -enddate

# Test de connexion SSL complète
openssl s_client -connect github.com:443

Conversions de format

openssl peut convertir des clés et certificats entre différents formats :

# PEM vers DER (binaire)
openssl x509 -in cert.pem -outform DER -out cert.der

# DER vers PEM
openssl x509 -in cert.der -inform DER -out cert.pem

# Clé privée RSA vers format PEM
openssl rsa -in private.key -out private_pem.pem

# PEM vers PKCS12 (pour Java/Windows)
openssl pkcs12 -export -in cert.pem -inkey private.key -out keystore.p12

# Extraire la clé publique d'un certificat
openssl x509 -in cert.pem -pubkey -noout > public.key

# Vérifier qu'une clé privée correspond à un certificat
openssl x509 -in cert.pem -noout -modulus | openssl md5
openssl rsa -in private.key -noout -modulus | openssl md5
# Les deux doivent donner le même hash

Générer un CSR (Certificate Signing Request)

Pour obtenir un certificat signé par une autorité (Let's Encrypt, DigiCert…), il faut d'abord créer un CSR :

# Générer une clé privée
openssl genrsa -out domaine.key 2048

# Créer le CSR (avec toutes les infos du domaine)
openssl req -new -key domaine.key -out domaine.csr

# Questions :
# - Country: CH
# - State: Bern
# - Locality: Tavannes
# - Organization: MaBoîte
# - Common Name: www.mondomaine.com (le sous-domaine principal!)
# - Email: admin@mondomaine.com

# Afficher le CSR
openssl req -in domaine.csr -text -noout

# CSR auto-signé pour test
openssl req -x509 -key domaine.key -out domaine.crt -days 365

Agent SSH — ne taper sa passphrase qu'une fois

ssh-agent garde les clés déchiffrées en mémoire pour la session :

# Démarrer l'agent
eval "$(ssh-agent -s)"
# Agent pid 12345

# Ajouter sa clé (demande la passphrase)
ssh-add ~/.ssh/cle_travail

# Lister les clés chargées
ssh-add -l

# Supprimer une clé
ssh-add -d ~/.ssh/cle_prod

# Supprimer toutes les clés
ssh-add -D

SSHFP — fingerprint DNS pour SSH

SSHFP est un enregistrement DNS qui permet à SSH de vérifier automatiquement l'authenticité du serveur :

# Récupérer le fingerprint SSH d'un serveur
ssh-keyscan -r srv001.example.com

# Générer l'enregistrement SSHFP à ajouter à la zone DNS
ssh-keyscan -H srv001.example.com | sshfp dns-zone.txt

# Côté client, activer la vérification SSHFP
nano ~/.ssh/config
# Ajouter : VerifyHostKeyDNS ask

Bonnes pratiques de sécurité

Règle	Recommandation
Clés	Utiliser Ed25519, minimum 4096 bits pour RSA
Passphrase	Toujours protéger les clés privées par une passphrase
Droits fichiers	`chmod 700 ~/.ssh` et `chmod 600 ~/.ssh/*`
Clé par usage	Une clé différente pour prod, dev, backup
Révoquer	Supprimer la clé publique des serveurs si compromise
Empreinte	Toujours vérifier le fingerprint d'un nouveau serveur
Certificates SSH	Pour infrastructure grande échelle, utiliser des certificats SSH signés par une CA

# Corriger les droits après copie d'une clé
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub
chmod 600 ~/.ssh/known_hosts
chmod 600 ~/.ssh/config

# Vérifier la configuration SSH
ssh -G user@srv001.example.com | grep -E "(identityfile|port|user)"

Résumé

ssh-keygen -t ed25519 = clé SSH moderne recommandée
ssh-copy-id user@serveur = copier la clé publique sur un serveur
~/.ssh/config = définir des alias et clés par serveur
ssh-agent = retenir la passphrase pour la session
ssh-keygen -R serveur = retirer un serveur du known_hosts
openssl dgst -sha256 fichier = calculer un hash SHA-256
sha256sum -c hashes.txt = vérifier l'intégrité de fichiers
openssl rand -base64 32 = générer des données aléatoires
openssl enc -aes-256-cbc -salt -in f.txt -out f.enc = chiffrer un fichier
openssl req -x509 -key key.pem -out cert.pem -days 365 = certificat auto-signé
openssl s_client -connect site:443 = inspecter le certificat d'un serveur
Toujours chmod 600 sur les clés privées, chmod 700 sur ~/.ssh