Configuración de WireGuard como VPN: Guía Completa de Configuración

Introducción

En una era de creciente vigilancia en línea, violaciones de datos y restricciones geográficas, las Redes Privadas Virtuales (VPN) se han convertido en herramientas esenciales para usuarios y organizaciones conscientes de la privacidad. WireGuard representa la próxima generación de tecnología VPN, ofreciendo un enfoque revolucionario que combina rendimiento excepcional, seguridad robusta y simplicidad notable en comparación con soluciones VPN tradicionales como OpenVPN e IPSec.

Desarrollado por Jason A. Donenfeld y oficialmente integrado en el kernel de Linux en la versión 5.6, WireGuard ha ganado rápidamente adopción en toda la industria. Los principales proveedores de VPN han integrado WireGuard en sus ofertas, y administradores de sistemas de todo el mundo están reemplazando la infraestructura VPN heredada con esta alternativa moderna. Todo el código base consiste en aproximadamente 4,000 líneas de código, haciéndolo auditable y mantenible en comparación con las más de 100,000 líneas de OpenVPN.

Esta guía completa proporciona todo lo necesario para implementar un servidor VPN WireGuard listo para producción en Linux. Aprenderás procedimientos de instalación en las principales distribuciones, gestión de claves criptográficas, configuración de red para varias topologías, configuración de clientes para múltiples plataformas, optimización de rendimiento, refuerzo de seguridad y técnicas de resolución de problemas.

Ya sea asegurando conexiones de trabajo remoto, creando una solución de navegación centrada en la privacidad, construyendo redes corporativas de sitio a sitio, accediendo a contenido con restricciones geográficas o estableciendo acceso seguro a redes domésticas mientras viajas, WireGuard proporciona la base para conectividad VPN rápida, segura y confiable.

Descripción General del Caso de Uso

¿Por Qué Elegir WireGuard?

WireGuard ofrece ventajas convincentes sobre las tecnologías VPN tradicionales:

Rendimiento Excepcional: WireGuard opera completamente en espacio de kernel en Linux, eliminando la sobrecarga de cambio de contexto. Los benchmarks muestran mejoras de rendimiento de 3-4x sobre OpenVPN y velocidades de red casi nativas, a menudo alcanzando más de 1 Gbps en hardware modesto.

Criptografía Moderna: Construido exclusivamente sobre primitivas criptográficas de última generación incluyendo Curve25519 para intercambio de claves, ChaCha20 para cifrado simétrico, Poly1305 para autenticación y BLAKE2s para hashing. Sin algoritmos obsoletos o vulnerables, sin opciones de configuración para cifrado más débil.

Superficie de Ataque Mínima: El código base compacto (4,000 líneas vs. las más de 100,000 de OpenVPN) reduce el potencial de vulnerabilidades. Menos código significa menos errores y auditorías de seguridad más fáciles por criptógrafos e investigadores de seguridad.

Sigilo y Resistencia a la Censura: El protocolo basado en UDP de WireGuard sin handshake hace que sea difícil de detectar y bloquear. Silencioso cuando no está en uso, no responde a paquetes no autorizados, haciendo ineficaz el escaneo de puertos.

Eficiencia de Batería: Los dispositivos móviles se benefician del diseño eficiente de WireGuard, consumiendo significativamente menos energía que OpenVPN, crucial para teléfonos inteligentes y tabletas con batería.

Roaming Sin Interrupciones: Maneja cambios de red con elegancia. Cambia de WiFi a datos celulares sin caídas de conexión, perfecto para usuarios móviles que se mueven entre redes.

Configuración Simple: Archivos de configuración basados en texto con parámetros mínimos. Sin infraestructura de certificados compleja, sin configuraciones TLS confusas, sin reglas arcanas de iptables para depurar.

Soporte Multiplataforma: Implementaciones nativas para Linux, Windows, macOS, iOS, Android, FreeBSD y más. Clientes de primera parte mantenidos por el proyecto WireGuard aseguran consistencia.

Escenarios Comunes de Implementación

VPN de Trabajo Remoto: Los empleados acceden de forma segura a recursos corporativos desde casa, cafeterías o mientras viajan, con cifrado de extremo a extremo protegiendo datos comerciales sensibles.

Privacidad y Seguridad: Enrutar todo el tráfico de Internet a través de un VPS para ocultar tu dirección IP de los sitios web, cifrar el tráfico en redes no confiables y evitar el monitoreo del ISP.

