Contrôle d’accès WireGuard avec Iptables

WireGuard vous permet de sécuriser l’accès à un hôte (c’est-à-dire un ordinateur, un téléphone mobile, un appareil Internet des objets, etc.) à partir d’un autre. Pour un hôte donné, vous pouvez contrôler les autres hôtes qui peuvent se connecter au premier hôte via WireGuard en spécifiant les clés publiques des autres hôtes dans la configuration de WireGuard du premier hôte. Cependant, WireGuard n’a pas un mécanisme intégré pour contrôler les services ou d’autres hôtes auxquels vous pouvez vous connecter via cette connexion WireGuard. Pour y parvenir, vous devez utiliser le logiciel de pare-feu sur l’hôte lui-même.

Iptables est le logiciel de pare-feu le plus couramment utilisé sous Linux. Cet article vous montrera comment utiliser iptables pour appliquer des ACLs (Listes de contrôle d’accès) aux services réseau exposés via WireGuard, pour chaque topologie primaire de WireGuard:

1. Point à Point
2. Hub et Spoke
3. Point à Site
4. Site à Site

Réseau d’exemple

Pour cet article, nous utiliserons le réseau suivant, où nous devons connecter six hôtes spécifiques entre eux, trois desquels sont sur le même LAN (Réseau local), que je nommerai Site A, et trois d’entre eux sont à distance :

Figure 1. Accès au réseau autorisé

La Station de travail d’Alice, située sur le LAN, doit être en mesure de se connecter aux ports TCP 22 (SSH), 25 (SMTP, pour envoyer un e-mail) et 143 (IMAP, pour vérifier son e-mail) sur le Serveur de messagerie ; les ports TCP 22 (SSH, pour l’accès sécurisé via shell), 80 (l’application web principale) et 8080 (une deuxième application web d’administration secondaire) sur le Serveur Web ; et le port TCP 5900 sur le Serveur VNC (Calcul distant réseau, pour accéder à une application de bureau en cours d’exécution sur le serveur).

La station de travail de Bob, située dans un bureau distant, doit être capable de se connecter aux ports TCP 25 (SMTP) et 143 (IMAP) du serveur de messagerie ; les ports TCP 80 (application HTTP principale) et 8080 (“application HTTP admin”) du serveur Web ; et le port TCP 5900 du serveur VNC.

Le portable de Cindy, situé dans son bureau à domicile ou en route, doit être capable de se connecter aux ports TCP 25 (SMTP) et 143 (IMAP) du serveur de messagerie ; et le port TCP 80 du serveur Web.

Le serveur VNC est situé dans un environnement cloud distant. Il doit accéder au port TCP 25 du serveur de messagerie (pour envoyer des e-mails), et au port TCP 80 du serveur Web (pour communiquer avec l’API web de l’application principale).

Les serveurs de messagerie et de Web sont situés sur le LAN. Le serveur Web doit accéder au port TCP 25 du serveur de messagerie, pour envoyer des e-mails.

En tableau, nos ACLs ressembleraient à ceci :

Tableau 1. ACL réseau

Autoriser | | | Serveur Web | 80 | Station de travail de Bob | Autoriser | | | Serveur Web | 80 | Portable de Cindy | Autoriser | | | Serveur Web | 80 | Serveur VNC | Autoriser | | | Serveur Web | 8080 | Station de travail d’Alice | Autoriser | | | Serveur Web | 8080 | Station de travail de Bob | Autoriser | | | Serveur VNC | 5900 | Station de travail d’Alice | Autoriser | | | Serveur VNC | 5900 | Station de travail de Bob | Autoriser | | | Tout le reste | Tout le reste | Tout le reste | Refuser | |

Pour simplifier, nous configurerons et déconfigurerons nos règles iptables via les paramètres PreUp et PostDown dans le fichier de configuration de l’interface WireGuard sur chaque hôte ; et nous nommerons l’interface WireGuard sur chaque hôte wg0 (en utilisant un fichier de configuration nommé /etc/wireguard/wg0.conf sur chaque hôte). De plus, nous utiliserons uniquement la version IPv4 d’iptables. La version IPv6 d’iptables fonctionne de la même manière, à l’exception du remplacement de la commande ip6tables par la commande iptables.

Point à point

Si nous utilisions WireGuard pour connecter nos hôtes exemples avec une topologie point à point, le diagramme réseau ressemblerait à ceci :

Figure 2. Réseau point à point

Nous utiliserions la redirection de ports (DNAT, Destination Network Address Translation) sur le routeur Internet au Site A pour permettre l’accès Internet au Serveur Mail sur le port 51823 et au Serveur Web sur le port 51824. Le Serveur VNC serait accessible à Internet via une adresse IP statique à 203.0.113.50. La Workstation d’Alice, la Workstation de Bob et l’Ordinateur portable de Cindy n’auraient pas d’adresses IP Internet fixes (et ainsi, ils devraient être l’initiateur de toute connexion WireGuard à un autre hôte).

Pour aider à garder tous ces adresses en ordre, voici un tableau des adresses publiques du point de terminaison de chaque hôte, de son adresse et de son port au sein du réseau local Site A, ainsi que de son adresse IP interne VPN WireGuard (Réseau Privé Virtuel) :

Tableau 2. Adresses point à point

Depuis chaque hôte est connecté directement aux autres hôtes via WireGuard, nous utiliserons leurs adresses IP privées WireGuard pour nos règles iptables et les appliquerons à la chaîne INPUT des règles iptables.

Les pare-feux pour les trois postes de travail des utilisateurs sont faciles car ils permettent uniquement les connexions initiées par l’extérieur. Comme ils sont simples, nous ajouterons simplement quelques règles directement à la chaîne INPUT. Les paramètres de chaque hôte seront identiques à ceux du pare-feu “Point A” dans le tutoriel configuration point-à-point — sauf que dans ce guide, nous supposerons que vous pouvez également ajuster les politiques par défaut de la chaîne iptables pour refuser toutes les connexions par défaut, comme décrit par la recommandation Politiques de chaîne à la fin de cet article. Lorsque vous refusez l’accès par défaut, vous avez besoin d’une règle supplémentaire de pare-feu pour accepter explicitement les connexions sur le port d’écoute de votre interface WireGuard (51820 ci-dessous):

# paramètres locaux pour le poste de travail d'Alice
[Interface]
PrivateKey = ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFA=
Address = 10.0.0.2/32
ListenPort = 51820

Cette configuration permettra à la Workstation d’Alice de recevoir les connexions sur le port 51820, qui est utilisé pour l’interface WireGuard.

enPort = 51820

# ingress WireGuard
PreUp = iptables -I INPUT -p udp --dport 51820 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51820 -j ACCEPT

# pare-feu local
PreUp = iptables -A INPUT -i wg0 -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A INPUT -i wg0 -j REJECT
PostDown = iptables -D INPUT -i wg0 -m state --state ESTABLISHED,RELATED -j ACCEPT
PostDown = iptables -D INPUT -i wg0 -j REJECT

# paramètres distants pour le serveur de messagerie
[Peer]
PublicKey = jUd41n3XYa3yXBzyBvWqlLhYgRef5RiBD7jwo70U+Rw=
Endpoint = 192.168.1.63:51823
AllowedIPs = 10.0.0.3/32

# paramètres distants pour le serveur Web
[Peer]
PublicKey = MMsBeTT9v/7XNWB8a/jSMn9O8olPVNduUwvUPJ6eB14=
Endpoint = 192.168.1.44:51824
AllowedIPs = 10.0.0.4/32

# paramètres distants pour le serveur VNC
[Peer]
PublicKey = kAYKIv6gpBDqueaVNOsY8ddKmIC2dnnXJQ0iKzWxfBI=
Endpoint = 203.0.113.50:51825
AllowedIPs = 10.0.0.5/32

# paramètres locaux pour le bureau de Bob
[Interface]
PrivateKey = EFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA=
Address = 10.0.0.6/32
ListenPort = 51820

# ingress Wireguard
PreUp = iptables -I INPUT -p udp --dport 51820 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51820 -j ACCEPT

# pare-feu local
PreUp = iptables -A INPUT -i wg0 -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A INPUT -i wg0 -j REJECT
PostDown = iptables -D INPUT -i wg0 -m state --state ESTABLISHED,RELATED -j ACCEPT
PostDown = iptables -D INPUT -i wg0 -j REJECT

# paramètres distants pour le serveur de messagerie
[Peer]
PublicKey = jUd41n3XYa3yXBzyBvWqlLhYgRef5RiBD7jwo70U+Rw=
Endpoint = 198.51.100.10:51823
AllowedIPs = 10.0.0.3/32

# paramètres distants pour le serveur Web
[Peer]
PublicKey = MMsBeTT9v/7XNWB8a/jSMn9O8olPVNduUwvUPJ6eB14=
Endpoint = 198.51.100.10:51824
AllowedIPs = 10.0.0.4/32

# paramètres distants pour le serveur VNC
[Peer]
PublicKey = kAYKIv6gpBDqueaVNOsY8ddKmIC2dnnXJQ0iKzWxfBI=
Endpoint = 203.0.113.50:51825
AllowedIPs = 10.0.0.5/32

# paramètres locaux pour le portable de Cindy
[Interface]
PrivateKey = GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGA=
Address = 10.0.0.7/32
ListenPort = 51820

