WireGuard sur TCP

Bien que vous puissiez tunneler n’importe quel protocole basé sur l’IP (TCP, UDP, ICMP, SCTP, IPIP, GRE, etc.) à l’intérieur de WireGuard, WireGuard lui-même utilise UDP pour son propre transport. Si vous avez besoin d’utiliser WireGuard dans un environnement réseau restrictif qui bloque les paquets UDP vers ou depuis des sources externes — mais qui permet le TCP — vous pouvez utiliser udp2raw pour configurer un tunnel TCP à travers lequel vous pouvez utiliser WireGuard.

Cet article vous montrera comment configurer une connexion WireGuard Point to Point à travers un tunnel udp2raw, où nous avons un point de terminaison, Endpoint A, derrière un NAT qui bloque le UDP et qui tente de se connecter à travers WireGuard à un service HTTP privé hébergé sur l’autre point de terminaison, Endpoint B. Endpoint B est également derrière un NAT, mais a le port TCP 443 forwarding vers lui depuis une adresse IP publique accessible 203.0.113.2.

Le diagramme ci-dessous illustre ce scénario :

Le service HTTP privé est en cours d’exécution sur le port TCP 8080 de Endpoint B. Nous allons configurer WireGuard et udp2raw de manière à ce que Endpoint A puisse accéder à ce service en utilisant l’adresse IP WireGuard de Endpoint B, 10.0.0.2 (c’est-à-dire avec une URL de http://10.0.0.2:8080/).

Les mêmes paramètres udp2raw fonctionneront également pour la plupart des autres topologies WireGuard, comme Point to Site ou Hub and Spoke. Cependant, si vous avez besoin d’utiliser WireGuard pour la route par défaut sur un pair (par exemple en utilisant AllowedIPs = 0.0.0.0/0 pour envoyer tout le trafic du pair à Internet via le tunnel WireGuard), vous devrez ajouter une route explicite pour l’autre point de terminaison WireGuard ; nous couvrirons cela dans la section Point to Internet.

Point to Point

D’abord, installez udp2raw sur les deux points de terminaison. Si votre gestionnaire de paquets d’OS ne comprend pas de package udp2raw, vous pouvez télécharger le code source et le compiler vous-même. Alternativement, vous pouvez télécharger un binaire Linux pré-constructé à partir de la page des versions udp2raw — le lien udp2raw_binaries.tar.gz de cette page contient des binaires pour une variété d’architectures Linux différentes, comme arm, amd64, etc. Ou vous pouvez télécharger un binaire Windows ou Mac à partir de la page des versions udp2raw-multiplatform — sur cette page, le lien udp2raw_mp_binaries.tar.gz comprend des binaires pour les deux Windows et Mac.

Dans ce guide, nous référerons au binaire udp2raw simplement comme udp2raw, comme si vous aviez placé le binaire spécifique à la plateforme à /usr/bin/udp2raw sur chaque point de terminaison ; mais vous devrez peut-être ajuster cela pour faire référence au nom réel du binaire ou au chemin complet vers le binaire que vous utilisez.

Ensuite, suivez la configuration de base WireGuard Point to Point pour installer WireGuard sur les deux points de terminaison, générer un paire de clés WireGuard pour chacun et configurer un fichier de configuration WireGuard de base à /etc/wireguard/wg0.conf sur chaque point de terminaison.

Point de terminaison A

Une fois que vous avez configuré la base de WireGuard pour le Point de terminaison A, vous pouvez l’ajuster pour utiliser udp2raw. Tout d’abord, ajoutez les paramètres suivants à la section [Interface] du fichier /etc/wireguard/wg0.conf sur Endpoint A :

[Interface]
Address = 10.0.0.1/24
PrivateKey = <Clé privée de Endpoint A>
ListenPort = 51820
PostUp = /usr/bin/udp2raw -s -l 127.0.0.1:51820 -r 203.0.113.2:443 --raw-mode faketcp --encrypt-level 2 -k <Clé udp2raw>
PostDown = /usr/bin/udp2raw -s -l 127.0.0.1:51820 -r 203.0.113.2:443 --raw-mode faketcp --encrypt-level 2 -k <Clé udp2raw> --kill

Assurez-vous de remplacer <Clé privée de Endpoint A> et <Clé udp2raw> par les valeurs appropriées.

Ensuite, redémarrez le service WireGuard sur Endpoint A :

sudo wg-quick down wg0
sudo wg-quick up wg0

Point de terminaison B

Sur Endpoint B, configurez udp2raw pour écouter les connexions TCP et les transmettre via UDP. Ajoutez les paramètres suivants à la section [Interface] du fichier /etc/wireguard/wg0.conf sur Endpoint B :

[Interface]
Address = 10.0.0.2/24
PrivateKey = <Clé privée de Endpoint B>
ListenPort = 51820
PostUp = /usr/bin/udp2raw -s -l 127.0.0.1:51820 -r 10.0.0.1:51820 --raw-mode faketcp --encrypt-level 2 -k <Clé udp2raw>
PostDown = /usr/bin/udp2raw -s -l 127.0.0.1:51820 -r 10.0.0.1:51820 --raw-mode faketcp --encrypt-level 2 -k <Clé udp2raw> --kill

Assurez-vous de remplacer <Clé privée de Endpoint B> et <Clé udp2raw> par les valeurs appropriées.

Ensuite, redémarrez le service WireGuard sur Endpoint B :

sudo wg-quick down wg0
sudo wg-quick up wg0

Maintenant, Endpoint A devrait être capable d’accéder au service HTTP privé de Endpoint B via l’adresse IP WireGuard 10.0.0.2.

Point to Internet

Si vous avez besoin d’utiliser WireGuard pour la route par défaut sur un pair (par exemple en utilisant AllowedIPs = 0.0.0.0/0 pour envoyer tout le trafic du pair à Internet via le tunnel WireGuard), vous devrez ajouter une route explicite pour l’autre point de terminaison WireGuard. Voici comment vous pouvez le faire sur Endpoint A :

sudo ip route add 10.0.0.2/32 via <Adresse IP de Endpoint B>

Assurez-vous de remplacer <Adresse IP de Endpoint B> par l’adresse IP réelle de Endpoint B.

Ensuite, redémarrez le service WireGuard sur Endpoint A :

sudo wg-quick down wg0
sudo wg-quick up wg0

Avec ces configurations, vous devriez être en mesure d’utiliser WireGuard à travers un tunnel TCP et d’accéder au service HTTP privé de l’autre point de terminaison.

Voici le texte corrigé :

Modifiez la ligne `PreUp` du fichier `/etc/wireguard/wg0.conf` sur le Point de terminaison A :

```bash
MTU = 1342
PreUp = udp2raw -c -l 127.0.0.1:50001 -r 203.0.113.2:443 -k "shared secret" -a >/var/log/udp2raw.log 2>&1 &
PostDown = killall udp2raw || true

Remplacez 203.0.113.2:443 par l’adresse IP publique et le port TCP que le Point de terminaison A utilisera pour se connecter au Point de terminaison B, et remplacez shared secret par une valeur de secret réelle.

Udp2raw ne fonctionnera pas pour tunneler des paquets sur Internet avec une charge utile de 1375 octets ou plus, donc nous devons réduire l’MTU (Unité maximale de transmission) de l’interface WireGuard. Un MTU de 1342 est le plus élevé que nous pouvons utiliser pour cette interface WireGuard dans ce cas, c’est ce que nous allons utiliser ici (mais vous devrez encore la réduire si n’importe quel lien entre vos deux points de terminaison a un MTU inférieur à la valeur standard de 1500).

Nous exécuterons udp2raw via une commande PreUp. Udp2raw par défaut s’attend à être lié à un terminal, donc nous ajouterons >/var/log/udp2raw.log 2>&1 & à la fin de la commande PreUp pour envoyer sa sortie vers un fichier de journalisation situé à /var/log/udp2raw.log, et l’exécuter en arrière-plan (pour qu’il ne bloque pas le démarrage de wg-quick).

Voici ce que fait chaque drapeau udp2raw mentionné ci-dessus :

-c

Exécute udp2raw en mode “client”, où il initie des connexions TCP au serveur udp2raw spécifié par le drapeau -r (un point de terminaison doit être en cours d’exécution en mode “client”, et l’autre en mode “server”).

-l 127.0.0.1:50001

Écoute les paquets UDP provenant de l’interface WireGuard locale sur le port UDP 50001. Vous pouvez changer ce port pour ce que vous voulez — il doit simplement correspondre à la configuration Endpoint de l’interface WireGuard locale (comme nous discuterons ci-dessous).

-r 203.0.113.2:443

Se connecte au serveur udp2raw distant qui écoute sur l’adresse IP publique 203.0.113.2 sur le port TCP 443. Changez cela pour utiliser l’adresse IP publique réelle et le port TCP de Endpoint B.

Dans notre scénario, le routeur du Site B est en train de transférer les connexions TCP port 443 à partir d’Internet pour l’adresse IP 203.0.113.2 vers l’adresse LAN du Site B de Endpoint B de 192.168.200.22. Dans d’autres situations, Endpoint B pourrait avoir une adresse IP publique statique directement routable à partir d’Internet, dans ce cas vous pouvez utiliser cette adresse IP ici au lieu de celle-ci. En général, l’adresse IP que vous spécifiez ici doit être une adresse IP publiquement-routable — pas une adresse IP privée.

-k "shared secret"

Définit le secret utilisé pour authentifier le client auprès du serveur udp2raw. Changez cette valeur par un secret réel (une bonne méthode consiste à exécuter la commande wg genpsk). Cette valeur doit être identique sur le client et le serveur udp2raw.

-a

Configure les règles iptables pour protéger la pile réseau Linux de l’essai de traiter les paquets TCP faux générés par udp2raw (sautez cette étape sur les plateformes non-linux).

La commande PostDown arrêtera toutes les instances en cours d’exécution de udp2raw (y compris celle que nous avons démarrée avec la commande PreUp).

Ensuite, changez le paramètre Endpoint dans la section [Peer] du fichier /etc/wireguard/wg0.conf de Endpoint A par celui-ci :

Endpoint = 127.0.0.1:50001

Cela permettra d’envoyer le tunnel WireGuard à travers le client udp2raw que nous avons configuré avec la commande PreUp précédente. Utilisez la même valeur pour le paramètre Endpoint que celle utilisée pour l’option -l du client udp2raw.

Le fichier de configuration complet de WireGuard pour Endpoint A devrait maintenant ressembler à ceci :

# /etc/wireguard/wg0.conf

# paramètres locaux pour Endpoint A
[Interface]
PrivateKey = AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEE=
Address = 10.0.0.1/32

```bash
envoyer wg via udp2raw
MTU = 1342
PreUp = udp2raw -c -l 127.0.0.1:50001 -r 203.0.113.2:443 -k "shared secret" -a >/var/log/udp2raw.log 2>&1 &
PostDown = killall udp2raw || true

# paramètres distants pour Endpoint B
[Peer]
PublicKey = fE/wdxzl0klVp/IR8UcaoGUMjqaWi3jAd7KzHKFS6Ds=
Endpoint = 127.0.0.1:50001
AllowedIPs = 10.0.0.2/32

### Endpoint B

Sur Endpoint B, ajoutez les paramètres suivants à la section `[Interface]` de son fichier `/etc/wireguard/wg0.conf`.

```bash
# recevoir wg via udp2raw
MTU = 1342
PreUp = udp2raw -s -l 192.168.200.22:443 -r 127.0.0.1:51822 -k "shared secret" -a >/var/log/udp2raw.log 2>&1 &
PostDown = killall udp2raw || true

Remplacez 192.168.200.22:443 par l’adresse IP et le port TCP réels de Point de terminaison B qui accepteront les connexions TCP depuis Point de terminaison A, et remplacez shared secret par la même valeur secrète que vous avez utilisée pour Point de terminaison A ci-dessus :

Comme pour Point de terminaison A, nous devons réduire le MTU de l’interface WireGuard de Point de terminaison B ; 1342 devrait fonctionner dans la plupart des cas (mais utilisez la même valeur de MTU que celle que vous avez utilisée pour Point de terminaison A si vous devez la diminuer).

Comme pour Point de terminaison A, nous exécuterons udp2raw via une commande PreUp, ajoutant >/var/log/udp2raw.log 2>&1 & à la fin de la commande PreUp pour envoyer sa sortie vers un fichier de journalisation situé à /var/log/udp2raw.log, et nous l’exécuterons en arrière-plan (pour qu’il ne bloque pas le démarrage de wg-quick).

Les trois premiers drapeaux que nous définissons pour udp2raw doivent être différents sur Point de terminaison B par rapport à Point de terminaison A. Voici ce que fait chaque drapeau udp2raw sur Point de terminaison B :

-s

Exécute udp2raw en mode “serveur”, où il écoute les connexions TCP sur l’adresse IP locale et le port spécifiés par le drapeau -l (un point de terminaison doit être en mode “client” et l’autre en mode “serveur”).

-l 192.168.200.22:443

Écoute les paquets TCP des clients udp2raw à l’adresse IP 192.168.200.22 sur le port TCP 443.

Dans notre scénario, le routeur de Site B est en train de transférer les connexions TCP port 443 pour l’adresse IP 203.0.113.2 vers l’adresse LAN de Site B de Point de terminaison B à 192.168.200.22. Dans d’autres situations, Point de terminaison B pourrait avoir une adresse IP publique statique directement routable depuis Internet, dans ce cas vous pouvez utiliser cette adresse IP ici au lieu.

En général, l’adresse IP que vous spécifiez ici devrait être l’adresse IP primaire de l’interface Ethernet publique de Point de terminaison B (qui peut être une adresse IP privée). Exécutez ip -brief address sur Point de terminaison B pour voir la liste de ses adresses.

-r 127.0.0.1:51822

Envoie les connexions tunnélées via udp2raw au point de terminaison local WireGuard qui écoute sur le port UDP 51822. Vous pouvez changer ce port en ce que vous voulez — il doit simplement correspondre à la configuration ListenPort de l’interface WireGuard locale.

-k "shared secret"

Définit le secret utilisé pour authentifier les clients au serveur udp2raw. Utilisez le même secret sur Endpoint B que celui que vous avez utilisé pour Endpoint A ci-dessus.

-a

Configure des règles iptables pour protéger la pile réseau Linux de tenter de traiter les paquets TCP faux générés par udp2raw (sautez cette étape sur les plateformes non-linux).

La commande PostDown arrêtera toutes les instances en cours d’exécution de udp2raw (y compris celle que nous avons démarrée avec la commande PreUp).

Le fichier de configuration complet de WireGuard pour Endpoint B devrait maintenant ressembler à ceci :

# /etc/wireguard/wg0.conf

# paramètres locaux pour Endpoint B
[Interface]
PrivateKey = ABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBFA=
Address = 10.0.0.2/32
ListenPort = 51822

# reçoit wg via udp2raw
MTU = 1342
PreUp = udp2raw -s -l 192.168.200.22:443 -r 127.0.0.1:51822 -k "shared secret" -a >/var/log/udp2raw.log 2>&1 &
PostDown = killall udp2raw || true

1342
PreUp = udp2raw -s -l 192.168.200.22:443 -r 127.0.0.1:51822 -k "shared secret" -a >/var/log/udp2raw.log 2>&1 &
PostDown = killall udp2raw || true

# paramètres distants pour Endpoint A
[Peer]
PublicKey = /TOE4TKtAqVsePRVR+5AA43HkAK5DSntkOCO7nYq5xU=
AllowedIPs = 10.0.0.1/32

### Testez-le

Démarrez l'interface WireGuard sur chaque point de terminaison (par exemple `sudo wg-quick up wg0`), démarrez le service HTTP privé sur Endpoint B, puis essayez de vous connecter à celui-ci depuis Endpoint A. Dans notre scénario, l'adresse IP privée de WireGuard de Endpoint B est `10.0.0.2`, et le service HTTP privé s'exécute dessus au port TCP `8080`, donc nous pouvons exécuter la commande cURL suivante sur Endpoint A pour y accéder :

```bash
$ curl 10.0.0.2:8080
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
...

Initiez les Connexions à partir de Endpoint B

Si vous devez permettre à l’Endpoint B (le serveur udp2raw) d’établir des connexions avec l’Endpoint A (le client udp2raw) — par exemple, si le service HTTP privé de notre scénario était en cours d’exécution sur l’Endpoint A au lieu de l’Endpoint B — ajoutez la configuration suivante PersistentKeepalive à la section [Peer] du fichier de configuration de l’Endpoint A :

# permettre à Endpoint B d'établir des connexions
PersistentKeepalive = 120

Cela entraînera le WireGuard de l’Endpoint A à tenter de se connecter au WireGuard de l’Endpoint B lors du démarrage, et à envoyer un paquet de maintenance toutes les 120 secondes après. Udp2raw enverra automatiquement une requête de cœur de vie de l’Endpoint A à l’Endpoint B chaque seconde pendant 2 à 3 minutes après chaque paquet de maintenance WireGuard, ce qui maintiendra le trou NAT vers l’Endpoint A ouvert jusqu’à la prochaine paquet de maintenance WireGuard (ce qui permettra à l’Endpoint B d’établir des connexions avec l’Endpoint A).

Pointer sur Internet

Si vous définissez AllowedIPs = 0.0.0.0/0 sur l’Endpoint A afin d’utiliser sa connexion WireGuard avec l’Endpoint B pour accéder à Internet (ou à d’autres réseaux larges), vous devrez ajouter une route explicite sur l’Endpoint A pour l’Endpoint B (sinon, l’Endpoint A essayera de transmettre le tunnel udp2raw lui-même via le tunnel WireGuard, créant un boucle infinie de tunnels imbriqués).

Exécutez la commande ip route sur l’Endpoint A et vous verrez une sortie similaire à celle-ci :

$ ip route
default via 192.168.1.1 dev eth0 proto dhcp metric 100
192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.11 metric 100

La ligne default via 192.168.1.1 dev eth0 indique que le système utilise 192.168.1.1 comme passerelle par défaut, connectée à travers son interface réseau eth0. Pour s’assurer que l’Endpoint A utilisera cette passerelle pour son tunnel udp2raw avec l’Endpoint B, au lieu du tunnel WireGuard, vous devez ajouter une route explicite pour l’adresse IP publique de l’Endpoint B (203.0.113.2), comme suit, en utilisant la même passerelle et interface que la route par défaut :

203.0.113.2 via 192.168.1.1 dev eth0

Vous pouvez ajouter une autre commande PreUp à la configuration de WireGuard sur le Point de terminaison A pour ajouter cette route au démarrage de wg-quick, comme suit :

PreUp = ip route add 203.0.113.2 via 192.168.1.1 dev eth0
PostDown = ip route del 203.0.113.2 via 192.168.1.1 dev eth0

La configuration complète du Point de terminaison A pour le point-à-internet serait alors la suivante :

# /etc/wireguard/wg0.conf

# paramètres locaux pour le Point de terminaison A
[Interface]
PrivateKey = AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEE=
Address = 10.0.0.1/32
DNS = 9.9.9.9

# route l'adresse publique du Point de terminaison B via la passerelle LAN
PreUp = ip route add 203.0.113.2 via 192.168.1.1 dev eth0
PostDown = ip route del 203.0.113.2 via 192.168.1.1 dev eth0

# envoie wg à travers udp2raw
MTU = 1342
PreUp = udp2raw -s -l 192.168.200.22:443 -r 127.0.0.1:51822 -k "shared secret" -a >/var/log/udp2raw.log 2>&1 &
PostDown = killall udp2raw || true

```bash
-c -l 127.0.0.1:50001 -r 203.0.113.2:443 -k "shared secret" -a >/var/log/udp2raw.log 2>&1 &
PostDown = killall udp2raw || true

# paramètres distants pour le Point de terminaison B
[Peer]
PublicKey = fE/wdxzl0klVp/IR8UcaoGUMjqaWi3jAd7KzHKFS6Ds=
Endpoint = 127.0.0.1:50001
AllowedIPs = 0.0.0.0/0, ::/0

Vous n’avez pas besoin de faire quoi que ce soit de spécial sur le Point de terminaison B (le serveur udp2raw) pour le point-à-internet via udp2raw — juste assurez-vous d’activer la transmission des paquets et le masquage, comme dans la configuration pour l’Hôte β dans le guide de base Configuration Point à Site WireGuard.

Dépannage

Journal udp2raw

Si les tunnels ne semblent pas fonctionner, vérifiez d’abord la sortie de udp2raw, qui nous avons redirigée dans le fichier /var/log/udp2raw.log sur chaque point de terminaison. Sur le Point de terminaison A, vous devriez voir une sortie similaire à celle-ci lorsque udp2raw démarre pour la première fois :

$ less -R /var/log/udp2raw.log
[2022-02-15 04:02:48][INFO]argc=9 udp2raw -c -l 127.0.0.1:50001 -r 203.0.113.2:443 -k shared secret -a
[2022-02-15 04:02:48][INFO]parsing address: 127.0.0.1:50001
[2022-02-15 04:02:48][INFO]its an ipv4 adress
[2022-02-15 04:02:48][INFO]ip_address is {127.0.0.1}, port is {50001}
[2022-02-15 04:02:48][INFO]parsing address: 203.0.113.2:443
[2022-02-15 04:02:48][INFO]its an ipv4 adress
[2022-02-15 04:02:48][INFO]ip_address is {203.0.113.2}, port is {443}
[2022-02-15 04:02:48][INFO]important variables: log_level=4:INFO raw_mode=faketcp cipher_mode=aes128cbc auth_mode=md5 key=shared local_addr=127.0.0.1:50001 remote_addr=203.0.113.2:443 socket_buf_size=1048576
[2022-02-15 04:02:48][WARN]you can run udp2raw with non-root account for better security. check README.md in repo for more info.
[2022-02-15 04:02:48][INFO]remote_ip=[203.0.113.2], make sure this is a valid IP address
[2022-02-15 04:02:48][INFO]const_id:fd21137c
[2022-02-15 04:02:48][INFO]run_command iptables -N udp2rawDwrW_fd21137c_C0
[2022-02-15 04:02:48][INFO]run_command iptables -F udp2rawDwrW_fd21137c_C0
[2022-02-15 04:02:48][INFO]run_command iptables -I udp2rawDwrW_fd21137c_C0 -j DROP
[2022-02-15 04:02:48][INFO]run_command iptables -I INPUT -s 203.0.113.2 -p tcp -m tcp --sport 443 -j udp2rawDwrW_fd21137c_C0
[2022-02-15 04:02:48][WARN]auto added iptables rules
[2022-02-15 04:02:48][INFO]source_addr is now 192.168.1.11
[2022-02-15 04:02:48][INFO]using port 16692

Et ensuite, une sortie comme celle-ci lorsque vous vous connectez au serveur udp2raw :

[2022-02-15 04:05:18][INFO]state changed from client_idle to client_tcp_handshake
[2022-02-15 04:05:18][INFO](re)sent tcp syn
[2022-02-15 04:05:18][INFO]state changed from client_tcp_handshake to client_handshake1
[2022-02-15 04:05:18][INFO](re)sent handshake1
[2022-02-15 04:05:18][INFO]changed state from client_handshake1 to client_handshake2, my_id is 25ad52ec, opposite id is 28c7f475
[2022-02-15 04:05:18][INFO](re)sent handshake2
[2022-02-15 04:05:18][INFO]changed state from client_handshake2 to client_ready

Sur le Point de terminaison B, vous verrez une sortie similaire lorsque udp2raw démarre :

$ less -R /var/log/udp2raw.log
[2022-02-15 04:05:13][INFO]argc=9 udp2raw -s -l 192.168.200.22:443 -r 127.0.0.1:51822 -k shared secret -a
[2022-02-15 04:05:13][INFO]parsing address: 192.168.200.22:443
[2022-02-15 04:05:13][INFO]its an ipv4 adress
[2022-02-15 04:05:13][INFO]ip_address is {192.168.200.22}, port is {443}
[2022-02-15 04:05:13][INFO]parsing address: 127.0.0.1:51822
[2022-02-15 04:05:13][INFO]its an ipv4 adress
[2022-02-15 04:05:13][INFO]ip_address is {127.0.0.1}, port is {51822}
[2022-02-15 04:05:13][INFO]important variables: log_level=4:INFO raw_mode=faketcp cipher_mode=aes128cbc auth_mode=md5 key=shared local_addr=192.168.200.22:443 remote_addr=127.0.0.1:51822 socket_buf_size=1048576
[2022-02-15 04:05:13][WARN]you can run udp2raw with non-root account for better security. check README.md in repo for more info.

Pour améliorer la sécurité, consultez le fichier README.md dans le dépôt pour plus d’informations.

[2022-02-15 04:05:13][INFO] remote_ip=[127.0.0.1], assurez-vous que c’est une adresse IP valide. [2022-02-15 04:05:13][INFO] const_id: 74593e80 [2022-02-15 04:05:14][INFO] run_command iptables -N udp2rawDwrW_74593e80_C0 [2022-02-15 04:05:14][INFO] run_command iptables -F udp2rawDwrW_74593e80_C0 [2022-02-15 04:05:14][INFO] run_command iptables -I udp2rawDwrW_74593e80_C0 -j DROP [2022-02-15 04:05:14][INFO] run_command iptables -I INPUT -d 192.168.200.22 -p tcp -m tcp –dport 443 -j udp2rawDwrW_74593e80_C0 [2022-02-15 04:05:14][WARN] règles iptables automatiquement ajoutées [2022-02-15 04:05:14][INFO] maintenant en écoute sur 192.168.200.22:443

Voici une sortie comme celle-ci lorsqu’il reçoit une connexion d’un client udp2raw :

[2022-02-15 04:05:18][INFO][198.51.100.1:35241] received syn, sent syn ack back
[2022-02-15 04:05:18][INFO][198.51.100.1:35241] got packet from a new ip
[2022-02-15 04:05:18][INFO][198.51.100.1:35241] created new conn, state: server_handshake1, my_id is f03ad003
[2022-02-15 04:05:18][INFO][198.51.100.1:35241] changed state to server_handshake1, my_id is f03ad003
[2022-02-15 04:05:18][INFO][198.51.100.1:35241] received handshake, opposite_id: c2d91811, my_id: f03ad003
[2022-02-15 04:05:18][INFO][198.51.100.1:35241] opposite const_id: 4d4e1d3e
[2022-02-15 04:05:18][INFO][198.51.100.1:35241] changed state to server_ready

Si vous ne voyez aucun message d’échange de clés dans les journaux udp2raw, vous devez corriger la configuration de udp2raw.

MTU de WireGuard

Si les connexions fonctionnent uniquement avec des petits paquets (comme avec ping ou dig), mais pas avec des paquets importants (comme le navigateur web ou le bureau à distance), vous avez probablement un problème d’MTU.

Vous verrez également des avertissements comme celui-ci dans les journaux udp2raw si vous n’avez pas configuré l’option MTU de WireGuard comme indiqué ci-dessus :

[2022-02-15 03:48:57][WARN] huge packet, data_len > 1800, dropped

[2022-02-15 03:51:50][WARN] huge packet, data len=1452 (>=1375). strongly suggested to set a smaller mtu at upper level, to get rid of this warn

Si les paquets sont trop grands pour passer à travers la connexion entre le Point de terminaison A et B, vous devrez réduire l’option MTU de WireGuard. Si un MTU de 1342 ne fonctionne pas, essayez de le diminuer à 1280 (la valeur légale la plus basse pour IPv6). Si 1280 fonctionne, essayez d’augmenter jusqu’à ce que la connexion cesse de fonctionner. Généralement, vous voulez l’MTU le plus élevé qui fonctionne, car un MTU plus élevé permet à la connexion d’utiliser moins de paquets (et moins de paquets signifie une connexion plus rapide et avec moins de jitter).

2/16/2022

by Justin Ludwig

• WireGuard
• Réseautage
• Point à Point