Evitar Restricciones Geográficas: Acceder a contenido bloqueado por región enrutando el tráfico a través de servidores en diferentes países, útil para servicios de streaming, investigación o evitar censura.

VPN de Sitio a Sitio: Conectar múltiples ubicaciones de oficina o centros de datos, permitiendo que los recursos en cada sitio se comuniquen de forma segura como si estuvieran en la misma red local.

Acceso Seguro al Hogar: Acceder a recursos de red doméstica (NAS, domótica, cámaras de seguridad) de forma segura mientras estás fuera sin exponer servicios directamente a Internet.

Acceso para Desarrolladores: Proporcionar a contratistas, consultores y desarrolladores remotos acceso seguro a entornos de desarrollo sin exponer la infraestructura públicamente.

Seguridad de Dispositivos IoT: Crear redes aisladas para dispositivos IoT, enrutando su tráfico a través de VPN para evitar la exposición de la red local y mejorar la privacidad.

Arquitectura Técnica

WireGuard implementa un modelo VPN punto a punto:

  • Diseño Peer-to-Peer: No hay distinción cliente/servidor a nivel de protocolo; todos los endpoints son peers
  • Asignación de IP Estática: Cada peer recibe una dirección IP VPN estática
  • Autenticación de Clave Pública: Los peers se identifican entre sí mediante claves públicas, sin nombres de usuario o contraseñas
  • Enrutamiento de IPs Permitidas: El enrutamiento de clave criptográfica determina qué tráfico usa VPN según la IP de destino
  • Travesía NAT: Travesía NAT incorporada y perforación de agujeros para conexiones a través de firewalls
  • Operación de Capa 3: Funciona en la capa de red, creando una interfaz de red virtual

Requisitos

Requisitos del Sistema

Requisitos Mínimos (VPN Personal, 1-5 usuarios):

  • CPU: 1 núcleo a 1.5+ GHz
  • RAM: 512MB
  • Almacenamiento: 5GB
  • Red: Ancho de banda de 10 Mbps
  • SO: Kernel de Linux 5.6+ (WireGuard integrado) o 3.10+ (instalación de módulo de kernel)

Requisitos Recomendados (VPN de Pequeña Empresa, 10-50 usuarios):

  • CPU: 2 núcleos a 2.0+ GHz
  • RAM: 2GB
  • Almacenamiento: 10GB
  • Red: Ancho de banda de 100 Mbps con baja latencia
  • SO: Ubuntu 22.04 LTS o Debian 12

Requisitos de Alto Rendimiento (Organización Grande, 100+ usuarios):

  • CPU: 4+ núcleos a 2.5+ GHz
  • RAM: 4GB+
  • Almacenamiento: 20GB SSD
  • Red: Ancho de banda dedicado de 1 Gbps
  • SO: Ubuntu 22.04 LTS con optimizaciones de kernel

Compatibilidad de Sistema Operativo

Oficialmente Soportados:

  • Ubuntu 20.04/22.04 LTS
  • Debian 11/12
  • CentOS Stream 8/9
  • Rocky Linux 8/9
  • AlmaLinux 8/9
  • Fedora 35+
  • Arch Linux
  • OpenSUSE Leap 15.3+

Requisitos de Kernel:

  • Kernel de Linux 5.6+ (WireGuard incorporado)
  • Kernel de Linux 3.10-5.5 (módulo de kernel WireGuard vía DKMS)

Requisitos de Red

IP Pública del Servidor: Dirección IP pública estática o DNS dinámico para que los clientes se conecten.

Puerto UDP: WireGuard usa un único puerto UDP (por defecto 51820, configurable).

Acceso al Firewall: Capacidad para configurar el firewall del servidor para permitir tráfico UDP en el puerto de WireGuard.

IPv4/IPv6: Soporta ambos protocolos; se recomienda configuración dual-stack.

Requisitos del Cliente

Clientes WireGuard disponibles para:

  • Linux: Herramientas de línea de comandos, integración con NetworkManager, servicio systemd
  • Windows: Cliente oficial de WireGuard para Windows
  • macOS: Cliente oficial de WireGuard para macOS, instalación vía Homebrew
  • iOS: Aplicación WireGuard de la App Store
  • Android: Aplicación WireGuard de Google Play Store
  • ChromeOS: Aplicación Android vía Play Store

Conocimientos Previos

  • Habilidades básicas de línea de comandos de Linux
  • Comprensión de redes IP y subredes
  • Familiaridad con configuración de firewall
  • Acceso SSH al servidor
  • Competencia con editor de texto (nano, vim)

Configuración Paso a Paso

