Wireguard est un peu moins connu que le lourd et vieux OpenVPN.

Il est moderne, très petit (une bonne chose pour la sécurité), très robuste, très rapide et très facile à gérer. Cela fait qu'on le retrouve de plus en plus sur Linux. Il convient moins pour des installations majeures et complexes ou à base de certificats par exemple.

Il existe des clients pour toutes les plateformes, y compris sur les smartphones.

Comme n'importe quel VPN, il permet

• de rassembler des machines distantes dans un même réseau local virtuel, tout en cryptant les communications entre elles. Il permet cela via la création d'une interface réseau additionnelle sur le poste, et virtuelle.
• Potentiellement, un VPN permet aussi de router et faire "ressortir" physiquement le trafic réseau d'une machine au niveau du serveur VPN. C'est une fonctionalité très médiatique, car elle permet de contourner des restrictions locales ou légales en restant "sous le radar" (jusqu'au point de sortie sur l'internet, généralement le serveur VPN)
• Le VPN peut cependant venir *en sus* d'une connexion existante vers l'internet. C'est utile pour ne pas impacter le débit des machines locales sans encombrer la bande passante du serveur.

Note : La version la plus pauvre d'un VPN ressemble assez à ce que l'on fait avec un tunnel SSH.

Installer WireGuard coté serveur et coté clients:

apt install wireguard

Il faut générer des clés privées et publiques sur chacun des postes et du serveur:

cd /etc/wireguard/
wg genkey | tee privatekey | wg pubkey > publickey
chmod go= privatekey

(vous obtiendrez des clés de la forme PeURxj4Q75RaVhBKkRTpNsBPiPSGb5oQijgJsTa29hg=)

voyez ci-dessous l'usage futé de cette ruse pour dé-anonymiser les clés générées, c'est probablement utile.

apt install ufw  # requis coté server

Sur le serveur, créer /etc/wireguard/wg0.conf, par exemple ci-desous. Les blocs "peer" sont les (futurs) clients, vous avez besoin de leurs clés publiques. Le ens2 est l'interface réseau publique que vous utilisez, que vous pourrez obtenir avec ip route list default.

[Interface]
Address = 10.0.0.1
ListenPort = 51820
# DNS = 1.1.1.1   # si voulu
PrivateKey = [ServerPrivateKey]
SaveConfig = true

## Nécessaire
PostUp = ufw route allow in on wg0 out on ens2
PreDown = ufw route delete allow in on wg0 out on ens2

## Si les peers doivent pouvoir sortir vers l'internet à travers
## le serveur, qui agira alors comme un proxy VPN:
PostUp = iptables -t nat -I POSTROUTING -o ens2 -j MASQUERADE
PreDown = iptables -t nat -D POSTROUTING -o ens2 -j MASQUERADE

## Si les peers doivent pouvoir communiquer entre eux,
## attention, cette approche est laxiste, préférez plutôt "ufw"
#PostUp = iptables -A FORWARD -i wg0 -j ACCEPT
#PostDown = iptables -D FORWARD -i wg0 -j ACCEPT

Pensez aussi à configurer la ligne net.ipv4.ip_forward=1 dans /etc/sysctl.conf (ou bien seulement dans /etc/ufw/sysctl.conf)

Pour ajouter des clients vous pouvez aussi utiliser la commande suivante plutôt que d'éditer le fichier de configuration, si vous n'utilisez pas de PreSharedKey (sinon voyez ci-après):

wg set wg0 peer ClientPublicHexKey allowed-ips 10.0.0.x/32
wg   # pour vérifier la config

si la key contient un slash "/", wg pensera parfois que ce sont des fichiers et non des valeurs immédiates. Il indiquera une erreur relative à fopen dans ce cas. vous pouvez parfois éviter le bug en fournissant le nom du fichier qui contient la clé (souvent le PreSharedKey ci-dessous)

Cela va créer des paragraphes supplémentaires dans la configuration serveur de wireguard:

[Peer]
PublicKey = [Peer1PublicKey]
# PresharedKey = [Peer1PresharedKey]   # si utilisé, voir ci-dessous
AllowedIPs = 10.0.0.10/32

[Peer]
PublicKey = [Peer1PublicKey]
AllowedIPs = 10.0.0.11/32

Vous auriez pu ajouter à la sécurité une clé symétrique, généralement spécifique à un client donné et indiquées chez le client et chez le serveur.

wg genpsk > Peer1PubKey

Elle devra être spécifié dans le [Peer] du serveur pour le client Peer1 ainsi qu'être mentionnée dans le [Interface] du client. On pourrait utiliser la même clé pour tous les client, mais c'est moins recommandé.

Dans ce cas l'ajout d'un client sur le serveur se fait avec:

wg set wg0 peer <Peer1PubKey> preshared-key <Peer1PreKey> allowed-ips 10.0.0.x/32

Retirer un client se fait ainsi:

wg set wg0 peer <ClientPublicHexKey> remove

Si vous n'utilisez pas SaveConfig = true ci-avant (c'est peut être préférable), validez avec

wg-quick save wg0

l'usage de wg save va écraser le fichier de configuration et tous ses commentaires Ca ne permet donc pas de conserver une idée claire de quelle clé appartient à qui. Voyez cette ruse pour trouver un clé publique qui contient un identifiant de l'utilisateur (ex. ses initiales). L'autre option conseillée est de créer un dossier client-keys par exemple en y conservant les clés publiques sous la forme de fichiers nomduclient.vpnip.pub.

Wireguard offre une pré-configuration systemd bien pratique:

systemctl start wg-quick@wg0.service
systemctl status wg-quick@wg0.service
#systemctl stop wg-quick@wg0.service

Et pour un démarrage automatique au lancement du serveur:

systemctl enable wg-quick@wg0.service  

Enfin, il faut autoriser le service wireguard lui-même

ufw allow 51820

(on pourrait être plus restrictif)

lorsque l'on a plusieurs services, il arrive que l'un ne démarre pas. On peut "ruser" en ajoutant dans /lib/systemd/system/wg-quick@.service une ligne de ce type dans la section [Service]: ExecStartPre=/bin/bash -c "until host vpn.monserveur.com &>/dev/null; do sleep 1; done"

Lister les client connectés

watch wg show all dump

Déboguer via le log kernel:

echo module wireguard +p > /sys/kernel/debug/dynamic_debug/control
dmesg -wT | grep wireguard
# ... control-C
echo module wireguard -p > /sys/kernel/debug/dynamic_debug/control

si vous ne laissez pas les clients communiquer librement entre eux (cf. les deux lignes iptables FORWARD dans le fichier de config), mais que vous voulez quand même permettre certains services entre clients, il faudra l'autoriser explicitement.

L'usage de ufw facilite l'écriture de règles précises. Par exemple, pour laisser un client particulier (10.0.0.10) se connecter au client (10.0.0.11) en SSH port 22:

ufw route allow in on wg0 out on wg0 from 10.0.0.10 to 10.0.0.11 port 22

Note: pour supprimer une règle, trouvez son index avec ufw status numbered puis faites un ufw delete INDEX. Attention au réordonnancement si vous devez éliminer plusieurs règles !

Exemple pour une autorisation d'un poste administrateur vers tous les clients VPN et tous les ports:

ufw route allow in on wg0 out on wg0 from 10.0.0.10 to 10.0.0.0/8

S'il n'est pas déja actif, activez-le: ufw enable ( avez-vous bien pensé à laisser passer l'acces SSH pour ne pas vous interdire l'accès?!)

Pour déboguer vos règles UFW vous pouvez faire ceci:

ufw logging low
tail -f /var/log/ufw.log
ufw logging off