# ingress Wireguard
PreUp = iptables -I INPUT -p udp --dport 51820 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51820 -j ACCEPT

# pare-feu local
PreUp = iptables -A INPUT -i wg0 -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A INPUT -i wg0 -j REJECT
PostDown = iptables -D INPUT -i wg0 -m state --state ESTABLISHED,RELATED -j ACCEPT
PostDown = iptables -D INPUT -i wg0 -j REJECT

# paramètres distants pour le serveur de messagerie
[Peer]
PublicKey = jUd41n3XYa3yXBzyBvWqlLhYgRef5RiBD7jwo70U+Rw=
Endpoint = 198.51.100.10:51823
AllowedIPs = 10.0.0.3/32

# paramètres distants pour le serveur Web
[Peer]
PublicKey = MMsBeTT9v/7XNWB8a/jSMn9O8olPVNduUwvUPJ6eB14=
Endpoint = 198.51.100.10:51824
AllowedIPs = 10.0.0.4/32

Le serveur de messagerie est le plus complexe ; passons-y ensuite. Il accepte les connexions de tous les autres hôtes dans notre réseau WireGuard, mais doit limiter l’accès à certaines ports pour certains hôtes (par exemple, pour permettre un accès SSH uniquement depuis la Workstation d’Alice ; consultez le tableau ACL du réseau pour la liste complète).

Nous pourrions ajouter toutes nos règles iptables directement à la chaîne INPUT ; mais pour garder les choses mieux organisées, nous ajoutons quatre chaînes personnalisées (wg0-input, wg0-input-ssh, wg0-input-smtp, et wg0-input-imap), et dirigeons les paquets entrants de notre interface WireGuard wg0 à travers elles :

# paramètres locaux pour le serveur de messagerie
[Interface]
PrivateKey = CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCGA=
Address = 10.0.0.3/32
ListenPort = 51823

# ingress WireGuard
PreUp = iptables -I INPUT -p udp --dport 51823 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51823 -j ACCEPT

# pare-feu local
PreUp = iptables -N wg0-input
PreUp = iptables -N wg0-input-ssh
PreUp = iptables -N wg0-input-smtp
PreUp = iptables -N wg0-input-imap

# rediriger les paquets entrants vers les chaînes personnalisées
PreUp = iptables -A INPUT -i wg0 -p tcp --dport 25 -j wg0-input-smtp
PreUp = iptables -A INPUT -i wg0 -p tcp --dport 143 -j wg0-input-imap
PreUp = iptables -A INPUT -i wg0 -p tcp --dport 22 -j wg0-input-ssh

# règles pour les chaînes personnalisées
PreUp = iptables -A wg0-input-smtp -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A wg0-input-smtp -p tcp --dport 25 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -j REJECT

PreUp = iptables -A wg0-input-imap -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A wg0-input-imap -p tcp --dport 143 -j ACCEPT
PreUp = iptables -A wg0-input-imap -j REJECT

PreUp = iptables -A wg0-input-ssh -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A wg0-input-ssh -p tcp --dport 22 -j ACCEPT
PreUp = iptables -A wg0-input-ssh -s 198.51.100.10/32 -j ACCEPT
PreUp = iptables -A wg0-input-ssh -j REJECT

PostDown = iptables -D INPUT -i wg0 -p tcp --dport 25 -j wg0-input-smtp
PostDown = iptables -D INPUT -i wg0 -p tcp --dport 143 -j wg0-input-imap
PostDown = iptables -D INPUT -i wg0 -p tcp --dport 22 -j wg0-input-ssh

PostDown = iptables -F wg0-input-smtp
PostDown = iptables -X wg0-input-smtp

PostDown = iptables -F wg0-input-imap
PostDown = iptables -X wg0-input-imap

PostDown = iptables -F wg0-input-ssh
PostDown = iptables -X wg0-input-ssh

PreUp = iptables -I INPUT -p udp --dport 51823 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51823 -j ACCEPT

PreUp = iptables -N wg0-input
PreUp = iptables -N wg0-input-ssh
PreUp = iptables -N wg0-input-smtp
PreUp = iptables -N wg0-input-imap

PreUp = iptables -I INPUT -i wg0 -j wg0-input

PreUp = iptables -A wg0-input -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A wg0-input -p tcp --dport 22 -j wg0-input-ssh
PreUp = iptables -A wg0-input -p tcp --dport 25 -j wg0-input-smtp
PreUp = iptables -A wg0-input -p tcp --dport 143 -j wg0-input-imap
PreUp = iptables -A wg0-input -j REJECT

PreUp = iptables -A wg0-input-ssh -s 10.0.0.2 -j ACCEPT

PreUp = iptables -A wg0-input-smtp -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.4 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.5 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.7 -j ACCEPT

PreUp = iptables -A wg0-input-imap -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A wg0-input-imap -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A wg0-input-imap -s 10.0.0.7 -j ACCEPT

PostDown = iptables -D INPUT -i wg0 -j wg0-input

PostDown = iptables -F wg0-input
PostDown = iptables -F wg0-input-ssh
PostDown = iptables -F wg0-input-smtp
PostDown = iptables -F wg0-input-imap

PostDown = iptables -X wg0-input
PostDown = iptables -X wg0-input-ssh
PostDown = iptables -X wg0-input-smtp
PostDown = iptables -X wg0-input-imap

# paramètres distants pour la Station de travail d'Alice
[Peer]
PublicKey = fE/wdxzl0klVp/IR8UcaoGUMjqaWi3jAd7KzHKFS6Ds=
AllowedIPs = 10.0.0.2/32

# paramètres distants pour le Serveur Web
[Peer]
PublicKey = MMsBeTT9v/7XNWB8a/jSMn9O8olPVNduUwvUPJ6eB14=
Endpoint = 192.168.1.44:51824
AllowedIPs = 10.0.0.4/32

# paramètres distants pour le Serveur VNC
[Peer]
PublicKey = kAYKIv6gpBDqueaVNOsY8ddKmIC2dnnXJQ0iKzWxfBI=
Endpoint = 203.0.113.50:51825
AllowedIPs = 10.0.0.5/32

# paramètres distants pour la Station de travail de Bob
[Peer]
PublicKey = af24MfZ5LzUedF5WlpK2+O8602g2fmiKO8dYdv8dUyI=
AllowedIPs = 10.0.0.6/32

# paramètres distants pour le Portable de Cindy
[Peer]
PublicKey = QHy/1+olsMKePzg/044wWUunKs/IfWzy4Ub/iJbzJ00=
AllowedIPs = 10.0.0.7/32

Analysons les règles ci-dessus étape par étape. Le premier bloc s’assure que lorsque l’interface WireGuard est mise en ligne, le port sur lequel elle écoute pour les paquets UDP chiffrés (51823, configuré via son paramètre ListenPort) est ouvert :

# ingress de WireGuard
PreUp = iptables -I INPUT -p udp --dport 51823 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51823 -j ACCEPT

La commande PreUp utilise le drapeau -I (alias --insert) au lieu du drapeau -A (alias --append) pour s’assurer que la règle est placée en premier dans la chaîne INPUT, afin de se situer avant toutes les autres règles iptables déjà configurées pour la chaîne INPUT du système. La commande PostDown supprime la règle lorsque l’interface est arrêtée.

Le prochain bloc utilise la commande iptables -N (-N pour --new-chain) pour créer quatre nouvelles chaînes, wg0-input, wg0-input-ssh, wg0-input-smtp, et wg0-input-imap :

PreUp = iptables -N wg0-input
PreUp = iptables -N wg0-input-ssh
PreUp = iptables -N wg0-input-smtp
PreUp = iptables -N wg0-input-imap

La commande suivante crée le lien entre la chaîne principale INPUT et la chaîne wg0-input, envoyant tous les paquets entrants sur l’interface WireGuard wg0 à la chaîne wg0-input :

PreUp = iptables -I INPUT -i wg0 -j wg0-input

Le prochain ensemble de règles s’applique aux paquets destinés à la chaîne wg0-input. La première règle accepte tous les paquets provenant de toutes les connexions initiantes par ce hôte lui-même (par exemple, si le Serveur Mail a fait une requête HTTP au Serveur Web, cette règle permettrait la réponse correspondante du Serveur Web à nouveau vers le Serveur Mail). La deuxième, troisième et quatrième règles dirigent les paquets SSH, SMTP et IMAP vers les chaînes wg0-input-ssh, wg0-input-smtp et wg0-input-imap, respectivement. La dernière règle rejette tous les autres paquets :

PreUp = iptables -A wg0-input -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A wg0-input -p tcp --dport 22 -j wg0-input-ssh
PreUp = iptables -A wg0-input -p tcp --dport 25 -j wg0-input-smtp
PreUp = iptables -A wg0-input -p tcp --dport 143 -j wg0-input-imap
PreUp = iptables -A wg0-input -j REJECT

Les règles suivantes définissent les autorisations pour chaque chaîne :

PreUp = iptables -A wg0-input-ssh -s 10.0.0.2 -j ACCEPT

PreUp = iptables -A wg0-input-smtp -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.4 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.5 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.7 -j ACCEPT