Paso 1: Instalar WireGuard

Ubuntu 20.04/22.04 y Debian 11/12:

# Actualizar lista de paquetes
sudo apt update

# Instalar WireGuard
sudo apt install wireguard -y

CentOS Stream 8/9 y Rocky/AlmaLinux 8/9:

# Habilitar repositorio EPEL
sudo dnf install epel-release elrepo-release -y

# Instalar herramientas de WireGuard
sudo dnf install wireguard-tools -y

# Si kernel < 5.6, instalar módulo de kernel
sudo dnf install kmod-wireguard -y

Verificar instalación:

wg version

Debería mostrar la información de versión de WireGuard.

Paso 2: Habilitar Reenvío de IP

El servidor WireGuard debe reenviar paquetes entre clientes VPN e Internet:

# Habilitar reenvío IPv4
echo "net.ipv4.ip_forward = 1" | sudo tee -a /etc/sysctl.conf

# Habilitar reenvío IPv6 (opcional)
echo "net.ipv6.conf.all.forwarding = 1" | sudo tee -a /etc/sysctl.conf

# Aplicar cambios inmediatamente
sudo sysctl -p

Verificar:

sysctl net.ipv4.ip_forward

Debería retornar net.ipv4.ip_forward = 1.

Paso 3: Generar Claves del Servidor

Crear directorio para la configuración de WireGuard:

sudo mkdir -p /etc/wireguard
sudo chmod 700 /etc/wireguard

Generar claves privada y pública:

# Generar clave privada
wg genkey | sudo tee /etc/wireguard/server_private.key
sudo chmod 600 /etc/wireguard/server_private.key

# Generar clave pública desde clave privada
sudo cat /etc/wireguard/server_private.key | wg pubkey | sudo tee /etc/wireguard/server_public.key

Ver claves (las necesitarás para la configuración):

# Clave privada del servidor
sudo cat /etc/wireguard/server_private.key

# Clave pública del servidor
sudo cat /etc/wireguard/server_public.key

Paso 4: Crear Configuración del Servidor

Identificar la interfaz de red de tu servidor:

ip -o -4 route show to default | awk '{print $5}'

Típicamente eth0, ens3, enp0s3 o similar. Anota esto para uso posterior.

Crear archivo de configuración de WireGuard:

sudo nano /etc/wireguard/wg0.conf

Agregar la siguiente configuración (reemplazar marcadores de posición):

[Interface]
# Clave privada del servidor
PrivateKey = SERVER_PRIVATE_KEY_HERE

# Subred VPN para red WireGuard
Address = 10.0.0.1/24

# Puerto de escucha de WireGuard
ListenPort = 51820

# Guardar estado de red actual
SaveConfig = false

# PostUp: Reglas a ejecutar cuando WireGuard inicia
PostUp = iptables -A FORWARD -i %i -j ACCEPT; iptables -A FORWARD -o %i -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

# PostDown: Reglas a ejecutar cuando WireGuard se detiene
PostDown = iptables -D FORWARD -i %i -j ACCEPT; iptables -D FORWARD -o %i -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

# Configuración del Cliente 1
[Peer]
# Clave pública del cliente (generar en dispositivo cliente)
PublicKey = CLIENT1_PUBLIC_KEY_HERE

# IPs permitidas para este cliente
AllowedIPs = 10.0.0.2/32

# Mantener conexión viva
PersistentKeepalive = 25

Importante: Reemplaza SERVER_PRIVATE_KEY_HERE con tu clave privada real del servidor del Paso 3, y reemplaza eth0 con tu interfaz de red real.

Establecer permisos apropiados:

sudo chmod 600 /etc/wireguard/wg0.conf

Paso 5: Configurar Firewall

UFW (Ubuntu/Debian):

# Permitir puerto de WireGuard
sudo ufw allow 51820/udp

# Permitir SSH (prevenir bloqueo)
sudo ufw allow 22/tcp

# Habilitar firewall si no está ya habilitado
sudo ufw enable

Firewalld (CentOS/Rocky):

# Permitir puerto de WireGuard
sudo firewall-cmd --permanent --add-port=51820/udp

# Habilitar masquerading
sudo firewall-cmd --permanent --add-masquerade

# Recargar firewall
sudo firewall-cmd --reload

Paso 6: Iniciar Servidor WireGuard

Habilitar e iniciar WireGuard:

# Habilitar WireGuard para iniciar al arrancar
sudo systemctl enable wg-quick@wg0

# Iniciar WireGuard ahora
sudo systemctl start wg-quick@wg0

