# [MONDE] GUIDE SSH ENTRE DEUX MACHINES DISTANTES - ULTRA DÉTAILLÉ

## [OBJECTIF] OBJECTIF : Connecter deux machines dans des pays différents

```
[FR] FRANCE                                    [SN] SÉNÉGAL
├─ PC Pierre                                 ├─ Serveur Ubuntu
├─ IP locale : 192.168.1.10                  ├─ IP locale : 192.168.1.100
├─ IP publique : 85.12.34.56                 ├─ IP publique : 41.82.123.45
└─ Box Internet (Livebox, Freebox...)        └─ Box Internet (Orange, Sonatel...)
```

---

## [DOCS] CHAPITRE 0 : COMPRENDRE LES BASES ESSENTIELLES

### [REFLEXION] Pourquoi c'est plus compliqué qu'en local ?

#### En local (ce qu'on a fait avant) :

```
[ECRAN] PC Windows ────[Même réseau local]────-> [CODE] VM Linux
   192.168.1.10                              192.168.1.100
   
[OK] Même WiFi/Ethernet
[OK] Communication directe
[OK] Pas de blocage
```

#### À distance (France -> Sénégal) :

```
[FR] PC                      [WEB] INTERNET                    [SN] Serveur
   │                             │                            │
   ├─ IP locale: 192.168.1.10    │                            ├─ IP locale: 192.168.1.100
   ├─ IP publique: 85.12.34.56   │                            ├─ IP publique: 41.82.123.45
   │                             │                            │
   └─ Box/Routeur ───────────────┼────────────────────────────-> Box/Routeur
        (FIREWALL)               │                                (FIREWALL)
                                 │
                                 └─ [X] Problème : Les box bloquent
                                      les connexions entrantes !
```

### [VERROUILLE] Le problème du NAT (Network Address Translation)

**Analogie simple :**

Imagine un immeuble (= ta box internet) avec plusieurs appartements (= tes appareils).

```
[ENTREPRISE] IMMEUBLE "85.12.34.56" (IP publique de ta box)
│
├─ [SORTIE] Appart. 1 : PC Pierre (192.168.1.10)
├─ [SORTIE] Appart. 2 : Téléphone (192.168.1.15)
└─ [SORTIE] Appart. 3 : Smart TV (192.168.1.20)
```

**Quand tu envoies une requête depuis ton PC :**

```
PC (192.168.1.10) : "Je veux aller sur Google !"
    v
Box : "OK, je note que l'appart. 1 a demandé. Je vais faire la demande avec MON adresse publique."
    v
Google voit : Demande depuis 85.12.34.56
    v
Google répond à : 85.12.34.56
    v
Box : "Ah ! C'est pour l'appart. 1, je lui renvoie !"
    v
PC reçoit la réponse [OK]
```

**Mais quand quelqu'un essaie de te contacter de l'extérieur :**

```
Serveur Sénégal : "Je veux parler à 85.12.34.56 !"
    v
Box France : "??? Qui ça ? Appart. 1, 2 ou 3 ? Je ne sais pas !"
    v
[X] BLOQUÉ (par sécurité)
```

**C'est pour ça qu'on a besoin de solutions spéciales !**

---

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

### [GUIDE] Qu'est-ce que c'est ?

**Tu dis à ta box : "Quand quelqu'un frappe au port 22, envoie-le vers mon serveur !"**

### [GRAPHIQUE] Schéma détaillé :

```
[SN] SÉNÉGAL (Serveur SSH)
│
├─ [ENTREPRISE] Box Internet
│  └─ IP publique : 41.82.123.45
│     │
│     └─ RÈGLE : Port 22 -> 192.168.1.100:22
│        "Toute connexion sur le port 22 va vers le serveur !"
│
└─ [CODE] Serveur Ubuntu
   └─ IP locale : 192.168.1.100
      └─ SSH écoute sur le port 22


[FR] FRANCE (Client)
│
└─ [ECRAN] PC Pierre
   └─ Commande : ssh user@41.82.123.45
      "Je me connecte à l'IP PUBLIQUE du Sénégal !"
```

### [CONFIG] ÉTAPE PAR ÉTAPE : Configuration

---

#### [SN] PARTIE 1 : CONFIGURATION AU SÉNÉGAL

##### Étape 1.1 : Vérifier l'IP publique

**Sur le serveur Ubuntu au Sénégal :**

```bash
curl ifconfig.me
```

**Résultat (exemple) :**

```
41.82.123.45
```

**[OK] C'est ton IP publique ! Note-la précieusement.**

**Alternative :**

Va sur https://www.whatismyip.com/ depuis le navigateur du serveur.

---

##### Étape 1.2 : Vérifier l'IP locale du serveur

```bash
ip a
```

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

**Exemple :**

```
inet 192.168.1.100/24
```

**[OK] IP locale : 192.168.1.100**

---

##### Étape 1.3 : S'assurer que SSH fonctionne

```bash
sudo systemctl status ssh
```

**Résultat attendu :**

```
[BLACK_CIRCLE] ssh.service - OpenBSD Secure Shell server
   Active: active (running)
   
Server listening on 0.0.0.0 port 22.
```

[OK] **SSH tourne sur le port 22.**

**Si SSH n'est pas installé :**