PreUp = iptables -A wg0-input-imap -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A wg0-input-imap -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A wg0-input-imap -s 10.0.0.7 -j ACCEPT

Enfin, le bloc PostDown nettoie les règles créées lors de la mise en ligne de l’interface WireGuard :

PostDown = iptables -D INPUT -i wg0 -j wg0-input

PostDown = iptables -F wg0-input
PostDown = iptables -F wg0-input-ssh
PostDown = iptables -F wg0-input-smtp
PostDown = iptables -F wg0-input-imap

PostDown = iptables -X wg0-input
PostDown = iptables -X wg0-input-ssh
PostDown = iptables -X wg0-input-smtp
PostDown = iptables -X wg0-input-imap

Ces règles permettent de contrôler le trafic entrant sur l’interface WireGuard, en assurant que seuls les paquets autorisés passent et en nettoyant les règles lorsqu’elles ne sont plus nécessaires.

paquets :

PreUp = iptables -A wg0-input -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A wg0-input -p tcp --dport 22 -j wg0-input-ssh
PreUp = iptables -A wg0-input -p tcp --dport 25 -j wg0-input-smtp
PreUp = iptables -A wg0-input -p tcp --dport 143 -j wg0-input-imap
PreUp = iptables -A wg0-input -j REJECT

Pour les paquets destinés à la chaîne wg0-input-ssh, la prochaine règle l’autorise si son adresse IP source est 10.0.0.2 (la Station de travail d’Alice) :

PreUp = iptables -A wg0-input-ssh -s 10.0.0.2 -j ACCEPT

Comme il n’y a pas d’autres règles pour la chaîne wg0-input-ssh, les paquets SSH de toutes autres sources reviennent à la chaîne wg0-input et sont rejetés par la dernière règle.

Pour les paquets destinés à la chaîne wg0-input-smtp, le prochain ensemble de règles l’autorise si son adresse IP source est 10.0.0.2, 10.0.0.4, 10.0.0.5, 10.0.0.6 ou 10.0.0.7 (toutes les autres hôtes dans cette VPN WireGuard) :

PreUp = iptables -A wg0-input-smtp -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.4 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.5 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A wg0-input-smtp -s 10.0.0.7 -j ACCEPT

Pour les paquets destinés à la chaîne wg0-input-imap, le prochain ensemble de règles l’autorise s’il son adresse IP source est 10.0.0.2, 10.0.0.6 ou 10.0.0.7 (Travail d’Alice, Travail de Bob ou Portable de Cindy) :

PreUp = iptables -A wg0-input-imap -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A wg0-input-imap -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A wg0-input-imap -s 10.0.0.7 -j ACCEPT

Comme pour la chaîne wg0-input-ssh, si un paquet ne correspond à aucune des règles de la chaîne wg0-input-smtp ou wg0-input-imap, il retourne à la chaîne wg0-input, où elle est rejetée par la dernière règle de cette chaîne.

Lorsque l’interface WireGuard est arrêtée, le lien entre la chaîne principale INPUT et notre chaîne personnalisée wg0-input est supprimé :

PostDown = iptables -D INPUT -i wg0 -j wg0-input

Et ensuite nous supprimons (avec l’option -F, pour --flush) toutes les règles de chaque chaîne wg0-input, wg0-input-ssh, wg0-input-smtp et wg0-input-imap :

PostDown = iptables -F wg0-input
PostDown = iptables -F wg0-input-ssh
PostDown = iptables -F wg0-input-smtp
PostDown = iptables -F wg0-input-imap

Et enfin, nous pouvons supprimer chaque une de nos chaînes personnalisées wg0-input, wg0-input-ssh, wg0-input-smtp et wg0-input-imap elles-mêmes (avec l’option -X, abrégée par --delete-chain) :

PostDown = iptables -X wg0-input
PostDown = iptables -X wg0-input-ssh
PostDown = iptables -X wg0-input-smtp
PostDown = iptables -X wg0-input-imap

Si nous ajoutons plus tard un nouvel hôte à notre VPN WireGuard — disons le Portable de Dave, à l’adresse IP 10.0.0.8 — nous pouvons accorder l’accès SMTP et IMAP à ce nouvel hôte en apportant les modifications suivantes à la configuration WireGuard du Serveur Mail :

1. Ajoutez une entrée [Peer] pour le Laptop de Dave (incluez au minimum la clé publique de la pair et la ligne AllowedIPs = 10.0.0.8/32). Cela accorde à l’ordinateur portable de Dave l’accès pour se connecter à l’interface WireGuard du serveur de messagerie.
2. Ajoutez une entrée PreUp = iptables -A wg0-input-smtp -s 10.0.0.8 -j ACCEPT. Cela accorde la connexion WireGuard depuis le Laptop de Dave l’accès au port SMTP du serveur de messagerie.
3. Ajoutez une entrée PreUp = iptables -A wg0-input-imap -s 10.0.0.8 -j ACCEPT. Cela accorde la connexion WireGuard depuis le Laptop de Dave l’accès au port IMAP du serveur de messagerie.

Les règles de pare-feu du serveur Web auront une structure similaire à celles du serveur de messagerie, mais avec un ensemble différent de ports. Nous allons à nouveau utiliser la chaîne wg0-input-ssh pour le port 22, mais maintenant utilisons `wg0-inp

ut-http` pour le port 80 et `wg0-input-admin` pour le port 8080. Notez que ces noms de chaînes personnalisées sont complètement arbitraires (seulement `INPUT` est un nom intégré) — j'ai simplement choisi des noms qui m'aideront à me souvenir de ce qu'ils servent quand je les revoirai dans deux mois :

