# SSH

SSH, pour *secure shell*, ouvre un terminal sur une autre machine à travers le réseau. Tout ce qui passe est chiffré. C'est la façon normale d'administrer un serveur, qui n'a ni écran ni clavier.

## Le problème

Le jour où le jeu a besoin d'un serveur, par exemple pour un [classement en ligne](/reseau/api), ce serveur est une machine distante : dans une [machine virtuelle](/virtualisation/virtualbox), ou louée chez un hébergeur. Il faut pouvoir y installer Python, y copier le code, lire ses journaux. Tout cela se fait par SSH.

On s'en sert aussi sans le savoir : envoyer du code sur GitHub avec une adresse en `git@github.com:...` passe par SSH.

## La notion

### Client et serveur

<Mermaid
  chart={`flowchart LR
    subgraph local [Votre machine]
      client[ssh<br/>le client]
    end
    subgraph distant [La machine distante]
      sshd[sshd<br/>le serveur SSH, port 22]
      shell[Un shell]
    end
    client -- connexion chiffrée --> sshd
    sshd --> shell`}
/>

```bash
ssh alice@192.168.1.20
```

| Morceau | Sens |
| --- | --- |
| `alice` | Le compte utilisateur **sur la machine distante** |
| `192.168.1.20` | L'adresse de la machine, ou son nom |
| `-p 2222` | Le port, si ce n'est pas le port 22 habituel |

Une fois connecté, l'invite change : chaque commande tapée s'exécute là-bas. On revient avec `exit` ou Ctrl + D.

### La première connexion

```text
The authenticity of host '192.168.1.20' can't be established.
ED25519 key fingerprint is SHA256:Xk3...
Are you sure you want to continue connecting (yes/no)?
```

SSH demande de confirmer l'identité du serveur. Une fois acceptée, son empreinte est rangée dans `~/.ssh/known_hosts`. Si elle change un jour, SSH refuse de se connecter et affiche un avertissement : soit le serveur a été réinstallé, soit quelqu'un se fait passer pour lui.

### Mot de passe ou clés

On peut s'identifier avec le mot de passe du compte distant. C'est simple, mais un mot de passe se devine et se vole. La bonne méthode est la **paire de clés**.

| Clé | Où elle est | Peut-on la donner ? |
| --- | --- | --- |
| Privée, `~/.ssh/id_ed25519` | Uniquement sur votre machine | **Jamais** |
| Publique, `~/.ssh/id_ed25519.pub` | Copiée sur chaque serveur | Oui, à tout le monde |

L'image à garder : la clé publique est un cadenas qu'on distribue, la clé privée est la seule clé qui l'ouvre.

<Mermaid
  chart={`sequenceDiagram
    participant C as Client, clé privée
    participant S as Serveur, clé publique
    C->>S: Je suis alice
    S->>C: Prouve-le, signe ce message
    Note over C: signe avec la clé privée
    C->>S: Voici la signature
    Note over S: vérifie avec la clé publique
    S->>C: Connexion acceptée`}
/>

La clé privée ne quitte jamais la machine. Le serveur vérifie seulement qu'on la possède.

## Mettre en place ses clés

<Stepper>

1. **Créer la paire.** Une seule fois par machine.

   ```bash
   ssh-keygen -t ed25519 -C "alice@portable"
   ```

   La commande demande où ranger la clé, on garde l'emplacement proposé, puis une phrase secrète qui protège la clé privée si le fichier est volé.

1. **Copier la clé publique sur le serveur.** Le mot de passe du compte distant est demandé une dernière fois.

   ```bash
   ssh-copy-id alice@192.168.1.20
   ```

   La clé est ajoutée au fichier `~/.ssh/authorized_keys` du compte distant.

1. **Vérifier.** La connexion ne demande plus le mot de passe du compte.

   ```bash
   ssh alice@192.168.1.20
   ```

</Stepper>

## Se simplifier la vie avec un fichier de configuration

Le fichier `~/.ssh/config` donne un nom court à chaque machine.

```text
Host vm-jeu
    HostName 127.0.0.1
    Port 2222
    User alice
```

```bash
ssh vm-jeu      # au lieu de : ssh -p 2222 alice@127.0.0.1
```

## Copier des fichiers

| Commande | Effet |
| --- | --- |
| `scp fichier.py vm-jeu:~/` | Copie un fichier vers le dossier personnel distant |
| `scp vm-jeu:~/scores.json .` | Rapatrie un fichier dans le dossier courant |
| `scp -r server vm-jeu:~/` | Copie un dossier entier |
| `rsync -av server/ vm-jeu:~/server/` | Synchronise : n'envoie que ce qui a changé |

On peut aussi lancer une seule commande sans ouvrir de session :

```bash
ssh vm-jeu "ls -la ~/server"
```

## SSH et GitHub

GitHub accepte une clé SSH à la place du mot de passe. On colle le contenu de la clé **publique** dans les réglages du compte, puis on teste :

```bash
cat ~/.ssh/id_ed25519.pub     # le texte à coller
ssh -T git@github.com         # doit répondre par un message de bienvenue
```

## Les erreurs fréquentes

| Message | Cause probable |
| --- | --- |
| `Connection refused` | Aucun serveur SSH n'écoute sur ce port |
| `Connection timed out` | Mauvaise adresse, machine éteinte, ou pare-feu |
| `Permission denied (publickey)` | Clé publique absente du serveur, ou mauvais nom d'utilisateur |
| `REMOTE HOST IDENTIFICATION HAS CHANGED` | L'empreinte du serveur a changé. Comprendre pourquoi avant de l'effacer |

L'option `-v` affiche le détail de la connexion et montre à quelle étape elle échoue : `ssh -v vm-jeu`.

## Les règles de sécurité

- La clé privée ne se copie pas, ne s'envoie pas, ne va pas dans Git.
- Une paire de clés par machine. Si un portable est perdu, on retire sa clé publique des serveurs, et les autres continuent de fonctionner.
- Une phrase secrète sur la clé privée.
- Sur un serveur exposé à Internet, on désactive la connexion par mot de passe une fois les clés en place.

## À retenir

- `ssh utilisateur@machine` ouvre un terminal distant.
- Clé privée chez soi, clé publique sur les serveurs.
- `~/.ssh/config` pour nommer ses machines.
- `scp` et `rsync` pour les fichiers.

## Exercices

1. Créer une paire de clés et afficher la clé publique. Vérifier les droits des deux fichiers avec `ls -l ~/.ssh`.
2. Se connecter à la machine virtuelle du cours [VirtualBox](/virtualisation/virtualbox) avec un mot de passe, puis installer sa clé et se reconnecter sans.
3. Ajouter une entrée `vm-jeu` dans `~/.ssh/config`.
4. Copier le dossier `src` du jeu sur la machine virtuelle, puis compter ses lignes à distance en une seule commande.
5. Ajouter sa clé publique à son compte GitHub et vérifier avec `ssh -T git@github.com`.