```bash
sudo apt update
sudo apt install openssh-server -y
sudo systemctl enable ssh
sudo systemctl start ssh
```

---

##### Étape 1.4 : Configurer le pare-feu (UFW)

```bash
# Installer UFW si pas déjà fait
sudo apt install ufw -y

# Autoriser SSH
sudo ufw allow 22/tcp

# Activer le pare-feu
sudo ufw enable

# Vérifier
sudo ufw status
```

**Résultat attendu :**

```
Status: active

To                         Action      From
--                         ------      ----
22/tcp                     ALLOW       Anywhere
```

[OK] **Le port 22 est autorisé.**

---

##### Étape 1.5 : Configurer la redirection de port sur la box

**[ATTENTION] CETTE ÉTAPE EST CRUCIALE ET VARIE SELON LA BOX !**

**Principe général :**

1. **Accède à l'interface de ta box**
2. **Trouve la section "NAT" ou "Redirection de port"**
3. **Crée une règle**

---

###### [OUTIL] Configuration générique (toutes les box)

**Paramètres à renseigner :**

```
Nom de la règle     : SSH Serveur
Port externe        : 22 (le port sur lequel Internet frappe)
Port interne        : 22 (le port sur le serveur local)
IP locale           : 192.168.1.100 (IP du serveur Ubuntu)
Protocole           : TCP
```

---

###### [MOBILE] Exemples pour différentes box sénégalaises

**[ORANGE] Orange Sénégal (Livebox) :**