```bash
# paramètres locaux pour le serveur Web
[Interface]
PrivateKey = CDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDHA=
Address = 10.0.0.4/32
ListenPort = 51824

# ingress WireGuard
PreUp = iptables -I INPUT -p udp --dport 51824 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51824 -j ACCEPT

# pare-feu local
PreUp = iptables -N wg0-input
PreUp = iptables -N wg0-input-ssh
PreUp = iptables -N wg0-input-http
PreUp = iptables -N wg0-input-admin

PreUp = iptables -A INPUT -i wg0 -j wg0-input

PreUp = iptables -A wg0-input -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A wg0-input -p tcp --dport 22 -j wg0-input-ssh
PreUp = iptables -A wg0-input -p tcp --dport 80 -j wg0-input-http
PreUp = iptables -A wg0-input -p tcp --dport 8080 -j wg0-input-admin
PreUp = iptables -A wg0-input -j REJECT

PreUp = iptables -A wg0-input-ssh -s 10.0.0.2 -j ACCEPT

PreUp = iptables -A wg0-input-http -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A wg0-input-http -s 10.0.0.5 -j ACCEPT
PreUp = iptables -A wg0-input-http -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A wg0-input-http -s 10.0.0.7 -j ACCEPT

PreUp = iptables -A wg0-input-admin -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A wg0-input-admin -s 10.0.0.6 -j ACCEPT

PostDown = iptables -D INPUT -i wg0 -j wg0-input

PostDown = iptables -F wg0-input
PostDown = iptables -F wg0-input-ssh
PostDown = iptables -F wg0-input-http
PostDown = iptables -F wg0-input-admin

PostDown = iptables -X wg0-input
PostDown = iptables -X wg0-input-ssh
PostDown = iptables -X wg0-input-http
PostDown = iptables -X wg0-input-admin

# paramètres distants pour le bureau d'Alice
[Peer]
PublicKey = fE/wdxzl0klVp/IR8UcaoGUMjqaWi3jAd7KzHKFS6Ds=
AllowedIPs = 10.0.0.2/32

# paramètres distants pour le serveur de messagerie
[Peer]
PublicKey = jUd41n3XYa3yXBzyBvWqlLhYgRef5RiBD7jwo70U+Rw=
Endpoint = 192.168.1.63:51823
AllowedIPs = 10.0.0.3/32

# paramètres distants pour le serveur VNC
[Peer]
PublicKey = kAYKIv6gpBDqueaVNOsY8ddKmIC2dnnXJQ0iKzWxfBI=
Endpoint = 203.0.113.50:51825
AllowedIPs = 10.0.0.5/32

# paramètres distants pour le bureau de Bob
[Peer]
PublicKey = af24MfZ5LzUedF5WlpK2+O8602g2fmiKO8dYdv8dUyI=
AllowedIPs = 10.0.0.6/32

# paramètres distants pour le portable de Cindy
[Peer]
PublicKey = QHy/1+olsMKePzg/044wWUunKs/IfWzy4Ub/iJbzJ00=
AllowedIPs = 10.0.0.7/32

Et enfin, le serveur VNC est un peu plus simple que les serveurs de messagerie et Web. Il n’a qu’un seul port (5900) pour lequel nous voulons accorder l’accès. Comme c’est plus simple, je vais simplement utiliser une seule chaîne personnalisée (wg0-input) et ajouter les règles qui accordent l’accès aux bureaux d’Alice et de Bob (10.0.0.2 et 10.0.0.6) directement à elle :

# paramètres locaux pour le serveur VNC
[Interface]
PrivateKey = EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE=
Address = 10.0.0.5/32
ListenPort = 51825

# ingress de WireGuard
PreUp = iptables -I INPUT -p udp --dport 51825 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51825 -j ACCEPT

pare-feu local

PreUp = iptables -N wg0-input PreUp = iptables -A INPUT -i wg0 -j wg0-input

PreUp = iptables -A wg0-input -m state –state ESTABLISHED,RELATED -j ACCEPT PreUp = iptables -A wg0-input -p tcp –dport 5900 -s 10.0.0.2 -j ACCEPT PreUp = iptables -A wg0-input -p tcp –dport 5900 -s 10.0.0.6 -j ACCEPT PreUp = iptables -A wg0-input -j REJECT

PostDown = iptables -D INPUT -i wg0 -j wg0-input PostDown = iptables -F wg0-input PostDown = iptables -X wg0-input

paramètres distants pour la station de travail d’Alice

[Peer] PublicKey = fE/wdxzl0klVp/IR8UcaoGUMjqaWi3jAd7KzHKFS6Ds= AllowedIPs = 10.0.0.2/32

paramètres distants pour le serveur de messagerie

[Peer] PublicKey = jUd41n3XYa3yXBzyBvWqlLhYgRef5RiBD7jwo70U+Rw= AllowedIPs = 10.0.0.3/32

cKey = jUd41n3XYa3yXBzyBvWqlLhYgRef5RiBD7jwo70U+Rw=
Endpoint = 192.168.1.63:51823
AllowedIPs = 10.0.0.3/32

# paramètres distants pour le serveur Web
[Peer]
PublicKey = MMsBeTT9v/7XNWB8a/jSMn9O8olPVNduUwvUPJ6eB14=
Endpoint = 192.168.1.44:51824
AllowedIPs = 10.0.0.4/32

# paramètres distants pour la station de travail de Bob
[Peer]
PublicKey = af24MfZ5LzUedF5WlpK2+O8602g2fmiKO8dYdv8dUyI=
AllowedIPs = 10.0.0.6/32

Note que bien que les règles iptables pour le serveur VNC ne permettent pas l'accès entrant du serveur de messagerie et du serveur Web, nous avons toujours inclus des entrées de pair pour eux. C'est parce que le serveur VNC doit établir des connexions sortantes vers le serveur de messagerie pour envoyer des e-mails et vers le serveur Web pour effectuer des appels API web. Nos règles iptables ne restreignent en aucune façon l'accès sortant, et elles permettent les réponses entrantes aux connexions que le serveur VNC a initiées via la règle `PreUp = iptables -A wg0-input -m state --state ESTABLISHED,RELATED -j ACCEPT`.

## Hub et Spoke

Si nous avions utilisé WireGuard pour connecter nos hôtes d'exemple avec une topologie [hub and spoke](/blog/2020/10/wireguard-topologies/#hub-and-spoke), le diagramme réseau ressemblerait à ceci :

![Hub and Spoke Network](images/hub-and-spoke.svg)

Figure 3. Réseau hub and spoke

Pour notre hub, nous ajoutons un serveur WireGuard dédié à Site A, auquel le routeur Internet de Site A transférera le port UDP 51821. Tous les autres hôtes dans le réseau WireGuard se connecteront à ce serveur, plutôt qu'à eux-mêmes : les hôtes WireGuard distants se connecteront à travers l'adresse IP Internet de Site A (198.51.100.10), et les hôtes locaux de Site A se connecteront à travers leur adresse LAN (192.168.1.101).

Voici un tableau des adresses IP publique du point de terminaison de chaque hôte, de son point de terminaison IP et de port dans le LAN de Site A, ainsi que de son adresse IP interne VPN WireGuard :

Tableau 3. Adresses Hub et Spoke

| Hôte | Adresse Internet | Adresse LAN | Adresse WireGuard |
| --- | --- | --- | --- |
| Serveur WireGuard | 198.51.100.10:51821 | 192.168.1.101:51821 | 10.0.0.1 |
| Poste de travail d'Alice | N/A | dynamique | 10.0.0.2 |
| Serveur de messagerie | N/A | 192.168.1.63:51823 | 10.0.0.3 |
| Serveur Web | N/A | 192.168.1.44:51824 | 10.0.0.4 |
| Serveur VNC | 203.0.113.50:51825 | N/A | 10.0.0.5 |
| Poste de travail de Bob | dynamique | N/A | 10.0.0.6 |
| Portable de Cindy | dynamique | N/A | 10.0.0.7 |

En ajoutant ce serveur WireGuard dédié à notre réseau d'exemple, nous ajoutons également quelques règles de contrôle d'accès pour lui. Nous autoriserons le Poste de travail d'Alice à se connecter via SSH au serveur et à envoyer des e-mails via le Serveur de messagerie. Conceptuellement, cela ajouterait deux lignes supplémentaires à notre table principale [ACLs du réseau](#network-acls) ci-dessus :

Tableau 4. ACLs Hub supplémentaires

| Hôte de destination | Port de destination | Hôte source | Accès |
| --- | --- | --- | --- |
| Serveur WireGuard | 22 | Poste de travail d'Alice | Autoriser |
| Serveur de messagerie | 25 | Serveur WireGuard | Autoriser |

Maintenant, étant donné que tout le trafic passe à travers notre hub Serveur WireGuard, c'est un endroit idéal pour appliquer le contrôle d'accès centralisé. Nous implémenterons toutes les ACLs de notre VPN WireGuard directement dans la configuration WireGuard du Serveur WireGuard :

```bash
# paramètres locaux pour le serveur WireGuard Hub
[Interface]
PrivateKey = AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEE=
Address = 10.0.0.1/32
ListenPort = 51821

# transfert de paquets
PreUp = sysctl -w net.ipv4.ip_forward=1

# entrée WireGuard
PreUp = iptables -I INPUT -p udp --dport 51821 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51821 -j ACCEPT

# pare-feu du hub
PreUp = iptables -N wg0-filter
PreUp = iptables -N to-wg-server-ssh
PreUp = iptables -N to-mail-server-ssh
PreU

```bash
p = iptables -N to-mail-server-smtp
PreUp = iptables -N to-mail-server-imap
PreUp = iptables -N to-web-server-ssh
PreUp = iptables -N to-web-server-http
PreUp = iptables -N to-web-server-admin
PreUp = iptables -N to-vnc-server

PreUp = iptables -I INPUT   -i wg0 -j wg0-filter
PreUp = iptables -I FORWARD -i wg0 -j wg0-filter
PreUp = iptables -I FORWARD -o wg0 -j wg0-filter
PreUp = iptables -I OUTPUT  -o wg0 -j wg0-filter

PreUp = iptables -A wg0-filter -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A wg0-filter -d 10.0.0.1 -p tcp --dport   22 -j to-wg-server-ssh
PreUp = iptables -A wg0-filter -d 10.0.0.3 -p tcp --dport   22 -j to-mail-server-ssh
PreUp = iptables -A wg0-filter -d 10.0.0.3 -p tcp --dport   25 -j to-mail-server-smtp
PreUp = iptables -A wg0-filter -d 10.0.0.3 -p tcp --dport  143 -j to-mail-server-imap
PreUp = iptables -A wg0-filter -d 10.0.0.4 -p tcp --dport   22 -j to-web-server-ssh
PreUp = iptables -A wg0-filter -d 10.0.0.4 -p tcp --dport   80 -j to-web-server-http
PreUp = iptables -A wg0-filter -d 10.0.0.4 -p tcp --dport 8080 -j to-web-server-admin
PreUp = iptables -A wg0-filter -d 10.0.0.5 -p tcp --dport 5900 -j to-vnc-server
PreUp = iptables -A wg0-filter -j REJECT

PreUp = iptables -A to-wg-server-ssh    -s 10.0.0.2 -j ACCEPT

PreUp = iptables -A to-mail-server-ssh  -s 10.0.0.2 -j ACCEPT

PreUp = iptables -A to-mail-server-smtp -s 10.0.0.1 -j ACCEPT  
PreUp = iptables -A to-mail-server-smtp -s 10.0.0.2 -j ACCEPT  
PreUp = iptables -A to-mail-server-smtp -s 10.0.0.4 -j ACCEPT  
PreUp = iptables -A to-mail-server-smtp -s 10.0.0.5 -j ACCEPT  
PreUp = iptables -A to-mail-server-smtp -s 10.0.0.6 -j ACCEPT  
PreUp = iptables -A to-mail-server-smtp -s 10.0.0.7 -j ACCEPT  

PreUp = iptables -A to-mail-server-imap -s 10.0.0.2 -j ACCEPT  
PreUp = iptables -A to-mail-server-imap -s 10.0.0.6 -j ACCEPT  
PreUp = iptables -A to-mail-server-imap -s 10.0.0.7 -j ACCEPT  

PreUp = iptables -A to-web-server-ssh   -s 10.0.0.2 -j ACCEPT  

PreUp = iptables -A to-web-server-http  -s 10.0.0.2 -j ACCEPT  
PreUp = iptables -A to-web-server-http  -s 10.0.0.5 -j ACCEPT  
PreUp = iptables -A to-web-server-http  -s 10.0.0.6 -j ACCEPT  
PreUp = iptables -A to-web-server-http  -s 10.0.0.7 -j ACCEPT  

PreUp = iptables -A to-web-server-admin -s 10.0.0.2 -j ACCEPT  
PreUp = iptables -A to-web-server-admin -s 10.0.0.6 -j ACCEPT  

PreUp = iptables -A to-vnc-server       -s 10.0.0.2 -j ACCEPT  
PreUp = iptables -A to-vnc-server       -s 10.0.0.6 -j ACCEPT  

PostDown = iptables -D INPUT   -i wg0 -j wg0-filter  
PostDown = iptables -D FORWARD -i wg0 -j wg0-filter  
PostDown = iptables -D FORWARD -o wg0 -j wg0-filter  
PostDown = iptables -D OUTPUT  -o wg0 -j wg0-filter  

PostDown = iptables -F wg0-filter  
PostDown = iptables -F to-wg-server-ssh  
PostDown = iptables -F to-mail-server-ssh  
PostDown = iptables -F to-mail-server-smtp  
PostDown = iptables -F to-mail-server-imap  
PostDown = iptables -F to-web-server-ssh  
PostDown = iptables -F to-web-server-http  
PostDown = iptables -F to-web-server-admin  
PostDown = iptables -F to-vnc-server

```bash
# wireguard ingress
PreUp = iptables -I INPUT -p udp --dport 51821 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51821 -j ACCEPT