Vous pouvez utiliser le parefeu aussi pour "ouvrir" un port standard qui serait bloqué chez le client. Par exemple si votre wireguard tourne sur le port 12345 qui est bloqué chez le client, vous pouvez rediriger le port 8080 qui est souvent autorisé vers le 12345 de cette façon (ens2 est ici l'interface d'entrée pour le serveur et -d 11.22.33.44 l'IP optionnelle de ce client)

iptables -t nat -I PREROUTING -i ens2 -d 11.22.33.44 -p udp -m multiport --dports 8080 -j REDIRECT --to-ports 12345

Sur chaque client, créer /etc/wireguard/wg0.conf. Le "peer" est ici le serveur.

[Interface]
Address = 10.0.0.10
PrivateKey = [Peer1PrivateKey]

[Peer]
PublicKey = [ServerPublicKey]
PresharedKey = [PresharedKey]
Endpoint = url.totheserver.com:51820
# IP cibles autorisées (ici tout le sous-réseau VPN)
# Utilisez "0.0.0.0/0" si vous voulez router tout le traffic via le serveur
AllowedIPs = 10.0.0.0/24

# Si vous êtes derrière un NAT vous pouvez maintenir la connexion avec:
PersistentKeepalive = 25

Bien sûr url.totheserver.com peut être une adresse IP

Réglez les droits avec chmod go-rwx /etc/wireguard/wg0.conf.

si vous passez par une connection 3G indirecte, vous aurez probablement à réduire la taille de vos paquets ethernet (ajoutez MTU=1280 dans la section [Interface]). Ref et explications avancées.

Pour un usage manuel côté client on aura:

wg-quick up wg0    # démarrer
wg-quick down wg0  # arrêter

S'il tourne, on peut vérifier les informations avec wg show, coté serveur et coté client, ou bien wg show all dump pour un journal plus compact.

Pour un lancement automatique:

systemctl enable wg-quick@wg0.service
systemctl start wg-quick@wg0.service
systemctl status wg-quick@wg0.service

Sources: ici et là

L'application officielle permet une configuration via QR code bien pratique. Il faut d'abord constituer le fichier de configuration android.conf et le ClientPrivatekey associé au client depuis un autre poste, par exemple:

[Interface]
Address = 10.0.0.123/32
PrivateKey = [ClientPrivatekey]=

[Peer]
Endpoint = wg.tecrd.com:51820
AllowedIPs = 10.0.0.0/24
PublicKey = [ServerPublicKey]=

Ensuite, vous pouvez utiliser la commande suivante pour générer le QR code de configuration à scanner depuis le téléphone:

qrencode -t ansiutf8 < android.conf

Si la connexion est refusée, vous aurez peut être à désactiver l'option "DNS Privé" dans le panneau de configuration du téléphone.

Cas d'usage : pouvoir accéder et gérer un PC windows à distance. Je recommande le "Windows Remote Desktop" de chez Microsoft (évitez toujours les tiers !). La partie "serveur" (coté PC qui doit être controllé) est disponible dans les versions "pro" de windows mais pas dans les version "familial". Le client MSRDP est par contre disponible sur n'importe quel windows.

Pour le client Wireguard sous windows, installer le fichier MSI téléchargeable sur https://www.wireguard.com/install/

Dans cette application, en bas à gauche de l'écran, sélectionner "Ajouter" en bas à gauche de l'écran, puis "AJouter un tunnel vide". Les clés privées et publiques du poste seront créées. Il faudra transmettre la clé publique au serveur. A la suite de la lé privée dans la section [Interface], vous pouvez ajouter les éléments ci-avant, tels quel:

Address = 10.0.0.XXX/32
MTU = 1280

[Peer]
PublicKey = [CléPubliqueDuServeur]
PresharedKey = [SiElleExiste]
AllowedIPs = 10.0.0.0/24
Endpoint = [IpServer:Port]
PersistentKeepalive = 25

De là, pour accéder au PC à distance, vous pouvez aller dans le menu windows, Paramètres / Système / Bureau à distance, l'activer, noter le nom du PC et autoriser ou noter le nom des utilisateurs autorisés à se connecter.