ssh

📋 Fiche Outil : ssh

ssh <utilisateur>@<IP>

1. Options de Commandes & Outils Associés

Il est important de distinguer la commande cliente ssh des outils de gestion de clés et d’administration.

2. Connexions et Tunnels (Port Forwarding)

Connexion classique

ssh utilisateur@192.168.x.x

Connexion avec Redirection Locale (Local Port Forwarding)

Permet d’accéder à un service qui n’écoute qu’en local (localhost) sur la machine distante (ex: une base de données PostgreSQL).

ssh -L 1234:localhost:5432 christine@10.129.141.118

Action : Cette commande relie le port local 1234 de la machine attaquante/admin au port 5432 de la cible. En laissant ce terminal ouvert, il est possible de se connecter localement :

psql -U christine -h localhost -p 1234

3. Authentification par Clés (Génération et Déploiement)

L’utilisation de paires de clés asymétriques remplace l’authentification classique par mot de passe. L’algorithme ed25519 est le standard actuel recommandé pour sa sécurité et sa rapidité.

Étape A : Générer la paire de clés (Machine Locale)

Sur Windows (PowerShell Administrateur) ou Linux :

ssh-keygen -t ed25519 -C "admin@monserveur"
# OU pour RSA : ssh-keygen -t rsa -b 4096

* Emplacement : Appuyer sur Entrée pour accepter le chemin par défaut (ex: C:UsersNom.sshid_ed25519 ou ~/.ssh/).

* Passphrase : Optionnelle. La laisser vide permet une connexion sans saisie. Ajouter un mot de passe chiffre la clé sur le disque (sécurité accrue).

* Résultat : Deux fichiers sont créés.

* id_ed25519 ➔ Clé privée (À garder secrète absolue).

* id_ed25519.pub ➔ Clé publique (À transférer sur le serveur).

Arborescence générée (ex: Windows) :

C:Userston_nom_d_utilisateur.ssh
├── id_rsa        → clé privée (à garder secrète)
└── id_rsa.pub    → clé publique (à transférer sur ton serveur)

Étape B : Transférer la clé publique sur le serveur cible

Méthode 1 : Automatique (Depuis Linux ou Git Bash)

ssh-copy-id -i ~/.ssh/id_ed25519.pub franck@192.168.x.x

Cette commande crée le dossier .ssh, place la clé dans le fichier authorized_keys et règle les permissions automatiquement.

Méthode 2 : Manuelle via SCP (Depuis Windows vers Linux)

Transférer la clé publique vers le répertoire personnel distant :

scp $env:USERPROFILE.sshid_ed25519.pub franck@192.168.x.x:/home/franck/

Étape C : Installation manuelle et gestion des permissions

Si le transfert a été fait via SCP, il faut configurer la clé manuellement sur le serveur cible. Le service SSH vérifie rigoureusement les droits d’accès : si les fichiers sont trop permissifs, la connexion sera refusée.

Se connecter au serveur par mot de passe, puis exécuter :

mkdir -p ~/.ssh
cat ~/id_ed25519.pub >> ~/.ssh/authorized_keys
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
rm ~/id_ed25519.pub

* Explications techniques :

* mkdir -p : Crée le dossier parent sans erreur s’il existe déjà.

* >> : Crucial. Ajoute (append) la clé à la fin du fichier. Utiliser > écraserait toutes les clés existantes.

* chmod 700 / 600 : Rend le dossier et le fichier lisibles uniquement par le propriétaire.

* rm : Supprime le fichier .pub résiduel pour garder le répertoire propre.

Vérifier que la clé est bien présente :

cat ~/.ssh/authorized_keys

Étape D : Tester la connexion

ssh -i ~/.ssh/id_ed25519 franck@192.168.x.x

4. Durcissement de la configuration SSH (Hardening)

La sécurisation est une étape incontournable. Il est interdit d’exposer le compte root directement sur le réseau.

Prérequis : Principe de moindre privilège

Il faut créer un utilisateur standard qui obtiendra les privilèges via sudo.

# Créer l'utilisateur et l'ajouter au groupe sudo
sudo adduser admin
sudo usermod -aG sudo admin

# Transférer la clé publique vers le nouveau profil
sudo mkdir -p /home/admin/.ssh
sudo touch /home/admin/.ssh/authorized_keys
sudo cp ~/.ssh/authorized_keys /home/admin/.ssh/authorized_keys

# Appliquer les permissions rigoureuses
sudo chown -R admin:admin /home/admin/.ssh
sudo chmod 700 /home/admin/.ssh
sudo chmod 600 /home/admin/.ssh/authorized_keys

# Vérifier les droits du répertoire
ls -ld /home/admin/.ssh

(Il faudra ensuite transférer ou copier les clés SSH vers /home/admin/.ssh en s’assurant de bien modifier le propriétaire avec sudo chown -R admin:admin /home/admin/.ssh).