Le prochain bloc crée une série de chaînes personnalisées que nous utiliserons pour appliquer nos ACLs :

PreUp = iptables -N wg0-filter
PreUp = iptables -N to-wg-server-ssh
PreUp = iptables -N to-mail-server-ssh
PreUp = iptables -N to-mail-server-smtp
PreUp = iptables -N to-mail-server-imap
PreUp = iptables -N to-web-server-ssh
PreUp = iptables -N to-web-server-http
PreUp = iptables -N to-web-server-admin
PreUp = iptables -N to-vnc-server

Le prochain bloc configure les règles de base pour tous les paquets entrants et sortants à travers l’interface wg0 du WireGuard de l’hôte (le trafic entrant et sortant du tunnel WireGuard). Iptables envoie automatiquement tous les paquets entrants avec une adresse de destination locale

le à sa chaîne intégrée INPUT, et tous les paquets entrants avec une adresse de destination non locale à sa chaîne intégrée FORWARD. Les paquets sortants générés sur l’hôte lui-même sont envoyés via la chaîne intégrée OUTPUT.

Ainsi, la première règle s’applique à tous les paquets entrants à travers l’interface WireGuard destinés au hub lui-même ; la deuxième règle s’applique à tous les paquets entrants à travers l’interface WireGuard destinés à d’autres hôtes ; la troisième règle s’applique aux paquets sortants vers l’interface WireGuard transférés depuis d’autres hôtes ; et la quatrième règle s’applique à tous les paquets sortants vers l’interface WireGuard de l’hôte lui-même. Chaque une de ces règles envoie les paquets correspondants à travers la chaîne wg0-filter (où nous implémenterons notre logique de contrôle d’accès centralisé) :

PreUp = iptables -I INPUT   -i wg0 -j wg0-filter
PreUp = iptables -I FORWARD -i wg0 -j wg0-filter
PreUp = iptables -I FORWARD -o wg0 -j wg0-filter
PreUp = iptables -I OUTPUT  -o wg0 -j wg0-filter

Nous utilisons le drapeau -I (ou --insert) dans les règles ci-dessus pour les ajouter en tête de leurs chaînes respectives, les évaluant avant toutes les autres règles qui ont été définies ailleurs pour la chaîne. Bien que la plupart des paquets que le serveur WireGuard rencontre dans cette situation viennent à la fois et sortent par l’interface wg0, potentiellement correspondant aux deux secondes et troisièmes règles, car notre chaîne wg0-filter prend toujours une décision d’autorisation (ACCEPT) ou de rejet (REJECT), aucun paquet ne sera effectivement correspondu à ces deux règles. Avoir les deux règles en place garantit que notre chaîne wg0-filter capture également le cas où un point de terminaison WireGuard distant tente de se connecter via le hub à un point de terminaison non-WireGuard, ou vice versa.

Le bloc suivant est celui où nous commençons à construire notre logique de contrôle d’accès centralisé. La première règle permet tous les paquets qui font partie d’une connexion existante (par exemple, les paquets transportant une réponse HTTP d’une requête HTTP précédemment autorisée). Les règles du milieu envoient les paquets vers des chaînes par service en fonction de leur adresse IP et port de destination. La dernière règle refuse tous les paquets envoyés à cette chaîne qui n’ont pas correspondu à une règle précédente (donc bloquant toutes les communications via notre réseau WireGuard non explicitement autorisées par les chaînes par service) :

PreUp = iptables -A to-mail-server-imap -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A to-mail-server-imap -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A to-mail-server-imap -s 10.0.0.7 -j ACCEPT

Les règles suivantes permettent à la Workstation d’Alice (10.0.0.2) de se connecter par SSH au Serveur Web ; et permettent à la Workstation d’Alice, le Serveur VNC (10.0.0.5), la Workstation de Bob (10.0.0.6) et l’Ordinateur portable de Cindy (10.0.0.7) de se connecter à l’application web principale sur le Serveur Web ; et permettent à la Workstation d’Alice et celle de Bob de se connecter à l’application web administrative sur le Serveur Web :

PreUp = iptables -A to-web-server-ssh   -s 10.0.0.2 -j ACCEPT

PreUp = iptables -A to-web-server-http  -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A to-web-server-http  -s 10.0.0.5 -j ACCEPT
PreUp = iptables -A to-web-server-http  -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A to-web-server-http  -s 10.0.0.7 -j ACCEPT

PreUp = iptables -A to-web-server-admin -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A to-web-server-admin -s 10.0.0.6 -j ACCEPT

Et les dernières règles iptables permettent à la Workstation d’Alice et celle de Bob de se connecter au Serveur VNC :

PreUp = iptables -A to-vnc-server -s 10.0.0.2 -j ACCEPT
PreUp = iptables -A to-vnc-server -s 10.0.0.6 -j ACCEPT

A to-vnc-server -s 10.0.0.2 -j ACCEPT PreUp = iptables -A to-vnc-server -s 10.0.0.6 -j ACCEPT

Les blocs PostDown démontrent les chaînes personnalisées définies ci-dessus. Le premier bloc supprime les règles qui envoient des paquets entrants et sortants vers et depuis l’interface WireGuard via la chaîne wg0-filter :

PostDown = iptables -D INPUT   -i wg0 -j wg0-filter
PostDown = iptables -D FORWARD -i wg0 -j wg0-filter
PostDown = iptables -D FORWARD -o wg0 -j wg0-filter
PostDown = iptables -D OUTPUT  -o wg0 -j wg0-filter

Et le prochain bloc PostDown supprime toutes les règles dans nos chaînes personnalisées :

PostDown = iptables -F wg0-filter
PostDown = iptables -F to-wg-server-ssh
PostDown = iptables -F to-mail-server-ssh
PostDown = iptables -F to-mail-server-smtp
PostDown = iptables -F to-mail-server-imap
PostDown = iptables -F to-web-server-ssh
PostDown = iptables -F to-web-server-http
PostDown = iptables -F to-web-server-admin
PostDown = iptables -F to-vnc-server

Et une fois les chaînes personnalisées vides, elles peuvent être supprimées par le dernier bloc PostDown :

PostDown = iptables -X wg0-filter
PostDown = iptables -X to-wg-server-ssh
PostDown = iptables -X to-mail-server-ssh
PostDown = iptables -X to-mail-server-smtp
PostDown = iptables -X to-mail-server-imap
PostDown = iptables -X to-web-server-ssh
PostDown = iptables -X to-web-server-http
PostDown = iptables -X to-web-server-admin
PostDown = iptables -X to-vnc-server

Vous pouvez également vouloir configurer un pare-feu séparé sur chaque autre hôte dans ce réseau WireGuard (en particulier, pour rejeter tout trafic non-WireGuard), mais vous n’avez pas besoin de le faire pour appliquer le contrôle d’accès à partir des connexions WireGuard. Par exemple, sur la Workstation d’Alice, vous pouvez configurer le pare-feu pour rejeter tous les flux entrants provenant de toutes les sources (voir l’astuce Politiques de chaîne à la fin de cet article); et ensuite dans la configuration WireGuard de la Workstation d’Alice, insérez une règle iptables pour permettre les paquets UDP entrants sur le port d’écoute WireGuard tandis que l’interface WireGuard est active :

# paramètres locaux pour la Workstation d'Alice
[Interface]
PrivateKey = ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFA=
Address = 10.0.0.2/32
ListenPort = 51820

# ingress WireGuard
PreUp = iptables -I INPUT -p udp --dport 51820 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51820 -j ACCEPT

# paramètres distants pour le Serveur WireGuard
[Peer]
PublicKey = /TOE4TKtAqVsePRVR+5AA43HkAK5DSntkOCO7nYq5xU=
Endpoint = 192.168.1.101:51821
AllowedIPs = 10.0.0.0/24

Vous n’avez pas besoin de règles iptables spécifiques à WireGuard sur la station de travail d’Alice, car nous avons ajouté des règles iptables au serveur WireGuard central.

Si nous ajoutions plus tard un nouvel hôte à notre VPN WireGuard — disons le laptop de Dave, avec l’adresse IP 10.0.0.8 — nous pourrions accorder l’accès SMTP et IMAP à ce nouvel hôte simplement en apportant les modifications suivantes à la configuration WireGuard du serveur WireGuard :