# Verificar estado
sudo systemctl status wg-quick@wg0

Verificar que la interfaz WireGuard está ejecutándose:

sudo wg show

Debería mostrar la configuración de la interfaz y peers conectados.

Verificar interfaz:

ip addr show wg0

Debería mostrar la interfaz wg0 con IP 10.0.0.1/24.

Paso 7: Generar Claves del Cliente

En tu dispositivo cliente (o generar en el servidor para distribución):

Cliente Linux/macOS:

# Instalar WireGuard primero si no está instalado
# Ubuntu/Debian: sudo apt install wireguard
# macOS: brew install wireguard-tools

# Generar clave privada del cliente
wg genkey > client_private.key
chmod 600 client_private.key

# Generar clave pública del cliente
cat client_private.key | wg pubkey > client_public.key

Cliente Windows:

Usa la interfaz gráfica del cliente oficial de WireGuard para Windows, que genera claves automáticamente.

Clientes Móviles (iOS/Android):

Usa la aplicación oficial de WireGuard, que genera claves al crear un nuevo túnel.

Paso 8: Crear Configuración del Cliente

Crear archivo de configuración del cliente:

nano client.conf

Agregar lo siguiente (reemplazar marcadores de posición):

[Interface]
# Clave privada del cliente
PrivateKey = CLIENT_PRIVATE_KEY_HERE

# Dirección IP VPN del cliente
Address = 10.0.0.2/32

# Servidor DNS (opcional, usar servidor VPN o DNS público)
DNS = 1.1.1.1, 8.8.8.8

[Peer]
# Clave pública del servidor
PublicKey = SERVER_PUBLIC_KEY_HERE

# IP pública y puerto del servidor
Endpoint = SERVER_PUBLIC_IP:51820

# Enrutar todo el tráfico a través de VPN (0.0.0.0/0)
# O subredes específicas para tunelización dividida
AllowedIPs = 0.0.0.0/0, ::/0

# Mantener conexión viva a través de NAT
PersistentKeepalive = 25

Desglose de Configuración:

  • PrivateKey: Clave privada del cliente (generada en Paso 7)
  • Address: Dirección IP VPN del cliente (10.0.0.2, 10.0.0.3, etc. para clientes adicionales)
  • DNS: Servidores DNS a usar cuando esté conectado (previene fugas de DNS)
  • PublicKey: Clave pública del servidor (del Paso 3)
  • Endpoint: Dirección IP pública del servidor y puerto de WireGuard
  • AllowedIPs: 0.0.0.0/0 enruta todo el tráfico a través de VPN (túnel completo); usar IPs específicas para túnel dividido
  • PersistentKeepalive: Mantiene la conexión viva a través de firewalls NAT (25 segundos recomendados)

Paso 9: Agregar Cliente a la Configuración del Servidor

En el servidor, agregar el peer del cliente a /etc/wireguard/wg0.conf:

sudo nano /etc/wireguard/wg0.conf

Agregar nueva sección [Peer]:

[Peer]
PublicKey = CLIENT_PUBLIC_KEY_HERE
AllowedIPs = 10.0.0.2/32
PersistentKeepalive = 25

Recargar configuración de WireGuard:

sudo systemctl restart wg-quick@wg0

# O recargar sin detener:
sudo wg syncconf wg0 <(wg-quick strip wg0)

Paso 10: Conectar Cliente

Cliente Linux:

# Copiar configuración al directorio de WireGuard
sudo cp client.conf /etc/wireguard/wg0.conf
sudo chmod 600 /etc/wireguard/wg0.conf

# Iniciar WireGuard
sudo wg-quick up wg0

# Verificar conexión
sudo wg show

Para habilitar al arrancar:

sudo systemctl enable wg-quick@wg0

Cliente Windows:

  1. Abrir cliente de WireGuard para Windows
  2. Hacer clic en "Importar túnel(es) desde archivo"
  3. Seleccionar client.conf
  4. Hacer clic en "Activar"

Cliente macOS:

  1. Abrir cliente de WireGuard para macOS
  2. Hacer clic en "+" y "Agregar desde archivo"
  3. Seleccionar client.conf
  4. Hacer clic en "Activar"

Clientes Móviles:

  1. Abrir aplicación de WireGuard
  2. Tocar "+" para agregar túnel
  3. Elegir "Crear desde archivo o archivo" o escanear código QR
  4. Activar conexión

Paso 11: Probar Conexión VPN

Verificar interfaz VPN en cliente:

ip addr show wg0

