Configurer une Clé SSH sur VPS Linux
Published on January 30, 2026 at 03:10 PM
Guide complet pour configurer l'authentification par clés SSH sur votre VPS Linux. Tutoriel détaillé pour Windows (PuTTY), Linux et macOS. Sécurisez votre serveur VeryCloud avec les clés SSH.
# Configurer une Clé SSH sur VPS Linux
## Introduction aux Clés SSH
Les clés SSH (Secure Shell) offrent une méthode d'authentification bien plus sécurisée que les mots de passe traditionnels. Au lieu de taper un mot de passe à chaque connexion, vous utilisez une paire de clés cryptographiques :
- **Clé privée** : Reste sur votre ordinateur local (ne jamais la partager)
- **Clé publique** : Installée sur le serveur VPS
Lorsque vous vous connectez, le serveur vérifie que votre clé privée correspond à la clé publique enregistrée. Si la correspondance est validée, vous êtes authentifié instantanément.
### Schéma de fonctionnement
```
┌─────────────────────┐ ┌─────────────────────┐
│ Votre PC │ │ VPS VeryCloud │
│ │ │ │
│ 🔑 Clé privée │◄────SSH Auth────► │ 🔓 Clé publique │
│ (id_rsa) │ │ (authorized_keys) │
│ │ ✅ Connexion │ │
└─────────────────────┘ automatique └─────────────────────┘
```
### Avantages des clés SSH
| Aspect | Mot de passe | Clé SSH |
|--------|--------------|---------|
| **Sécurité** | Vulnérable aux attaques brute-force | Quasi-impossible à craquer |
| **Commodité** | Saisie manuelle à chaque connexion | Connexion automatique |
| **Partage** | Risque si divulgué | Clé publique partageable sans risque |
| **Longueur** | Généralement 8-20 caractères | 2048-4096 bits de cryptage |
| **Automatisation** | Difficile à scripter | Idéal pour les scripts |
---
## 🖥️ Méthode 1 : Générer une Clé SSH sur Windows avec PuTTY
### Étape 1 : Télécharger PuTTY et PuTTYgen
PuTTY est le client SSH le plus populaire pour Windows. PuTTYgen est l'utilitaire de génération de clés inclus.
1. Rendez-vous sur le site officiel : https://www.putty.org/
2. Téléchargez le package d'installation MSI (64-bit ou 32-bit selon votre système)
3. Installez PuTTY - PuTTYgen sera automatiquement inclus
> 💡 **Astuce VeryCloud** : Vous pouvez également télécharger uniquement `puttygen.exe` si vous avez déjà PuTTY installé.
### Étape 2 : Lancer PuTTYgen
1. Ouvrez PuTTYgen via :
- **Menu Démarrer** → **Tous les programmes** → **PuTTY** → **PuTTYgen**
- Ou double-cliquez sur `puttygen.exe`
2. L'interface de génération de clés s'affiche avec les options suivantes :
- Type de clé (RSA, DSA, ECDSA, Ed25519, SSH-1)
- Nombre de bits pour la génération
- Bouton "Generate" pour créer une nouvelle clé
### Étape 3 : Configurer les paramètres
Avant de générer la clé, vérifiez les paramètres en bas de la fenêtre :
| Paramètre | Valeur recommandée | Description |
|-----------|-------------------|-------------|
| **Type of key** | RSA ou EdDSA (Ed25519) | Algorithme de chiffrement |
| **Number of bits** | 4096 (RSA) ou 256 (Ed25519) | Longueur de la clé |
> 💡 **Recommandation VeryCloud** : Pour une sécurité maximale, choisissez **RSA 4096 bits** ou **EdDSA (Ed25519)** qui est plus moderne et performant.
**Diagramme : Choix de l'algorithme**
```
Algorithmes disponibles :
┌─────────────────────────────────────────┐
│ RSA 4096 bits │
│ ✅ Compatible universellement │
│ ✅ Sécurité prouvée │
│ ⚠️ Clés plus volumineuses │
└─────────────────────────────────────────┘
┌─────────────────────────────────────────┐
│ EdDSA (Ed25519) │
│ ✅ Moderne et rapide │
│ ✅ Clés compactes │
│ ✅ Recommandé pour nouveaux serveurs │
└─────────────────────────────────────────┘
```
### Étape 4 : Générer la paire de clés
1. Cliquez sur le bouton **Generate**
2. **Important** : Déplacez votre souris de manière aléatoire dans la zone vide sous "Please generate some randomness by moving the mouse over the blank area" pour générer de l'entropie (aléatoire cryptographique)
3. Attendez que la barre de progression se remplisse
**Processus de génération :**
```
Génération en cours...
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 45%
Déplacez votre souris aléatoirement
pour générer de l'entropie...
```
### Étape 5 : Configurer et sauvegarder les clés
Une fois la clé générée, vous verrez :
- Une zone de texte avec votre clé publique (format OpenSSH)
- Les champs "Key fingerprint" et "Key comment"
- Les champs "Key passphrase" et "Confirm passphrase"
- Les boutons "Save public key" et "Save private key"
#### Ajouter une passphrase (recommandé)
La passphrase ajoute une couche de sécurité supplémentaire. Même si quelqu'un obtient votre clé privée, il ne pourra pas l'utiliser sans la passphrase.
1. Dans **Key passphrase**, entrez une phrase secrète forte
2. Confirmez dans **Confirm passphrase**
> 🔒 **Conseil de sécurité** : Utilisez une phrase de 12+ caractères avec majuscules, minuscules, chiffres et symboles.
**Exemple de passphrase forte :**
```
Mauvais : password123
Bon : Mon VPS VeryCloud 2026!
```
#### Sauvegarder la clé privée
1. Cliquez sur **Save private key**
2. Choisissez un emplacement sécurisé (ex: `Documents/SSH_Keys/`)
3. Nommez le fichier (ex: `verycloud_vps.ppk`)
> ⚠️ **IMPORTANT** : Le fichier `.ppk` (PuTTY Private Key) doit rester confidentiel et ne jamais être partagé.
#### Sauvegarder la clé publique
1. Cliquez sur **Save public key**
2. Nommez le fichier (ex: `verycloud_vps.pub`)
#### Copier la clé publique au format OpenSSH
**Important** : Pour les serveurs Linux, vous devez copier la clé au format OpenSSH :
1. Sélectionnez **tout le texte** dans la zone "Public key for pasting into OpenSSH authorized_keys file"
2. Copiez-le (Ctrl+C)
3. Gardez-le de côté pour l'installation sur le serveur
**Format OpenSSH :**
```
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDx... rsa-key-20260130
```
### Étape 6 : Configurer PuTTY pour utiliser la clé
1. Ouvrez **PuTTY**
2. Dans le menu de gauche, naviguez vers : **Connection** → **SSH** → **Auth** → **Credentials**
3. Cliquez sur **Browse** à côté de "Private key file for authentication"
4. Sélectionnez votre fichier `.ppk`
5. Retournez à **Session**, entrez l'IP de votre VPS VeryCloud et sauvegardez la session
**Configuration complète PuTTY :**
```
┌──────────────────────────────────┐
│ Session Settings │
├──────────────────────────────────┤
│ Host Name: 51.91.XXX.XXX │
│ Port: 22 │
│ Connection type: SSH │
├──────────────────────────────────┤
│ Connection > SSH > Auth > │
│ Credentials │
│ Private key: verycloud_vps.ppk │
└──────────────────────────────────┘
```
---
## 🐧 Méthode 2 : Générer une Clé SSH sur Linux/macOS
### Étape 1 : Ouvrir le Terminal
- **Linux** : Ctrl+Alt+T ou cherchez "Terminal" dans vos applications
- **macOS** : Applications → Utilitaires → Terminal
### Étape 2 : Générer la paire de clés
#### Option A : Clé RSA 4096 bits (compatible universellement)
```bash
ssh-keygen -t rsa -b 4096 -C "[email protected]"
```
**Explication des options :**
- `-t rsa` : Type d'algorithme (RSA)
- `-b 4096` : Longueur de la clé (4096 bits)
- `-C` : Commentaire (votre email pour identifier la clé)
#### Option B : Clé Ed25519 (recommandée, plus moderne)
```bash
ssh-keygen -t ed25519 -C "[email protected]"
```
**Avantages Ed25519 :**
```
✅ Plus rapide que RSA
✅ Clés plus petites (256 bits vs 4096)
✅ Sécurité équivalente avec moins de bits
✅ Génération plus rapide
✅ Recommandé par les experts en sécurité
```
### Étape 3 : Suivre les instructions
**Sortie console :**
```bash
Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/utilisateur/.ssh/id_ed25519):
```
1. **Emplacement** : Appuyez sur Entrée pour accepter l'emplacement par défaut (`~/.ssh/id_ed25519`)
```bash
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
```
2. **Passphrase** : Entrez une phrase secrète (recommandé) ou appuyez sur Entrée pour aucune
**Résultat de la génération :**
```bash
Your identification has been saved in /home/utilisateur/.ssh/id_ed25519
Your public key has been saved in /home/utilisateur/.ssh/id_ed25519.pub
The key fingerprint is:
SHA256:AbCdEfGh1234567890... [email protected]
The key's randomart image is:
+--[ED25519 256]--+
| .o. |
| . .o |
| o + |
| . .. o |
| . S . . |
| . o = . |
| o * +. |
| . = Bo+. |
| o.=X*=E |
+----[SHA256]-----+
```
### Étape 4 : Vérifier la création
```bash
ls -la ~/.ssh/
```
**Sortie attendue :**
```
drwx------ 2 user user 4096 jan 30 10:00 .
drwxr-xr-x 25 user user 4096 jan 30 10:00 ..
-rw------- 1 user user 464 jan 30 10:00 id_ed25519 # Clé privée
-rw-r--r-- 1 user user 102 jan 30 10:00 id_ed25519.pub # Clé publique
```
### Étape 5 : Afficher la clé publique
```bash
cat ~/.ssh/id_ed25519.pub
```
**Résultat :**
```
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAbCdEfGh... [email protected]
```
> 📋 **Important** : Copiez cette ligne complète pour l'installation sur le serveur.
---
## 🚀 Installer la Clé Publique sur le VPS VeryCloud
### Vue d'ensemble du processus
```
┌──────────────────────────────────────────────────────────┐
│ Installation de la clé │
├──────────────────────────────────────────────────────────┤
│ │
│ 1. Copier la clé publique depuis votre PC │
│ ↓ │
│ 2. Se connecter au VPS VeryCloud (SSH) │
│ ↓ │
│ 3. Créer le dossier ~/.ssh │
│ ↓ │
│ 4. Ajouter la clé dans authorized_keys │
│ ↓ │
│ 5. Définir les permissions correctes │
│ ↓ │
│ 6. Tester la connexion │
│ │
└──────────────────────────────────────────────────────────┘
```
### Méthode 1 : Avec ssh-copy-id (Linux/macOS - Recommandée)
La commande `ssh-copy-id` automatise l'installation :
```bash
ssh-copy-id -i ~/.ssh/id_ed25519.pub root@IP_DU_VPS
```
**Exemple avec VPS VeryCloud :**
```bash
ssh-copy-id -i ~/.ssh/id_ed25519.pub [email protected]
```
**Sortie console :**
```
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/user/.ssh/id_ed25519.pub"
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s)
[email protected]'s password: [saisissez votre mot de passe]
Number of key(s) added: 1
Now try logging into the machine with: "ssh '[email protected]'"
and check to make sure that only the key(s) you wanted were added.
```
✅ **Succès** : La clé est maintenant installée !
### Méthode 2 : Installation manuelle
Si `ssh-copy-id` n'est pas disponible ou depuis Windows :
#### Étape 1 : Connectez-vous au VPS avec mot de passe
```bash
ssh [email protected]
```
**Première connexion :**
```
The authenticity of host '51.91.123.456' can't be established.
ED25519 key fingerprint is SHA256:AbCdEfGh1234567890...
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '51.91.123.456' (ED25519) to the list of known hosts.
[email protected]'s password: [entrez votre mot de passe]
```
#### Étape 2 : Créer le dossier .ssh (si nécessaire)
```bash
mkdir -p ~/.ssh
chmod 700 ~/.ssh
```
**Explication des permissions :**
```
chmod 700 = rwx------
↑
Seul le propriétaire peut lire/écrire/exécuter
drwx------ = directory (d) + read/write/execute (rwx) owner only
```
#### Étape 3 : Créer/éditer le fichier authorized_keys
```bash
nano ~/.ssh/authorized_keys
```
#### Étape 4 : Coller la clé publique
Collez la clé publique copiée précédemment (une seule ligne).
**Format attendu dans le fichier :**
```
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAbCdEfGh... [email protected]
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQC... [email protected]
```
> 💡 **Astuce** : Vous pouvez avoir plusieurs clés (une par ligne) pour différents ordinateurs.
**Commandes nano :**
```
Ctrl+X : Quitter
Y : Confirmer la sauvegarde
Entrée : Valider le nom de fichier
```
#### Étape 5 : Sauvegarder et définir les permissions
```bash
# Sauvegarder dans nano : Ctrl+X, puis Y, puis Entrée
# Définir les permissions
chmod 600 ~/.ssh/authorized_keys
```
**Structure des permissions :**
```
~/.ssh/ → 700 (drwx------)
~/.ssh/authorized_keys → 600 (-rw-------)
Permissions expliquées :
700 = rwx------ (propriétaire : lecture/écriture/exécution)
600 = rw------- (propriétaire : lecture/écriture uniquement)
```
#### Étape 6 : Tester la connexion
Déconnectez-vous et reconnectez-vous :
```bash
exit
ssh [email protected]
```
**Si tout fonctionne :**
```
Welcome to Ubuntu 24.04 LTS (GNU/Linux 6.8.0-51-generic x86_64)
* VeryCloud VPS - Datacenter Telehouse Paris
* Protection Anti-DDoS Netrix active
* Support 24/7 : https://manager.verycloud.fr
Last login: Thu Jan 30 10:30:45 2026 from 91.123.45.67
root@vps-verycloud:~#
```
✅ **Connexion réussie sans mot de passe !**
### Méthode 3 : En une seule commande (depuis votre PC local)
```bash
cat ~/.ssh/id_ed25519.pub | ssh [email protected] "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"
```
Cette commande enchaîne toutes les étapes automatiquement :
1. Lit votre clé publique
2. Se connecte au serveur
3. Crée le dossier .ssh
4. Ajoute la clé à authorized_keys
5. Définit les permissions correctes
---
## 🔒 Sécuriser le Serveur SSH
Une fois les clés SSH configurées, renforcez la sécurité en désactivant l'authentification par mot de passe.
### Schéma de sécurisation
```
Avant Après
┌─────────────────┐ ┌─────────────────┐
│ SSH accepte : │ │ SSH accepte : │
│ ✅ Mots de passe│ ═══> │ ❌ Mots de passe│
│ ✅ Clés SSH │ │ ✅ Clés SSH │
└─────────────────┘ └─────────────────┘
Vulnérable Sécurisé
(attaques brute-force) (protection maximale)
```
### Étape 1 : Éditer la configuration SSH
```bash
sudo nano /etc/ssh/sshd_config
```
### Étape 2 : Modifier les paramètres
Recherchez et modifiez ces lignes (utilisez Ctrl+W pour rechercher) :
```conf
# Désactiver l'authentification par mot de passe
PasswordAuthentication no
# Désactiver les mots de passe vides
PermitEmptyPasswords no
# Activer l'authentification par clé publique
PubkeyAuthentication yes
# Désactiver l'authentification challenge-response
ChallengeResponseAuthentication no
# Optionnel : Désactiver la connexion root (créez un utilisateur sudo d'abord)
# PermitRootLogin prohibit-password
```
**Tableau des options de sécurité :**
| Paramètre | Valeur | Description |
|-----------|--------|-------------|
| `PasswordAuthentication` | `no` | Désactive les mots de passe |
| `PubkeyAuthentication` | `yes` | Active les clés SSH |
| `PermitRootLogin` | `prohibit-password` | Root uniquement avec clé SSH |
| `PermitEmptyPasswords` | `no` | Interdit les mots de passe vides |
| `ChallengeResponseAuthentication` | `no` | Désactive auth. interactive |
### Étape 3 : Redémarrer le service SSH
```bash
sudo systemctl restart sshd
```
**Vérification du statut :**
```bash
sudo systemctl status sshd
```
**Sortie attendue :**
```
● ssh.service - OpenBSD Secure Shell server
Loaded: loaded (/lib/systemd/system/ssh.service; enabled)
Active: active (running) since Thu 2026-01-30 10:45:23 UTC; 5s ago
```
> ⚠️ **ATTENTION CRITIQUE** : Gardez une session SSH ouverte pendant les tests ! Si la configuration est incorrecte, vous pourriez perdre l'accès. Vous pouvez toujours accéder via la console VNC dans votre espace client VeryCloud en cas de problème.
**Procédure de sécurité :**
```
1. Ouvrez 2 sessions SSH
2. Testez la connexion par clé dans la session #2
3. Si ça fonctionne, modifiez la config
4. Redémarrez SSH
5. Testez à nouveau la session #2
6. Si succès, fermez la session #1
```
---
## 🛠️ Gestion des Clés SSH
### Ajouter plusieurs clés
Vous pouvez autoriser plusieurs clés (plusieurs ordinateurs, plusieurs utilisateurs) :
```bash
nano ~/.ssh/authorized_keys
```
**Exemple de fichier avec plusieurs clés :**
```
# Laptop personnel
ssh-ed25519 AAAAC3... user@laptop-perso
# PC bureau
ssh-rsa AAAAB3... user@pc-bureau
# Serveur de backup
ssh-ed25519 AAAAC3... backup@server
# Clé de l'équipe DevOps
ssh-rsa AAAAB3... [email protected]
```
### Supprimer une clé
Éditez `authorized_keys` et supprimez la ligne correspondant à la clé :
```bash
nano ~/.ssh/authorized_keys
# Supprimez la ligne
# Sauvegardez : Ctrl+X, Y, Entrée
```
### Changer la passphrase d'une clé existante
```bash
ssh-keygen -p -f ~/.ssh/id_ed25519
```
**Processus interactif :**
```
Enter old passphrase: [ancienne passphrase]
Enter new passphrase: [nouvelle passphrase]
Enter same passphrase again: [confirmation]
Your identification has been saved with the new passphrase.
```
### Afficher l'empreinte (fingerprint) d'une clé
```bash
ssh-keygen -lf ~/.ssh/id_ed25519.pub
```
**Sortie :**
```
256 SHA256:AbCdEfGh1234567890KLMNOPqrstUVWXyz01234 [email protected] (ED25519)
↑ ↑ ↑ ↑
Bits Hash Comment Type
```
### Lister toutes les clés autorisées sur le serveur
```bash
cat ~/.ssh/authorized_keys
```
ou pour une vue plus lisible :
```bash
while read -r line; do
echo "$line" | ssh-keygen -lf /dev/stdin
done < ~/.ssh/authorized_keys
```
---
## 🔄 Convertir les Formats de Clés
### Schéma des formats
```
┌──────────────┐ Conversion ┌──────────────┐
│ Format PPK │ ◄═════════════════► │ Format │
│ (PuTTY) │ │ OpenSSH │
│ │ │ (Linux/Mac) │
│ Windows │ │ Unix-like │
└──────────────┘ └──────────────┘
```
### PPK vers OpenSSH (PuTTY → Linux)
Dans PuTTYgen :
1. Cliquez sur **Load**
2. Sélectionnez votre fichier `.ppk`
3. Allez dans **Conversions** → **Export OpenSSH key**
4. Sauvegardez le fichier (ex: `id_rsa` sans extension)
**Résultat :** Clé compatible avec Linux/macOS
### OpenSSH vers PPK (Linux → PuTTY)
Dans PuTTYgen :
1. Allez dans **Conversions** → **Import key**
2. Sélectionnez votre clé privée OpenSSH (`id_rsa` ou `id_ed25519`)
3. (Optionnel) Ajoutez une passphrase
4. Cliquez sur **Save private key**
5. Sauvegardez en `.ppk`
**Résultat :** Clé compatible avec PuTTY sur Windows
---
## 🔧 Dépannage
### Erreur : "Permission denied (publickey)"
**Message complet :**
```
[email protected]: Permission denied (publickey).
```
**Causes possibles :**
1. ❌ Clé publique non installée sur le serveur
2. ❌ Mauvaises permissions sur `.ssh` ou `authorized_keys`
3. ❌ Clé privée incorrecte utilisée
4. ❌ SELinux bloque l'accès (CentOS/RHEL)
**Solutions :**
```bash
# Sur le serveur VeryCloud
# 1. Vérifier les permissions
ls -ld ~/.ssh
ls -l ~/.ssh/authorized_keys
# Corriger si nécessaire
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
# 2. Vérifier que la clé est bien présente
cat ~/.ssh/authorized_keys
# 3. Vérifier les logs SSH
sudo tail -20 /var/log/auth.log
# ou sur certains systèmes
sudo journalctl -u sshd -n 20
# 4. Vérifier la configuration SSH
sudo grep -E "PubkeyAuthentication|PasswordAuthentication" /etc/ssh/sshd_config
```
**Diagnostic détaillé depuis votre PC :**
```bash
# Connexion en mode verbose (3 niveaux)
ssh -vvv [email protected]
# Vous verrez :
# - Les clés tentées
# - Les algorithmes proposés
# - La raison exacte du refus
```
### Erreur : "Connection refused"
**Message complet :**
```
ssh: connect to host 51.91.123.456 port 22: Connection refused
```
**Causes possibles :**
- ❌ Service SSH non démarré
- ❌ Pare-feu bloquant le port 22
- ❌ IP incorrecte
- ❌ Port SSH changé (n'est plus 22)
**Solutions :**
```bash
# Sur le serveur (via console VNC VeryCloud)
# 1. Vérifier le statut SSH
sudo systemctl status sshd
# 2. Démarrer SSH si arrêté
sudo systemctl start sshd
# 3. Activer au démarrage
sudo systemctl enable sshd
# 4. Vérifier le pare-feu
sudo ufw status
sudo ufw allow 22/tcp
# 5. Vérifier que SSH écoute
sudo ss -tlnp | grep :22
# Devrait afficher: LISTEN ... sshd
# 6. Vérifier le port SSH configuré
sudo grep "^Port" /etc/ssh/sshd_config
```
**Vérification VeryCloud :**
- Connectez-vous à l'espace client VeryCloud
- Vérifiez que le VPS est bien démarré (statut "Running")
- Utilisez la console VNC si SSH ne fonctionne pas
### Erreur : "Host key verification failed"
**Message complet :**
```
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
Host key verification failed.
```
**Cause :** Le serveur a changé (réinstallation OS, nouvelle IP, attaque MITM)
**Solution si légitime (réinstallation) :**
```bash
# Supprimer l'ancienne entrée
ssh-keygen -R 51.91.123.456
```
ou
```bash
# Éditer manuellement
nano ~/.ssh/known_hosts
# Supprimer la ligne correspondant à l'IP
```
**Vérification de sécurité :**
```bash
# Vérifier le fingerprint via la console VNC VeryCloud
ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub
```
### La passphrase est demandée à chaque connexion
**Solution :** Utilisez `ssh-agent` pour mémoriser la passphrase
```bash
# Démarrer l'agent
eval "$(ssh-agent -s)"
# Ajouter la clé
ssh-add ~/.ssh/id_ed25519
# Vérifier
ssh-add -l
```
**Sortie :**
```
Agent pid 12345
Identity added: /home/user/.ssh/id_ed25519 ([email protected])
256 SHA256:AbCdEfGh... [email protected] (ED25519)
```
**Pour rendre permanent (Linux/macOS) :**
Ajoutez dans `~/.bashrc` ou `~/.zshrc` :
```bash
# Auto-start SSH agent
if [ -z "$SSH_AUTH_SOCK" ]; then
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519 2>/dev/null
fi
```
### Erreur : "Too many authentication failures"
**Message :**
```
Received disconnect from 51.91.123.456: Too many authentication failures
```
**Cause :** Trop de clés essayées (limite par défaut : 6)
**Solution :**
```bash
# Spécifier la clé exacte
ssh -i ~/.ssh/id_ed25519 [email protected]
# Ou configurer dans ~/.ssh/config
nano ~/.ssh/config
```
Ajoutez :
```
Host verycloud
HostName 51.91.123.456
User root
IdentityFile ~/.ssh/id_ed25519
IdentitiesOnly yes
```
Utilisez : `ssh verycloud`
---
## 📋 Récapitulatif des Commandes
### Génération de clés
| Action | Commande |
|--------|----------|
| Générer clé RSA 4096 | `ssh-keygen -t rsa -b 4096 -C "[email protected]"` |
| Générer clé Ed25519 | `ssh-keygen -t ed25519 -C "[email protected]"` |
| Changer passphrase | `ssh-keygen -p -f ~/.ssh/id_ed25519` |
| Voir fingerprint | `ssh-keygen -lf ~/.ssh/id_ed25519.pub` |
| Voir empreinte MD5 | `ssh-keygen -lf ~/.ssh/id_ed25519.pub -E md5` |
### Installation sur serveur
| Action | Commande |
|--------|----------|
| Copier clé (auto) | `ssh-copy-id -i ~/.ssh/id_ed25519.pub user@IP` |
| Afficher clé publique | `cat ~/.ssh/id_ed25519.pub` |
| Créer dossier .ssh | `mkdir -p ~/.ssh && chmod 700 ~/.ssh` |
| Définir permissions | `chmod 600 ~/.ssh/authorized_keys` |
| Copie manuelle | `cat ~/.ssh/id_ed25519.pub \| ssh user@IP "cat >> ~/.ssh/authorized_keys"` |
### Diagnostic et maintenance
| Action | Commande |
|--------|----------|
| Tester connexion verbose | `ssh -vvv user@IP` |
| Vérifier service SSH | `sudo systemctl status sshd` |
| Redémarrer SSH | `sudo systemctl restart sshd` |
| Voir logs SSH | `sudo tail -f /var/log/auth.log` |
| Supprimer host connu | `ssh-keygen -R IP` |
| Lister clés chargées | `ssh-add -l` |
| Tester config SSH | `sudo sshd -t` |
---
## 📁 Structure des Fichiers SSH
```
~/.ssh/
├── authorized_keys # Clés publiques autorisées (sur serveur)
├── id_ed25519 # Clé privée Ed25519 (sur client)
├── id_ed25519.pub # Clé publique Ed25519 (sur client)
├── id_rsa # Clé privée RSA (sur client)
├── id_rsa.pub # Clé publique RSA (sur client)
├── known_hosts # Empreintes des serveurs connus
├── config # Configuration personnalisée (optionnel)
└── authorized_keys2 # Fichier legacy (non utilisé normalement)
```
### Diagramme des permissions
```
Fichier/Dossier Permission Signification
──────────────────────────────────────────────────────
~/.ssh/ 700 drwx------
Seul user peut RWX
authorized_keys 600 -rw-------
Seul user peut RW
id_ed25519 (privée) 600 -rw-------
Clé privée protégée
id_ed25519.pub 644 -rw-r--r--
Publique, tous lisent
known_hosts 644 -rw-r--r--
Liste serveurs connus
config 600 -rw-------
Config personnelle
```
### Commandes de permissions
```bash
# Réparer toutes les permissions SSH
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_*
chmod 644 ~/.ssh/id_*.pub
chmod 600 ~/.ssh/authorized_keys
chmod 644 ~/.ssh/known_hosts
chmod 600 ~/.ssh/config 2>/dev/null
```
---
## 💡 Bonnes Pratiques VeryCloud
### Sécurité
```
✅ Checklist Sécurité SSH
┌─────────────────────────────────────────┐
│ 1. Utilisez Ed25519 ou RSA 4096 bits │
│ 2. Ajoutez TOUJOURS une passphrase │
│ 3. Ne partagez JAMAIS la clé privée │
│ 4. Sauvegardez vos clés en sécurité │
│ 5. Clés différentes par environnement │
│ 6. Désactivez les mots de passe │
│ 7. Auditez authorized_keys │
│ 8. Renouvelez les clés annuellement │
│ 9. Utilisez ssh-agent │
│10. Configurez ~/.ssh/config │
└─────────────────────────────────────────┘
```
### Configuration SSH avancée (~/.ssh/config)
Créez un fichier de configuration pour simplifier vos connexions :
```bash
nano ~/.ssh/config
```
**Exemple de configuration :**
```
# VPS Production VeryCloud
Host verycloud-prod
HostName 51.91.123.456
User root
IdentityFile ~/.ssh/verycloud_prod_ed25519
Port 22
ServerAliveInterval 60
ServerAliveCountMax 3
# VPS Développement VeryCloud
Host verycloud-dev
HostName 51.91.123.789
User admin
IdentityFile ~/.ssh/verycloud_dev_ed25519
Port 22
# Configuration globale
Host *
AddKeysToAgent yes
IdentitiesOnly yes
HashKnownHosts yes
```
**Utilisation simplifiée :**
```bash
# Au lieu de
ssh [email protected]
# Utilisez simplement
ssh verycloud-prod
```
### Automatisation et scripts
**Script de backup automatique :**
```bash
#!/bin/bash
# backup_vps.sh
VPS="verycloud-prod"
BACKUP_DIR="/home/backup/vps"
DATE=$(date +%Y%m%d_%H%M%S)
# Créer backup
ssh $VPS "tar -czf /tmp/backup_$DATE.tar.gz /var/www /etc"
# Télécharger
scp $VPS:/tmp/backup_$DATE.tar.gz $BACKUP_DIR/
# Nettoyer
ssh $VPS "rm /tmp/backup_$DATE.tar.gz"
echo "Backup terminé : $BACKUP_DIR/backup_$DATE.tar.gz"
```
---
## ❓ FAQ
### Quelle est la différence entre RSA et Ed25519 ?
| Aspect | RSA 4096 | Ed25519 |
|--------|----------|---------|
| **Sécurité** | Excellente | Excellente |
| **Performance** | Plus lent | Plus rapide |
| **Taille clé privée** | ~3.3 KB | ~400 bytes |
| **Taille clé publique** | ~800 bytes | ~68 bytes |
| **Génération** | ~5 secondes | <1 seconde |
| **Compatibilité** | Universelle | OpenSSH 6.5+ (2014) |
| **Résistance quantique** | Non | Non |
| **Recommandation** | Anciens systèmes | VPS modernes VeryCloud |
**Recommandation VeryCloud :** Ed25519 pour tous les nouveaux VPS (Ubuntu 22.04+, Debian 12+)
### Puis-je utiliser la même clé pour plusieurs serveurs VeryCloud ?
✅ **Oui**, vous pouvez installer la même clé publique sur plusieurs VPS.
**Avantages :**
- Une seule clé à gérer
- Connexion simplifiée
- Moins de fichiers à sauvegarder
**Inconvénients :**
- Si la clé est compromise, tous vos serveurs sont vulnérables
- Pas de traçabilité par serveur
**Recommandation VeryCloud :**
```
Production → clé_prod_ed25519
Développement → clé_dev_ed25519
Test → clé_test_ed25519
Personnel → clé_perso_ed25519
```
### Comment ajouter un commentaire à ma clé ?
Le paramètre `-C` permet d'ajouter un commentaire identifiant :
```bash
ssh-keygen -t ed25519 -C "verycloud-prod-2026-laptop-dell"
```
Le commentaire apparaît à la fin de la clé publique :
```
ssh-ed25519 AAAAC3... verycloud-prod-2026-laptop-dell
```
**Utilité :**
- Identifier rapidement la provenance de la clé
- Tracer quelle machine utilise quelle clé
- Organiser les clés dans `authorized_keys`
### Est-ce que les clés SSH expirent ?
❌ **Non**, les clés SSH n'ont pas de date d'expiration intégrée.
**Bonnes pratiques de rotation :**
```
┌─────────────────────────────────────┐
│ Fréquence recommandée │
├─────────────────────────────────────┤
│ Clés personnelles : 1-2 ans │
│ Clés d'équipe : 6-12 mois │
│ Clés de service : 3-6 mois │
│ Après compromission : Immédiat │
│ Départ employé : Immédiat │
└─────────────────────────────────────┘
```
### Comment copier ma clé SSH entre ordinateurs ?
**Méthode sécurisée (recommandée) :**
1. Sur l'ordinateur source :
```bash
# Afficher la clé privée
cat ~/.ssh/id_ed25519
# Afficher la clé publique
cat ~/.ssh/id_ed25519.pub
```
2. Transférez via canal sécurisé :
- Clé USB chiffrée
- Gestionnaire de mots de passe (1Password, Bitwarden)
- `scp` entre vos machines
- **JAMAIS par email, Slack, Discord**
3. Sur le nouvel ordinateur :
```bash
mkdir -p ~/.ssh
chmod 700 ~/.ssh
# Créer la clé privée
nano ~/.ssh/id_ed25519
# Collez le contenu
chmod 600 ~/.ssh/id_ed25519
# Créer la clé publique
nano ~/.ssh/id_ed25519.pub
# Collez le contenu
chmod 644 ~/.ssh/id_ed25519.pub
```
**Via SCP (si vous avez déjà SSH entre vos machines) :**
```bash
# Depuis machine source vers nouvelle machine
scp ~/.ssh/id_ed25519* user@nouvelle-machine:~/.ssh/
```
### Que faire si j'ai perdu ma clé privée ?
**Scénario critique :** Vous ne pouvez plus vous connecter
**Solutions :**
1. **Via console VNC VeryCloud** (recommandé) :
```bash
# Connectez-vous via la console VNC
# Ajoutez une nouvelle clé temporaire
echo "ssh-ed25519 AAAAC3... nouvelle@cle" >> ~/.ssh/authorized_keys
```
2. **Générer une nouvelle paire** :
```bash
# Sur votre PC
ssh-keygen -t ed25519 -C "nouvelle-cle-secours"
# Installer via VNC ou support VeryCloud
```
3. **Contacter le support VeryCloud** :
- Support 24/7 disponible
- Peuvent vous aider à récupérer l'accès
**Prévention :**
- ✅ Sauvegardez vos clés dans un gestionnaire de mots de passe
- ✅ Gardez une copie chiffrée hors ligne
- ✅ Maintenez plusieurs clés autorisées
### Comment désactiver temporairement une clé sans la supprimer ?
**Commentez la ligne dans authorized_keys :**
```bash
nano ~/.ssh/authorized_keys
```
Ajoutez `#` au début de la ligne :
```
# ssh-ed25519 AAAAC3... cle-temporairement-desactivee
ssh-rsa AAAAB3... cle-active
```
**Réactivez** en supprimant le `#`
---
## 🎯 Checklist Complète de Configuration
### Phase 1 : Génération des clés
- [ ] Clé SSH générée (Ed25519 ou RSA 4096)
- [ ] Passphrase forte définie (12+ caractères)
- [ ] Clé privée sauvegardée en lieu sûr
- [ ] Clé publique copiée dans le presse-papier
- [ ] Commentaire ajouté à la clé (identification)
### Phase 2 : Installation sur VPS VeryCloud
- [ ] Connexion initiale au VPS réussie (mot de passe)
- [ ] Dossier `~/.ssh` créé avec permissions 700
- [ ] Clé publique ajoutée dans `authorized_keys`
- [ ] Permissions `authorized_keys` définies à 600
- [ ] Test de connexion SSH par clé réussi
- [ ] Mot de passe désactivé dans `sshd_config`
- [ ] Service SSH redémarré
- [ ] Nouvelle connexion testée (uniquement par clé)
### Phase 3 : Sécurité
- [ ] `PasswordAuthentication no` configuré
- [ ] `PubkeyAuthentication yes` vérifié
- [ ] `PermitRootLogin` configuré selon besoin
- [ ] Session de secours maintenue pendant tests
- [ ] Accès console VNC VeryCloud vérifié (backup)
- [ ] Clé privée jamais partagée
- [ ] Backup de la clé effectué
### Phase 4 : Configuration avancée
- [ ] `~/.ssh/config` créé et configuré
- [ ] `ssh-agent` configuré pour passphrase
- [ ] Alias de connexion testés
- [ ] Script d'automatisation créé (si besoin)
- [ ] Documentation personnelle mise à jour
### Phase 5 : Documentation et maintenance
- [ ] IP du VPS notée
- [ ] Utilisateur SSH documenté
- [ ] Emplacement de la clé privée noté
- [ ] Passphrase stockée en sécurité
- [ ] Date de création notée (rotation annuelle)
- [ ] Procédure de récupération définie
---
## 📚 Ressources Complémentaires
### Documentation VeryCloud
| Ressource | Lien |
|-----------|------|
| **Espace client** | [manager.verycloud.fr](https://manager.verycloud.fr) |
| **Documentation** | [docs.verycloud.fr](https://verycloud.fr/docs) |
| **Support 24/7** | Tickets dans l'espace client |
| **Console VNC** | Accessible dans l'espace client |
| **Statut services** | [status.verycloud.fr](https://status.verycloud.fr) |
### Documentation technique SSH
| Sujet | Lien |
|-------|------|
| Manuel OpenSSH | `man ssh` ou `man sshd_config` |
| RFC 4251 (SSH Protocol) | https://www.rfc-editor.org/rfc/rfc4251 |
| Ed25519 Signature Scheme | https://ed25519.cr.yp.to/ |
### Outils recommandés
| Outil | Usage | Lien |
|-------|-------|------|
| **PuTTY** | Client SSH Windows | https://www.putty.org/ |
| **KeePassXC** | Gestionnaire mots de passe | https://keepassxc.org/ |
| **WinSCP** | Transfert fichiers Windows | https://winscp.net/ |
| **Termius** | Client SSH multi-plateforme | https://termius.com/ |
### Communauté VeryCloud
| Plateforme | Description | Accès |
|------------|-------------|-------|
| **Discord** | 600+ membres, support communautaire | [Rejoindre](https://verycloud.fr/links/discord) |
| **Forum** | Guides et tutoriels avancés | docs.verycloud.fr |
---
## Besoin d'aide ?
L'équipe VeryCloud est disponible 24/7 pour vous accompagner :
```
┌──────────────────────────────────────┐
│ Support VeryCloud 24/7 │
├──────────────────────────────────────┤
│ │
│ 📚 Documentation │
│ docs.verycloud.fr │
│ │
│ 🎫 Support technique │
│ manager.verycloud.fr │
│ (Ouvrir un ticket) │
│ │
│ 💬 Discord communautaire │
│ 600+ membres actifs │
│ │
│ 📊 Statut des services │
│ status.verycloud.fr │
│ │
└──────────────────────────────────────┘
```
**Horaires support :**
- 🕐 **24/7/365** - Support technique par ticket
- 💬 **24/7** - Communauté Discord
- 📱 **Temps de réponse** - Moins de 30 minutes en moyenne
---
*Guide rédigé par VeryCloud SAS • Dernière mise à jour : 30 janvier 2026*
*Version 2.0 - Testé sur Ubuntu 24.04 LTS, Debian 12, avec OpenSSH 9.6+*