272 lines
9.2 KiB
Markdown
272 lines
9.2 KiB
Markdown
---
|
|
title: Wireguard 14
|
|
description: Ancien guide WireGuard 14 conservé à titre archivé, voir le guide WireGuard à jour pour une installation actuelle.
|
|
---
|
|
|
|
|
|
:ellipsis{left=0px width=40rem top=10rem blur=140px zIndex=60}
|
|
|
|
::note{to="/serveex/core/wireguard"}
|
|
|
|
wg-easy 15 est devenu bien plus compliqué, « not so easy » dirait-on. C'est justement pour ça que ce vieux tutoriel v14 vaut la peine d'être gardé sous le coude : c'est toujours la façon la plus simple de monter un serveur WireGuard si vous n'avez pas besoin de ce qu'apporte la nouvelle version.
|
|
::
|
|
|
|
## Introduction
|
|
L'utilisation d'un VPN permet d'accéder à distance aux ressources locales du serveur sans les exposer sur internet. C'est notamment une manière propre de sécuriser l'accès à la console SSH, plutot que d'exposer le port sur internet. C'est pouvoir se connecter à son réseau où que l'on soit, de maniere sécurisée, et de faire dialoguer des machines qui sont sur des réseaux différents.
|
|
|
|
Ici nous utiliserons [Wireguard](https://www.wireguard.com/), un serveur VPN sécurisé et très performant, à l'aide des conteneurs :
|
|
|
|
- [wg-easy](https://github.com/wg-easy/wg-easy) pour le serveur, qui propose une interface web très simple pour controler les connexions et télécharger les fichiers de conf (notamment par QR code pour les téléphones)
|
|
- [Wireguard](https://docs.linuxserver.io/images/docker-wireguard/?h=wireguard) pour les clients linux
|
|
|
|
Il existe aussi des clients Windows, MacOS, iOS et Android.
|
|
|
|
Le principe est le suivant :
|
|
|
|
- Sur internet, n'importe qui peut contacter n'importe quel box internet et donc essayer de contacter n'importe quel serveur exposé.
|
|
- Votre serveur est sur votre réseau local. Il est accessible depuis le réseau local mais pas depuis internet, mis à part les services exposés (comme nous l'avons fait avec Dockge). Pour accéder aux ressources non exposées, vous devez être connecté sur le meme réseau que votre serveur et donc etre chez vous. De plus, vous devez laisser ouvert les ports utilisés par vos services à travers le pare feu de votre serveur.
|
|
- Nous souhaitons ici au contraire, depuis n'importe où, pouvoir accéder de maniere securisée aux services non exposés sur internet du serveur, comme la console SSH qui permet de se connecter à la machine par exemple.
|
|
- Nous souhaitons aussi accéder aux services d'autres serveurs, et par exemple relier de maniere sécurisée deux instances de Dockge pour tout controler depuis la meme interface.
|
|
|
|
Pour cela nous allons créer un **réseau privé virtuel**, ou VPN, c'est à dire un tunnel sécurisé auquel personne n'a accès à part les machines que vous relierez entre elles. Elles feront partie d'un nouveau réseau et pourront dialoguer entre elle comme dans un réseau local.
|
|
|
|
D'autre part, vous pourrez ajouter votre téléphone, un ordinateur portable ou n'importe quel appareil au réseau pour pouvoir utiliser vos ressources depuis vos appareils quotidiens, où que vous soyiez.
|
|
|
|
|
|
|
|
Dans cette illustration, la machine 1 est sur deux réseaux :
|
|
|
|
- son réseau local (tous les appareils liés à la box, avec une adresse IP du type `192.168.x.x ` donc ici la machine 1 et la machine 2)
|
|
- le réseau du VPN (tous les appareils reliés au VPN, avec une seconde adresse IP du type `10.8.x.x` donc ici la machine 1 et 4)
|
|
|
|
On peut aussi faire en sorte que les machines reliées au réseau virtuel partagent les acces à leur réseau local. Ici nous ne le ferons pas, pour des raisons de sécurité, et de complexité en terme de sous-réseau (si les deux machines distantes ont des machines locales qui utilisent la meme adresse IP locale, par exemple `192.168.1.1`, cela posera des conflits).
|
|
|
|
Ainsi, sur le réseau virtuel, seules les machines directement reliées pourront dialoguer entre elle depuis ce réseau. Elles ne pourront pas dialoguer avec une machine situées sur un autre réseau local et non reliée au VPN.
|
|
|
|
## Côté serveur
|
|
::note
|
|
📋 __À vérifier au préalable :__
|
|
|
|
- Vérifiez que le port `51820 UDP` est disponible et correctement redirigé par votre box vers le serveur (`Source 51820 UDP -> Destination 51820 UDP -> Serveur`).
|
|
- Vérifiez que le port `51821 TCP` est disponible pour l'interface web.
|
|
::
|
|
|
|
::warning{to="https://wg-easy.github.io/wg-easy/latest/"}
|
|
|
|
__Attention :__ ce tutoriel utilise la version `14` de **wg-easy**. La version `15` introduit des changements incompatibles avec cette configuration.
|
|
::
|
|
|
|
::file-tree
|
|
---
|
|
tree:
|
|
/:
|
|
- srv:
|
|
- docker:
|
|
- wg-easy:
|
|
- config:
|
|
- etc_wireguard/
|
|
- compose.yaml
|
|
- .env
|
|
---
|
|
::
|
|
|
|
Le conteneur tourne en mode `HOST`, c'est-à-dire qu'il utilise directement la pile réseau de l'hôte.
|
|
|
|
::steps{level="3"}
|
|
### Déployer la stack
|
|
|
|
Ouvrez Dockge, cliquez sur `compose`, et nommez la stack `wg_easy`.
|
|
|
|
Collez la configuration suivante :
|
|
|
|
```yaml [compose.yaml]
|
|
---
|
|
services:
|
|
wg-easy:
|
|
network_mode: host
|
|
env_file:
|
|
- .env
|
|
environment:
|
|
- LANG=fr
|
|
- WG_HOST=${HOST}
|
|
- PASSWORD_HASH=${PW}
|
|
- WG_DEFAULT_ADDRESS=${ADDRESS}
|
|
- WG_HIDE_KEYS=never
|
|
- WG_ALLOWED_IPS=${IPS}
|
|
- WG_DEFAULT_DNS=
|
|
- UI_TRAFFIC_STATS=true
|
|
- UI_CHART_TYPE=1
|
|
image: ghcr.io/wg-easy/wg-easy:14
|
|
container_name: wg-easy
|
|
volumes:
|
|
- /srv/docker/wg_easy/config/etc_wireguard:/etc/wireguard
|
|
restart: unless-stopped
|
|
cap_add:
|
|
- NET_ADMIN
|
|
- SYS_MODULE
|
|
```
|
|
|
|
::tip{icon=""}
|
|
✨ __Astuce :__
|
|
|
|
- Vous pouvez aussi indiquer votre propre port WireGuard avec `WG_PORT`
|
|
- Ajoutez le label Watchtower pour activer les mises à jour automatiques
|
|
|
|
```yaml [compose.yaml]
|
|
---
|
|
services:
|
|
wg-easy:
|
|
#...
|
|
labels:
|
|
- com.centurylinklabs.watchtower.enable=true
|
|
```
|
|
::
|
|
|
|
Dans le `.env` :
|
|
|
|
```properties [.env]
|
|
HOST=
|
|
PW=
|
|
ADDRESS=
|
|
IPS=
|
|
```
|
|
|
|
| Variable | Description | Exemple |
|
|
|--------------|-------------|---------|
|
|
| `HOST` | IP publique d'accès à votre hôte (l'IP de la box si c'est chez vous) | `80.75.137.27` |
|
|
| `PW` | Hash bcrypt du mot de passe, [à générer ici](https://bcrypt-generator.com/). **ATTENTION :** doublez les `$` | `$$2a$$12$$FF6T4QqSP9Ho` |
|
|
| `ADDRESS` | Plage d'adresses DHCP du VPN, le `x` doit rester, les autres chiffres peuvent varier | `10.8.0.x` |
|
|
| `IPS` | Les IP routées par les clients dans le VPN. Utilisez `10.8.0.0/24` pour ne router que le trafic du VPN. Pour inclure le réseau local, ajoutez `192.168.0.0/16` séparé par une virgule. | `10.8.0.0/24` |
|
|
|
|
Déployez la stack.
|
|
|
|
### Terminé !
|
|
::
|
|
|
|
### Activer le forwarding sur l'hôte
|
|
|
|
Pour permettre la communication entre les clients du VPN, activez :
|
|
|
|
```bash [Terminal]
|
|
sudo sysctl net.ipv4.ip_forward=1
|
|
sudo sysctl net.ipv4.conf.all.src_valid_mark=1
|
|
```
|
|
|
|
### Récupérer les fichiers de configuration
|
|
|
|
Pour configurer les clients, téléchargez les fichiers de configuration depuis le serveur :
|
|
|
|
- Allez sur `http://ipdevotreserveur:51821`
|
|
- Créez un client
|
|
- Téléchargez le fichier de configuration
|
|
- Renommez-le en `wg0.conf`
|
|
|
|
::caution
|
|
|
|
En cas d'échec, vérifiez les règles de votre pare-feu.
|
|
::
|
|
|
|
## Sur le serveur client
|
|
::note
|
|
|
|
Nous partons du principe que le client est un serveur Linux avec Docker installé
|
|
::
|
|
|
|
::file-tree
|
|
---
|
|
tree:
|
|
/:
|
|
- srv:
|
|
- docker:
|
|
- wireguard:
|
|
- config:
|
|
- wg_confs/
|
|
- compose.yaml
|
|
---
|
|
::
|
|
|
|
::steps{level="3"}
|
|
### Créer le dossier de configuration
|
|
|
|
Créez le dossier `/srv/docker/wireguard/config/wg_confs` :
|
|
|
|
::tip{icon="" to="/serveex/files/file-browser-quantum"}
|
|
✨ __Astuce :__ utilisez **File Browser** pour parcourir et modifier vos fichiers sans terminal
|
|
::
|
|
|
|
```bash [Terminal]
|
|
sudo mkdir -p /srv/docker/wireguard/config/wg_confs
|
|
```
|
|
|
|
### Copier le fichier de configuration
|
|
|
|
Copiez le fichier `wg0.conf` téléchargé précédemment :
|
|
|
|
::tip{icon=""}
|
|
✨ __Astuce :__ le plus simple est de transférer le fichier en SFTP dans `/home/votreutilisateur`, puis de le déplacer :
|
|
|
|
```bash [Terminal]
|
|
sudo cp ~/wg0.conf /srv/docker/wireguard/config/wg_confs
|
|
```
|
|
::
|
|
|
|
### Déployer le conteneur
|
|
|
|
Créez le `compose.yaml` dans `/srv/docker/wireguard` :
|
|
|
|
```bash [Terminal]
|
|
sudo nano /srv/docker/wireguard/compose.yaml
|
|
```
|
|
|
|
Collez :
|
|
|
|
```yaml [compose.yaml]
|
|
---
|
|
services:
|
|
wireguard:
|
|
image: lscr.io/linuxserver/wireguard:latest
|
|
container_name: wireguard
|
|
network_mode: host
|
|
cap_add:
|
|
- NET_ADMIN
|
|
- SYS_MODULE #facultatif
|
|
environment:
|
|
- TZ=Europe/Paris
|
|
volumes:
|
|
- /srv/docker/wireguard/config:/config
|
|
- /lib/modules:/lib/modules #facultatif
|
|
restart: unless-stopped
|
|
```
|
|
|
|
Appuyez sur :kbd{value="Ctrl+O"}, puis :kbd{value="Enter"} pour enregistrer, et :kbd{value="Ctrl+X"} pour quitter.
|
|
|
|
Démarrez le conteneur :
|
|
|
|
```bash [Terminal]
|
|
cd /srv/docker/wireguard
|
|
sudo docker compose up -d
|
|
```
|
|
|
|
::note
|
|
|
|
Répétez pour chaque client
|
|
::
|
|
|
|
### Terminé !
|
|
::
|
|
|
|
## Autres appareils
|
|
|
|
- **Téléphone :** installez Wireguard et scannez le QR code depuis l'interface web (`http://ipdevotreserveur:51821`)
|
|
- **PC :** installez le client Wireguard et importez le fichier de configuration
|
|
|
|
::warning
|
|
|
|
__Attention :__ si un appareil client est sur le même réseau local que le serveur, modifiez `wg0.conf` et remplacez l'endpoint par l'IP locale du serveur :
|
|
`Endpoint = ip-de-votre-serveur:51820`
|
|
::
|
|
|
|
Et voici le résultat :
|
|
|
|
|