Debería mostrar la interfaz wg0 con IP 10.0.0.2/32.

Hacer ping al servidor VPN:

ping 10.0.0.1

Debería recibir respuestas del servidor VPN.

Verificar IP pública:

curl ifconfig.me

Debería mostrar la IP pública del servidor, no la IP original del cliente.

Prueba de fuga de DNS:

curl https://www.dnsleaktest.com/

O visitar dnsleaktest.com en el navegador para verificar que las consultas DNS se enrutan a través de VPN.

Configuración

Configuración de Tunelización Dividida

Enrutar solo tráfico específico a través de VPN en lugar de todo el tráfico:

Configuración del Cliente para Tunelización Dividida:

[Interface]
PrivateKey = CLIENT_PRIVATE_KEY_HERE
Address = 10.0.0.2/32

[Peer]
PublicKey = SERVER_PUBLIC_KEY_HERE
Endpoint = SERVER_PUBLIC_IP:51820

# Solo enrutar redes específicas a través de VPN
AllowedIPs = 10.0.0.0/24, 192.168.1.0/24, 172.16.0.0/16

PersistentKeepalive = 25

Esto enruta solo redes privadas a través de VPN mientras deja otro tráfico (Internet) a través del gateway predeterminado.

Configuración de Múltiples Clientes

Agregar múltiples clientes creando secciones peer únicas:

Configuración del Servidor con Múltiples Clientes:

[Interface]
PrivateKey = SERVER_PRIVATE_KEY
Address = 10.0.0.1/24
ListenPort = 51820
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

# Cliente 1
[Peer]
PublicKey = CLIENT1_PUBLIC_KEY
AllowedIPs = 10.0.0.2/32

# Cliente 2
[Peer]
PublicKey = CLIENT2_PUBLIC_KEY
AllowedIPs = 10.0.0.3/32

# Cliente 3
[Peer]
PublicKey = CLIENT3_PUBLIC_KEY
AllowedIPs = 10.0.0.4/32

# Cliente 4
[Peer]
PublicKey = CLIENT4_PUBLIC_KEY
AllowedIPs = 10.0.0.5/32

Cada cliente necesita una dirección IP VPN única dentro de la subred (10.0.0.x).

Configuración de VPN de Sitio a Sitio

Conectar dos redes juntas (por ejemplo, red doméstica y red de oficina):

Configuración del Servidor A (Oficina - 192.168.1.0/24):

[Interface]
PrivateKey = OFFICE_PRIVATE_KEY
Address = 10.0.0.1/24
ListenPort = 51820
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]
PublicKey = HOME_PUBLIC_KEY
Endpoint = HOME_PUBLIC_IP:51820
AllowedIPs = 10.0.0.2/32, 192.168.2.0/24
PersistentKeepalive = 25

Configuración del Servidor B (Casa - 192.168.2.0/24):

[Interface]
PrivateKey = HOME_PRIVATE_KEY
Address = 10.0.0.2/24
ListenPort = 51820
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]
PublicKey = OFFICE_PUBLIC_KEY
Endpoint = OFFICE_PUBLIC_IP:51820
AllowedIPs = 10.0.0.1/32, 192.168.1.0/24
PersistentKeepalive = 25

Esto permite que dispositivos en 192.168.1.0/24 se comuniquen con dispositivos en 192.168.2.0/24 a través de VPN.

Soporte IPv6

Habilitar IPv6 junto con IPv4:

[Interface]
PrivateKey = SERVER_PRIVATE_KEY
Address = 10.0.0.1/24, fd42:42:42::1/64
ListenPort = 51820
PostUp = iptables -A FORWARD -i %i -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE; ip6tables -A FORWARD -i %i -j ACCEPT; ip6tables -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; ip6tables -D FORWARD -i %i -j ACCEPT; ip6tables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

[Peer]
PublicKey = CLIENT_PUBLIC_KEY
AllowedIPs = 10.0.0.2/32, fd42:42:42::2/128

Configuración del cliente:

[Interface]
PrivateKey = CLIENT_PRIVATE_KEY
Address = 10.0.0.2/32, fd42:42:42::2/128

[Peer]
PublicKey = SERVER_PUBLIC_KEY
Endpoint = SERVER_PUBLIC_IP:51820
AllowedIPs = 0.0.0.0/0, ::/0

Generación de Código QR para Clientes Móviles

Generar código QR para configuración fácil de dispositivos móviles:

Instalar qrencode:

sudo apt install qrencode -y

Generar código QR:

qrencode -t ansiutf8 < client.conf