1. Ouvre ton navigateur : http://192.168.1.1
2. Identifiant : `admin` / Mot de passe : (sur l'étiquette de la box)
3. Va dans : **Avancé** -> **NAT/PAT** -> **Ajouter une règle**
4. Remplis :
   ```
   Application      : SSH
   Port externe     : 22
   Port interne     : 22
   Adresse IP       : 192.168.1.100
   Protocole        : TCP
   ```
5. **Enregistrer**

**[JAUNE] Sonatel (Box ADSL) :**

1. http://192.168.1.1
2. Login : `admin` / Mot de passe : `admin` (ou sur la box)
3. **Advanced** -> **Port Forwarding**
4. Remplis :
   ```
   Service Name     : SSH
   External Port    : 22
   Internal Port    : 22
   Internal IP      : 192.168.1.100
   Protocol         : TCP
   ```
5. **Apply**

**[ROUGE] Free (Freebox, si tu es en France) :**

1. Va sur : https://mafreebox.freebox.fr
2. **Paramètres de la Freebox** -> **Gestion des ports**
3. **Ajouter une redirection**
4. Remplis :
   ```
   IP destination   : 192.168.1.100
   Port début       : 22
   Port fin         : 22
   Protocole        : TCP
   ```
5. **Valider**

---

##### Étape 1.6 : Tester localement

**Avant de tester depuis la France, vérifie que ça marche en local.**

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

```bash
ssh utilisateur@192.168.1.100
```

**Si ça marche :** [OK] SSH fonctionne localement.

---

##### Étape 1.7 : Vérifier que le port est ouvert

**Utilise un site externe pour vérifier :**

Va sur : https://www.yougetsignal.com/tools/open-ports/

**Renseigne :**

- **IP Address :** `41.82.123.45` (ton IP publique)
- **Port Number :** `22`

**Clique sur "Check"**

**Résultat attendu :**

```
Port 22 is open on 41.82.123.45
```

[OK] **Le port est accessible depuis Internet !**

**Si "closed" :**

- [X] La redirection de port n'est pas bien configurée
- Revérifie l'étape 1.5

---

#### [FR] PARTIE 2 : CONNEXION DEPUIS LA FRANCE

##### Étape 2.1 : Se connecter avec l'IP publique

**Ouvre PowerShell sur ton PC en France :**

```powershell
ssh utilisateur@41.82.123.45
```

**[ATTENTION] Remplace :**

- `utilisateur` par le nom d'utilisateur sur le serveur Ubuntu au Sénégal
- `41.82.123.45` par l'IP publique réelle du Sénégal

**Premier message (normal) :**

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

**Tape :** `yes`

**Message suivant :**

```
utilisateur@41.82.123.45's password:
```

**Tape ton mot de passe.**

**Si tout va bien :**

```
Welcome to Ubuntu 22.04 LTS
Last login: ...
utilisateur@serveur:~$
```

[BRAVO] **TU ES CONNECTÉ DEPUIS LA FRANCE ! [FR] -> [SN]**

---

##### Étape 2.2 : Tester des commandes

```bash
# Voir où tu es
pwd

# Voir l'IP du serveur
ip a

# Créer un fichier de test
echo "Connexion depuis la France !" > test_france.txt

# Vérifier
cat test_france.txt
```

---

##### Étape 2.3 : Configurer les clés SSH (sécurité)

**Pour ne plus avoir à taper le mot de passe et sécuriser la connexion.**

**Sur ton PC en France (PowerShell) :**

```powershell
# Générer une paire de clés
ssh-keygen -t ed25519 -C "pierre@france"
```

**Appuie sur Entrée 3 fois (emplacement par défaut, pas de passphrase).**

**Copier la clé vers le serveur au Sénégal :**

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

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

**Ajuster les permissions sur le serveur :**

```powershell
ssh utilisateur@41.82.123.45 "chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys"
```

**Tester la connexion sans mot de passe :**

```powershell
ssh utilisateur@41.82.123.45
```

**Si tu es connecté directement :** [OK] Les clés SSH fonctionnent !

---

##### Étape 2.4 : Désactiver l'authentification par mot de passe

**Pour sécuriser au maximum, on désactive les mots de passe.**

**Sur le serveur au Sénégal :**

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

**Modifie :**

```bash
PasswordAuthentication no
```

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

**Redémarre SSH :**

```bash
sudo systemctl restart ssh
```

**Maintenant, seules les personnes avec la clé SSH peuvent se connecter !**

---

### [ATTENTION] PROBLÈMES COURANTS ET SOLUTIONS

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

**Erreur :**

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

**Causes possibles :**

1. **La redirection de port n'est pas configurée**
   - Revérifie l'étape 1.5
   - Utilise https://www.yougetsignal.com/tools/open-ports/

2. **Le pare-feu du serveur bloque SSH**
   ```bash
   sudo ufw allow 22/tcp
   ```

3. **L'IP publique a changé**
   - Les IP des box changent souvent
   - Vérifie avec `curl ifconfig.me` sur le serveur
   - Voir la solution avec DynDNS plus bas

---

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

**Erreur :**

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

**Causes :**

1. **SSH n'est pas démarré sur le serveur**
   ```bash
   sudo systemctl start ssh
   sudo systemctl enable ssh
   ```

2. **Mauvais port dans la redirection**
   - Vérifie que la règle pointe bien vers `192.168.1.100:22`

---

#### Problème 3 : L'IP publique change tout le temps

**Solution : Utiliser un nom de domaine dynamique (DynDNS)**

**Qu'est-ce que c'est ?**

Un service qui associe un nom (exemple : `monserveur.ddns.net`) à ton IP publique.

**Services gratuits recommandés :**

- **No-IP** : https://www.noip.com/
- **DuckDNS** : https://www.duckdns.org/
- **FreeDNS** : https://freedns.afraid.org/

---

##### Configuration No-IP (exemple)

**1. Créer un compte**

Va sur https://www.noip.com/sign-up

**2. Créer un hostname**

- **Hostname :** `monserveur-senegal`
- **Domain :** Choisis parmi les gratuits (exemple : `ddns.net`)
- **Résultat :** `monserveur-senegal.ddns.net`

**3. Installer le client No-IP sur le serveur Ubuntu**

```bash
cd /tmp
wget https://www.noip.com/client/linux/noip-duc-linux.tar.gz
tar -xzf noip-duc-linux.tar.gz
cd noip-2.1.9-1/
sudo make
sudo make install
```

**Configuration :**

```bash
sudo /usr/local/bin/noip2 -C
```

**Renseigne :**

- **Username :** ton email No-IP
- **Password :** ton mot de passe No-IP
- **Update interval :** `30` (minutes)

**Démarrer le service :**

```bash
sudo /usr/local/bin/noip2
```

**Vérifier :**

```bash
sudo /usr/local/bin/noip2 -S
```

**4. Maintenant, connecte-toi avec le nom de domaine :**

```powershell
ssh utilisateur@monserveur-senegal.ddns.net
```

[OK] **Plus besoin de se soucier de l'IP qui change !**

---

### [OBJECTIF] RÉCAPITULATIF MÉTHODE 1

**[OK] Avantages :**

- Simple à configurer (une fois qu'on comprend)
- Connexion directe (rapide)
- Gratuit
- Pas besoin de serveur tiers

**[X] Inconvénients :**

- Il faut accéder à la box (pas toujours possible)
- L'IP publique peut changer (solution : DynDNS)
- Si le port 22 est bloqué par le FAI (rare mais possible)

---

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

### [GUIDE] Qu'est-ce qu'un VPN ?

**Analogie simple :**

Imagine un tunnel privé entre la France et le Sénégal, à travers Internet.

```
[FR] PC France ═══════[Tunnel sécurisé]═══════ [SN] Serveur Sénégal
   │                                             │
   └─ IP dans le tunnel : 10.8.0.1             └─ IP dans le tunnel : 10.8.0.2
```

**Une fois le tunnel créé :**

```
ssh utilisateur@10.8.0.2
```

**C'est comme si vous étiez sur le MÊME réseau local !**

---

### [GRAPHIQUE] Schéma détaillé :

```
[WEB] AVANT LE VPN :

[FR] France              INTERNET              [SN] Sénégal
192.168.1.10 ────×────────────────×──────── 192.168.1.100
                  [X] Bloqué par NAT [X]


[WEB] AVEC LE VPN :

[FR] France                                    [SN] Sénégal
│                                             │
├─ IP réelle : 192.168.1.10                  ├─ IP réelle : 192.168.1.100
├─ IP VPN : 10.8.0.1                         ├─ IP VPN : 10.8.0.2
│                                             │
└──────────[Tunnel VPN chiffré]──────────────┘
           [OK] Communication directe [OK]
```

---

### [CONFIG] CONFIGURATION AVEC WIREGUARD (VPN moderne, rapide)

**Pourquoi WireGuard ?**

- [OK] Moderne et rapide
- [OK] Plus simple que OpenVPN
- [OK] Intégré dans Linux
- [OK] Sécurité maximale
- [OK] Fonctionne même avec du NAT des deux côtés

---

#### [SN] PARTIE 1 : CONFIGURATION DU SERVEUR (SÉNÉGAL)

##### Étape 1.1 : Installer WireGuard

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

---

##### Étape 1.2 : Générer les clés du serveur

```bash
# Se placer dans le bon dossier
cd /etc/wireguard

# Générer la clé privée du serveur
wg genkey | sudo tee server_private.key | wg pubkey | sudo tee server_public.key
```

**Afficher les clés :**

```bash
# Clé privée (GARDE-LA SECRÈTE !)
sudo cat /etc/wireguard/server_private.key

# Clé publique (tu la partageras avec le client)
sudo cat /etc/wireguard/server_public.key
```

**Exemple de résultat :**

```
Clé privée : 4JhT8vK2...  (garde-la secrète !)
Clé publique : Xn9k2L...  (note-la, tu en auras besoin)
```

---

##### Étape 1.3 : Créer le fichier de configuration du serveur

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

**Contenu :**

```ini
[Interface]
# Clé privée du serveur
PrivateKey = COLLE_ICI_LA_CLÉ_PRIVÉE_DU_SERVEUR
# Adresse IP du serveur dans le tunnel VPN
Address = 10.8.0.1/24
# Port d'écoute (51820 par défaut)
ListenPort = 51820

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

[Peer]
# Clé publique du client (on la mettra après l'avoir générée)
PublicKey = ON_LA_METTRA_APRES
# IP autorisée pour ce client
AllowedIPs = 10.8.0.2/32
```

**[ATTENTION] Remplace :**

- `COLLE_ICI_LA_CLÉ_PRIVÉE_DU_SERVEUR` par ta clé privée serveur

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

---

##### Étape 1.4 : Configurer le pare-feu

```bash
# Autoriser le port WireGuard
sudo ufw allow 51820/udp

# Autoriser le forwarding
sudo ufw route allow in on wg0 out on eth0

# Recharger UFW
sudo ufw reload
```

---

##### Étape 1.5 : Configurer la redirection de port sur la box

**Sur la box Internet au Sénégal :**

```
Nom de la règle     : WireGuard VPN
Port externe        : 51820
Port interne        : 51820
IP locale           : 192.168.1.100
Protocole           : UDP ([ATTENTION] UDP, pas TCP !)
```

**[ATTENTION] C'est UDP, pas TCP ! WireGuard utilise UDP.**

---

#### [FR] PARTIE 2 : CONFIGURATION DU CLIENT (FRANCE)

##### Étape 2.1 : Installer WireGuard

**Sur Windows, télécharge WireGuard :**

https://www.wireguard.com/install/

**Installe-le.**

---

##### Étape 2.2 : Générer les clés du client

**Ouvre PowerShell en administrateur :**

```powershell
# Installer WireGuard en ligne de commande (si pas déjà fait)
# ou utilise l'interface graphique

# Générer les clés
cd $env:USERPROFILE
mkdir wireguard
cd wireguard

# Génère la clé privée
wg genkey > client_private.key

# Génère la clé publique
type client_private.key | wg pubkey > client_public.key
```

**Afficher les clés :**

```powershell
type client_private.key
type client_public.key
```

**Note les deux clés.**

---

##### Étape 2.3 : Créer le fichier de configuration du client

**Crée un fichier `senegal.conf` :**

```powershell
notepad senegal.conf
```

**Contenu :**

```ini
[Interface]
# Clé privée du client
PrivateKey = COLLE_ICI_LA_CLÉ_PRIVÉE_DU_CLIENT
# Adresse IP du client dans le tunnel VPN
Address = 10.8.0.2/24
# DNS (optionnel, utilise Google DNS)
DNS = 8.8.8.8

[Peer]
# Clé publique du serveur (Sénégal)
PublicKey = COLLE_ICI_LA_CLÉ_PUBLIQUE_DU_SERVEUR
# IP publique du serveur + port
Endpoint = 41.82.123.45:51820
# Tout le trafic vers 10.8.0.0/24 passe par le VPN
AllowedIPs = 10.8.0.0/24
# Garde la connexion active
PersistentKeepalive = 25
```

**[ATTENTION] Remplace :**

- `COLLE_ICI_LA_CLÉ_PRIVÉE_DU_CLIENT` par ta clé privée client
- `COLLE_ICI_LA_CLÉ_PUBLIQUE_DU_SERVEUR` par la clé publique du serveur (Sénégal)
- `41.82.123.45` par l'IP publique réelle du Sénégal

**Sauvegarde le fichier.**

---

##### Étape 2.4 : Importer la configuration dans WireGuard

**1. Ouvre WireGuard sur Windows**

**2. Clique sur "Add Tunnel" (Ajouter un tunnel)**

**3. Choisis "Add from file" (Ajouter depuis un fichier)**

**4. Sélectionne `senegal.conf`**

**5. Clique sur "Activate" (Activer)**

---

##### Étape 2.5 : Finaliser la configuration côté serveur

**Maintenant qu'on a la clé publique du client, on la met sur le serveur.**

**Sur le serveur au Sénégal :**

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

**Remplace :**

```ini
PublicKey = ON_LA_METTRA_APRES
```

**Par :**

```ini
PublicKey = COLLE_ICI_LA_CLÉ_PUBLIQUE_DU_CLIENT
```

**Sauvegarde.**

---

##### Étape 2.6 : Démarrer WireGuard sur le serveur

```bash
# Démarrer WireGuard
sudo wg-quick up wg0

# Activer au démarrage
sudo systemctl enable wg-quick@wg0
```

**Vérifier :**

```bash
sudo wg show
```

**Résultat attendu :**

```
interface: wg0
  public key: Xn9k2L...
  private key: (hidden)
  listening port: 51820

peer: [clé publique du client]
  endpoint: 85.12.34.56:xxxxx
  allowed ips: 10.8.0.2/32
  latest handshake: X seconds ago
  transfer: X KiB received, Y KiB sent
```

[OK] **Si tu vois "latest handshake" avec un temps récent, le VPN fonctionne !**

---

##### Étape 2.7 : Tester la connexion VPN

**Sur ton PC en France (avec le VPN activé) :**

```powershell
ping 10.8.0.1
```

**Résultat attendu :**

```
Réponse de 10.8.0.1 : octets=32 temps=150ms TTL=64
```

[OK] **Le VPN fonctionne !**

**Maintenant, connecte-toi en SSH via le VPN :**

```powershell
ssh utilisateur@10.8.0.1
```

[BRAVO] **TU ES CONNECTÉ VIA LE VPN ! [FR] -> [VPN] -> [SN]**

---

### [MOBILE] BONUS : WireGuard sur téléphone

**Tu peux aussi installer WireGuard sur ton téléphone !**

**1. Télécharge l'app WireGuard :**

- **Android :** Google Play Store
- **iOS :** App Store

**2. Crée une configuration client pour le téléphone :**

**Sur le serveur au Sénégal :**

```bash
# Générer les clés pour le téléphone
cd /etc/wireguard
wg genkey | sudo tee phone_private.key | wg pubkey | sudo tee phone_public.key

# Afficher les clés
sudo cat phone_private.key
sudo cat phone_public.key
```

**3. Ajoute le téléphone comme peer dans `/etc/wireguard/wg0.conf` :**

```ini
[Peer]
PublicKey = CLÉ_PUBLIQUE_DU_TÉLÉPHONE
AllowedIPs = 10.8.0.3/32
```

**Redémarre WireGuard :**

```bash
sudo wg-quick down wg0
sudo wg-quick up wg0
```

**4. Sur le téléphone, crée une config `senegal_phone.conf` :**

```ini
[Interface]
PrivateKey = CLÉ_PRIVÉE_DU_TÉLÉPHONE
Address = 10.8.0.3/24
DNS = 8.8.8.8

[Peer]
PublicKey = CLÉ_PUBLIQUE_DU_SERVEUR
Endpoint = 41.82.123.45:51820
AllowedIPs = 10.8.0.0/24
PersistentKeepalive = 25
```

**5. Scanne le QR code ou importe le fichier dans l'app WireGuard**

**6. Active le VPN sur le téléphone**

**Maintenant, tu peux te connecter en SSH depuis ton téléphone ! [MOBILE] -> [SN]**

---

### [OBJECTIF] RÉCAPITULATIF MÉTHODE 2 (VPN)

**[OK] Avantages :**

- Connexion comme si tu étais sur le même réseau
- Fonctionne même avec NAT des deux côtés
- Tout le trafic est chiffré
- Tu peux connecter plusieurs appareils (PC, téléphone, tablette)
- Pas besoin de redirection de port pour chaque service (juste le port VPN)

**[X] Inconvénients :**

- Plus complexe à configurer
- Il faut quand même une redirection de port pour le VPN
- Légère latence supplémentaire (mais WireGuard est très rapide)

---

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

### [GUIDE] Qu'est-ce que c'est ?

**Le principe :**

Si tu ne peux PAS accéder au serveur au Sénégal (pas d'accès à la box, port bloqué, etc.), le serveur au Sénégal se connecte à un serveur relais accessible, puis tu te connectes au relais.

```
[SN] Serveur Sénégal ──────-> [WEB] Serveur Relais (VPS) <-────── [FR] PC France
   (bloqué/NAT)              (accessible partout)         (connexion)
```

**Analogie :**

Imagine que tu ne peux pas appeler directement quelqu'un (il n'a pas de téléphone fixe). Mais il peut t'appeler. Alors il appelle une messagerie vocale (le relais), dépose un message, et toi tu appelles la messagerie pour écouter.

---

### [GRAPHIQUE] Schéma détaillé :

```
ÉTAPE 1 : Le serveur Sénégal se connecte au relais

[SN] Serveur Sénégal
   └──[ssh -R 2222:localhost:22 relais]──-> [WEB] VPS Relais
                                              │
                                              └─ Crée un tunnel inverse
                                                 Port 2222 -> Sénégal:22


ÉTAPE 2 : Tu te connectes au relais, qui redirige vers le Sénégal

[FR] PC France
   └──[ssh user@vps-relais.com -p 2222]──-> [WEB] VPS Relais
                                              │
                                              └──[Tunnel]──-> [SN] Sénégal
```

---

### [CONFIG] CONFIGURATION

#### [WEB] PARTIE 1 : OBTENIR UN SERVEUR RELAIS (VPS)

**Options :**

1. **Gratuit (limité) :**
   - **Oracle Cloud Free Tier** : https://www.oracle.com/cloud/free/
     - VM gratuite à vie
   - **Google Cloud Free Tier** : 3 mois gratuits
   - **AWS Free Tier** : 12 mois gratuits

2. **Payant (recommandé pour du sérieux) :**
   - **DigitalOcean** : 5$/mois
   - **Vultr** : 5$/mois
   - **Contabo** : 4€/mois

**Pour ce guide, on va utiliser Oracle Cloud (gratuit).**

---

##### Étape 1.1 : Créer une instance Oracle Cloud

**1. Va sur https://www.oracle.com/cloud/free/**

**2. Crée un compte (gratuit)**

**3. Crée une instance :**

- **Shape :** VM.Standard.E2.1.Micro (gratuit)
- **Image :** Ubuntu 22.04
- **Région :** Choisis proche (Europe par exemple)

**4. Note l'IP publique du VPS :**

Exemple : `150.230.45.67`

**5. Télécharge la clé SSH privée** (Oracle la génère pour toi)

**6. Connecte-toi au VPS :**

```powershell
ssh -i C:\chemin\vers\cle_oracle.pem ubuntu@150.230.45.67
```

---

##### Étape 1.2 : Configurer le VPS relais

**Une fois connecté au VPS :**

```bash
# Mettre à jour
sudo apt update && sudo apt upgrade -y

# Installer SSH (normalement déjà installé)
sudo apt install openssh-server -y

# Autoriser le port forwarding
sudo nano /etc/ssh/sshd_config
```

**Trouve et décommente (ou ajoute) :**

```bash
GatewayPorts yes
```

**Sauvegarde et redémarre SSH :**

```bash
sudo systemctl restart ssh
```

---

##### Étape 1.3 : Créer un utilisateur dédié pour le tunnel

**Sur le VPS :**

```bash
# Créer l'utilisateur "tunnel"
sudo adduser tunnel

# Lui donner un mot de passe fort
```

**Ou utilise des clés SSH (recommandé) :**

```bash
# Sur le serveur Sénégal, génère une clé
ssh-keygen -t ed25519 -f ~/.ssh/tunnel_key

# Copie la clé publique vers le VPS
ssh-copy-id -i ~/.ssh/tunnel_key.pub tunnel@150.230.45.67
```

---

#### [SN] PARTIE 2 : CONFIGURATION DU SERVEUR SÉNÉGAL

##### Étape 2.1 : Créer le script de connexion inverse

**Sur le serveur Ubuntu au Sénégal :**

```bash
nano ~/reverse_ssh.sh
```

**Contenu :**

```bash
#!/bin/bash

# IP du VPS relais
VPS_IP="150.230.45.67"
# Utilisateur sur le VPS
VPS_USER="tunnel"
# Port sur lequel le tunnel sera accessible
TUNNEL_PORT="2222"
# Clé SSH privée (si tu utilises des clés)
SSH_KEY="$HOME/.ssh/tunnel_key"

# Créer le tunnel SSH inverse
ssh -N -R $TUNNEL_PORT:localhost:22 $VPS_USER@$VPS_IP -i $SSH_KEY -o ServerAliveInterval=60 -o ServerAliveCountMax=3 -o ExitOnForwardFailure=yes
```

**Explication des options :**

- `-N` : Ne pas exécuter de commande (juste le tunnel)
- `-R 2222:localhost:22` : Redirige le port 2222 du VPS vers le port 22 du serveur Sénégal
- `-o ServerAliveInterval=60` : Envoie un paquet toutes les 60 secondes pour garder la connexion active
- `-o ServerAliveCountMax=3` : Se déconnecte après 3 paquets sans réponse
- `-o ExitOnForwardFailure=yes` : Quitte si le tunnel échoue

**Rendre le script exécutable :**

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

---

##### Étape 2.2 : Tester le tunnel

**Lance le script :**

```bash
~/reverse_ssh.sh
```

**Le terminal va "bloquer" (c'est normal, le tunnel est actif).**

**Laisse ce terminal ouvert.**

---

##### Étape 2.3 : Automatiser avec un service systemd

**Pour que le tunnel se lance automatiquement au démarrage :**

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

**Contenu :**

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

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

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

**[ATTENTION] Remplace `ton_utilisateur` par ton nom d'utilisateur réel.**

**Activer le service :**

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

**Vérifier :**

```bash
sudo systemctl status reverse-ssh
```

**Résultat attendu :**

```
[BLACK_CIRCLE] reverse-ssh.service - Reverse SSH Tunnel to VPS
   Active: active (running)
```

[OK] **Le tunnel est actif en permanence !**

---

#### [FR] PARTIE 3 : CONNEXION DEPUIS LA FRANCE

##### Étape 3.1 : Vérifier que le tunnel fonctionne

**Connecte-toi au VPS relais :**

```powershell
ssh ubuntu@150.230.45.67
```

**Sur le VPS, vérifie les connexions :**

```bash
netstat -tuln | grep 2222
```

**Résultat attendu :**

```
tcp        0      0 0.0.0.0:2222            0.0.0.0:*               LISTEN
```

[OK] **Le port 2222 écoute ! Le tunnel est actif.**

---

##### Étape 3.2 : Se connecter au serveur Sénégal via le relais

**Depuis ton PC en France :**

**Méthode 1 : Connexion directe au VPS sur le port 2222**

```powershell
ssh -p 2222 utilisateur_senegal@150.230.45.67
```

**[ATTENTION] Remplace :**

- `utilisateur_senegal` par l'utilisateur du serveur Sénégal (PAS `tunnel` !)
- `150.230.45.67` par l'IP du VPS

**Si tout va bien :**

```
Welcome to Ubuntu 22.04 LTS
utilisateur_senegal@serveur-senegal:~$
```

[BRAVO] **TU ES CONNECTÉ AU SÉNÉGAL VIA LE RELAIS ! [FR] -> [WEB] -> [SN]**

---

**Méthode 2 : Double saut SSH (plus sécurisé)**

```powershell
ssh -J ubuntu@150.230.45.67 -p 2222 utilisateur_senegal@localhost
```

**Explication :**

- `-J` : Jump host (passe par le VPS)
- Tu te connectes au VPS, qui redirige vers le serveur Sénégal

---

##### Étape 3.3 : Simplifier avec un alias

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

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

**Contenu :**

```
Host senegal-via-relais
    HostName 150.230.45.67
    User utilisateur_senegal
    Port 2222
    IdentityFile ~/.ssh/id_ed25519
```

**Maintenant, tu peux juste taper :**

```powershell
ssh senegal-via-relais
```

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

---

### [VERROUILLE] Sécuriser le tunnel inverse

#### 1. Limiter l'accès au port 2222 sur le VPS

**Sur le VPS, configure le pare-feu :**

```bash
# Installer UFW
sudo apt install ufw -y

# Autoriser SSH normal
sudo ufw allow 22/tcp

# Autoriser UNIQUEMENT ton IP française sur le port 2222
sudo ufw allow from 85.12.34.56 to any port 2222

# Activer UFW
sudo ufw enable
```

**[ATTENTION] Remplace `85.12.34.56` par ton IP publique en France.**

**Si ton IP change souvent, utilise un range :**

```bash
sudo ufw allow from 85.12.0.0/16 to any port 2222
```

---

#### 2. Désactiver l'authentification par mot de passe

**Sur le serveur Sénégal ET sur le VPS, utilise uniquement des clés SSH.**

---

### [GRAPHIQUE] Surveillance du tunnel

**Sur le serveur Sénégal, crée un script de monitoring :**

```bash
nano ~/check_tunnel.sh
```

**Contenu :**

```bash
#!/bin/bash

# Vérifie si le tunnel est actif
if ! pgrep -f "ssh.*$VPS_IP" > /dev/null; then
    echo "Tunnel down! Redémarrage..." >> /var/log/reverse-ssh.log
    systemctl restart reverse-ssh
else
    echo "Tunnel OK" >> /var/log/reverse-ssh.log
fi
```

**Rendre exécutable :**

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

**Ajoute à cron (vérifie toutes les 5 minutes) :**

```bash
crontab -e
```

**Ajoute :**

```
*/5 * * * * /home/ton_utilisateur/check_tunnel.sh
```

---

### [OBJECTIF] RÉCAPITULATIF MÉTHODE 3 (SSH Inverse)

**[OK] Avantages :**

- Fonctionne MÊME si le serveur Sénégal est derrière un NAT strict
- Pas besoin d'accès à la box Internet
- Fonctionne même si le port 22 est bloqué côté Sénégal (le serveur SORT, pas ENTRE)
- Tunnel maintenu en permanence

**[X] Inconvénients :**

- Nécessite un VPS (gratuit possible mais limité)
- Plus complexe à configurer
- Point de défaillance unique (si le VPS tombe, tout s'arrête)
- Latence légèrement supérieure (double saut)

---

## [GRAPHIQUE] TABLEAU COMPARATIF DES 3 MÉTHODES

| Critère | Port Forwarding | VPN (WireGuard) | SSH Inverse |
|---------|----------------|-----------------|-------------|
| **Complexité** | ** Moyenne | *** Élevée | **** Très élevée |
| **Accès box nécessaire** | [OK] Oui | [OK] Oui (pour le VPN) | [X] Non |
| **Coût** | [ARGENT] Gratuit | [ARGENT] Gratuit | [ARGENT][ARGENT] VPS requis |
| **Sécurité** | [VERROUILLE][VERROUILLE][VERROUILLE] Bonne | [VERROUILLE][VERROUILLE][VERROUILLE][VERROUILLE] Excellente | [VERROUILLE][VERROUILLE][VERROUILLE] Bonne |
| **Vitesse** | [RAPIDE][RAPIDE][RAPIDE] Rapide | [RAPIDE][RAPIDE] Rapide | [RAPIDE] Acceptable |
| **Fonctionne avec NAT strict** | [X] Non | [ATTENTION] Difficile | [OK] Oui |
| **Plusieurs services** | [ATTENTION] 1 port = 1 service | [OK] Tous les services | [OK] Tous les services |
| **IP dynamique** | [ATTENTION] Problème | [ATTENTION] Problème | [OK] Pas de problème |

---

## [OBJECTIF] QUELLE MÉTHODE CHOISIR ?

### [OK] Choisis **Port Forwarding** si :

- Tu as accès à la box Internet au Sénégal
- L'IP publique est relativement stable (ou tu peux utiliser DynDNS)
- Tu veux juste SSH (pas besoin d'autres services)
- Tu veux la solution la plus simple

### [OK] Choisis **VPN (WireGuard)** si :

- Tu veux connecter plusieurs appareils
- Tu as besoin d'accéder à plusieurs services (pas juste SSH)
- Tu veux une sécurité maximale
- L'IP change souvent mais tu as accès à la box

### [OK] Choisis **SSH Inverse** si :

- Tu N'AS PAS accès à la box Internet au Sénégal
- Le serveur est derrière un NAT très strict
- Les ports sont bloqués par le FAI
- Tu es prêt à payer/utiliser un VPS gratuit

---

## [OUTILS] COMBINAISONS POSSIBLES

### Option 1 : VPN + SSH

**Utilise WireGuard pour créer le réseau, puis SSH par-dessus.**

**Avantages :**

- Sécurité maximale (double chiffrement)
- Accès à tous les services
- Comme un réseau local

---

### Option 2 : Port Forwarding + DynDNS

**Configure la redirection de port + un nom de domaine dynamique.**

**Avantages :**

- Simple
- Pas besoin de mémoriser l'IP
- Gratuit

---

### Option 3 : SSH Inverse + Autossh

**Utilise `autossh` pour maintenir le tunnel automatiquement.**

**Installation sur le serveur Sénégal :**

```bash
sudo apt install autossh -y
```

**Modifie le script :**

```bash
#!/bin/bash
autossh -M 0 -N -R 2222:localhost:22 tunnel@150.230.45.67 -i ~/.ssh/tunnel_key -o ServerAliveInterval=60 -o ServerAliveCountMax=3
```

**`autossh` redémarre automatiquement le tunnel s'il tombe.**

---

## [TEST] TESTS PRATIQUES

### Test 1 : Vérifier la latence

**Depuis la France, teste le ping :**

```powershell
# Port Forwarding
ping 41.82.123.45

# VPN
ping 10.8.0.1

# SSH Inverse
ping 150.230.45.67
```

**Résultat typique France -> Sénégal :**

- Direct (Port Forwarding) : 150-200 ms
- VPN : 160-210 ms (+ ~10 ms)
- SSH Inverse (via VPS Europe) : 180-250 ms

---

### Test 2 : Transfert de fichiers

**Teste la vitesse de transfert :**

```powershell
# Crée un fichier de test de 100 Mo
fsutil file createnew test100mb.bin 104857600

# Transfert vers le Sénégal
scp test100mb.bin utilisateur@IP:/tmp/
```

**Mesure le temps.**

---

### Test 3 : Stabilité de la connexion

**Laisse une connexion SSH ouverte pendant plusieurs heures.**

**Vérifie qu'elle ne se déconnecte pas.**

**Si déconnexions fréquentes, ajoute dans `~/.ssh/config` :**

```
Host senegal
    ServerAliveInterval 60
    ServerAliveCountMax 3
```

---

## [COURS] RÉCAPITULATIF FINAL

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

1. **Comprendre le NAT** et pourquoi c'est un problème
2. **Port Forwarding** : Redirection de port sur la box
3. **VPN avec WireGuard** : Créer un réseau privé virtuel
4. **SSH Inverse** : Utiliser un serveur relais

### [NOTE] Commandes essentielles :

```bash
# PORT FORWARDING
ssh utilisateur@IP_PUBLIQUE

# VPN
wg-quick up wg0
ssh utilisateur@10.8.0.1

# SSH INVERSE
ssh -R 2222:localhost:22 relais@VPS
ssh -p 2222 utilisateur@VPS
```

---

## [RAPIDE] ALLER PLUS LOIN

### Sécurité renforcée

**1. Fail2Ban sur tous les serveurs**

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

---

**2. Certificats SSL pour le VPN**

Utilise Let's Encrypt si tu as un nom de domaine.

---

**3. Authentification à deux facteurs (2FA)**

Ajoute Google Authenticator sur SSH.

---

### Monitoring

**Installe Netdata pour surveiller les serveurs :**

```bash
bash <(curl -Ss https://my-netdata.io/kickstart.sh)
```

**Accès web : `http://IP:19999`**

---

### Automatisation

**Utilise Ansible pour gérer plusieurs serveurs :**

```bash
sudo apt install ansible -y
```

**Crée un playbook pour déployer SSH automatiquement sur plusieurs machines.**

---

## [BRAVO] FÉLICITATIONS !

Tu maîtrises maintenant **3 méthodes** pour connecter deux machines distantes avec SSH, même à l'international ! [MONDE]

**Tu peux maintenant :**

- [OK] Administrer un serveur au Sénégal depuis la France
- [OK] Choisir la meilleure méthode selon la situation
- [OK] Sécuriser tes connexions SSH
- [OK] Contourner les limitations NAT
- [OK] Créer des tunnels VPN professionnels

**Tu es un expert SSH international ! [RAPIDE][FR][SN]**