1. Ajoutez une entrée [Peer] pour le laptop de Dave (incluez au minimum la clé publique de la pair, ainsi que la ligne AllowedIPs = 10.0.0.8/32). Cela accorde à l’ordinateur portable de Dave l’accès pour se connecter à l’interface WireGuard du serveur WireGuard.
2. Ajoutez une entrée PreUp = iptables -A to-mail-server-smtp -s 10.0.0.8 -j ACCEPT. Cela accorde l’accès au tunnel WireGuard transféré depuis le laptop de Dave à la port SMTP du serveur de messagerie.
3. Ajoutez une entrée PreUp = iptables -A to-mail-server-imap -s 10.0.0.8 -j ACCEPT. Cela accorde l’accès au tunnel WireGuard transféré depuis le laptop de Dave à la port IMAP du serveur de messagerie.

Point to Site

Si nous utilisions WireGuard pour connecter nos hôtes d’exemple avec une topologie point to site, les configurations serait similaires, mais avec des ajustements spécifiques à cette configuration.

Ies/#point-to-site), le diagramme réseau serait comme suit :

Figure 4. Réseau point à site

Nous ajoutons également un serveur WireGuard dédié à Site A dans ce scénario pour se connecter aux points de terminaison distants. Le routeur Internet de Site A serait configuré pour transférer le port UDP 51821 vers ce serveur, permettant aux points de terminaison distants de se connecter avec l’adresse IP Internet de Site A, qui est 198.51.100.10. Le serveur WireGuard dédié masquerait (SNAT, Source Network Address Translation) les points de terminaison WireGuard distants sur le réseau local d’Alice, afin que les connexions provenant de tout point de terminaison distant (le serveur VNC, la station de travail de Bob ou le laptop de Cindy) apparaissent aux hôtes du réseau local (la station de travail d’Alice, le serveur de messagerie ou le serveur Web) comme venant directement du serveur WireGuard dédié.

De plus, pour permettre à la Workstation d’Alice de se connecter au serveur VNC, le serveur WireGuard dédié devrait également effectuer un forwarding (DNAT) du port TCP 5900 de la Workstation d’Alice vers le serveur VNC via son tunnel WireGuard.

Voici un tableau des adresses IP et ports publics Internet et internes de chaque hôte, ainsi que les adresses IP qui peuvent être utilisées pour y accéder via le VPN WireGuard et celles qui peuvent y être accessibles depuis le LAN Site A :

Tableau 5. Adresses Point à Site

Comme WireGuard ne serait pas impliqué dans les connexions entre le Portable d’Alice, le Serveur de messagerie et le Serveur Web, nous devrions configurer des pare-feux individuels sur chaque hôte pour appliquer un contrôle d’accès parmi eux. Cependant, nous pouvons toujours utiliser le serveur WireGuard dédié pour appliquer un contrôle d’accès aux autres connexions dans notre réseau WireGuard.

Le tutoriel Configuration point à site couvre en détail la configuration de base de WireGuard pour ce scénario. Ici, nous allons simplement nous concentrer sur le pare-feu du serveur WireGuard dédié — qui ressemblera beaucoup au serveur WireGuard hub dans le scénario Hub and Spoke ci-dessus, à l’exception du fait que nous utilisons les adresses LAN des hôtes de Site A, plutôt que leurs adresses WireGuard (puisqu’ils n’ont pas d’adresses WireGuard dans ce scénario). De plus, dans ce scénario, nous avons besoin d’une section pour masquerer les paquets du réseau WireGuard lorsqu’ils sont transférés au LAN de Site A ; et une section pour transférer le port 5900 du LAN de Site A vers le serveur VNC (10.0.0.5) :

# paramètres locaux pour le serveur WireGuard dédié à Site A
[Interface]
PrivateKey = AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEE=
Address = 10.0.0.1/32
ListenPort = 51821

# transfert de paquets
PreUp = sysctl -w net.ipv4.ip_forward=1

# masquage
PreUp = iptables -t mangle -A PREROUTING -i wg0 -j MARK --set-mark 0x200
PreUp = iptables -t nat -A POSTROUTING ! -o wg0 -m mark --mark 0x200 -j MASQUERADE
PostDown = iptables -t mangle -D PREROUTING -i wg0 -j MARK --set-mark 0x200
PostDown = iptables -t nat -D POSTROUTING ! -o wg0 -m mark --mark 0x200 -j MASQUERADE

# transfert de port
PreUp = iptables -t nat -A PREROUTING -d 192.168.1.101 -p tcp --dport 5900 -j DNAT --to-destination 10.0.0.5:5900

port 5900 -j DNAT –to-destination 10.0.0.5

PostDown = iptables -t nat -D PREROUTING -d 192.168.1.101 -p tcp –dport 5900 -j DNAT –to-destination 10.0.0.5

entrée WireGuard

PreUp = iptables -I INPUT -p udp –dport 51821 -j ACCEPT PostDown = iptables -D INPUT -p udp –dport 51821 -j ACCEPT

pare-feu du site

PreUp = iptables -N wg0-filter PreUp = iptables -N to-mail-server-smtp PreUp = iptables -N to-mail-server-imap PreUp = iptables -N to-web-server-http PreUp = iptables -N to-web-server-admin PreUp = iptables -N to-vnc-server

PreUp = iptables -I INPUT -i wg0 -j wg0-filter
PreUp = iptables -I FORWARD -i wg0 -j wg0-filter
PreUp = iptables -I FORWARD -o wg0 -j wg0-filter
PreUp = iptables -I OUTPUT -o wg0 -j wg0-filter

PreUp = iptables -A wg0-filter -m state –state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A wg0-filter -d 192.168.1.63 -p tcp –dport 25 -j to-mail-server-smtp
PreUp = iptables -A wg0-filter -d 192.168.1.63 -p tcp –dport 143 -j to-mail-server-imap
PreUp = iptables -A wg0-filter -d 192.168.1.44 -p tcp –dport 80 -j to-web-server-http
PreUp = iptables -A wg0-filter -d 192.168.1.44 -p tcp –dport 8080 -j to-web-server-admin
PreUp = iptables -A wg0-filter -d 10.0.0.5 -p tcp –dport 5900 -j to-vnc-server
PreUp = iptables -A wg0-filter -j REJECT

PreUp = iptables -A to-mail-server-smtp -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A to-mail-server-smtp -s 10.0.0.7 -j ACCEPT

PreUp = iptables -A to-mail-server-imap -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A to-mail-server-imap -s 10.0.0.7 -j ACCEPT

PreUp = iptables -A to-web-server-http -s 10.0.0.5 -j ACCEPT
PreUp = iptables -A to-web-server-http -s 10.0.0.6 -j ACCEPT
PreUp = iptables -A to-web-server-http -s 192.168.1.7 -j ACCEPT

PreUp = iptables -A to-web-server-admin -s 10.0.0.6 -j ACCEPT

PreUp = iptables -A to-vnc-server -s 192.168.1.12 -j ACCEPT
PreUp = iptables -A to-vnc-server -s 10.0.0.6 -j ACCEPT

PostDown = iptables -D INPUT -i wg0 -j wg0-filter
PostDown = iptables -D FORWARD -i wg0 -j wg0-filter
PostDown = iptables -D FORWARD -o wg0 -j wg0-filter
PostDown = iptables -D OUTPUT -o wg0 -j wg0-filter

PostDown = iptables -F wg0-filter
PostDown = iptables -F to-mail-server-smtp
PostDown = iptables -F to-mail-server-imap
PostDown = iptables -F to-web-server-http
PostDown = iptables -F to-web-server-admin
PostDown = iptables -F to-vnc-server

PostDown = iptables -X wg0-filter
PostDown = iptables -X to-mail-server-smtp
PostDown = iptables -X to-mail-server-imap
PostDown = iptables -X to-web-server-http
PostDown = iptables -X to-web-server-admin
PostDown = iptables -X to-vnc-server

# paramètres distants pour le serveur VNC
[Peer]
PublicKey = kAYKIv6gpBDqueaVNOsY8ddKmIC2dnnXJQ0iKzWxfBI=
Endpoint = 203.0.113.50:51825
AllowedIPs = 10.0.0.5/32

# paramètres distants pour le bureau de Bob
[Peer]
PublicKey = af24MfZ5LzUedF5WlpK2+O8602g2fmiKO8dYdv8dUyI=
AllowedIPs = 10.0.0.6/32

# paramètres distants pour le portable de Cindy
[Peer]
PublicKey = QHy/1+olsMKePzg/044wWUunKs/IfWzy4Ub/iJbzJ00=
AllowedIPs = 10.0.0.7/32

Note que le masquage se produira après le filtrage du pare-feu (donc les règles de filtre verront l’adresse source originale 10.0.0.x des paquets masqués), tandis que le transfert de ports se produira avant le filtrage du pare-feu (donc les règles de filtre verront l’adresse destination réécrite 10.0.0.5 sur les paquets transférés).

