# [COURS] GUIDE SSH SUR VIRTUALBOX - ULTRA DÉTAILLÉ POUR DÉBUTANTS ABSOLUS

## * AVANT DE COMMENCER : COMPRENDRE LES BASES

### Qu'est-ce que SSH ?

**SSH = Secure Shell = Coquille Sécurisée**

C'est un protocole qui permet de **se connecter à distance** à un ordinateur (serveur) et de le **contrôler comme si tu étais devant**.

#### Analogie simple :

**Sans SSH (en physique) :**
```
[UTILISATEUR] Toi devant la VM
│
└─ Tu tapes directement sur le clavier de la VM
   Tu vois l'écran de la VM
   [OK] Mais il faut être devant !
```

**Avec SSH (à distance) :**
```
[ECRAN] Ton PC Windows ──────[Internet/Réseau]─────-> [CODE] VM Linux
   │                                              │
   └─ Tu tapes depuis ton PC                      └─ La VM exécute
      Tu vois le résultat sur ton PC                 Et renvoie la réponse
      [OK] Tu peux être n'importe où !
```

#### Pourquoi utiliser SSH ?

1. **Confort** : Tu restes sur ton PC, pas besoin d'ouvrir la fenêtre VirtualBox
2. **Copier-coller** : Tu peux copier-coller des commandes facilement
3. **Plusieurs connexions** : Tu peux ouvrir plusieurs terminaux en même temps
4. **Réalisme** : C'est comme ça qu'on administre de VRAIS serveurs
5. **Transfert de fichiers** : Tu peux envoyer/recevoir des fichiers (avec SCP/SFTP)

### Comment fonctionne SSH ?

```
┌─────────────────────────────────────────────────────────────────┐
│                    CONNEXION SSH                                │
└─────────────────────────────────────────────────────────────────┘

[ECRAN] CLIENT SSH                         [CODE] SERVEUR SSH
(Ton PC Windows)                      (Ta VM Linux)
      │                                     │
      │  1. "Je veux me connecter"          │
      │────────────────────────────────────>│
      │                                     │
      │  2. "OK, identifie-toi"             │
      │<────────────────────────────────────│
      │                                     │
      │  3. "Voici mon mot de passe"        │
      │     (chiffré [VERROUILLE])                    │
      │────────────────────────────────────>│
      │                                     │
      │  4. "OK, connecté ! [BRAVO]"             │
      │<────────────────────────────────────│
      │                                     │
      │  Maintenant tout est CHIFFRÉ [VERROUILLE]     │
      │<══════════════════════════════════> │
```

**Important :** Tout ce qui passe entre le client et le serveur est **chiffré**.

### Les deux méthodes d'authentification SSH

#### 1⃣ Par mot de passe (Simple mais moins sécurisé)

```
Toi : "Je suis Pierre, mon mot de passe est monmotdepasse"
Serveur : "OK, je vérifie... C'est bon, entre !"
```

**Avantages :**
- [OK] Simple à configurer
- [OK] Pas besoin de fichiers supplémentaires

**Inconvénients :**
- [X] Peut être attaqué par force brute
- [X] Tu dois taper le mot de passe à chaque fois

#### 2⃣ Par clé SSH (Recommandé, plus sécurisé)

**Analogie :** C'est comme une serrure et une clé physique :
- **Clé publique** = La serrure (tu peux la donner à tout le monde)
- **Clé privée** = La clé (tu la gardes SECRÈTE)

**Avantages :**
- [OK] BEAUCOUP plus sécurisé
- [OK] Impossible à attaquer par force brute
- [OK] Connexion automatique
- [OK] Tu peux désactiver les mots de passe complètement

### Le port SSH : 22

SSH écoute par défaut sur le **port 22**.

**Analogie :** Imagine un immeuble (= ton serveur) :

```
[ENTREPRISE] Serveur (192.168.1.100)
│
├─ [SORTIE] Porte 22 <- SSH (accès à distance)
├─ [SORTIE] Porte 80 <- HTTP (sites web)
├─ [SORTIE] Porte 443 <- HTTPS (sites web sécurisés)
└─ [SORTIE] Porte 3306 <- MySQL (base de données)
```

---

## [OBJECTIF] OBJECTIF DU PROJET

On va **configurer SSH sur ta VM Linux** pour que tu puisses **te connecter depuis ton PC Windows**.

### Situation FINALE :

```
[WEB] Tu ouvres PowerShell (ou PuTTY)
│
└─ Tu tapes : ssh pierre@192.168.1.100
   │
   └─ Tu es connecté à la VM ! [BRAVO]
      │
      └─ Tu tapes tes commandes confortablement
         [OK] Copier-coller possible
         [OK] Comme un vrai admin ! [SMILING_FACE_WITH_SUNGLASSES]
```

---

## [DOCS] ÉTAPE 0 : PRÉREQUIS

### [OK] Ce que tu dois avoir AVANT :

1. **VirtualBox** avec une VM Linux
2. **La VM en "Accès par pont"** (Bridged Adapter)
3. **Une IP fixe** (exemple : 192.168.1.100)
4. **Connexion Internet** fonctionnelle

---

## [PACKAGE] ÉTAPE 1 : INSTALLER LE SERVEUR SSH

### 1. Connecte-toi à ta VM

Ouvre VirtualBox, démarre ta VM.

### 2. Mets à jour la liste des paquets

```bash
sudo apt update
```

### 3. Installe OpenSSH Server

```bash
sudo apt install openssh-server -y
```

**Résultat attendu :**

```
Setting up openssh-server (1:9.0p1-1ubuntu7) ...
Creating SSH2 RSA key...
Created symlink /etc/systemd/system/multi-user.target.wants/ssh.service
```

[OK] Si tu vois "Created symlink", c'est installé ! [BRAVO]

### 4. Vérifie que SSH tourne

```bash
sudo systemctl status ssh
```

**Résultat attendu :**

```
[BLACK_CIRCLE] ssh.service - OpenBSD Secure Shell server
     Active: active (running)
              ^^^^^^^^^^^^
          IL TOURNE ! [OK]
     
Dec 06 12:00:00 ubuntu sshd[1501]: Server listening on 0.0.0.0 port 22.
                                                            ^^^^^^^^
                                                        PORT 22 [OK]
```

[OK] Si tu vois "active (running)" et "port 22", c'est parfait ! [BRAVO]

---

## [CONFIG] ÉTAPE 2 : CONFIGURER LE SERVEUR SSH

### [NETTOYAGE] Sauvegarder l'ancienne configuration

```bash
sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.backup
```

### [NOTE] Éditer la configuration

```bash
sudo nano /etc/ssh/sshd_config
```

### [RECHERCHE] Options importantes à configurer

#### 1⃣ Port SSH

Recherche : `Ctrl + W` puis tape `Port`

```bash
#Port 22
```

**Pour ce guide, on garde le port 22** (plus simple).

**Si tu veux le changer :**

```bash
Port 2222
```

---

#### 2⃣ Authentification par mot de passe

Recherche : `Ctrl + W` puis tape `PasswordAuthentication`

**Décommente et laisse sur `yes` :**

```bash
PasswordAuthentication yes
```

**[ATTENTION] On le mettra sur `no` après avoir configuré les clés SSH !**

---

#### 3⃣ Interdire la connexion root

Recherche : `Ctrl + W` puis tape `PermitRootLogin`

```bash
PermitRootLogin no
```

**Pourquoi ?** Force à se connecter avec un utilisateur normal puis faire `sudo`.

---

#### 4⃣ Utilisateurs autorisés (Optionnel mais recommandé)

Ajoute cette ligne à la FIN du fichier :

```bash
AllowUsers ton_nom_utilisateur
```

**Exemple :** Si ton utilisateur s'appelle `pierre` :

```bash
AllowUsers pierre
```

**[ATTENTION] Remplace par TON nom d'utilisateur !**

---

#### 5⃣ Bannière de connexion (Optionnel)

Recherche : `Ctrl + W` puis tape `Banner`

```bash
Banner /etc/ssh/ssh_banner
```

**Crée le fichier bannière :**

```bash
sudo nano /etc/ssh/ssh_banner
```

**Contenu exemple :**

```
╔════════════════════════════════════════════╗
║                                            ║
║        SERVEUR SSH - VM LINUX              ║
║                                            ║
║  [ATTENTION]  ACCÈS RESTREINT                       ║
║  [VERROUILLE] Connexion surveillée                   ║
║                                            ║
╚════════════════════════════════════════════╝
```

Sauvegarde : `Ctrl + O`, `Entrée`, `Ctrl + X`

---

#### 6⃣ Délai de connexion

Recherche : `Ctrl + W` puis tape `LoginGraceTime`

```bash
LoginGraceTime 1m
```

---

#### 7⃣ Nombre de tentatives

Recherche : `Ctrl + W` puis tape `MaxAuthTries`

```bash
MaxAuthTries 3
```

---

#### 8⃣ Désactiver X11 Forwarding

Recherche : `Ctrl + W` puis tape `X11Forwarding`

```bash
X11Forwarding no
```

---

### [LISTE] Configuration finale recommandée

Résumé des lignes à vérifier :

```bash
Port 22
PasswordAuthentication yes
PermitRootLogin no
AllowUsers pierre
Banner /etc/ssh/ssh_banner
LoginGraceTime 1m
MaxAuthTries 3
X11Forwarding no
```

### [SAUVEGARDE] Sauvegarder

Dans nano :
1. `Ctrl + O` (sauvegarder)
2. `Entrée`
3. `Ctrl + X` (quitter)