Configuration du service : /etc/ssh/sshd_config

Ouvrir le fichier de configuration principal :

sudo nano /etc/ssh/sshd_config

Tableau des Directives de Sécurité

Note sur les environnements Cloud : Il faut parfois vérifier si d’autres fichiers surchargent ces paramètres :

sudo grep -Ri PasswordAuthentication /etc/ssh
# Ex: sudo nano /etc/ssh/sshd_config.d/50-cloud-init.conf

Application et Gestion du Pare-Feu

Avant de redémarrer le service, vérifier la syntaxe et mettre à jour le pare-feu (UFW ou Iptables) si le port a été changé.

Mise à jour Pare-feu (Exemple Port 2222) :

# Avec UFW
sudo ufw allow 2222/tcp

# Avec Iptables
sudo iptables -A INPUT -p tcp -s 10.10.20.0/24 --dport 2222 -j ACCEPT
sudo iptables -v -n -L --line-numbers  # Trouver le numéro de la règle port 22
sudo iptables -D INPUT 3               # Supprimer l'ancienne règle

Validation et Redémarrage :

sudo sshd -t
sudo systemctl daemon-reload
sudo systemctl restart ssh

Vérification & Dépannage

Vérifier la configuration active en mémoire

Pour s’assurer que le service a bien pris en compte la désactivation des mots de passe et du compte root :

sudo sshd -T | egrep -i 'passwordauthentication|pubkeyauthentication|permitrootlogin'

Tester l’impossibilité de se connecter par mot de passe

Cette commande force le client à utiliser un mot de passe et doit impérativement retourner l’erreur Permission denied (publickey).

ssh -v -o PreferredAuthentications=password -o PubkeyAuthentication=no admin@10.0.0.100

Supprimer une ancienne empreinte (Host Key Verification Failed)

Si le serveur distant a été réinstallé, son empreinte cryptographique change. SSH bloque la connexion par sécurité. Il faut nettoyer le fichier local :

ssh-keygen -R 192.168.1.x

Connexion SSH lors de la création d’un conteneur

Lors du déploiement d’un nouveau conteneur en laboratoire, il est souvent nécessaire d’activer temporairement la connexion du compte root par mot de passe pour effectuer la configuration initiale.

Sur le serveur (dans le conteneur) : Cette commande sed modifie le fichier de configuration à la volée pour autoriser root, puis le service est redémarré.

sudo sed -i 's/^#?PermitRootLogin .*/PermitRootLogin yes/' /etc/ssh/sshd_config
sudo systemctl restart ssh

En Local (depuis la machine attaquante/admin) : Il faut se connecter en utilisant le mot de passe root. L’option PubkeyAuthentication=no est utilisée pour forcer la demande de mot de passe au cas où votre client SSH tenterait automatiquement de présenter une clé cryptographique.

ssh -o PubkeyAuthentication=no root@10.0.0.99

Connection SSH avec clé renommé

Le fichier de configuration SSH (L’approche structurelle)

Comme brièvement évoqué précédemment, la méthode la plus propre pour gérer plusieurs connexions consiste à configurer le client SSH local. Cela permet d’associer automatiquement une adresse IP, un utilisateur et une clé spécifique.

• Création du fichier : Il faut créer un fichier nommé exactement config (sans aucune extension comme .txt) dans le répertoire C:UsersAdministrateur.ssh.

• Édition du contenu : Il convient d’y insérer les règles de connexion. Par exemple :

   Host cible-ubuntu
    HostName 10.10.30.53
    User franck
    IdentityFile ~/.ssh/id_sshubuntu01

• Résultat : Dès lors, il suffit de taper la commande ssh cible-ubuntu. Le système lira le fichier de configuration, déduira qu’il faut joindre l’IP 10.10.30.53 avec le compte franck, et ira chercher la bonne clé de manière transparente.

Procédure d’activation de l’agent SSH sous Windows

Il faut s’assurer que la console PowerShell est exécutée avec les privilèges Administrateur pour effectuer ces modifications sur le système.

1. Modifier le type de démarrage du service : La commande suivante modifie la configuration dans le registre Windows pour autoriser le lancement manuel du service.

Get-Service ssh-agent | Set-Service -StartupType Manual

(Note : Il est possible de remplacer Manual par Automatic si l’objectif est que l’agent soit toujours actif au démarrage de l’ordinateur).

1. Démarrer le service : La commande initiale peut maintenant s’exécuter sans erreur.

Start-Service ssh-agent

1. Vérifier l’état : En cybersécurité, il faut toujours vérifier qu’une action a bien eu le résultat escompté. L’état renvoyé doit être Running.

    Get-Service ssh-agent

1. Charger la clé privée : Une fois l’agent actif en arrière-plan, il est prêt à recevoir et à mémoriser la clé d’authentification.

