188 lines
9.1 KiB
Markdown
188 lines
9.1 KiB
Markdown
# Configuration d'un tunnel Wireguard d'un serveur local à un VPS
|
|
|
|
Cette configuration permet d'établir une connexion entre votre réseau local et un serveur VPS, vous offrant la possibilité d'ouvrir les ports nécessaires sur le VPS sans exposer directement votre réseau. Vous bénéficiez également de la protection DDoS fournie par le serveur distant. Cette solution est pratique si vous ne pouvez pas ouvrir de ports sur votre routeur ou si vous disposez d'une adresse IP dynamique. L'utilisation d'un VPS comme intermédiaire vous permet de contourner les limitations de votre routeur ou de votre fournisseur d'accès Internet, tout en offrant une sécurité supplémentaire.
|
|
|
|
## Prérequis
|
|
|
|
- Un minimum de connaissances en réseau, administration VPS.
|
|
- Vous disposez d'un VPS sur Debian chez IONOS, OVH, autres.
|
|
- Connaître l'adresse IP publique du VPS.
|
|
- Une heure de temps pour faire la configuration.
|
|
|
|
## Installation du serveur WireGuard sur le VPS
|
|
|
|
Connectez-vous en SSH à votre machine :
|
|
|
|
1. Connectez-vous en tant que root :
|
|
```bash
|
|
sudo -i
|
|
```
|
|
2. Suivez les instructions de ce [dépôt](https://github.com/angristan/wireguard-install) pour installer votre serveur WireGuard. Laissez tout par défaut et appelez votre client le nom de votre machine locale pour vous en souvenir si vous créez plusieurs clients.
|
|
4. À la fin de l'installation, vous aurez accès au fichier de configuration. Exécutez la commande `cat /chemindevotrefichier.conf` pour copier les informations du client. Notez ces informations quelque part afin de pouvoir les utiliser plus tard dans le processus d'installation.
|
|
|
|
4. Vous pouvez créer plusieurs clients, mais les machines ne communiqueront pas ensemble avec `iptables -I FORWARD -i wg0 -s 10.66.66.0/24 -d 10.66.66.0/24 -j DROP`, ce qui est une bonne pratique de sécurité.
|
|
5. Vous devez lire le fichier de configuration pour comprendre son fonctionnement :
|
|
|
|
```ini
|
|
# Description :
|
|
# Cette configuration vous permet d'établir une connexion entre une machine dans votre réseau local ou un routeur OPNsense et un serveur VPS. Cela vous permet d'ouvrir les ports nécessaires sur le VPS sans exposer votre réseau local, tout en bénéficiant de la protection DDoS fournie par le serveur distant.
|
|
|
|
# Prérequis :
|
|
# - Avoir un serveur VPS chez OVH ou Ionos avec Debian
|
|
# - Installer https://github.com/angristan/wireguard-install et générer un client
|
|
# - Connaître l'interface réseau en utilisant la commande 'ip a' et remplacer 'ens6' par le nom correct de l'interface
|
|
# - Connaître l'adresse IP publique du VPS
|
|
|
|
# Sauvegarder la configuration actuelle avant de la modifier
|
|
# Effectuez cette sauvegarde avant toute modification
|
|
# cp /etc/wireguard/wg0.conf /etc/wireguard/wg0.conf.bak
|
|
|
|
# Arrêter le service WireGuard avant de modifier la configuration
|
|
# sudo wg-quick down wg0
|
|
|
|
# Modifier la configuration de WireGuard
|
|
# Ouvrez le fichier de configuration pour le modifier
|
|
# nano /etc/wireguard/wg0.conf
|
|
# Supprimez la section entre 'PrivateKey = x' et '### Client opnsense' et rajouter cette configuration avec tout les commentaires pour vous aidez
|
|
# Remplacez 'PORT_WIREGUARD' et 'IP_PUBLIQUE_DU_SERVEUR-VPS' par le port WireGuard et l'adresse IP publique du VPS
|
|
# Il est important d'ouvrir en `PostUp` et en `PostDown` le port que vous avez ouvert.
|
|
# Pour un deuxième client, ajoutez les lignes et modifiez l'adresse IP locale : '10.66.66.3' en prenant exemple sur '10.66.66.2'
|
|
|
|
# Règles iptables à appliquer après avoir configuré l'interface WireGuard
|
|
PostUp = sysctl -w net.ipv4.ip_forward=1 # Active le forwarding IPv4 pour permettre le routage entre les interfaces
|
|
PostUp = iptables -I INPUT -p udp --dport PORT_WIREGUARD -j ACCEPT # Autorise le trafic entrant sur le port UDP de WireGuard (remplacez 'PORT_WIREGUARD' par le numéro de port réel)
|
|
PostUp = iptables -A FORWARD -i wg0 -o ens6 -j ACCEPT # Autorise le trafic passant de l'interface WireGuard (wg0) vers l'interface réseau (ens6)
|
|
PostUp = iptables -A FORWARD -i ens6 -o wg0 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Autorise les connexions établies et connexes à revenir sur l'interface WireGuard
|
|
PostUp = iptables -I FORWARD -i wg0 -s 10.66.66.0/24 -d 10.66.66.0/24 -j DROP # Bloque le trafic interne au sous-réseau WireGuard pour éviter les boucles ou les attaques internes
|
|
|
|
# Règles de translation d'adresse réseau (NAT) pour le trafic sortant et entrant
|
|
PostUp = iptables -t nat -A POSTROUTING -s 10.66.66.2/32 -o ens6 -j SNAT --to-source IP_PUBLIQUE_DU_SERVEUR-VPS # Effectue une translation d'adresse pour le trafic sortant du client vers l'IP publique (remplacez 'IP_PUBLIQUE_DU_SERVEUR' par l'adresse réelle)
|
|
PostUp = iptables -t nat -A PREROUTING -i ens6 -d IP_PUBLIQUE_DU_SERVEUR-VPS -p tcp --dport 80 -j DNAT --to-destination 10.66.66.2:80 # Redirige le trafic HTTP entrant vers l'adresse IP du client WireGuard
|
|
PostUp = iptables -t nat -A PREROUTING -i ens6 -d IP_PUBLIQUE_DU_SERVEUR-VPS -p tcp --dport 443 -j DNAT --to-destination 10.66.66.2:443 # Redirige le trafic HTTPS entrant vers l'adresse IP du client WireGuard
|
|
|
|
# Règles iptables à retirer lors de la suppression de l'interface WireGuard
|
|
PostDown = iptables -D INPUT -p udp --dport PORT_WIREGUARD -j ACCEPT || true # Supprime la règle autorisant le trafic entrant sur le port UDP de WireGuard (remplacez 'PORT_WIREGUARD' par le numéro de port réel)
|
|
PostDown = iptables -D FORWARD -i wg0 -o ens6 -j ACCEPT || true # Supprime la règle autorisant le trafic de wg0 vers ens6
|
|
PostDown = iptables -D FORWARD -i ens6 -o wg0 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT || true # Supprime la règle autorisant les connexions établies à retourner vers wg0
|
|
PostDown = iptables -D FORWARD -i wg0 -s 10.66.66.0/24 -d 10.66.66.0/24 -j DROP || true # Supprime la règle bloquant le trafic interne au sous-réseau WireGuard
|
|
PostDown = iptables -t nat -D POSTROUTING -s 10.66.66.2/32 -o ens6 -j SNAT --to-source IP_PUBLIQUE_DU_SERVEUR-VPS || true # Supprime la règle de NAT pour le trafic sortant du client
|
|
PostDown = iptables -t nat -D PREROUTING -i ens6 -d IP_PUBLIQUE_DU_SERVEUR-VPS -p tcp --dport 80 -j DNAT --to-destination 10.66.66.2:80 || true # Supprime la redirection du trafic HTTP entrant
|
|
PostDown = iptables -t nat -D PREROUTING -i ens6 -d IP_PUBLIQUE_DU_SERVEUR-VPS -p tcp --dport 443 -j DNAT --to-destination 10.66.66.2:443 || true # Supprime la redirection du trafic HTTPS entrant
|
|
|
|
# Redémarrer le service WireGuard après avoir modifié la configuration
|
|
# sudo wg-quick up wg0
|
|
|
|
# Configuration OPNsense :
|
|
# Par exemple, rediriger le port de 192.168.1.x vers [local_ip_wireguard_client_10.66.66.X]
|
|
```
|
|
5. Éditez le fichier de configuration :
|
|
```bash
|
|
nano /etc/wg0.conf
|
|
```
|
|
## Installation du client Wireguard sur le serveur dans votre réseau local
|
|
|
|
Ce guide fournit les instructions étape par étape pour installer le client généré précédemment sur un système Debian.
|
|
|
|
|
|
### 1. Mise à jour du Système
|
|
|
|
Mettez à jour les paquets du système :
|
|
|
|
```bash
|
|
sudo apt update && sudo apt upgrade -y
|
|
```
|
|
|
|
### 2. Installer WireGuard
|
|
|
|
Installez WireGuard à partir des dépôts de Debian :
|
|
|
|
```bash
|
|
sudo apt install wireguard curl resolvconf iptables -y
|
|
```
|
|
|
|
### 3. Générer des Clés
|
|
|
|
Générez une clé privée et une clé publique pour l'interface WireGuard :
|
|
|
|
```bash
|
|
wg genkey | tee privatekey | wg pubkey > publickey
|
|
```
|
|
|
|
### 4. Configurer WireGuard
|
|
|
|
Créez un fichier de configuration pour l'interface WireGuard :
|
|
|
|
```bash
|
|
sudo nano /etc/wireguard/wg0.conf
|
|
```
|
|
|
|
Collez ou modifiez la configuration suivante dans le fichier, en remplaçant les espaces réservés par les valeurs appropriées :
|
|
|
|
```ini
|
|
[Interface]
|
|
PrivateKey = VOTRE_CLE_PRIVEE
|
|
Address = 10.0.0.2/24 # IP locale pour l'interface WireGuard
|
|
ListenPort = 51820 # Le port WireGuard
|
|
|
|
# Autoriser le trafic entrant UDP sur le port 22 depuis le réseau local
|
|
PostUp = iptables -A INPUT -s 192.168.0.0/24 -p udp --dport 22 -j ACCEPT
|
|
|
|
# Bloquer tout autre trafic entrant depuis le réseau local
|
|
PostUp = iptables -A INPUT -s 192.168.0.0/24 -j DROP
|
|
|
|
# Supprimer la règle autorisant le trafic entrant TCP sur le port 22 depuis le réseau local
|
|
PostDown = iptables -D INPUT -s 192.168.0.0/24 -p tcp --dport 22 -j ACCEPT
|
|
|
|
# Supprimer la règle autorisant le trafic entrant UDP sur le port 22 depuis le réseau local
|
|
PostDown = iptables -D INPUT -s 192.168.0.0/24 -p udp --dport 22 -j ACCEPT
|
|
|
|
# Supprimer la règle bloquant tout autre trafic entrant depuis le réseau local
|
|
PostDown = iptables -D INPUT -s 192.168.0.0/24 -j DROP
|
|
|
|
[Peer]
|
|
PublicKey = CLE_PUBLIQUE_DU_SERVEUR
|
|
Endpoint = IP_PUBLIQUE_DU_SERVEUR:51820 # Le port WireGuard
|
|
AllowedIPs = 0.0.0.0/0
|
|
```
|
|
|
|
### 5. Démarrer WireGuard
|
|
|
|
Mettez en route l'interface WireGuard :
|
|
|
|
```bash
|
|
sudo wg-quick up wg0
|
|
```
|
|
|
|
Activez WireGuard au démarrage :
|
|
|
|
```bash
|
|
sudo systemctl enable wg-quick@wg0
|
|
```
|
|
|
|
### 6. Vérifier la Connexion
|
|
|
|
Vérifiez l'état de WireGuard :
|
|
|
|
```bash
|
|
sudo wg
|
|
```
|
|
|
|
### 7. Tester l'IP Publique
|
|
|
|
Vérifiez votre adresse IP publique en utilisant `curl` :
|
|
|
|
```bash
|
|
curl ifconfig.me
|
|
```
|
|
|
|
### 8. Arrêter WireGuard
|
|
|
|
Fermez l'interface :
|
|
|
|
```bash
|
|
sudo wg-quick down wg0
|
|
```
|
|
### 9. Votre serveur est normalement accessible
|
|
|
|
Votre serveur est normalement accessible depuis l'extérieur et bloque le trafic du réseau local.
|