### [OK] Vérifier la syntaxe

```bash
sudo sshd -t
```

**Si aucun message :** [OK] Configuration correcte !

**Si erreur :**

```bash
# Voir la ligne problématique (exemple ligne 45)
sed -n '45p' /etc/ssh/sshd_config
```

### [SYNC] Redémarrer SSH

```bash
sudo systemctl restart ssh
```

**Vérifier :**

```bash
sudo systemctl status ssh
```

---

## [HOT] ÉTAPE 3 : CONFIGURER LE PARE-FEU (UFW)

### [PACKAGE] Installer UFW

```bash
sudo apt install ufw -y
```

### [OUTIL] Configurer UFW

#### 1. Autoriser SSH (AVANT d'activer le pare-feu)

```bash
sudo ufw allow ssh
```

**Ou :**

```bash
sudo ufw allow 22/tcp
```

#### 2. Si tu as changé le port SSH (exemple 2222)

```bash
sudo ufw allow 2222/tcp
```

#### 3. Activer le pare-feu

```bash
sudo ufw enable
```

**Message :**

```
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
```

Tape `y` puis `Entrée`.

#### 4. Vérifier le statut

```bash
sudo ufw status
```

**Résultat attendu :**

```
Status: active

To                         Action      From
--                         ------      ----
22/tcp                     ALLOW       Anywhere
22/tcp (v6)                ALLOW       Anywhere (v6)
```

[OK] Le port 22 est autorisé ! [BRAVO]

---

## [TEST] ÉTAPE 4 : TESTER LA CONNEXION DEPUIS WINDOWS

### [CODE] Méthode 1 : PowerShell (Windows 10/11)

**Windows 10/11 a SSH intégré dans PowerShell !**

#### 1. Ouvre PowerShell

- Appuie sur `Windows + X`
- Sélectionne "Windows PowerShell"

#### 2. Connecte-toi à la VM

```powershell
ssh pierre@192.168.1.100
```

**[ATTENTION] Remplace :**
- `pierre` par TON nom d'utilisateur Linux
- `192.168.1.100` par l'IP de TA VM

**Premier message (normal) :**

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

**Explication :**
- C'est la PREMIÈRE connexion
- SSH te demande de confirmer que c'est bien le bon serveur
- Tape `yes` puis `Entrée`

**Message suivant :**

```
Warning: Permanently added '192.168.1.100' (ED25519) to the list of known hosts.
pierre@192.168.1.100's password:
```

**Tape ton mot de passe Linux** (il ne s'affichera pas, c'est normal).

**Si la bannière est configurée, tu la verras :**

```
╔════════════════════════════════════════════╗
║        SERVEUR SSH - VM LINUX              ║
╚════════════════════════════════════════════╝
```

**Puis :**

```
Welcome to Ubuntu 22.04 LTS (GNU/Linux 5.15.0-91-generic x86_64)

Last login: Fri Dec  6 12:45:00 2024 from 192.168.1.10
pierre@ubuntu:~$ 
         ^^^^^^
    TU ES CONNECTÉ ! [BRAVO]
```

#### 3. Teste des commandes

```bash
# Voir où tu es
pwd

# Afficher le nom du serveur
hostname

# Voir l'IP
ip a

# Créer un fichier de test
echo "Test SSH" > test.txt

# Voir le fichier
cat test.txt
```

#### 4. Se déconnecter

```bash
exit
```

**Ou :** `Ctrl + D`

---

### [ECRAN] Méthode 2 : PuTTY (Windows 7/8 ou alternative)

**Si PowerShell ne marche pas, utilise PuTTY.**

#### 1. Télécharge PuTTY

Va sur : https://www.putty.org/

Télécharge : `putty.exe` (version 64-bit)

#### 2. Lance PuTTY

Double-clique sur `putty.exe`.

#### 3. Configure la connexion

**Dans la fenêtre PuTTY :**

```
Host Name (or IP address) : 192.168.1.100
Port : 22
Connection type : SSH
```

**[ATTENTION] Remplace `192.168.1.100` par l'IP de ta VM.**

#### 4. (Optionnel) Sauvegarde la session

- Dans "Saved Sessions", tape un nom : `VM Linux`
- Clique sur "Save"
- La prochaine fois, tu pourras juste double-cliquer sur "VM Linux"

#### 5. Connecte-toi

Clique sur "Open".

**Premier message :**

```
PuTTY Security Alert

The server's host key is not cached in the registry.
...
Do you trust this host?
```

Clique sur "Accept".

**Puis :**

```
login as: pierre
pierre@192.168.1.100's password:
```

Tape ton mot de passe.

**Tu es connecté ! [BRAVO]**

---

## [CLE] ÉTAPE 5 : CONFIGURER LES CLÉS SSH (SÉCURITÉ MAXIMALE)

### [REFLEXION] Pourquoi des clés SSH ?

**Authentification par clé = BEAUCOUP plus sécurisé que le mot de passe.**

**Avantages :**
- [OK] Impossible à attaquer par force brute
- [OK] Pas besoin de taper le mot de passe
- [OK] Tu peux désactiver complètement les mots de passe

### [LISTE] Processus en 3 étapes :

1. **Générer une paire de clés** sur Windows (clé publique + clé privée)
2. **Copier la clé publique** sur la VM
3. **Désactiver l'authentification par mot de passe** sur la VM

---

### [SECURISE] Étape 5.1 : Générer les clés SSH (Windows)

#### Avec PowerShell

**1. Ouvre PowerShell**

**2. Génère les clés**

```powershell
ssh-keygen -t ed25519 -C "ton_email@exemple.com"
```

**Explication :**
- `ssh-keygen` = Programme pour générer des clés
- `-t ed25519` = Type de clé (ed25519 = moderne, rapide, sécurisé)
- `-C "..."` = Commentaire (pour identifier la clé)

**Message :**

```
Generating public/private ed25519 key pair.
Enter file in which to save the key (C:\Users\TonNom/.ssh/id_ed25519):
```