ssh-add C:UsersAdministrateur.sshid_sshubuntu01

Intégration Avancée (GitHub, VSCode, Obsidian sous Windows)

Pour l’installation d’une clé SSH avec git/github voir 2. Commande Git

Pour ne pas avoir à saisir la passphrase de la clé SSH à chaque action (Git push, connexion distante VSCode), il convient d’activer l’Agent SSH sous Windows.

Sous Linux / Mac :

eval "$(ssh-agent -s)" # Lance ssh-agent de façon sécurisée
ssh-add ~/.ssh/id_ed25519 # Active la clé SSH
ssh -T git@github.com # Test

Sous Windows (PowerShell Administrateur) :

Set-Service ssh-agent -StartupType Automatic
Start-Service ssh-agent
ssh-add "$env:USERPROFILE.sshid_ed25519"

# Forcer Git à utiliser le SSH de Windows (VSCode / PowerShell)
git config --global core.sshCommand "C:/Windows/System32/OpenSSH/ssh.exe"
git config --global gpg.ssh.program "C:/Windows/System32/OpenSSH/ssh-keygen.exe"

ssh -T git@github.com # Test

–
–
–
–
–
–
–
—

–

OLD VERSION NOTE (A SUPPR)

Connection

ssh christine@10.129.141.118

Connection en “LocalHost”

ssh -L 1234:localhost:5432 christine@10.129.141.118

puis en laissant la connection active se connecter à postsql

psql -U christine -h localhost -p 1234

pour les commande sous psql voir PSQL

Connexion via Clé RSA

ssh -i id_rsa kenobi@10.10.235.207

Connexion SSH via chiffrement

Etape 1 : Générer une paire de clés SSH sur Windows

Sur windows ouvrir PowerShell en tant qu’administrateur et entrez la commande suivante :

ssh-keygen

ssh-keygen -t rsa -b 4096

• Emplacement du fichier : appuie sur Entrée pour le chemin par défaut (C:Userston_nom_d_utilisateur.sshid_rsa)
• Passphrase : si tu veux te connecter sans rien taper, laisse vide et appuie sur Entrée deux fois.

– Si tu mets un mot de passe ici, il te sera demandé à chaque connexion.

C:Userston_nom_d_utilisateur.ssh
├── id_rsa        → clé privée (à garder secrète)
└── id_rsa.pub    → clé publique (à transférer sur ton serveur)

Etape 2 : Copier la clé publique sur le serveur linux

Depuis le terminal PowerShell sur Windows (faire soit commande scp ou ssh-copy):

Commande scp (depuis windows)

scp $env:USERPROFILE.sshid_rsa.pub franck@192.168.x.x:/home/franck/

Commande ssh-copy-id (depuis linux)

ssh-copy-id franck@192.168.x.x

Etape 3 : Ajouter la clé publique dans le fichier authorized_keys

Se connecter sur la machine

ssh user@192.168.x.x

Une fois connecté, tape ces commandes une par une :

mkdir -p ~/.ssh
cat ~/id_rsa.pub >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys
chmod 700 ~/.ssh
rm ~/id_rsa.pub

• mkdir -p ~/.ssh → crée le dossier .ssh si besoin.
• cat → ajoute ta clé dans le fichier authorized_keys.
• chmod → fixe les bons droits (très important pour que ça fonctionne).
• rm → supprime la clé publique qui traînait dans ton /home (plus propre 👍)

Pour vérifier la clé :

cat ~/.ssh/authorized_keys

Etape 4 : Authentification par mot de passe SSH

sudo nano /etc/ssh/sshd_config

Pour faire une recherche = Ctrl + W ou utiliser les flèches pour une recherche manuelle.

Vérifier et modifier les lignes pour qu’elles soit identique et sans # devant

PasswordAuthentication no
PermitRootLogin no
PubkeyAuthentication yes

Ctrl + O = Enregistrer puis Ctrl + X pour quitter

Redémarrer le service SSH pour appliquer les changements :

sudo systemctl restart ssh

Connextion SSH via conteneur

# Sur le serveur
sudo sed -i 's/^#?PermitRootLogin .*/PermitRootLogin yes/' /etc/ssh/sshd_config
sudo systemctl restart ssh
ip a

# en Local (se connecter en utilisant le mot de passe root)
ssh -o PubkeyAuthentication=no root@10.0.0.99

VSCODE PASSPHRASE

Set-Service ssh-agent -StartupType Automatic
Start-Service ssh-agent

ssh-add « $env:USERPROFILE.sshid_ed25519”

Puis dans le terminal VScode :

git config –global core.sshCommand « C:/Windows/System32/OpenSSH/ssh.exe”

et dans Powershell

git config –global gpg.ssh.program « C:/Windows/System32/OpenSSH/ssh-keygen.exe”

SUpp SSSH

ssh-keygen -R 192.168.1.x