Un VPN multi-hop achemine votre trafic a travers deux serveurs dans deux pays differents, de sorte qu'aucune machine ne sait jamais a la fois qui vous etes et ce que vous faites. Les VPN commerciaux proposent cela sous le nom de "Double VPN" ou "Secure Core", mais la version la plus privee est celle que vous construisez vous-meme a partir de deux serveurs que vous seul controlez. Ce guide enchaine deux serveurs WireGuard - un serveur d'entree auquel vous vous connectez et un serveur de sortie par lequel votre trafic sort - afin que votre vraie IP soit cachee derriere deux sauts que personne d'autre ne peut journaliser.
Comment fonctionne la chaine
Votre appareil se connecte uniquement au serveur d'entree. Le serveur d'entree n'envoie pas votre trafic directement sur internet - il transmet plutot tout via un second tunnel WireGuard vers le serveur de sortie, qui atteint ensuite internet. Le chemin est donc : vous → entree → sortie → internet. Le serveur d'entree voit votre vraie IP mais jamais votre destination ; le serveur de sortie voit votre destination mais ne voit toujours que le serveur d'entree. Les sites voient l'IP du serveur de sortie. Nous donnons au serveur de sortie la plage 10.8.0.0/24 et au serveur d'entree 10.7.0.0/24 pour vos appareils.
Etape 1 : Configurer le serveur de sortie
Le serveur de sortie est simplement un serveur WireGuard normal. Sur le VPS de sortie, installez WireGuard et generez ses cles :
apt update && apt install -y wireguard
wg genkey | tee /etc/wireguard/exit.key | wg pubkey > /etc/wireguard/exit.pub
cat /etc/wireguard/exit.key # this is EXIT_PRIVATE_KEY
cat /etc/wireguard/exit.pub # this is EXIT_PUBLIC_KEYTrouvez votre interface reseau publique (generalement eth0) avec ip route show default. Creez ensuite /etc/wireguard/wg0.conf sur le serveur de sortie :
[Interface]
Address = 10.8.0.1/24
ListenPort = 51820
PrivateKey = EXIT_PRIVATE_KEY
PostUp = iptables -A FORWARD -i %i -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i %i -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE
[Peer]
# The entry server (we add its key in Step 4)
PublicKey = ENTRY_LINK_PUBLIC_KEY
AllowedIPs = 10.8.0.2/32Remplacez eth0 si votre interface est differente. Laissez ENTRY_LINK_PUBLIC_KEY comme espace reserve pour l'instant - nous le generons a l'etape 4.
Etape 2 : Activer le forwarding et demarrer la sortie
Activez le forwarding IP de facon permanente, puis demarrez WireGuard sur le serveur de sortie :
echo 'net.ipv4.ip_forward=1' > /etc/sysctl.d/99-wg.conf
sysctl -p /etc/sysctl.d/99-wg.conf
ufw allow 51820/udp
systemctl enable --now wg-quick@wg0Notez l'IP publique du serveur de sortie - nous l'appellerons EXIT_IP.
Etape 3 : Configurer le serveur d'entree (votre cote)
Sur le VPS d'entree, installez WireGuard et generez deux paires de cles - une pour le tunnel qui fait face a vos appareils (wg0) et une pour le lien vers la sortie (wg1) :
apt update && apt install -y wireguard
wg genkey | tee /etc/wireguard/entry0.key | wg pubkey > /etc/wireguard/entry0.pub # faces your devices
wg genkey | tee /etc/wireguard/entry1.key | wg pubkey > /etc/wireguard/entry1.pub # link to exitLa cle publique dans entry1.pub est le ENTRY_LINK_PUBLIC_KEY que vous avez laisse comme espace reserve sur le serveur de sortie a l'etape 1. Revenez et collez-le maintenant dans le wg0.conf de la sortie, puis executez systemctl restart wg-quick@wg0 sur le serveur de sortie.
Etape 4 : Creer le lien entree-sortie (wg1)
Sur le serveur d'entree, creez /etc/wireguard/wg1.conf. Cela fait du serveur d'entree un client du serveur de sortie :
[Interface]
Address = 10.8.0.2/24
PrivateKey = ENTRY_LINK_PRIVATE_KEY
# Do NOT route the whole server through the exit - that would cut your own SSH.
# Send only your client subnet (10.7.0.0/24) through the exit, via a separate table.
Table = off
PostUp = ip rule add from 10.7.0.0/24 table 120; ip route add default dev wg1 table 120
PostDown = ip rule del from 10.7.0.0/24 table 120; ip route del default dev wg1 table 120
[Peer]
# The exit server
PublicKey = EXIT_PUBLIC_KEY
Endpoint = EXIT_IP:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25ENTRY_LINK_PRIVATE_KEY est le contenu de entry1.key. C'est l'etape la plus importante a reussir. Un simple AllowedIPs = 0.0.0.0/0 ferait router par WireGuard le trafic propre du serveur d'entree - y compris votre session SSH - via la sortie, ce qui coupe votre acces au serveur. Table = off empeche cela, et les regles de policy routing envoient uniquement votre sous-reseau client via la sortie, laissant le serveur lui-meme accessible normalement.
Etape 5 : Creer le tunnel d'entree pour vos appareils (wg0)
Toujours sur le serveur d'entree, creez /etc/wireguard/wg0.conf. C'est le tunnel auquel votre telephone ou ordinateur portable se connecte, et les regles de routage poussent ce trafic dans wg1 :
[Interface]
Address = 10.7.0.1/24
ListenPort = 51820
PrivateKey = ENTRY_DEVICE_PRIVATE_KEY
PostUp = iptables -A FORWARD -i wg0 -o wg1 -j ACCEPT; iptables -A FORWARD -i wg1 -o wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o wg1 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -o wg1 -j ACCEPT; iptables -D FORWARD -i wg1 -o wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o wg1 -j MASQUERADE
[Peer]
# Your device (we add its key in Step 6)
PublicKey = CLIENT_PUBLIC_KEY
AllowedIPs = 10.7.0.2/32ENTRY_DEVICE_PRIVATE_KEY est le contenu de entry0.key. Le masquerading sur wg1 cache votre appareil derriere le serveur d'entree, de sorte que la sortie ne voit jamais que l'entree.
Etape 6 : Creer la config de l'appareil et se connecter
Generez une paire de cles pour votre appareil (sur votre ordinateur ou sur le serveur d'entree), puis construisez la config client. Mettez la cle publique de l'appareil dans le wg0.conf de l'entree la ou est indique CLIENT_PUBLIC_KEY. La config de votre appareil ressemble a ceci :
[Interface]
PrivateKey = CLIENT_PRIVATE_KEY
Address = 10.7.0.2/32
DNS = 1.1.1.1
[Peer]
PublicKey = ENTRY_DEVICE_PUBLIC_KEY
Endpoint = ENTRY_IP:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25Ici, ENTRY_DEVICE_PUBLIC_KEY vient de entry0.pub, et ENTRY_IP est l'IP publique du serveur d'entree - le seul serveur auquel votre appareil parle.
Etape 7 : Demarrer l'entree et verifier la chaine
Sur le serveur d'entree, activez le forwarding et demarrez les deux tunnels dans l'ordre (le lien d'abord, puis le tunnel de l'appareil) :
echo 'net.ipv4.ip_forward=1' > /etc/sysctl.d/99-wg.conf
sysctl -p /etc/sysctl.d/99-wg.conf
ufw allow 51820/udp
systemctl enable --now wg-quick@wg1
systemctl enable --now wg-quick@wg0Importez maintenant la config client dans l'application WireGuard sur votre appareil et connectez-vous. Pour confirmer que la chaine fonctionne, verifiez votre IP - elle doit indiquer le pays du serveur de sortie, pas de l'entree :
curl https://api.ipify.orgSi cela renvoie l'IP du serveur de sortie, votre trafic saute a travers les deux serveurs. Lancez un test de fuite sur notre page d'outils reseau pour vous assurer qu'il n'y a pas de fuites DNS ou WebRTC.
sysctl net.ipv4.ip_forward doit renvoyer 1) sur les deux serveurs, que le serveur de sortie a votre cle d'entree dans son bloc [Peer], et que les deux pare-feux autorisent l'UDP 51820. Si l'IP indique le pays d'entree au lieu de la sortie, la regle MASQUERADE -o wg1 sur l'entree ne s'est pas chargee - redemarrez wg0 sur le serveur d'entree.Est-ce que ca en vaut la peine ?
Un multi-hop auto-heberge est le setup le plus prive qui soit : deux serveurs qui vous appartiennent, dans deux pays, sans fournisseur au milieu qui garde des journaux. Les compromis sont la vitesse (deux sauts ajoutent de la latence) et le cout (deux VPS au lieu d'un). Pour la navigation quotidienne, un seul serveur suffit ; construisez la chaine quand votre modele de menace l'exige vraiment. Et rappelez-vous : un multi-hop protege votre vie privee, il ne change pas la loi de l'endroit ou vous vivez.