Il est également à noter que, comme pour le pare-feu du serveur WireGuard central dans le scénario Hub et Spoke, dans ce scénario nous exécutons également les chaînes directes INPUT et OUTPUT (pour les paquets qui entrent ou sortent de l’interface WireGuard directement vers ou depuis le serveur WireGuard dédié), ainsi que la chaîne FORWARD, à travers notre chaîne wg0-filter. Cela garantit que nous appliquons nos ACL sur les connexions directes entre le serveur

WireGuard dédié et les points de terminaison WireGuard distants (par exemple, en empêchant le serveur WireGuard de se connecter par SSH au bureau de Bob, et vice-versa) — même si nous n’avons pas d’accords explicites d’accès direct vers ou depuis le serveur WireGuard lui-même.

En dehors des règles iptables que nous avons configurées ici pour l’interface WireGuard du serveur WireGuard, il serait probablement également utile de configurer certaines règles iptables qui imposeraient un contrôle d’accès au serveur WireGuard depuis le réseau LAN Site A (par exemple, pour permettre uniquement l’accès SSH à partir du bureau d’Alice). Cependant, nous ne les configurons pas ici, car nous voulons que ces règles soient en vigueur tout le temps, et non seulement lorsque l’interface WireGuard est active.

Pour les hôtes distants WireGuard, tels que le serveur VNC ou le bureau de Bob, qui doivent permettre l’accès à tous les hôtes dans le réseau WireGuard lui-même ainsi que au réseau LAN Site A, nous voulons spécifier à la fois le sous-réseau pour le réseau WireGuard et le réseau LAN Site A dans le paramètre AllowedIPs pour la paire du serveur WireGuard dans leur configuration WireGuard :

# paramètres locaux pour le serveur VNC
[Interface]
PrivateKey = EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE=
Address = 10.0.0.5/32
ListenPort = 51825

# ingress pour WireGuard
PreUp = iptables -I INPUT -p udp --dport 51825 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51825 -j ACCEPT

# paramètres distants pour le serveur WireGuard
[Peer]
PublicKey = /TOE4TKtAqVsePRVR+5AA43HkAK5DSntkOCO7nYq5xU=
Endpoint = 198.51.100.10:51821
AllowedIPs = 10.0.0.0/24, 192.168.1.0/24

# paramètres locaux pour le bureau de Bob
[Interface]
PrivateKey = EFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA=
Address = 10.0.0.6/32
ListenPort = 51820

# ingress pour WireGuard
PreUp = iptables -I INPUT -p udp --dport 51820 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51820 -j ACCEPT

# paramètres distants pour le serveur WireGuard
[Peer]
PublicKey = /TOE4TKtAqVsePRVR+5AA43HkAK5DSntkOCO7nYq5xU=
Endpoint = 198.51.100.10:51821
AllowedIPs = 10.0.0.0/24, 192.168.1.0/24

Les hôtes qui n’ont besoin d’accès qu’au réseau LAN Site A, comme le portable de Cindy, n’ont besoin que de spécifier leur sous-réseau pour le paramètre AllowedIPs :

# paramètres locaux pour le portable de Cindy
[Interface]
PrivateKey = GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGA=
Address = 10.0.0.7/32
ListenPort = 51820

# ingress WireGuard
PreUp = iptables -I INPUT -p udp --dport 51820 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51820 -j ACCEPT

# paramètres distants pour le serveur WireGuard
[Peer]
PublicKey = /TOE4TKtAqVsePRVR+5AA43HkAK5DSntkOCO7nYq5xU=
Endpoint = 198.51.100.10:51821
AllowedIPs = 192.168.1.0/24

Site à Site

Si nous ajustions un peu notre exemple de scénario, de telle sorte que le serveur VNC, la station de travail de Bob et le portable de Cindy soient tous sur le même LAN dans une bureau distant (appelons-le Site B), nous pourrions utiliser une topologie site à site pour connecter les deux sites avec WireGuard. Le diagramme réseau dans ce cas serait le suivant :

Figure 5. Réseau site à site

Nous ajouterions un serveur WireGuard dédié A au Site A et un serveur WireGuard dédié B au Site B. Le routeur Internet du Site A forwarderait le port UDP 51821 vers le serveur WireGuard A, et le routeur Internet du Site B forwarderait le port UDP 51822 vers le serveur WireGuard B. Le routeur pour le LAN du Site A routera les paquets pour le LAN du Site B via le serveur WireGuard A, et le routeur pour le LAN du Site B routera les paquets pour le LAN du Site A via le serveur WireGuard B.

Voici un tableau de l’adresse IP publique d’entrée et du port de chaque hôte, de son adresse IP dans son LAN et de son adresse IP interne VPN WireGuard :

Table 6. Adresses IP

Comme les deux serveurs WireGuard n’auront qu’à toucher au trafic inter-réseau, nous pouvons utiliser ces derniers pour appliquer uniquement la partie inter-réseau de nos ACLs. Cela réduirait la liste ACL réseau listée en haut de cet article à cette liste beaucoup plus modeste :

Tableau 7. ACL entre sites

Si nous savions que nous allions uniquement connecter Site A à Site B via WireGuard, nous pourrions appliquer cette liste sur un seul des deux serveurs WireGuard dédiés. Mais dans le cas où nous devons jamais connecter un autre site (ou toute autre paire) à notre réseau WireGuard, il serait préférable d’appliquer le contrôle d’accès pour les hôtes de Site A (le Serveur de messagerie et le Serveur Web) sur le Serveur WireGuard A, et le contrôle d’accès pour les hôtes de Site B (le Serveur VNC et le Serveur WireGuard B) sur le Serveur WireGuard B.

Le tutoriel Configuration site à site couvre en détail la configuration de WireGuard pour ce scénario, donc nous allons nous concentrer à nouveau sur les paramètres du pare-feu. Le pare-feu que nous avons ici pour le Serveur WireGuard A ressemble beaucoup au hub WireGuard Server dans le Scénario Hub et Spoke ci-dessus, sauf qu’il ne force l’accès qu’au Serveur de messagerie et au Serveur Web (et utilise des adresses LAN au lieu d’adresses WireGuard pour les différents hôtes):

# paramètres locaux pour le Serveur WireGuard A du Site A
[Interface]
PrivateKey = AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEE=
Address = 10.0.0.1/32
ListenPort = 51821

# transfert de paquets
PreUp = sysctl -w net.ipv4.ip_forward=1

# ingress WireGuard
PreUp = iptables -I INPUT -p udp --dport 51821 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51821 -j ACCEPT

# pare-feu du Site A
PreUp = iptables -N wg0-filter
PreUp = iptables -N to-mail-server-smtp
PreUp = iptables -N to-mail-server-imap
PreUp = iptables -N to-web-server-http
PreUp = iptables -N to-web-server-admin

PreUp = iptables -I INPUT   -i wg0 -j wg0-filter
PreUp = iptables -I FORWARD -i wg0 -j wg0-filter

PreUp = iptables -A wg0-filter -m state --state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A wg0-filter -d 192.168.1.63  -p tcp --dport   25 -j to-mail-server-smtp
PreUp = iptables -A wg0-filter -d 192.168.1.63  -p tcp --dport  143 -j to-mail-server-imap
PreUp = iptables -A wg0-filter -d 192.168.1.44  -p tcp --dport   80 -j to-web-server-http
PreUp = iptables -A wg0-filter -d 192.168.1.44  -p tcp --dpor

tant qu'elle ne passe pas par le serveur central).