Muestra código QR en terminal. Escanear con aplicación móvil de WireGuard para importar configuración.

Para imagen PNG:

qrencode -t png -o client.png < client.conf

Configuración de DNS Dinámico

Si el servidor tiene dirección IP dinámica, usar servicio DDNS:

Instalar ddclient:

sudo apt install ddclient -y

Configurar proveedor DDNS (Cloudflare, No-IP, DynDNS, etc.) en /etc/ddclient.conf.

Actualizar endpoint de configuración del cliente:

Endpoint = your-hostname.ddns.net:51820

Optimización

Optimización de MTU

Encontrar MTU óptimo para prevenir fragmentación:

# Probar desde cliente a servidor
ping -M do -s 1472 10.0.0.1

Si los paquetes no llegan, reducir tamaño hasta que sea exitoso. Agregar 28 bytes (cabeceras IP + ICMP) para MTU final.

Establecer MTU en configuración de WireGuard:

[Interface]
MTU = 1420

Valores MTU comunes de WireGuard:

  • 1420: Estándar para la mayoría de redes
  • 1400: Conservador para redes problemáticas
  • 1280: MTU mínimo IPv6

Ajuste de Parámetros del Kernel

Optimizar rendimiento de red:

sudo nano /etc/sysctl.conf

Agregar:

# Aumentar tamaños de buffer
net.core.rmem_max = 26214400
net.core.wmem_max = 26214400
net.core.rmem_default = 26214400
net.core.wmem_default = 26214400

# Optimizar manejo de conexiones
net.ipv4.tcp_fastopen = 3
net.ipv4.tcp_slow_start_after_idle = 0

# Reducir sockets TIME_WAIT
net.ipv4.tcp_fin_timeout = 15
net.ipv4.tcp_tw_reuse = 1

# Control de congestión BBR (kernel 4.9+)
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr

Aplicar:

sudo sysctl -p

Rendimiento Multi-Núcleo

Habilitar multi-cola en interfaz WireGuard:

Verificar núcleos de CPU:

nproc

Establecer tamaño de cola basado en núcleos:

sudo ethtool -L wg0 combined 4

Reemplazar 4 con el número de núcleos de tu CPU.

Optimización de Keep-Alive de Conexión

Ajustar PersistentKeepalive basado en timeout NAT:

  • 25 segundos: Predeterminado recomendado para la mayoría de dispositivos NAT
  • 15 segundos: NAT agresivo con timeouts cortos
  • 60 segundos: Configuración conservadora, reduce sobrecarga
  • 0: Deshabilitar (solo para conexiones estables, no NAT)

PreSharedKey para Seguridad Post-Cuántica

Agregar claves pre-compartidas para capa de seguridad adicional:

Generar PSK:

wg genpsk

Agregar a configuración peer del servidor:

[Peer]
PublicKey = CLIENT_PUBLIC_KEY
PresharedKey = GENERATED_PSK_HERE
AllowedIPs = 10.0.0.2/32

Agregar a configuración peer del cliente:

[Peer]
PublicKey = SERVER_PUBLIC_KEY
PresharedKey = GENERATED_PSK_HERE
Endpoint = SERVER_PUBLIC_IP:51820
AllowedIPs = 0.0.0.0/0

PSK proporciona protección contra potenciales ataques futuros de computadoras cuánticas sobre Curve25519.

Resolución de Problemas

La Conexión No se Establece

Verificar estado del servicio WireGuard:

sudo systemctl status wg-quick@wg0

Verificar que la interfaz está activa:

ip link show wg0

Debería mostrar state UNKNOWN o UP.

Verificar errores de configuración:

sudo wg-quick up wg0

Buscar mensajes de error indicando configuraciones incorrectas.

Verificar que el firewall permite puerto UDP:

# Verificar UFW
sudo ufw status

# Verificar firewalld
sudo firewall-cmd --list-all

# Probar puerto con netcat desde cliente
nc -u SERVER_IP 51820

Verificar IP pública del servidor:

curl ifconfig.me

Asegurarse de que la configuración del cliente usa la IP correcta del servidor.

Verificar que las claves son correctas:

Verificar que:

  • El servidor tiene la clave privada correcta
  • El cliente tiene la clave privada correcta
  • La sección peer del servidor tiene la clave pública correcta del cliente
  • La sección peer del cliente tiene la clave pública correcta del servidor

Sin Acceso a Internet a Través de VPN

Verificar reenvío de IP:

sysctl net.ipv4.ip_forward

