Una VPN multi-hop enruta tu trafico a traves de dos servidores en dos paises distintos, de modo que ninguna maquina sabe a la vez quien eres y que haces. Las VPN comerciales lo ofrecen como "Double VPN" o "Secure Core", pero la version mas privada es la que construyes tu mismo con dos servidores que solo tu controlas. Esta guia encadena dos servidores WireGuard - un servidor de entrada al que te conectas y un servidor de salida por el que sale tu trafico - para que tu IP real quede oculta tras dos saltos que nadie mas puede registrar.

Antes de empezar: esta es una guia avanzada. Si aun no has montado un solo servidor WireGuard, sigue primero nuestra guia de WireGuard en VPS - aqui se asume que ese proceso te resulta familiar. Necesitas dos VPS, idealmente de proveedores distintos en paises distintos, ambos con un Ubuntu o Debian nuevo y acceso root.

Como funciona la cadena

Tu dispositivo se conecta solo al servidor de entrada. El servidor de entrada no envia tu trafico directamente a internet - en su lugar lo reenvia todo a traves de un segundo tunel WireGuard al servidor de salida, que llega a internet. Asi que la ruta es: tu → entrada → salida → internet. El servidor de entrada ve tu IP real pero nunca tu destino; el de salida ve tu destino pero solo ve siempre el servidor de entrada. Los sitios ven la IP del servidor de salida. Daremos al servidor de salida el rango 10.8.0.0/24 y al de entrada 10.7.0.0/24 para tus dispositivos.

Paso 1: Configurar el servidor de salida

El servidor de salida es simplemente un servidor WireGuard normal. En el VPS de salida, instala WireGuard y genera sus claves:

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_KEY

Encuentra tu interfaz de red publica (normalmente eth0) con ip route show default. Luego crea /etc/wireguard/wg0.conf en el servidor de salida:

[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/32

Reemplaza eth0 si tu interfaz es distinta. Deja ENTRY_LINK_PUBLIC_KEY como marcador por ahora - lo generamos en el Paso 4.

Paso 2: Activar el forwarding y arrancar la salida

Activa el reenvio IP de forma permanente y luego arranca WireGuard en el servidor de salida:

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@wg0

Anota la IP publica del servidor de salida - la llamaremos EXIT_IP.

Paso 3: Configurar el servidor de entrada (tu lado)

En el VPS de entrada, instala WireGuard y genera dos pares de claves - uno para el tunel que da a tus dispositivos (wg0) y otro para el enlace a la salida (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 exit

La clave publica en entry1.pub es el ENTRY_LINK_PUBLIC_KEY que dejaste como marcador en el servidor de salida en el Paso 1. Vuelve y pegalo ahora en el wg0.conf de la salida, luego ejecuta systemctl restart wg-quick@wg0 en el servidor de salida.

Paso 4: Crear el enlace entrada-salida (wg1)

En el servidor de entrada, crea /etc/wireguard/wg1.conf. Esto convierte al servidor de entrada en cliente del de salida:

[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 = 25

ENTRY_LINK_PRIVATE_KEY es el contenido de entry1.key. Este es el paso mas importante de acertar. Un simple AllowedIPs = 0.0.0.0/0 haria que WireGuard enrutara el trafico propio del servidor de entrada - incluida tu sesion SSH - a traves de la salida, lo que corta tu acceso al servidor. Table = off lo evita, y las reglas de policy routing envian solo tu subred de cliente por la salida, dejando el servidor accesible como siempre.

Paso 5: Crear el tunel de entrada para tus dispositivos (wg0)

Todavia en el servidor de entrada, crea /etc/wireguard/wg0.conf. Este es el tunel al que se conecta tu movil o portatil, y las reglas de enrutado empujan ese trafico hacia 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/32

ENTRY_DEVICE_PRIVATE_KEY es el contenido de entry0.key. El masquerading en wg1 esconde tu dispositivo detras del servidor de entrada, de modo que la salida solo ve siempre la entrada.

Paso 6: Crear la config del dispositivo y conectar

Genera un par de claves para tu dispositivo (en tu ordenador o en el servidor de entrada), luego construye la config del cliente. Pon la clave publica del dispositivo en el wg0.conf de la entrada donde dice CLIENT_PUBLIC_KEY. La config de tu dispositivo se ve asi:

[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 = 25

Aqui ENTRY_DEVICE_PUBLIC_KEY viene de entry0.pub, y ENTRY_IP es la IP publica del servidor de entrada - el unico servidor con el que habla tu dispositivo.

Paso 7: Arrancar la entrada y verificar la cadena

En el servidor de entrada, activa el forwarding y arranca ambos tuneles en orden (primero el enlace, luego el tunel del dispositivo):

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@wg0

Ahora importa la config del cliente en la app de WireGuard de tu dispositivo y conecta. Para confirmar que la cadena funciona, comprueba tu IP - debe mostrar el pais del servidor de salida, no el de entrada:

curl https://api.ipify.org

Si eso devuelve la IP del servidor de salida, tu trafico salta por ambos servidores. Haz una prueba de fugas en nuestra pagina de herramientas de red para asegurarte de que no hay fugas de DNS ni WebRTC.

Errores comunes: si no tienes internet tras conectar, comprueba que el reenvio IP esta activo (sysctl net.ipv4.ip_forward debe devolver 1) en ambos servidores, que el servidor de salida tiene tu clave de entrada en su bloque [Peer], y que ambos cortafuegos permiten UDP 51820. Si la IP muestra el pais de entrada en vez del de salida, la regla MASQUERADE -o wg1 en la entrada no se cargo - reinicia wg0 en el servidor de entrada.

Merece la pena?

Un multi-hop auto-alojado es el montaje mas privado que existe: dos servidores tuyos, en dos paises, sin proveedor en medio que guarde registros. Los compromisos son la velocidad (dos saltos anaden latencia) y el coste (dos VPS en vez de uno). Para la navegacion diaria basta con un solo servidor; construye la cadena cuando tu modelo de amenaza lo pida de verdad. Y recuerda: un multi-hop protege tu privacidad, no cambia la ley del lugar donde vives.

Mejor precio

Tu VPN multi-hop: encadena dos servidores WireGuard