Et de manière similaire, le pare-feu pour le serveur WireGuard B ressemble beaucoup au serveur WireGuard central dans le scénario [Hub and Spoke](#hub-and-spoke) ci-dessus, à l'exception du fait qu'il applique uniquement le contrôle d'accès pour le serveur VNC et le serveur WireGuard B lui-même (en utilisant des adresses LAN au lieu d'adresses WireGuard pour correspondre aux hôtes) :

```bash
# paramètres locaux pour le serveur WireGuard de Site B
[Interface]
PrivateKey = ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFA=
Address = 10.0.0.2/32
ListenPort = 51822

# transfert des paquets
PreUp = sysctl -w net.ipv4.ip_forward=1

# ingress WireGuard
PreUp = iptables -I INPUT -p udp --dport 51822 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51822 -j ACCEPT

# pare-feu de Site B
PreUp = iptables -N wg0-filter
PreUp = iptables -N to-wg-server-ssh
PreUp = iptables -N to-vnc-server

PreUp = iptables -I INPUT   -i wg0 -j wg0-filter
PreUp = iptables -I FORWARD -i wg0 -j wg0-filter

PreUp = iptables -A wg0-filter -m state –state ESTABLISHED,RELATED -j ACCEPT
PreUp = iptables -A wg0-filter -d 192.168.200.22 -p tcp –dport 22 -j to-wg-server-ssh
PreUp = iptables -A wg0-filter -d 192.168.200.50 -p tcp –dport 5900 -j to-vnc-server
PreUp = iptables -A wg0-filter -j REJECT

PreUp = iptables -A to-wg-server-ssh -s 192.168.1.12 -j ACCEPT

PreUp = iptables -A to-vnc-server -s 192.168.1.12 -j ACCEPT

PostDown = iptables -D INPUT -i wg0 -j wg0-filter
PostDown = iptables -D FORWARD -i wg0 -j wg0-filter

PostDown = iptables -F wg0-filter
PostDown = iptables -F to-wg-server-ssh
PostDown = iptables -F to-vnc-server

PostDown = iptables -X wg0-filter
PostDown = iptables -X to-wg-server-ssh
PostDown = iptables -X to-vnc-server

paramètres distants pour le serveur WireGuard de Site A

[Peer]
PublicKey = /TOE4TKtAqVsePRVR+5AA43HkAK5DSntkOCO7nYq5xU=
Endpoint = 198.51.100.10:51821
AllowedIPs = 192.168.1.0/24

Dans les deux cas, nous exécutons la chaîne INPUT directe (pour les paquets entrants via l’interface WireGuard destinés au hôte local) ainsi que la chaîne FORWARD (pour les paquets entrants via l’interface WireGuard destinés à un autre hôte) à travers notre chaîne wg0-filter. Cela garantit que nous appliquons nos ACLs au trafic tentant de se connecter directement aux serveurs WireGuard dédiés, ainsi que les connexions qu’ils transmettent (par exemple, pour empêcher la Workstation de Bob de se connecter directement au Serveur WireGuard A, en plus d’empêchant la Workstation de Charlie de se connecter directement au Serveur WireGuard B).

Voici le texte corrigé :

La Workstation de Bob doit se connecter à tout autre hôte du Site A.

Mais contrairement au scénario Hub and Spoke, dans ce scénario nous appliquons uniquement les règles de contrôle d’accès pour le site local sur chaque serveur WireGuard du site — c’est pourquoi, contrairement au scénario Hub and Spoke, nous ne redirigeons pas également les paquets sortants via l’interface WireGuard à travers notre chaîne wg0-filter.

À l’extérieur des règles iptables que nous avons configurées ici pour l’interface WireGuard de nos serveurs WireGuard dédiés, il serait probablement également utile de configurer certaines règles iptables qui imposeraient un contrôle d’accès aux serveurs WireGuard à partir de leur propre LAN (par exemple, pour empêcher la connexion SSH de la machine de travail de Bob au serveur WireGuard B). Cependant, nous ne les configurons pas ici, car nous voulons que ces règles soient en vigueur toutes les heures, et non seulement lorsque l’interface WireGuard est active.

Autres conseils

Politiques des chaînes

Dans ce guide, je vous recommande d’ajouter une règle finale -j REJECT à toutes vos chaînes iptables de WireGuard pour refuser tout trafic WireGuard qui n’est pas explicitement autorisé. En tant que meilleure pratique, vous devriez également définir la politique par défaut des chaînes INPUT et FORWARD sur tous vos hôtes sur DROP dès le démarrage du système afin de refuser l’accès réseau par défaut, plutôt que de le permettre par défaut à travers le board (ce qui rendra ces règles finales -j REJECT superflues).

Cependant, la meilleure façon de configurer cela varie considérablement entre les différentes distributions Linux modernes et leurs versions. Dans les temps anciens, vous simplement exécutiez les commandes suivantes en tant que partie de vos scripts init :

iptables -P INPUT DROP
iptables -P FORWARD DROP

Avec les distributions modernes, cependant, vous devriez vérifier la documentation particulière de la distribution sur la façon et le lieu où configurer votre configuration iptables initiale. Arch Linux en particulier a un excellent tutoriel sur la façon de configurer iptables avec un ensemble simple de règles de base.

Faire des changements de configuration

Chaque fois que vous apportez des modifications à vos fichiers de configuration WireGuard pour changer les scripts PreUp ou PostDown, il est préférable de d’abord arrêter l’interface WireGuard, de faire vos modifications et ensuite de redémarrer l’interface. Souvent, chaque commande PreUp est associée à une commande PostDown qui est conçue pour annuler ou réinitialiser l’effet de la commande PreUp. C’est particulièrement vrai avec les commandes iptables, où dans de nombreux cas, chaque règle que vous ajoutez avec une commande PreUp doit être supprimée avec une commande PostDown.

Par exemple, disons que vous avez un ensemble de commandes PreUp et PostDown dans votre configuration WireGuard comme suit :

PreUp = iptables -I INPUT -p udp --dport 51820 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51820 -j ACCEPT

Et sans arrêter l’interface, vous changez le port dans ces commandes de 51820 à 51821 :

PreUp = iptables -I INPUT -p udp --dport 51821 -j ACCEPT
PostDown = iptables -D INPUT -p udp --dport 51821 -j ACCEPT

Maintenant, si vous arrêtez l’interface, vous aurez deux problèmes :

1. La commande PostDown échouera, car vous n’avez pas encore créé la règle de port 51821 qu’elle doit supprimer.
2. La règle pour le port 51820 ne sera pas supprimée (et restera donc en vigueur).

Vous pouvez toujours exécuter les anciennes versions des commandes PostDown manuellement pour supprimer les règles anciennes, mais vous trouverez que vous épargnerez de la frustration si vous rappelez-vous d’arrêter l’interface avant de modifier sa configuration.

Erreurs iptables

Voici quelques erreurs iptables courantes et comment les corriger :

1. Règle non trouvée : Si une règle n’est pas trouvée lors d’une suppression, assurez-vous que la règle existe bien avant d’essayer de la supprimer.
2. Politique incorrecte : Assurez-vous que la politique par défaut est correctement définie sur DROP pour les chaînes INPUT et FORWARD.
3. Port non valide : Vérifiez que le port spécifié dans la règle iptables est valide et n’est pas déjà utilisé.

Ce texte est maintenant plus fluide et grammaticalement correct, tout en conservant la structure Markdown originale.

Voici le texte corrigé :

Chaîne déjà existante

iptables: Chain already exists.

Vous verrez ce message d’erreur si vous essayez de créer une chaîne iptables personnalisée qui existe déjà. Si vous voyez ce message d’erreur lorsque vous essayez de mettre en ligne une interface WireGuard, cela signifie probablement que vous avez au moins une commande PreUp = iptables -N dans votre configuration WireGuard qui ne correspond pas exactement à une commande PostDown = iptables -X correspondante (ou n’a pas correspondé exactement lorsque vous avez précédemment arrêté l’interface WireGuard — voir le conseil Modifier les changements de configuration ci-dessus).

Exécutez sudo iptables -L pour lister toutes vos chaînes et règles iptables. Supprimez toute chaîne listée qui devrait être créée par des commandes PreUp dans votre configuration WireGuard, via les commandes suivantes (où my-chain est le nom de la chaîne) :

sudo iptables -F my-chain
sudo iptables -X my-chain

Répertoire non vide

iptables: Directory not empty.

Vous verrez ce message d’erreur si vous essayez de supprimer une chaîne iptables qui contient toujours des règles. Si vous voyez ce message d’erreur lorsque vous essayez d’arrêter une interface WireGuard, cela signifie probablement que vous avez oublié d’inclure une commande PostDown = iptables -F pour une chaîne avant la commande PostDown = iptables -X pour elle.

Exécutez sudo iptables -L pour lister toutes vos chaînes et règles iptables. Supprimez toute chaîne existante listée que vous vouliez supprimer avec vos commandes PostDown en exécutant les commandes suivantes (où my-chain est le nom d’une chaîne à supprimer) :

sudo iptables -F my-chain
sudo iptables -X my-chain

Trop de liens

iptables: Too many links

Vous verrez ce message d’erreur si vous essayez de supprimer une chaîne iptables personnalisée qui est toujours référencée par une règle quelconque. Exécutez la commande sudo iptables-save pour lister votre ensemble complet de règles iptables, et trouvez les règles qui font référence à la chaîne que vous essayez de supprimer (si la chaîne que vous essayez de supprimer est nommée my-chain, les règles que vous recherchez contiendront -j my-chain). Les règles commenceront par le drapeau -A, comme -A INPUT -i wg0 -j my-chain — supprimez chaque règle offensante en exécutant une commande iptables avec le même contenu de règle exact, sauf que le drapeau -A (aka --append) est remplacé par le drapeau -D (aka --delete) :

sudo iptables -D INPUT -i wg0 -j my-chain

Règle incorrecte

iptables: Bad rule (does a matching rule exist in that chain?).

Vous verrez ce message d’erreur si vous essayez de supprimer une règle qui n’existe pas réellement. Si vous voyez cette erreur lorsque vous essayez de mettre en panne une interface WireGuard, cela signifie probablement que vous avez au moins une commande PostDown = iptables -D dans votre configuration WireGuard qui ne correspond pas à une commande PreUp = iptables -A (ou -I) exactement (ou ne correspond pas exactement à la commande PreUp de la dernière fois que vous avez mis en panne l’interface WireGuard — voir le conseil Faire des modifications de configuration ci-dessus).

Exécutez la commande sudo iptables-save pour lister votre ensemble actuel de règles iptables, et trouvez la version exacte des règles que vous essayez de supprimer. Les règles commenceront par le drapeau -A, comme -A to-vnc-server -s 10.0.0.2/32 -j ACCEPT — vous pouvez supprimer une règle listée en exécutant une commande iptables avec ce contenu de règle exact, sauf que le drapeau -A (aka --append) est remplacé par le drapeau -D (aka --delete) :

sudo iptables -D to-vnc-server -s 10.0.0.2/32 -j ACCEPT

4/5/2021

by [Justin Ludwi

• Justin Ludwig
• WireGuard
• Réseautage
• Pare-feu
• iptables