Debe retornar net.ipv4.ip_forward = 1.

Verificar reglas NAT:

sudo iptables -t nat -L -n -v

Debería mostrar regla MASQUERADE para interfaz WireGuard.

Verificar nombre de interfaz del servidor:

Asegurarse de que las reglas PostUp y PostDown usan la interfaz de red correcta (eth0, ens3, etc.):

ip route | grep default

Probar enrutamiento desde el servidor:

# En el servidor, hacer ping desde interfaz VPN
ping -I wg0 8.8.8.8

Si esto funciona, el enrutamiento del servidor es correcto. El problema está con el cliente.

Verificar DNS:

# En el cliente, probar resolución DNS
nslookup google.com

Si falla, agregar DNS a configuración del cliente:

DNS = 1.1.1.1, 8.8.8.8

Alta Latencia o Pérdida de Paquetes

Verificar configuración de MTU:

# Desde el cliente
ping -M do -s 1400 10.0.0.1

Reducir MTU si se experimenta fragmentación:

[Interface]
MTU = 1400

Medir latencia real:

ping 10.0.0.1

Comparar con ping a la IP pública del servidor:

ping SERVER_PUBLIC_IP

WireGuard agrega sobrecarga mínima (típicamente <1ms).

Verificar uso de CPU del servidor:

top

Uso alto de CPU indica cuello de botella de rendimiento.

Monitorear errores de interfaz de red:

ip -s link show wg0

Buscar paquetes descartados o errores.

Peer No se Muestra como Conectado

Verificar estado del peer:

sudo wg show

Buscar marca de tiempo "latest handshake". Si muestra "(none)" o marca de tiempo muy antigua, no hay comunicación reciente.

Verificar AllowedIPs:

El cliente debe enviar tráfico destinado a IPs en AllowedIPs del servidor para ese peer. De manera similar, el servidor debe enviar tráfico a IPs en AllowedIPs del cliente.

Verificar PersistentKeepalive:

Si el peer está detrás de NAT, asegurarse de que PersistentKeepalive está configurado:

PersistentKeepalive = 25

Reiniciar WireGuard:

sudo systemctl restart wg-quick@wg0

Verificar registros del sistema:

sudo journalctl -u wg-quick@wg0 -f

Errores de Permiso Denegado

Verificar permisos de archivos:

ls -la /etc/wireguard/

Los archivos de configuración y claves deberían ser:

sudo chmod 600 /etc/wireguard/wg0.conf
sudo chmod 600 /etc/wireguard/*_private.key

Verificar propiedad:

sudo chown root:root /etc/wireguard/wg0.conf

Puerto Ya en Uso

Verificar qué está usando el puerto 51820:

sudo netstat -tulpn | grep 51820

Detener servicio en conflicto o cambiar puerto de WireGuard:

ListenPort = 51821

Actualizar Endpoint del cliente para que coincida con el nuevo puerto.

Consideraciones de Seguridad

Mejores Prácticas de Gestión de Claves

  • Nunca compartir claves privadas: Las claves privadas deben permanecer en el dispositivo para el que fueron generadas
  • Rotar claves periódicamente: Generar nuevas claves cada 6-12 meses para aplicaciones sensibles
  • Almacenamiento seguro de claves: Almacenar claves con permisos 600, propiedad de root
  • Respaldar claves de forma segura: Cifrar respaldos de claves privadas
  • Claves separadas por dispositivo: Cada dispositivo cliente debe tener un par de claves único

Refuerzo del Firewall

Restringir WireGuard a IPs específicas (si las IPs de cliente son estáticas):

# UFW
sudo ufw allow from CLIENT_IP to any port 51820 proto udp

# iptables
sudo iptables -A INPUT -p udp --dport 51820 -s CLIENT_IP -j ACCEPT
sudo iptables -A INPUT -p udp --dport 51820 -j DROP

Limitar tasa de intentos de conexión:

# iptables
sudo iptables -A INPUT -p udp --dport 51820 -m state --state NEW -m recent --set
sudo iptables -A INPUT -p udp --dport 51820 -m state --state NEW -m recent --update --seconds 60 --hitcount 10 -j DROP

Aislamiento de Tráfico

Prevenir que clientes VPN accedan entre sí:

# Agregar a PostUp
iptables -A FORWARD -i wg0 -o wg0 -j DROP

Esto previene movimiento lateral entre clientes VPN.

Prevención de Fuga de DNS

Forzar todo DNS a través de VPN:

[Interface]
DNS = 10.0.0.1
PostUp = iptables -A OUTPUT ! -o %i -m mark ! --mark $(wg show %i fwmark) -m addrtype ! --dst-type LOCAL -j REJECT

PostDown = iptables -D OUTPUT ! -o %i -m mark ! --mark $(wg show %i fwmark) -m addrtype ! --dst-type LOCAL -j REJECT

Registro de Auditoría

Registrar conexiones de WireGuard:

sudo nano /etc/rsyslog.d/wireguard.conf

Agregar:

:msg, contains, "wireguard" /var/log/wireguard.log
& stop

Reiniciar rsyslog:

sudo systemctl restart rsyslog

Monitorear conexiones:

tail -f /var/log/wireguard.log

Configuración Avanzada

Interfaz de Gestión Web

Instalar wg-easy para gestión basada en web:

# Instalar Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Ejecutar wg-easy
docker run -d \
  --name=wg-easy \
  -e WG_HOST=YOUR_SERVER_IP \
  -e PASSWORD=admin \
  -v ~/.wg-easy:/etc/wireguard \
  -p 51820:51820/udp \
  -p 51821:51821/tcp \
  --cap-add=NET_ADMIN \
  --cap-add=SYS_MODULE \
  --sysctl="net.ipv4.conf.all.src_valid_mark=1" \
  --sysctl="net.ipv4.ip_forward=1" \
  --restart unless-stopped \
  weejewel/wg-easy

Acceder a interfaz web en http://YOUR_SERVER_IP:51821.

Configuración de Failover

Configurar failover automático entre múltiples servidores VPN:

Configuración del Cliente con Múltiples Peers:

[Interface]
PrivateKey = CLIENT_PRIVATE_KEY
Address = 10.0.0.2/32

# Servidor primario
[Peer]
PublicKey = PRIMARY_SERVER_PUBLIC_KEY
Endpoint = primary.example.com:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25

# Servidor de respaldo (se usará si el primario falla)
[Peer]
PublicKey = BACKUP_SERVER_PUBLIC_KEY
Endpoint = backup.example.com:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25

WireGuard usará automáticamente el peer disponible.

Monitoreo y Alertas

Monitorear WireGuard con Prometheus:

Instalar prometheus-wireguard-exporter:

go install github.com/MindFlavor/prometheus_wireguard_exporter@latest

Ejecutar exportador:

prometheus_wireguard_exporter -n /etc/wireguard/wg0.conf

Acceder a métricas en http://localhost:9586/metrics.

Conclusión

Ahora tienes un servidor VPN WireGuard completamente operativo que proporciona conectividad segura y de alto rendimiento para usuarios remotos, protección de privacidad o puente de red. Esta solución VPN moderna ofrece seguridad de nivel empresarial con complejidad mínima y rendimiento excepcional.

Logros clave de esta guía:

  • Criptografía moderna usando Curve25519, ChaCha20 y Poly1305
  • Servidor listo para producción con firewall apropiado, enrutamiento e integración systemd
  • Soporte multi-cliente con claves únicas y direcciones IP por dispositivo
  • Compatibilidad multiplataforma para Linux, Windows, macOS, iOS y Android
  • Optimización de rendimiento a través de ajuste de MTU, parámetros de kernel y configuración eficiente
  • Refuerzo de seguridad con gestión apropiada de claves, aislamiento de tráfico y prevención de fugas de DNS
  • Topologías flexibles soportando configuraciones de túnel completo, túnel dividido y sitio a sitio

La simplicidad de WireGuard no compromete la funcionalidad. La configuración directa permite gestión fácil mientras que la criptografía moderna proporciona seguridad robusta. A diferencia de soluciones VPN heredadas que requieren infraestructura de certificados compleja y opciones de configuración confusas, WireGuard logra mejores resultados con menos complejidad.

El mantenimiento regular incluye monitoreo de peers conectados, revisión de registros para intentos de acceso no autorizados, actualización de paquetes de WireGuard y rotación periódica de claves para aplicaciones de alta seguridad. El código base mínimo significa que las actualizaciones son infrecuentes pero importantes para la seguridad.

A medida que WireGuard continúa ganando adopción en toda la industria, mantenerse actualizado con las mejores prácticas a través de la documentación oficial en wireguard.com y la lista de correo asegura que tu infraestructura VPN permanezca segura y eficiente.

Ya sea protegiendo trabajadores remotos, asegurando tráfico de Internet personal o construyendo topologías de red complejas, WireGuard proporciona la base para conectividad VPN rápida, segura y confiable.

¡Mantente seguro!