**Appuie sur `Entrée`** (accepte l'emplacement par défaut).

**Message suivant :**

```
Enter passphrase (empty for no passphrase):
```

**Options :**

**Option A : Pas de passphrase (plus simple)**
- Appuie sur `Entrée` deux fois (passphrase vide)

**Option B : Avec passphrase (plus sécurisé)**
- Tape un mot de passe fort
- Confirme-le
- **Avantage :** Si quelqu'un vole ta clé privée, il ne pourra pas l'utiliser sans la passphrase

**Pour ce guide, on va choisir SANS passphrase** (appuie sur `Entrée` deux fois).

**Résultat :**

```
Your identification has been saved in C:\Users\TonNom/.ssh/id_ed25519
Your public key has been saved in C:\Users\TonNom/.ssh/id_ed25519.pub
The key fingerprint is:
SHA256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ton_email@exemple.com
The key's randomart image is:
+--[ED25519 256]--+
|        .o+*B*o  |
|         +=*=*.  |
|        ..=oB+   |
|         o.*o .  |
|        S o. .   |
|       . o  .    |
|        E  .     |
|         ..      |
|          ..     |
+----[SHA256]-----+
```

[OK] **Clés générées ! [BRAVO]**

**Tu as maintenant 2 fichiers :**
- `id_ed25519` = Clé PRIVÉE (garde-la SECRÈTE !)
- `id_ed25519.pub` = Clé PUBLIQUE (tu peux la partager)

---

### [SORTIE] Étape 5.2 : Copier la clé publique sur la VM

#### Méthode 1 : Commande `ssh-copy-id` (PowerShell moderne)

**Cette commande copie automatiquement ta clé publique sur le serveur.**

```powershell
type $env:USERPROFILE\.ssh\id_ed25519.pub | ssh pierre@192.168.1.100 "cat >> ~/.ssh/authorized_keys"
```

**[ATTENTION] Remplace `pierre` et `192.168.1.100` par tes valeurs !**

**On te demandera ton mot de passe (dernière fois !).**

**Résultat :**

```
pierre@192.168.1.100's password: [tape ton mot de passe]
```

[OK] **Clé copiée !**

---

#### Méthode 2 : Copie manuelle (alternative)

**1. Affiche ta clé publique**

```powershell
type $env:USERPROFILE\.ssh\id_ed25519.pub
```

**Résultat (exemple) :**

```
ssh-ed25519 AAAAxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ton_email@exemple.com
```

**Sélectionne et copie TOUTE cette ligne** (de `ssh-ed25519` jusqu'au mail).

**2. Connecte-toi à la VM**

```powershell
ssh pierre@192.168.1.100
```

**3. Crée le dossier `.ssh` (s'il n'existe pas)**

```bash
mkdir -p ~/.ssh
```

**4. Crée/édite le fichier `authorized_keys`**

```bash
nano ~/.ssh/authorized_keys
```

**5. Colle ta clé publique**

- Clic droit dans nano (ou `Shift + Insert`)
- La ligne complète doit être collée

**6. Sauvegarde**

- `Ctrl + O`, `Entrée`, `Ctrl + X`

**7. Change les permissions (IMPORTANT !)**

```bash
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
```

**Explication :**
- `700` = Seul le propriétaire peut lire/écrire/exécuter
- `600` = Seul le propriétaire peut lire/écrire
- SSH REFUSE de fonctionner si les permissions sont trop ouvertes

**8. Déconnecte-toi**

```bash
exit
```

---

### [OK] Étape 5.3 : Tester la connexion par clé

**Depuis PowerShell, reconnecte-toi :**

```powershell
ssh pierre@192.168.1.100
```

**Cette fois, PAS de mot de passe demandé ! [BRAVO]**

**Tu es connecté directement :**

```
Welcome to Ubuntu 22.04 LTS
Last login: Fri Dec  6 13:00:00 2024 from 192.168.1.10
pierre@ubuntu:~$ 
```

[OK] **L'authentification par clé fonctionne ! [BRAVO]**

---

### [VERROUILLE] Étape 5.4 : Désactiver l'authentification par mot de passe

**Maintenant que les clés fonctionnent, on peut désactiver les mots de passe.**

**Dans la VM :**

```bash
sudo nano /etc/ssh/sshd_config
```

**Trouve et modifie :**

```bash
PasswordAuthentication no
```

**Sauvegarde :** `Ctrl + O`, `Entrée`, `Ctrl + X`

**Vérifie la syntaxe :**

```bash
sudo sshd -t
```

**Redémarre SSH :**

```bash
sudo systemctl restart ssh
```

**Déconnecte-toi :**

```bash
exit
```

---

### [TEST] Tester que les mots de passe sont désactivés

**1. Essaie de te connecter depuis un AUTRE PC (qui n'a pas la clé)**

**Ou renomme temporairement ta clé privée :**

```powershell
Rename-Item $env:USERPROFILE\.ssh\id_ed25519 id_ed25519.bak
```

**2. Essaie de te connecter :**

```powershell
ssh pierre@192.168.1.100
```

**Résultat attendu :**

```
pierre@192.168.1.100: Permission denied (publickey).
```

[OK] **Les mots de passe sont bien désactivés ! Seules les clés SSH fonctionnent.**

**3. Restore ta clé :**

```powershell
Rename-Item $env:USERPROFILE\.ssh\id_ed25519.bak id_ed25519
```

---

## [GRAPHIQUE] ÉTAPE 6 : SURVEILLER LES CONNEXIONS SSH

### [RECHERCHE] Voir les connexions actuelles

**Dans la VM :**

```bash
who
```

**Résultat (exemple) :**

```
pierre   pts/0        2024-12-06 13:15 (192.168.1.10)
```

**Explication :**
- `pierre` = Utilisateur connecté
- `pts/0` = Terminal virtuel numéro 0
- `192.168.1.10` = IP du client

**Voir plus de détails :**

```bash
w
```

**Résultat :**

```
 13:20:05 up  1:30,  1 user,  load average: 0.00, 0.00, 0.00
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
pierre   pts/0    192.168.1.10     13:15    0.00s  0.02s  0.00s w
```

---

### [DOC] Voir les logs SSH

**Commande pour voir les dernières connexions :**

```bash
sudo journalctl -u ssh -n 50
```

**Explication :**
- `journalctl` = Gestionnaire de logs système
- `-u ssh` = Uniquement les logs SSH
- `-n 50` = Les 50 dernières lignes

**Voir les logs en temps réel :**

```bash
sudo journalctl -u ssh -f
```

**Pour arrêter :** `Ctrl + C`

---

### [VERROUILLE] Voir les tentatives de connexion échouées

```bash
sudo grep "Failed password" /var/log/auth.log
```

**Résultat (exemple) :**

```
Dec  6 12:30:15 ubuntu sshd[2345]: Failed password for invalid user admin from 203.0.113.42 port 51234 ssh2
Dec  6 12:30:20 ubuntu sshd[2346]: Failed password for root from 203.0.113.42 port 51235 ssh2
```

**Explication :**
- Des robots essaient de se connecter avec des mots de passe communs
- Ils tentent `admin`, `root`, etc.
- **C'est normal !** Ton serveur est protégé.

---

### [SECURITE] Installer Fail2Ban (Protection automatique)

**Fail2Ban = Ban automatique des IPs qui échouent trop souvent**

#### Installation :

```bash
sudo apt install fail2ban -y
```

#### Configuration :

```bash
sudo nano /etc/fail2ban/jail.local
```

**Ajoute :**

```bash
[sshd]
enabled = true
port = 22
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
bantime = 3600
findtime = 600
```

**Explication :**
- `maxretry = 3` = 3 échecs maximum
- `bantime = 3600` = Ban pour 1 heure (3600 secondes)
- `findtime = 600` = Dans une fenêtre de 10 minutes

**Sauvegarde et démarre Fail2Ban :**

```bash
sudo systemctl restart fail2ban
sudo systemctl enable fail2ban
```

**Voir les IPs bannies :**

```bash
sudo fail2ban-client status sshd
```

---

## [BRAVO] RÉCAPITULATIF FINAL

### Ce qu'on a fait :

[OK] **Installé OpenSSH Server** sur la VM
[OK] **Configuré SSH** (port, utilisateurs, sécurité)
[OK] **Configuré le pare-feu** (UFW)
[OK] **Testé la connexion** depuis Windows
[OK] **Configuré les clés SSH** (sécurité maximale)
[OK] **Désactivé les mots de passe**
[OK] **Surveillé les connexions**

### Commandes essentielles :

```bash
# Connexion depuis Windows
ssh pierre@192.168.1.100

# Copier un fichier vers la VM
scp fichier.txt pierre@192.168.1.100:~/

# Copier un fichier depuis la VM
scp pierre@192.168.1.100:~/fichier.txt .

# Voir les connexions actives
who

# Voir les logs SSH
sudo journalctl -u ssh -f

# Redémarrer SSH après modification
sudo systemctl restart ssh
```

---

## [RAPIDE] ALLER PLUS LOIN

### Connexion automatique avec un alias

**Dans PowerShell, crée un profil :**

```powershell
notepad $PROFILE
```

**Ajoute :**

```powershell
function vm { ssh pierre@192.168.1.100 }
```

**Sauvegarde. Maintenant, tu peux juste taper :**

```powershell
vm
```

**Et tu es connecté ! [RAPIDE]**

---

### Transférer des fichiers (SCP)

**Copier un fichier vers la VM :**

```powershell
scp C:\Users\TonNom\fichier.txt pierre@192.168.1.100:~/
```

**Copier un fichier depuis la VM :**

```powershell
scp pierre@192.168.1.100:~/fichier.txt C:\Users\TonNom\
```

---

### Monter un dossier distant (SSHFS)

**Installer SSHFS sur Windows :** https://github.com/winfsp/sshfs-win

**Monter le dossier home de la VM :**

```powershell
net use Z: \\sshfs\pierre@192.168.1.100
```

**Maintenant, tu accèdes à la VM comme à un disque dur local ! [BRAVO]**

---

## [TEST] ÉTAPE 7 : TESTS PRATIQUES DEPUIS WINDOWS

### Test 1 : Connexion simple avec PowerShell

**Ouvre PowerShell et connecte-toi :**

```powershell
ssh pierre@192.168.1.100
```

**Résultat attendu :**

```
Welcome to Ubuntu 22.04 LTS (GNU/Linux 5.15.0-91-generic x86_64)

pierre@ubuntu:~$ 
```

[OK] **Si tu vois ça, la connexion fonctionne !**

---

### Test 2 : Vérifier les informations système

**Une fois connecté, tape :**

```bash
# Voir la version du système
lsb_release -a

# Voir l'uptime (depuis combien de temps le serveur tourne)
uptime

# Voir l'utilisation de la mémoire
free -h

# Voir l'espace disque
df -h

# Voir les processus en cours
top
```

**Pour quitter `top` :** Appuie sur `q`

---

### Test 3 : Créer un fichier depuis SSH

```bash
# Créer un fichier
echo "Test SSH depuis Windows" > test_ssh.txt

# Vérifier qu'il existe
ls -l test_ssh.txt

# Voir son contenu
cat test_ssh.txt
```

**Résultat attendu :**

```
Test SSH depuis Windows
```

---

### Test 4 : Transférer un fichier (Windows -> VM)

**1. Crée un fichier sur Windows**

**Dans PowerShell :**

```powershell
# Crée un fichier de test
echo "Fichier depuis Windows" > C:\Users\$env:USERNAME\Desktop\test_windows.txt
```

**2. Copie-le vers la VM avec SCP**

```powershell
scp C:\Users\$env:USERNAME\Desktop\test_windows.txt pierre@192.168.1.100:~/
```

**Résultat attendu :**

```
test_windows.txt                              100%   22     0.5KB/s   00:00
```

[OK] **Fichier transféré !**

**3. Vérifie sur la VM**

**Connecte-toi à la VM :**

```powershell
ssh pierre@192.168.1.100
```

**Vérifie le fichier :**

```bash
ls -l test_windows.txt
cat test_windows.txt
```

**Résultat :**

```
Fichier depuis Windows
```

[OK] **Le fichier est bien là ! [BRAVO]**

---

### Test 5 : Transférer un fichier (VM -> Windows)

**1. Crée un fichier sur la VM**

**Dans la VM :**

```bash
echo "Fichier depuis la VM" > test_vm.txt
```

**Déconnecte-toi :**

```bash
exit
```

**2. Copie-le vers Windows avec SCP**

**Dans PowerShell :**

```powershell
scp pierre@192.168.1.100:~/test_vm.txt C:\Users\$env:USERNAME\Desktop\
```

**3. Vérifie sur Windows**

```powershell
type C:\Users\$env:USERNAME\Desktop\test_vm.txt
```

**Résultat :**

```
Fichier depuis la VM
```

[OK] **Le fichier est bien arrivé ! [BRAVO]**

---

### Test 6 : Copier un dossier entier

**Créons un dossier avec plusieurs fichiers sur Windows :**

```powershell
# Crée un dossier
mkdir C:\Users\$env:USERNAME\Desktop\projet_test

# Crée des fichiers dedans
echo "Fichier 1" > C:\Users\$env:USERNAME\Desktop\projet_test\file1.txt
echo "Fichier 2" > C:\Users\$env:USERNAME\Desktop\projet_test\file2.txt
echo "Fichier 3" > C:\Users\$env:USERNAME\Desktop\projet_test\file3.txt
```

**Copie le dossier complet vers la VM :**

```powershell
scp -r C:\Users\$env:USERNAME\Desktop\projet_test pierre@192.168.1.100:~/
```

**Explication :**
- `-r` = Récursif (copie le dossier ET son contenu)

**Vérifie sur la VM :**

```powershell
ssh pierre@192.168.1.100
```

```bash
ls -l projet_test/
cat projet_test/file1.txt
```

[OK] **Le dossier complet a été copié ! [BRAVO]**

---

### Test 7 : Exécuter une commande à distance (sans se connecter)

**Tu peux exécuter UNE commande sur la VM sans ouvrir une session interactive.**

**Exemple : Voir l'uptime de la VM**

```powershell
ssh pierre@192.168.1.100 "uptime"
```

**Résultat :**

```
 13:45:23 up  2:15,  1 user,  load average: 0.00, 0.01, 0.05
```

**Autre exemple : Créer un fichier à distance**

```powershell
ssh pierre@192.168.1.100 "echo 'Créé depuis Windows' > distant.txt"
```

**Vérifier :**

```powershell
ssh pierre@192.168.1.100 "cat distant.txt"
```

**Résultat :**

```
Créé depuis Windows
```

**Cas d'usage pratique : Redémarrer un service**

```powershell
ssh pierre@192.168.1.100 "sudo systemctl restart apache2"
```

---

### Test 8 : Tunneling SSH (Accéder à un port distant)

**Le tunneling SSH permet d'accéder à un service qui tourne sur la VM depuis ton PC.**

**Exemple : Si tu as un serveur web sur la VM (port 80)**

#### Scénario :

```
VM : Serveur web sur http://localhost:80
     Accessible SEULEMENT depuis la VM

Problème : Tu veux y accéder depuis ton navigateur Windows
```

#### Solution : Tunnel SSH

```powershell
ssh -L 8080:localhost:80 pierre@192.168.1.100
```

**Explication :**
- `-L` = Local port forwarding (transfert de port local)
- `8080` = Port sur TON PC Windows
- `localhost:80` = Port sur la VM
- **Signifie :** "Redirige le port 8080 de mon PC vers le port 80 de la VM"

**Maintenant, dans ton navigateur Windows :**

```
http://localhost:8080
```

**Tu verras le site web de la VM ! [BRAVO]**

**La connexion reste ouverte. Pour arrêter, tape `exit` dans le terminal.**

---

### Test 9 : Connexion avec PuTTY (Alternative graphique)

**Si tu préfères une interface graphique, utilise PuTTY.**

#### Configuration PuTTY avec clé SSH

**1. Convertir la clé SSH en format PuTTY**

PuTTY utilise un format différent (`.ppk`).

**Télécharge PuTTYgen :** https://www.putty.org/

**Lance PuTTYgen :**

1. Clique sur "Load"
2. Va dans `C:\Users\TonNom\.ssh\`
3. Change le filtre en bas : "All Files (*.*)"
4. Sélectionne `id_ed25519` (la clé PRIVÉE)
5. Clique sur "Save private key"
6. Ignore l'avertissement sur la passphrase
7. Sauvegarde sous : `id_ed25519.ppk`

**2. Configure PuTTY**

**Lance PuTTY :**

- **Host Name :** `192.168.1.100`
- **Port :** `22`
- **Connection type :** `SSH`

**Puis, dans le menu de gauche :**

- Va dans : `Connection -> SSH -> Auth -> Credentials`
- **Private key file :** Clique sur "Browse"
- Sélectionne `id_ed25519.ppk`

**Retourne dans "Session" :**

- **Saved Sessions :** Tape `VM Linux`
- Clique sur "Save"

**3. Connecte-toi**

- Double-clique sur "VM Linux" dans la liste
- **Login as :** Tape `pierre`
- Tu es connecté automatiquement (sans mot de passe) ! [BRAVO]

---

### Test 10 : Vérifier la sécurité SSH

**Connecte-toi à la VM et vérifie la configuration :**

```bash
# Vérifier que le mot de passe est désactivé
sudo grep "PasswordAuthentication" /etc/ssh/sshd_config

# Résultat attendu :
# PasswordAuthentication no
```

[OK] **Si tu vois `no`, les mots de passe sont bien désactivés.**

```bash
# Vérifier que root ne peut pas se connecter
sudo grep "PermitRootLogin" /etc/ssh/sshd_config

# Résultat attendu :
# PermitRootLogin no
```

[OK] **Si tu vois `no`, root ne peut pas se connecter.**

```bash
# Voir le port SSH
sudo grep "^Port" /etc/ssh/sshd_config

# Si rien n'apparaît, c'est le port 22 par défaut
```

---

### Test 11 : Tester Fail2Ban (si installé)

**1. Simule des échecs de connexion**

**Depuis un AUTRE PC (ou renomme ta clé temporairement) :**

```powershell
# Renomme la clé
Rename-Item $env:USERPROFILE\.ssh\id_ed25519 id_ed25519.bak
```

**Essaie de te connecter 4 fois avec un mauvais mot de passe :**

```powershell
ssh pierre@192.168.1.100
```

**Après 3 échecs, ton IP sera bannie pendant 1 heure.**

**2. Vérifie sur la VM**

```bash
# Voir les IPs bannies
sudo fail2ban-client status sshd
```

**Résultat :**

```
Status for the jail: sshd
|- Filter
|  |- Currently failed: 0
|  |- Total failed:     3
|  `- File list:        /var/log/auth.log
`- Actions
   |- Currently banned: 1
   |- Total banned:     1
   `- Banned IP list:   192.168.1.10
                         ^^^^^^^^^^^
                    TON IP EST BANNIE !
```

**3. Débanner ton IP (pour continuer les tests)**

```bash
sudo fail2ban-client set sshd unbanip 192.168.1.10
```

**4. Restore ta clé**

```powershell
Rename-Item $env:USERPROFILE\.ssh\id_ed25519.bak id_ed25519
```

---

### Test 12 : Session SSH persistante (Screen/Tmux)

**Problème :** Si tu te déconnectes, tous les programmes en cours s'arrêtent.

**Solution :** Utilise `screen` ou `tmux` pour créer des sessions persistantes.

#### Installation de Screen

```bash
sudo apt install screen -y
```

#### Utilisation

**1. Démarre une session screen**

```bash
screen -S ma_session
```

**2. Lance un programme long**

```bash
# Par exemple, un ping infini
ping 8.8.8.8
```

**3. Détache la session**

Appuie sur : `Ctrl + A` puis `D`

**Tu es déconnecté de la session, MAIS le ping continue !**

**4. Déconnecte-toi complètement de SSH**

```bash
exit
```

**5. Reconnecte-toi**

```powershell
ssh pierre@192.168.1.100
```

**6. Rattache la session**

```bash
screen -r ma_session
```

**Le ping est toujours en cours ! [BRAVO]**

**Pour arrêter :** `Ctrl + C` puis tape `exit`

---

## [RECHERCHE] ÉTAPE 8 : DÉPANNAGE (TROUBLESHOOTING)

### Problème 1 : "Connection refused"

**Erreur :**

```
ssh: connect to host 192.168.1.100 port 22: Connection refused
```

**Causes possibles :**

#### Cause 1 : SSH n'est pas démarré

**Solution :**

```bash
sudo systemctl start ssh
sudo systemctl enable ssh
```

#### Cause 2 : Le pare-feu bloque le port 22

**Vérifier :**

```bash
sudo ufw status
```

**Si le port 22 n'est pas autorisé :**

```bash
sudo ufw allow 22/tcp
```

#### Cause 3 : Mauvaise IP

**Vérifier l'IP de la VM :**

```bash
ip a
```

**Cherche l'IP qui commence par `192.168.1.X`**

---

### Problème 2 : "Permission denied (publickey)"

**Erreur :**

```
pierre@192.168.1.100: Permission denied (publickey).
```

**Causes possibles :**

#### Cause 1 : La clé publique n'est pas sur le serveur

**Solution :**

Recommence l'Étape 5.2 (Copier la clé publique).

#### Cause 2 : Mauvaises permissions sur `.ssh`

**Sur la VM :**

```bash
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
```

#### Cause 3 : Mauvaise clé privée

**Vérifie que tu utilises la bonne clé :**

```powershell
ls $env:USERPROFILE\.ssh\
```

**Tu dois voir `id_ed25519` et `id_ed25519.pub`**

---

### Problème 3 : "WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!"

**Erreur complète :**

```
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
```

**Cause :**

Tu as réinstallé SSH sur la VM, ou l'IP a changé d'appareil.

**Solution :**

**Supprime l'ancienne entrée :**

```powershell
ssh-keygen -R 192.168.1.100
```

**Puis reconnecte-toi (tu devras re-accepter la nouvelle clé) :**

```powershell
ssh pierre@192.168.1.100
```

---

### Problème 4 : "Connection timed out"

**Erreur :**

```
ssh: connect to host 192.168.1.100 port 22: Connection timed out
```

**Causes possibles :**

#### Cause 1 : La VM n'est pas sur le même réseau

**Vérifie que la VM est en "Accès par pont" (Bridged Adapter).**

**Dans VirtualBox :**

1. Éteins la VM
2. Configuration -> Réseau
3. Mode d'accès réseau : **Accès par pont**

#### Cause 2 : Pare-feu Windows bloque SSH

**Autorise SSH dans le pare-feu Windows :**

1. Panneau de configuration
2. Pare-feu Windows Defender
3. Paramètres avancés
4. Règles de sortie
5. Nouvelle règle
6. Port -> TCP -> 22
7. Autoriser

---

### Problème 5 : SSH fonctionne mais c'est TRÈS lent

**Cause possible : Problème de résolution DNS**

**Solution :**

**Sur la VM, édite `/etc/ssh/sshd_config` :**

```bash
sudo nano /etc/ssh/sshd_config
```

**Ajoute cette ligne :**

```bash
UseDNS no
```

**Redémarre SSH :**

```bash
sudo systemctl restart ssh
```

---

### Problème 6 : "Too many authentication failures"

**Erreur :**

```
Received disconnect from 192.168.1.100: Too many authentication failures
```

**Cause :**

Tu as plusieurs clés SSH et SSH essaie toutes les clés avant la bonne.

**Solution :**

**Spécifie quelle clé utiliser :**

```powershell
ssh -i $env:USERPROFILE\.ssh\id_ed25519 pierre@192.168.1.100
```

**Ou crée un fichier config SSH :**

```powershell
notepad $env:USERPROFILE\.ssh\config
```

**Contenu :**

```
Host vm
    HostName 192.168.1.100
    User pierre
    IdentityFile ~/.ssh/id_ed25519
    IdentitiesOnly yes
```

**Maintenant, tu peux juste taper :**

```powershell
ssh vm
```

---

## [DOCS] ÉTAPE 9 : CONFIGURATION SSH AVANCÉE

### Créer un fichier config SSH (sur Windows)

**Le fichier config permet de créer des raccourcis pour tes serveurs.**

**Crée le fichier :**

```powershell
notepad $env:USERPROFILE\.ssh\config
```

**Exemple de configuration :**

```
# VM Linux principale
Host vm
    HostName 192.168.1.100
    User pierre
    Port 22
    IdentityFile ~/.ssh/id_ed25519

# VM de test
Host vm-test
    HostName 192.168.1.101
    User admin
    Port 2222
    IdentityFile ~/.ssh/id_rsa

# Serveur de production (exemple)
Host prod
    HostName exemple.com
    User deployer
    Port 22
    IdentityFile ~/.ssh/id_prod
    ForwardAgent yes
```

**Maintenant, tu peux te connecter avec :**

```powershell
ssh vm
ssh vm-test
ssh prod
```

**Beaucoup plus simple ! [BRAVO]**

---

### Copier plusieurs fichiers en une commande

**Copier plusieurs fichiers vers la VM :**

```powershell
scp file1.txt file2.txt file3.txt pierre@192.168.1.100:~/documents/
```

**Copier avec un motif (wildcard) :**

```powershell
scp *.txt pierre@192.168.1.100:~/documents/
```

**Copier tous les fichiers d'un dossier :**

```powershell
scp -r C:\projet\* pierre@192.168.1.100:~/projet/
```

---

### Synchroniser des dossiers (avec rsync)

**Rsync est plus puissant que SCP : il ne copie que les fichiers modifiés.**

**Installation sur la VM :**

```bash
sudo apt install rsync -y
```

**Utilisation depuis Windows (avec WSL ou Git Bash) :**

```bash
rsync -avz --progress /c/Users/TonNom/projet/ pierre@192.168.1.100:~/projet/
```

**Explication :**
- `-a` = Archive (préserve permissions, dates)
- `-v` = Verbose (affiche les détails)
- `-z` = Compression
- `--progress` = Affiche la progression

---

### Utiliser un agent SSH (pour ne pas retaper la passphrase)

**Si tu as mis une passphrase sur ta clé, tu dois la taper à chaque connexion.**

**Solution : Utilise un agent SSH qui mémorise la passphrase.**

**Démarre l'agent SSH :**

```powershell
Start-Service ssh-agent
```

**Ajoute ta clé :**

```powershell
ssh-add $env:USERPROFILE\.ssh\id_ed25519
```

**Entre ta passphrase (une seule fois).**

**Maintenant, tu peux te connecter sans retaper la passphrase ! [BRAVO]**

---

## [SECURITE] ÉTAPE 10 : SÉCURITÉ AVANCÉE

### Changer le port SSH (22 -> 2222)

**Pourquoi ?** Le port 22 est scanné en permanence par des robots.

**1. Sur la VM, édite la config SSH :**

```bash
sudo nano /etc/ssh/sshd_config
```

**Change :**

```bash
Port 2222
```

**2. Mets à jour le pare-feu :**

```bash
sudo ufw allow 2222/tcp
sudo ufw delete allow 22/tcp
```

**3. Redémarre SSH :**

```bash
sudo systemctl restart ssh
```

**4. Depuis Windows, connecte-toi avec le nouveau port :**

```powershell
ssh -p 2222 pierre@192.168.1.100
```

**Ou dans ton fichier config :**

```
Host vm
    HostName 192.168.1.100
    User pierre
    Port 2222
    IdentityFile ~/.ssh/id_ed25519
```

---

### Désactiver les connexions root (déjà fait)

**Vérifier :**

```bash
sudo grep "PermitRootLogin" /etc/ssh/sshd_config
```

**Doit afficher :**

```
PermitRootLogin no
```

[OK] **Root ne peut pas se connecter directement.**

---

### Autoriser uniquement certaines IPs (optionnel)

**Si tu veux que SEULEMENT ton PC puisse se connecter :**

**Édite la config SSH :**

```bash
sudo nano /etc/ssh/sshd_config
```

**Ajoute :**

```bash
AllowUsers pierre@192.168.1.10
```

**[ATTENTION] Remplace `192.168.1.10` par l'IP de TON PC Windows !**

**Redémarre SSH :**

```bash
sudo systemctl restart ssh
```

**Maintenant, seule l'IP `192.168.1.10` peut se connecter.**

---

### Activer la double authentification (2FA)

**Pour une sécurité ultime, tu peux activer l'authentification à deux facteurs.**

**Installation de Google Authenticator :**

```bash
sudo apt install libpam-google-authenticator -y
```

**Configuration :**

```bash
google-authenticator
```

**Réponds :**

- Do you want authentication tokens to be time-based? **Y**
- Scanne le QR code avec Google Authenticator sur ton téléphone
- Do you want me to update your "~/.google_authenticator" file? **Y**
- Do you want to disallow multiple uses? **Y**
- Do you want to do so? **N** (sauf si décalage horaire)
- Do you want to enable rate-limiting? **Y**

**Édite PAM :**

```bash
sudo nano /etc/pam.d/sshd
```

**Ajoute EN HAUT :**

```bash
auth required pam_google_authenticator.so
```

**Édite SSH config :**

```bash
sudo nano /etc/ssh/sshd_config
```

**Change :**

```bash
ChallengeResponseAuthentication yes
```

**Redémarre SSH :**

```bash
sudo systemctl restart ssh
```

**Maintenant, quand tu te connectes, il faudra :**
1. Ta clé SSH
2. Le code à 6 chiffres de Google Authenticator

**Sécurité maximale ! [VERROUILLE]**

---

## [COURS] RÉCAPITULATIF COMPLET

### [OK] Ce qu'on a appris :

1. **Les bases de SSH** (qu'est-ce que c'est, comment ça marche)
2. **Installation et configuration** d'OpenSSH Server
3. **Sécurisation** (pare-feu, clés SSH, désactivation mots de passe)
4. **Tests pratiques** (connexion, transfert de fichiers)
5. **Dépannage** (résolution des problèmes courants)
6. **Configuration avancée** (fichier config, tunneling, rsync)
7. **Sécurité avancée** (port custom, 2FA, restrictions IP)

### [NOTE] Commandes essentielles :

```bash
# CONNEXION
ssh utilisateur@ip                    # Connexion basique
ssh -p 2222 utilisateur@ip           # Avec port custom
ssh vm                               # Avec fichier config

# TRANSFERT DE FICHIERS
scp fichier.txt user@ip:~/           # Copier un fichier
scp -r dossier/ user@ip:~/           # Copier un dossier
scp user@ip:~/fichier.txt .          # Récupérer un fichier

# EXÉCUTION À DISTANCE
ssh user@ip "commande"               # Exécuter une commande

# TUNNELING
ssh -L 8080:localhost:80 user@ip     # Tunnel SSH

# GESTION SSH (sur la VM)
sudo systemctl status ssh            # Voir le statut
sudo systemctl restart ssh           # Redémarrer
sudo sshd -t                         # Tester la config

# SURVEILLANCE
who                                  # Voir les connexions
sudo journalctl -u ssh -f            # Logs en temps réel
sudo fail2ban-client status sshd     # IPs bannies
```

### [BRAVO] Tu es maintenant un expert SSH ! [BRAVO]

Tu sais :
- [OK] Installer et configurer un serveur SSH
- [OK] Te connecter depuis Windows en toute sécurité
- [OK] Utiliser les clés SSH (sécurité maximale)
- [OK] Transférer des fichiers
- [OK] Dépanner les problèmes
- [OK] Sécuriser ton serveur comme un pro

**Bravo ! [RAPIDE]**

# [MONDE] CONNEXION SSH ENTRE DEUX MACHINES DISTANTES (FRANCE <-> SÉNÉGAL)

## [OBJECTIF] OBJECTIF DU GUIDE

Connecter deux ordinateurs situés dans **deux pays différents** via SSH, en comprenant **TOUS les détails techniques**.

### [IMPORTANT] Scénario :

```
[FR] FRANCE                          [SN] SÉNÉGAL
┌─────────────────┐                ┌─────────────────┐
│  PC Windows     │                │  Serveur Linux  │
│  IP Locale:     │                │  IP Locale:     │
│  192.168.1.10   │                │  192.168.1.100  │
│                 │                │                 │
│  Box Internet   │                │  Box Internet   │
│  IP Publique:   │                │  IP Publique:   │
│  85.20.XX.XX    │                │  41.82.XX.XX    │
└─────────────────┘                └─────────────────┘
        │                                  │
        └──────── INTERNET ────────────────┘
                 5000+ km
```

---

## [RECHERCHE] COMPRENDRE LE PROBLÈME

### [ATTENTION] Pourquoi c'est différent de la connexion locale ?

#### Connexion LOCALE (même réseau) :
```
PC Windows ──[WiFi/Ethernet]──-> VM Linux
192.168.1.10                    192.168.1.100

[OK] Direct
[OK] Même réseau
[OK] Pas de configuration spéciale
```

#### Connexion DISTANTE (Internet) :
```
PC France ──[Box]──[Internet]──[Box]──-> Serveur Sénégal
192.168.1.10   85.20.XX.XX   41.82.XX.XX   192.168.1.100
    │              │              │              │
  IP Privée    IP Publique   IP Publique    IP Privée

[X] Pas de connexion directe possible !
[X] Les IPs privées (192.168.X.X) ne sont pas accessibles depuis Internet
[X] Il faut une configuration spéciale
```

### [LOGIQUE] Les concepts clés à comprendre :

#### 1⃣ **IP Privée vs IP Publique**

**IP Privée (192.168.X.X, 10.X.X.X) :**
```
[ACCUEIL] Maison France                    [ACCUEIL] Maison Sénégal
│                                   │
├─ [MOBILE] Téléphone: 192.168.1.5       ├─ [MOBILE] Téléphone: 192.168.1.5
├─ [CODE] PC: 192.168.1.10             ├─ [CODE] Serveur: 192.168.1.100
└─ [TELEVISION] TV: 192.168.1.15             └─ [TELEVISION] TV: 192.168.1.15

[OK] Uniques DANS la maison
[X] Pas accessibles depuis l'extérieur
[X] Les deux maisons peuvent avoir les MÊMES IPs privées !
```

**IP Publique (unique au monde) :**
```
[MONDE] INTERNET
│
├─ [FR] Box France: 85.20.XX.XX (UNIQUE)
│   └─ Toute la maison est derrière cette IP
│
└─ [SN] Box Sénégal: 41.82.XX.XX (UNIQUE)
    └─ Toute la maison est derrière cette IP

[OK] Unique au monde
[OK] Accessible depuis Internet
```

#### 2⃣ **NAT (Network Address Translation)**

**Analogie : La réception d'un immeuble**

```
[ENTREPRISE] IMMEUBLE (= Box Internet)
│
│  [PERSONNE][PRO] Réceptionniste (= NAT)
│  ├─ "Je reçois tout le courrier"
│  ├─ "Je distribue aux bons appartements"
│  └─ "Je sais qui habite où"
│
├─ [SORTIE] Appartement 1: 192.168.1.10 (PC)
├─ [SORTIE] Appartement 2: 192.168.1.100 (Serveur)
└─ [SORTIE] Appartement 3: 192.168.1.15 (TV)
```

**Problème :**
```
[POSTBOX] Facteur (= Internet)
│
└─ "J'ai un colis pour 192.168.1.100"
   │
   └─ [PERSONNE][PRO] Réceptionniste : "Cette adresse n'existe pas !"
                          "Moi, je suis au 85.20.XX.XX"
                          "Je ne connais pas 192.168.1.100"

[X] LE COLIS NE PEUT PAS ÊTRE LIVRÉ
```

**Solution : Redirection de port (Port Forwarding)**
```
[PERSONNE][PRO] Réceptionniste configuré :
│
├─ RÈGLE : "Si quelqu'un frappe au PORT 2222"
│          "-> Redirige vers l'appartement 192.168.1.100 port 22"
│
└─ Maintenant :
   [POSTBOX] Internet -> "Je veux 85.20.XX.XX:2222"
                  │
                  └─-> [PERSONNE][PRO] NAT -> "OK, je redirige vers 192.168.1.100:22"
                                  │
                                  └─-> [OK] SERVEUR SÉNÉGAL REÇOIT LA CONNEXION
```

---

## [DOCS] MÉTHODES DE CONNEXION DISTANTE

Il existe **3 méthodes principales** :

### [BLEU] MÉTHODE 1 : REDIRECTION DE PORT (Port Forwarding)

**[OK] Avantages :**
- Configuration simple
- Gratuit
- Contrôle total

**[X] Inconvénients :**
- Nécessite accès à la box
- IP publique peut changer (IP dynamique)
- Exposition directe sur Internet

**[GRAPHIQUE] Complexité :** *****

---

### [VERT] MÉTHODE 2 : VPN (Réseau Privé Virtuel)

**Créer un "tunnel" entre les deux pays**

```
[FR] PC France ══[Tunnel VPN]══ [SN] Serveur Sénégal
   10.8.0.1                       10.8.0.2
   
[OK] Comme si vous étiez sur le même réseau local
[OK] Tout le trafic est chiffré
```

**[OK] Avantages :**
- Très sécurisé
- Connexion stable
- Plusieurs machines possibles

**[X] Inconvénients :**
- Configuration plus complexe
- Nécessite un serveur VPN

**[GRAPHIQUE] Complexité :** *****

---

### [VIOLET] MÉTHODE 3 : SSH INVERSE (Reverse SSH) + Serveur Relais

**Passer par un serveur intermédiaire**

```
[FR] PC France ──-> [CLOUD] Serveur Cloud <-── [SN] Serveur Sénégal
                  (VPS, toujours accessible)
```

**[OK] Avantages :**
- Pas besoin de toucher aux box
- Fonctionne même derrière des pare-feu stricts
- IP publique fixe (du VPS)

**[X] Inconvénients :**
- Nécessite un VPS (3-5€/mois)
- Configuration intermédiaire

**[GRAPHIQUE] Complexité :** *****

---

## [RAPIDE] MÉTHODE 1 : REDIRECTION DE PORT (DÉTAILLÉE)

### [LISTE] Prérequis

**Sur le serveur au Sénégal :**
- [OK] Linux installé (Ubuntu/Debian)
- [OK] OpenSSH Server installé
- [OK] Accès physique ou à distance à la box Internet
- [OK] Connexion Internet stable

---

### [OUTIL] ÉTAPE 1 : Préparer le serveur (Sénégal)

#### 1⃣ Installer SSH (si pas déjà fait)

```bash
sudo apt update
sudo apt install openssh-server -y
```

#### 2⃣ Configurer SSH

```bash
sudo nano /etc/ssh/sshd_config
```

**Configuration recommandée :**

```bash
# Port SSH (on va utiliser 22 localement, 2222 publiquement)
Port 22

# Sécurité
PermitRootLogin no
PasswordAuthentication no  # Après avoir configuré les clés !
PubkeyAuthentication yes
MaxAuthTries 3
LoginGraceTime 1m

# Utilisateurs autorisés
AllowUsers votre_nom_utilisateur
```

**Redémarrer SSH :**

```bash
sudo systemctl restart ssh
```

#### 3⃣ Configurer le pare-feu

```bash
sudo apt install ufw -y
sudo ufw allow 22/tcp
sudo ufw enable
```

#### 4⃣ Noter l'IP privée du serveur

```bash
ip a
```

**Cherche l'IP qui commence par `192.168.X.X` ou `10.X.X.X`**

**Exemple :** `192.168.1.100`

---

### [WEB] ÉTAPE 2 : Trouver l'IP publique (Sénégal)

#### Méthode 1 : Depuis le serveur

```bash
curl ifconfig.me
```

**Ou :**

```bash
curl icanhazip.com
```

**Résultat (exemple) :** `41.82.123.45`

**[EDIT] NOTE CETTE IP !**

#### Méthode 2 : Sur la box

- Connecte-toi à l'interface web de la box
- Généralement : `192.168.1.1` ou `192.168.0.1`
- Cherche "WAN IP" ou "IP publique"

---

### [MELANGE] ÉTAPE 3 : Configurer la redirection de port (Sénégal)

**[ATTENTION] Cette étape dépend de ta box Internet. Voici les étapes générales :**

#### [CLE] Accéder à l'interface de la box

**1. Ouvre un navigateur**

**2. Tape l'adresse de la box :**
- Souvent : `192.168.1.1` ou `192.168.0.1` ou `192.168.1.254`

**3. Identifie-toi :**
- Login/mot de passe souvent indiqués sur la box
- Par défaut : `admin/admin` ou `admin/password`

#### [OUTIL] Créer la redirection

**Cherche un menu appelé :**
- "NAT" / "PAT"
- "Port Forwarding"
- "Redirection de port"
- "Virtual Server"
- "Applications et Jeux"

**Créer une règle :**

```
Nom de la règle : SSH_Serveur
Protocole : TCP
Port externe : 2222
IP interne : 192.168.1.100 (IP de ton serveur)
Port interne : 22
État : Activé
```

**[GUIDE] Explication :**
```
Quand quelqu'un frappe à la porte du PORT 2222 de mon IP publique
-> Redirige vers le serveur 192.168.1.100 sur son PORT 22
```

**Sauvegarde la règle.**

---

### [HOT] ÉTAPE 4 : Ouvrir le port sur le pare-feu de la box (si nécessaire)

**Certaines box ont un pare-feu intégré.**

**Cherche un menu :**
- "Firewall"
- "Pare-feu"
- "Sécurité"

**Autorise le port 2222 en TCP.**

---

### [TEST] ÉTAPE 5 : Tester LOCALEMENT (depuis le Sénégal)

**Avant de tester depuis la France, vérifie que tout fonctionne localement.**

**Depuis un autre PC sur le MÊME réseau au Sénégal :**

```bash
ssh -p 2222 utilisateur@41.82.123.45
```

**[ATTENTION] Remplace :**
- `utilisateur` par ton nom d'utilisateur Linux
- `41.82.123.45` par ton IP publique

**Si ça marche :** [OK] La redirection fonctionne !

**Si ça ne marche pas :**
- Vérifie que SSH tourne : `sudo systemctl status ssh`
- Vérifie la redirection de port sur la box
- Vérifie le pare-feu : `sudo ufw status`

---

### [FR] ÉTAPE 6 : Se connecter depuis la France

**Ouvre PowerShell (Windows) :**

```powershell
ssh -p 2222 utilisateur@41.82.123.45
```

**[ATTENTION] Remplace :**
- `utilisateur` par ton nom d'utilisateur sur le serveur
- `41.82.123.45` par l'IP publique du Sénégal

**Premier message (normal) :**

```
The authenticity of host '[41.82.123.45]:2222 ([41.82.123.45]:2222)' can't be established.
ED25519 key fingerprint is SHA256:xxxxxxxxx.
Are you sure you want to continue connecting (yes/no/[fingerprint])? 
```

**Tape `yes`**

**Puis entre ton mot de passe.**

**Si tu vois :**

```
utilisateur@serveur-senegal:~$ 
```

**[OK] [BRAVO] TU ES CONNECTÉ DEPUIS LA FRANCE ! [BRAVO] [OK]**

---

### [SECURISE] ÉTAPE 7 : Sécuriser avec des clés SSH

**Connexion par mot de passe depuis Internet = DANGEREUX**

**Les robots scannent Internet 24/7 et tentent des mots de passe.**

#### Générer des clés SSH (depuis la France)

```powershell
ssh-keygen -t ed25519 -C "connexion-senegal"
```

**Appuie sur `Entrée` pour tout accepter par défaut.**

#### Copier la clé publique vers le Sénégal

```powershell
type $env:USERPROFILE\.ssh\id_ed25519.pub | ssh -p 2222 utilisateur@41.82.123.45 "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"
```

**Entre ton mot de passe (dernière fois).**

#### Configurer les permissions (sur le serveur Sénégal)

**Connecte-toi :**

```powershell
ssh -p 2222 utilisateur@41.82.123.45
```

**Puis :**

```bash
chmod 700 ~/.ssh
chmod 600 ~/.ssh/authorized_keys
```

**Déconnecte-toi :**

```bash
exit
```

#### Tester la connexion par clé

```powershell
ssh -p 2222 utilisateur@41.82.123.45
```

**Pas de mot de passe demandé ! [OK]**

#### Désactiver les mots de passe (sur le serveur)

```bash
sudo nano /etc/ssh/sshd_config
```

**Change :**

```bash
PasswordAuthentication no
```

**Redémarre SSH :**

```bash
sudo systemctl restart ssh
```

**Maintenant, SEULES les clés SSH fonctionnent ! [VERROUILLE]**

---

### [NOTE] ÉTAPE 8 : Créer un raccourci (France)

**Créer un fichier config SSH :**

```powershell
notepad $env:USERPROFILE\.ssh\config
```

**Ajoute :**

```
Host senegal
    HostName 41.82.123.45
    User utilisateur
    Port 2222
    IdentityFile ~/.ssh/id_ed25519
```

**Maintenant, tu peux juste taper :**

```powershell
ssh senegal
```

**Et tu es connecté ! [RAPIDE]**

---

### [ATTENTION] PROBLÈME : IP PUBLIQUE DYNAMIQUE

**La plupart des box ont une IP publique qui CHANGE régulièrement.**

```
Aujourd'hui : 41.82.123.45
Demain : 41.82.200.78 <- CHANGÉE !

[X] Ta connexion ne marche plus
```

#### [OUTIL] Solution 1 : IP fixe (payant)

**Demande à ton FAI (Fournisseur d'Accès Internet) une IP fixe.**

**Avantages :**
- [OK] IP ne change jamais

**Inconvénients :**
- [X] Souvent payant (5-10€/mois supplémentaires)

---

#### [OUTIL] Solution 2 : DNS Dynamique (GRATUIT)

**Utiliser un nom de domaine qui suit ton IP publique.**

**Principe :**

```
Au lieu de : ssh utilisateur@41.82.123.45
Tu utilises : ssh utilisateur@monserveur.ddns.net

Le service DDNS met à jour automatiquement l'IP
```

**Services DDNS gratuits :**
- **No-IP** : https://www.noip.com/
- **DuckDNS** : https://www.duckdns.org/
- **Dynu** : https://www.dynu.com/

**Exemple avec DuckDNS :**

**1. Crée un compte sur DuckDNS**

**2. Crée un sous-domaine :**
- Exemple : `serveur-senegal.duckdns.org`

**3. Sur le serveur au Sénégal, installe le client DuckDNS :**

```bash
mkdir ~/duckdns
cd ~/duckdns
nano duck.sh
```

**Contenu du script :**

```bash
#!/bin/bash
echo url="https://www.duckdns.org/update?domains=serveur-senegal&token=TON_TOKEN&ip=" | curl -k -o ~/duckdns/duck.log -K -
```

**[ATTENTION] Remplace :**
- `serveur-senegal` par ton sous-domaine
- `TON_TOKEN` par le token donné par DuckDNS

**Rendre le script exécutable :**

```bash
chmod +x duck.sh
```

**Tester :**

```bash
./duck.sh
```

**Si le fichier `duck.log` contient "OK", ça marche !**

**4. Automatiser avec cron (mise à jour toutes les 5 minutes) :**

```bash
crontab -e
```

**Ajoute :**

```bash
*/5 * * * * ~/duckdns/duck.sh >/dev/null 2>&1
```

**5. Depuis la France, connecte-toi avec le nom de domaine :**

```powershell
ssh -p 2222 utilisateur@serveur-senegal.duckdns.org
```

**[OK] Maintenant, même si l'IP change, le nom de domaine suit ! [BRAVO]**

---

## [VERT] MÉTHODE 2 : VPN (DÉTAILLÉE)

**Créer un réseau privé virtuel entre France et Sénégal.**

### [OBJECTIF] Avantages du VPN

```
SANS VPN :
[FR] France -> [Internet public] -> [SN] Sénégal
         ^
    Exposition sur Internet
    Port 2222 visible de tous

AVEC VPN :
[FR] France ══[Tunnel chiffré]══ [SN] Sénégal
   10.8.0.1                       10.8.0.2
   
[OK] Comme sur le même réseau local
[OK] Tout est chiffré
[OK] Pas de port exposé publiquement
```

---

### [LISTE] Prérequis

- Un des deux ordinateurs doit avoir une **IP publique accessible**
- Ou utiliser un serveur VPS (recommandé)

**On va utiliser WireGuard (VPN moderne, rapide, simple).**

---

### [OUTIL] ÉTAPE 1 : Installer WireGuard (sur les deux machines)

#### Sur le serveur Sénégal (Ubuntu/Debian)

```bash
sudo apt update
sudo apt install wireguard -y
```

#### Sur le PC France (Windows)

**Télécharge WireGuard :**
- https://www.wireguard.com/install/

**Installe le logiciel.**

---

### [CLE] ÉTAPE 2 : Générer les clés

#### Sur le serveur Sénégal

```bash
cd /etc/wireguard
sudo wg genkey | sudo tee privatekey | sudo wg pubkey | sudo tee publickey
```

**Affiche les clés :**

```bash
sudo cat privatekey
# Exemple : sB2xJQabcdefghijklmnopqrstuvwxyz1234567890=

sudo cat publickey
# Exemple : zYxWvU9876543210zyxwvutsrqponmlkjihgfedcba=
```

**[EDIT] NOTE CES CLÉS !**

---

#### Sur le PC France

**Ouvre WireGuard (interface graphique)**

**Clique sur "Add Tunnel" -> "Add empty tunnel"**

**WireGuard génère automatiquement :**
- Clé privée (garde-la secrète)
- Clé publique (partage-la)

**[EDIT] NOTE LA CLÉ PUBLIQUE !**

---

### [CONFIG] ÉTAPE 3 : Configurer WireGuard

#### Sur le serveur Sénégal

```bash
sudo nano /etc/wireguard/wg0.conf
```

**Contenu :**

```ini
[Interface]
Address = 10.8.0.1/24
ListenPort = 51820
PrivateKey = CLÉ_PRIVÉE_SÉNÉGAL

# Autoriser le forwarding
PostUp = sysctl -w net.ipv4.ip_forward=1
PostDown = sysctl -w net.ipv4.ip_forward=0

[Peer]
# PC France
PublicKey = CLÉ_PUBLIQUE_FRANCE
AllowedIPs = 10.8.0.2/32
```

**[ATTENTION] Remplace :**
- `CLÉ_PRIVÉE_SÉNÉGAL` par la clé privée générée
- `CLÉ_PUBLIQUE_FRANCE` par la clé publique du PC France

**Démarrer WireGuard :**

```bash
sudo wg-quick up wg0
sudo systemctl enable wg-quick@wg0
```

---

#### Sur le PC France (WireGuard GUI)

**Dans l'interface WireGuard, modifie la configuration :**

```ini
[Interface]
PrivateKey = CLÉ_PRIVÉE_FRANCE
Address = 10.8.0.2/24

[Peer]
# Serveur Sénégal
PublicKey = CLÉ_PUBLIQUE_SÉNÉGAL
Endpoint = 41.82.123.45:51820
AllowedIPs = 10.8.0.0/24
PersistentKeepalive = 25
```

**[ATTENTION] Remplace :**
- `CLÉ_PRIVÉE_FRANCE` (déjà remplie normalement)
- `CLÉ_PUBLIQUE_SÉNÉGAL` par la clé publique du serveur
- `41.82.123.45` par l'IP publique du Sénégal

**Sauvegarde et active le tunnel (bouton "Activate").**

---

### [MELANGE] ÉTAPE 4 : Redirection de port pour WireGuard (Sénégal)

**Sur la box au Sénégal, crée une redirection :**

```
Nom : WireGuard
Protocole : UDP
Port externe : 51820
IP interne : 192.168.1.100
Port interne : 51820
```

---

### [TEST] ÉTAPE 5 : Tester le VPN

**Depuis le PC France, avec le VPN activé :**

```powershell
ping 10.8.0.1
```

**Si tu reçois des réponses :** [OK] Le VPN fonctionne !

**Connecte-toi en SSH via le VPN :**

```powershell
ssh utilisateur@10.8.0.1
```

**[OK] Tu es connecté via le tunnel VPN ! [BRAVO]**

**Avantages :**
- [OK] Connexion chiffrée
- [OK] Pas besoin de redirection de port SSH
- [OK] Tous les services sont accessibles

---

## [VIOLET] MÉTHODE 3 : SSH INVERSE + SERVEUR RELAIS

**Pour contourner les limitations (box derrière CGNAT, pare-feu strict, pas d'accès à la box).**

### [OBJECTIF] Principe

```
[SN] Serveur Sénégal ──┐
                       ├──-> [CLOUD] VPS (Serveur relais)
[FR] PC France ────────┘          │
                            IP fixe publique
                            Toujours accessible
```

**Le serveur Sénégal se connecte AU VPS (connexion sortante = toujours possible).**

**Le PC France se connecte AU VPS, qui redirige vers le Sénégal.**

---

### [LISTE] Prérequis

**Un VPS (Virtual Private Server) :**
- **Fournisseurs recommandés :**
  - Hetzner (3€/mois)
  - OVH (3-5€/mois)
  - DigitalOcean (5$/mois)
  - Contabo (5€/mois)

**Caractéristiques minimales :**
- 1 CPU
- 1 GB RAM
- Linux (Ubuntu/Debian)
- IP publique fixe

---

### [OUTIL] ÉTAPE 1 : Configurer le VPS

**Connecte-toi au VPS :**

```bash
ssh root@IP_DU_VPS
```

**Installe SSH (déjà présent normalement) :**

```bash
apt update
apt install openssh-server -y
```

**Configure SSH pour autoriser le tunneling :**

```bash
nano /etc/ssh/sshd_config
```

**Ajoute/modifie :**

```bash
GatewayPorts yes
AllowTcpForwarding yes
```

**Redémarre SSH :**

```bash
systemctl restart ssh
```

---

### [OUTIL] ÉTAPE 2 : Créer le tunnel depuis le Sénégal

**Sur le serveur Sénégal, crée le tunnel SSH inverse :**

```bash
ssh -R 2222:localhost:22 -N -f root@IP_DU_VPS
```

**Explication :**
- `-R 2222:localhost:22` = Redirige le port 2222 du VPS vers le port 22 local
- `-N` = Ne pas exécuter de commande (juste le tunnel)
- `-f` = Passer en arrière-plan
- `root@IP_DU_VPS` = Se connecter au VPS

**Ce que ça fait :**

```
VPS Port 2222 ──[Tunnel]──-> Serveur Sénégal Port 22
```

---

### [OUTIL] ÉTAPE 3 : Automatiser le tunnel (important !)

**Le tunnel peut se couper. On va le relancer automatiquement.**

**Crée un script :**

```bash
nano ~/ssh_tunnel.sh
```

**Contenu :**

```bash
#!/bin/bash
while true; do
    ssh -R 2222:localhost:22 -N -o ServerAliveInterval=60 -o ExitOnForwardFailure=yes root@IP_DU_VPS
    echo "Tunnel coupé. Reconnexion dans 10 secondes..."
    sleep 10
done
```

**Rendre exécutable :**

```bash
chmod +x ~/ssh_tunnel.sh
```

**Créer un service systemd :**

```bash
sudo nano /etc/systemd/system/ssh-tunnel.service
```

**Contenu :**

```ini
[Unit]
Description=SSH Reverse Tunnel to VPS
After=network.target

[Service]
Type=simple
User=votre_utilisateur
ExecStart=/home/votre_utilisateur/ssh_tunnel.sh
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
```

**Activer le service :**

```bash
sudo systemctl daemon-reload
sudo systemctl enable ssh-tunnel
sudo systemctl start ssh-tunnel
```

**Vérifier :**

```bash
sudo systemctl status ssh-tunnel
```

---

### [FR] ÉTAPE 4 : Se connecter depuis la France

**Le tunnel est maintenant actif. Pour te connecter :**

```powershell
ssh -p 2222 utilisateur@IP_DU_VPS
```

**Ce qui se passe :**

```
PC France -> VPS:2222 -> [Tunnel] -> Serveur Sénégal:22

[OK] Tu es connecté au serveur Sénégal !
```

---

### [NOTE] ÉTAPE 5 : Configuration SSH simplifiée (France)

```powershell
notepad $env:USERPROFILE\.ssh\config
```

**Ajoute :**

```
Host senegal
    HostName IP_DU_VPS
    User utilisateur
    Port 2222
    IdentityFile ~/.ssh/id_ed25519
```

**Maintenant :**

```powershell
ssh senegal
```

**[OK] Connecté au Sénégal via le VPS ! [BRAVO]**

---

## [GRAPHIQUE] COMPARAISON DES MÉTHODES

| Critère | Port Forwarding | VPN | SSH Inverse |
|---------|----------------|-----|-------------|
| **Coût** | Gratuit | Gratuit | 3-5€/mois (VPS) |
| **Complexité** | ***** | ***** | ***** |
| **Sécurité** | ***** | ***** | ***** |
| **Fonctionne derrière CGNAT** | [X] | [X] | [OK] |
| **Nécessite accès box** | [OK] | [OK] | [X] |
| **IP dynamique** | [ATTENTION] (DDNS requis) | [ATTENTION] (DDNS requis) | [OK] (VPS fixe) |
| **Stabilité** | ***** | ***** | ***** |

---

## [SECURITE] SÉCURITÉ IMPORTANTE

### [ATTENTION] Règles de sécurité ABSOLUES

**1. JAMAIS de mot de passe depuis Internet**

```bash
# Dans /etc/ssh/sshd_config
PasswordAuthentication no
```

**Utilise UNIQUEMENT les clés SSH !**

---

**2. Fail2Ban (bannir les attaquants)**

```bash
sudo apt install fail2ban -y
```

**Configure :**

```bash
sudo nano /etc/fail2ban/jail.local
```

```ini
[sshd]
enabled = true
port = 2222
maxretry = 3
bantime = 86400
findtime = 600
```

---

**3. Changer le port SSH**

**Port 22 = scanné 24/7 par des robots**

```bash
# Dans /etc/ssh/sshd_config
Port 2222
```

---

**4. Limiter les utilisateurs autorisés**

```bash
# Dans /etc/ssh/sshd_config
AllowUsers ton_utilisateur
```

---

**5. Désactiver root**

```bash
PermitRootLogin no
```

---

**6. Surveiller les logs**

```bash
# Voir les tentatives échouées
sudo grep "Failed password" /var/log/auth.log

# Voir les connexions réussies
sudo grep "Accepted" /var/log/auth.log
```

---

## [BRAVO] RÉCAPITULATIF FINAL

### [OK] Tu sais maintenant :

1. **Comprendre** la différence entre IP privée et publique
2. **Configurer** une redirection de port
3. **Utiliser** un DNS dynamique
4. **Créer** un VPN avec WireGuard
5. **Mettre en place** un tunnel SSH inverse
6. **Sécuriser** ton serveur contre les attaques

### [RAPIDE] Commandes essentielles

```bash
# Connexion directe (port forwarding)
ssh -p 2222 utilisateur@IP_PUBLIQUE_SENEGAL

# Connexion via VPN
ssh utilisateur@10.8.0.1

# Connexion via VPS relais
ssh -p 2222 utilisateur@IP_DU_VPS

# Voir l'IP publique
curl ifconfig.me

# Tester la connectivité
ping IP_PUBLIQUE

# Surveiller SSH
sudo journalctl -u ssh -f
```

### [COURS] Tu es maintenant capable de connecter deux machines à travers le monde ! [MONDE][BRAVO]