{"schemaVersion":1,"id":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals","title":"WireGuard Mesh Networking: Los Internals de Tailscale y Headscale Explicados","description":"Cómo Tailscale construye una red mesh encima de WireGuard. Servidores DERP relay, NAT traversal, MagicDNS, y una guía práctica para armar tu propia red privada overlay con Headscale.","language":"es","datePublished":"2026-01-28","dateModified":null,"contentFormat":"text/markdown","content":"Networking\n\n# WireGuard Mesh Networking: Los Internals de Tailscale y Headscale Explicados\n\n2026-01-2810 min lectura\n\nLucio Durán\nEngineering Manager & AI Solutions Architect\n\nTambién disponible en: [English](<https://lucioduran.com/blog/wireguard-mesh-networking-tailscale-internals>)\n\n## WireGuard: La Base\n\nTodo arranca con [WireGuard](<https://www.wireguard.com/>). WireGuard es un protocolo de VPN que hace una cosa excepcionalmente bien: crear túneles encriptados punto a punto con configuración mínima.\n\nUna config completa de WireGuard se ve así:\n\n```ini\n# /etc/wireguard/wg0.conf en Nodo A\n[Interface]\nPrivateKey = yAnz5TF+lXXJte14tji3zlMNq+hd2rYUIgJBgB3fBmk=\nAddress = 10.0.0.1/24\nListenPort = 51820\n\n[Peer]\nPublicKey = xTIBA5rboUvnH4htodjb6e697QjLERt1NAB4mZqp8Dg=\nAllowedIPs = 10.0.0.2/32\nEndpoint = 203.0.113.50:51820\n```\n\nEso es todo. Sin certificados, sin autoridades certificantes, sin negociación HMAC. Solo pares de claves Curve25519 y encriptación ChaCha20-Poly1305. El protocolo cabe en unas 4.000 líneas de código del kernel.\n\nPero WireGuard crudo tiene un problema fundamental para uso real: **se necesita saber la dirección IP y el puerto de cada peer de antemano**. Si el Nodo B está detrás de un NAT, su endpoint público cambia. Si el Nodo C está en una red móvil, su IP cambia cada vez que cambia de antena. Con 50 nodos, tendrías que actualizar 2.450 configuraciones de peer cada vez que una IP cambia. Ahí es donde entra [Tailscale](<https://tailscale.com/>).\n\n## La Arquitectura de Tailscale\n\nTailscale es, en esencia, un sistema de coordinación que resuelve el problema de configuración de WireGuard. A continuación, va la arquitectura:\n\n```\n┌─────────────────────────────────────────────┐\n│ Servidor de Coordinación │\n│ (Tailscale SaaS o Headscale self-hosted) │\n│ │\n│ • Registro de nodos (claves púb, endpoints) │\n│ • Motor de políticas ACL │\n│ • Configuración DNS │\n│ • Autenticación OIDC │\n└──────────────┬───────────────────────────────┘\n │ HTTPS (solo plano de control)\n ┌──────────┼──────────┐\n ▼ ▼ ▼\n┌────────┐ ┌────────┐ ┌────────┐\n│ Nodo A │ │ Nodo B │ │ Nodo C │\n│agente │ │agente │ │agente │\n│tailsca │ │tailsca │ │tailsca │\n└───┬────┘ └───┬────┘ └───┬────┘\n │ │ │\n └──────────┼──────────┘\n Túneles WireGuard\n (directos, peer-to-peer)\n```\n\nEl servidor de coordinación nunca ve tu tráfico de datos. Solo maneja:\n\n1. Registro de nodos y sus claves públicas\n2. Distribución de información de endpoints (direcciones IP, puertos)\n3. Evaluación de políticas ACL\n4. Coordinación de NAT traversal\n\nTodo el flujo de datos real va directamente entre nodos sobre WireGuard. El servidor de coordinación es un plano de control, no un plano de datos.\n\n## NAT Traversal: La Parte Difícil\n\nHacer que dos dispositivos detrás de NAT se hablen directamente es el problema de networking más difícil que Tailscale resuelve. Hay varios tipos de NAT, y cada uno requiere estrategias diferentes:\n\n### STUN: Descubriendo Tu Dirección Pública\n\nEl primer paso es averiguar tu propia IP pública y puerto. Tailscale usa STUN (Session Traversal Utilities for NAT):\n\n```\nNodo A (detrás de NAT) Servidor STUN Nodo B (detrás de NAT)\n │ │ │\n │── STUN Binding Request ────→ │ │\n │ │ │\n │←── Tu IP:puerto público ─────│ │\n │ (203.0.113.50:34567) │ │\n │ │ │\n │ │ ←── STUN Request ────│\n │ │ │\n │ │── Tu IP pública ───→ │\n │ │ (198.51.100.22: │\n │ │ 45678) │\n```\n\n### Hole Punching\n\nUna vez que ambos nodos conocen sus direcciones públicas (por STUN), intentan UDP hole punching:\n\n```\nNodo A (NAT: 203.0.113.50:34567) Nodo B (NAT: 198.51.100.22:45678)\n │ │\n │── paquete UDP a 198.51.100.22:45678 ─→│ (puede ser descartado por el NAT de B)\n │ │\n │←── paquete UDP a 203.0.113.50:34567 ──│ (puede ser descartado por el NAT de A)\n │ │\n │── paquete UDP (retransmit) ──────────→│ (AHORA el NAT de B tiene un mapping)\n │ │\n │←── paquete UDP (retransmit) ──────────│ (AHORA el NAT de A tiene un mapping)\n │ │\n │◄═══════ túnel WireGuard ═══════════►│ (¡conexión directa!)\n```\n\nAmbos lados simultáneamente envían paquetes UDP a la dirección pública del otro. Los primeros paquetes pueden ser perdidos porque el NAT no vio tráfico de esa fuente todavía. Pero el paquete saliente crea un mapping NAT, así que cuando el paquete del otro lado llega, el NAT lo deja pasar.\n\nEsto funciona para full cone, restricted cone y port-restricted NAT. Para symmetric NAT (donde el puerto cambia por destino), el hole punching falla porque el puerto descubierto por STUN no coincide con el puerto usado para la conexión al peer.\n\n### Predicción de Puertos\n\nPara tipos de NAT más difíciles, Tailscale intenta predicción de puertos. Si un NAT asigna puertos secuenciales (muchos lo hacen), se puede predecir el siguiente puerto:\n\n```go\n// Lógica simplificada de predicción de puertos\nfunc predictPorts(observedPorts []uint16) []uint16 {\n if len(observedPorts) < 2 {\n return nil\n }\n // Chequear patrón secuencial\n delta := observedPorts[1] - observedPorts[0]\n predicted := observedPorts[len(observedPorts)-1] + delta\n\n // Retornar un rango alrededor del puerto predicho\n candidates := make([]uint16, 0, 32)\n for i := predicted - 16; i <= predicted + 16; i++ {\n candidates = append(candidates, i)\n }\n return candidates\n}\n```\n\nCuando la predicción de puertos no es posible, Tailscale usa un approach de \"ataque de cumpleaños\", ambos lados simultáneamente prueban muchos puertos, esperando una colisión. Con 256 pruebas de cada lado, hay aproximadamente un 50% de probabilidad de pegar con la combinación de puerto correcta (matemática de la paradoja del cumpleaños).\n\n## DERP: Cuando las Conexiones Directas Fallan\n\nCuando el hole punching falla (NAT simétrico en ambos lados, o UDP bloqueado completamente), Tailscale cae a DERP, Designated Encrypted Relay for Packets.\n\nLos servidores DERP son esencialmente relays WebSocket que reenvían paquetes WireGuard encriptados:\n\n```\nNodo A Servidor DERP Nodo B\n │ │ │\n │── paquete WG ───────→│ │\n │ encriptado/HTTPS │── paquete WG ────────→ │\n │ │ encriptado/HTTPS │\n │ │ │\n │←── paquete WG ───────│←── paquete WG ────────│\n │ encriptado/HTTPS │ encriptado/HTTPS │\n```\n\nPuntos clave sobre DERP:\n\n- **Los servidores DERP no pueden desencriptar tráfico**. Solo reenvían paquetes encriptados de WireGuard. El servidor DERP ve blobs encriptados.\n- **DERP corre sobre HTTPS (TCP puerto 443)**. Funciona a través de firewalls corporativos y portales cautivos que bloquean UDP.\n- **Tailscale corre servidores DERP globalmente**. El tráfico rutea por el servidor DERP más cercano basado en latencia.\n- **DERP es un fallback, no el default**. Tailscale continuamente intenta establecer conexiones directas y solo usa DERP cuando es necesario.\n\nSe puede correr tu propio servidor DERP:\n\n```bash\n# Compilar el servidor DERP\ngo install tailscale.com/cmd/derper@latest\n\n# Correrlo\nderper \\\n --hostname=derp.example.com \\\n --certmode=letsencrypt \\\n --certdir=/var/lib/derper/certs \\\n --stun \\\n --verify-clients\n```\n\n## MagicDNS: Nombres en Vez de IPs\n\nMagicDNS es el sistema DNS automático de Tailscale. Cada nodo recibe un nombre legible en tu tailnet:\n\n```\nlaptop.tail12345.ts.net → 100.64.0.1\nserver.tail12345.ts.net → 100.64.0.2\nnas.tail12345.ts.net → 100.64.0.3\n```\n\nPor debajo, Tailscale corre un resolver DNS local (generalmente en ` 100.100.100.100 `) que intercepta queries DNS para tu dominio tailnet, los resuelve de la lista de nodos provista por el servidor de coordinación, y reenvía todas las demás queries a tu DNS upstream configurado.\n\n## Armando Tu Propia Red: Headscale\n\n[Headscale](<https://github.com/juanfont/headscale>) es una implementación open-source del servidor de coordinación de Tailscale. Es compatible con el cliente oficial de Tailscale, así que se tiene toda la magia del NAT traversal y WireGuard sin depender de la infraestructura de Tailscale.\n\n### Configurando Headscale\n\n```bash\n# Instalar Headscale\nwget https://github.com/juanfont/headscale/releases/download/v0.23.0/headscale_0.23.0_linux_amd64.deb\nsudo dpkg -i headscale_0.23.0_linux_amd64.deb\n```\n\nConfigurarlo:\n\n```yaml\n# /etc/headscale/config.yaml\nserver_url: https://headscale.example.com:443\nlisten_addr: 0.0.0.0:443\n\ntls_cert_path: /etc/headscale/tls/cert.pem\ntls_key_path: /etc/headscale/tls/key.pem\n\ndb_type: sqlite3\ndb_path: /var/lib/headscale/db.sqlite\n\nip_prefixes:\n - 100.64.0.0/10\n - fd7a:115c:a1e0::/48\n\ndns_config:\n nameservers:\n - 1.1.1.1\n - 8.8.8.8\n magic_dns: true\n base_domain: mesh.example.com\n\nderp:\n server:\n enabled: true\n region_id: 999\n region_code: \"custom\"\n region_name: \"Mi DERP\"\n stun_listen_addr: 0.0.0.0:3478\n urls: []\n auto_update_enabled: false\n\noidc:\n issuer: https://auth.example.com\n client_id: headscale\n client_secret: tu-secreto\n scope: [\"openid\", \"profile\", \"email\"]\n```\n\n### Registrar Nodos\n\n```bash\n# Crear un usuario (namespace)\nheadscale users create engineering\n\n# Generar una pre-auth key\nheadscale preauthkeys create --user engineering --reusable --expiration 24h\n# Output: key-abc123def456...\n\n# En el nodo cliente, unirse usando el cliente oficial de Tailscale\ntailscale up --login-server https://headscale.example.com --authkey key-abc123def456\n```\n\n### Políticas ACL\n\nHeadscale soporta el formato de políticas ACL de Tailscale:\n\n```json\n{\n \"acls\": [\n {\n \"action\": \"accept\",\n \"src\": [\"group:engineering\"],\n \"dst\": [\"tag:production:443\", \"tag:production:22\"]\n },\n {\n \"action\": \"accept\",\n \"src\": [\"group:ops\"],\n \"dst\": [\"*:*\"]\n }\n ],\n \"groups\": {\n \"group:engineering\": [\"user1@example.com\", \"user2@example.com\"],\n \"group:ops\": [\"admin@example.com\"]\n },\n \"tagOwners\": {\n \"tag:production\": [\"group:ops\"],\n \"tag:staging\": [\"group:engineering\"]\n }\n}\n```\n\n## Avanzado: Subnet Routing y Exit Nodes\n\n### Subnet Router\n\nUn subnet router expone una red entera a tu tailnet sin instalar Tailscale en cada dispositivo:\n\n```bash\n# En el nodo subnet router\necho 'net.ipv4.ip_forward = 1' | sudo tee -a /etc/sysctl.conf\necho 'net.ipv6.conf.all.forwarding = 1' | sudo tee -a /etc/sysctl.conf\nsudo sysctl -p\n\n# Anunciar la subnet local\ntailscale up --advertise-routes=192.168.1.0/24,10.0.0.0/8\n\n# En el servidor headscale, aprobar las rutas\nheadscale routes enable --route 192.168.1.0/24\nheadscale routes enable --route 10.0.0.0/8\n```\n\nAhora cada nodo en tu tailnet puede alcanzar ` 192.168.1.0/24 ` a través del subnet router, sin ningún cambio en los dispositivos de esa subnet.\n\n### Exit Node\n\nUn exit node rutea todo el tráfico de internet a través de un nodo específico, útil para acceder a servicios con restricción regional o rutear por una red confiable:\n\n```bash\n# En el exit node\ntailscale up --advertise-exit-node\n\n# En headscale, aprobarlo\nheadscale routes enable --route 0.0.0.0/0\nheadscale routes enable --route ::/0\n\n# En el cliente, usar el exit node\ntailscale up --exit-node=server.mesh.example.com\n```\n\n## Monitoreo de Tu Mesh\n\nA continuación, un script para monitorear la salud de la mesh:\n\n```bash\n#!/bin/bash\n# mesh-health.sh - Monitorear conectividad de la mesh Tailscale/Headscale\n\necho \"=== Reporte de Salud de la Mesh ===\"\necho \"Fecha: $(date -u +%Y-%m-%dT%H:%M:%SZ)\"\necho \"\"\n\nSTATUS=$(tailscale status --json)\n\nDIRECT=$(echo \"$STATUS\" | jq '[.Peer[] | select(.CurAddr != \"\")] | length')\nRELAY=$(echo \"$STATUS\" | jq '[.Peer[] | select(.Relay != \"\" and .CurAddr == \"\")] | length')\nOFFLINE=$(echo \"$STATUS\" | jq '[.Peer[] | select(.Online == false)] | length')\nTOTAL=$(echo \"$STATUS\" | jq '.Peer | length')\n\necho \"Peers: $TOTAL total, $DIRECT directos, $RELAY relayeados, $OFFLINE offline\"\necho \"\"\n\necho \"=== Peers Relayeados (subóptimo) ===\"\necho \"$STATUS\" | jq -r '.Peer[] | select(.Relay != \"\" and .CurAddr == \"\") |\n \"\\(.HostName)\\t\\(.TailscaleIPs[0])\\trelay: \\(.Relay)\"'\n```\n\n## Rendimiento: WireGuard vs OpenVPN vs IPSec\n\nEstos benchmarks se corrieron en dos máquinas conectadas por un link de 1Gbps a través de un NAT:\n\n| Protocolo | Throughput | Overhead de Latencia | Uso de CPU |\n| --- | --- | --- | --- |\n| Sin VPN (baseline) | 940 Mbps | 0ms | - |\n| WireGuard | 890 Mbps | 0.3ms | 2% |\n| OpenVPN (UDP) | 620 Mbps | 1.2ms | 15% |\n| OpenVPN (TCP) | 410 Mbps | 2.8ms | 22% |\n| IPSec (IKEv2) | 820 Mbps | 0.5ms | 5% |\n\nLa ventaja de rendimiento de WireGuard viene de ejecución en kernel-space, criptografía moderna, overhead de protocolo mínimo y headers de tamaño fijo.\n\n## El Estado del Arte en 2026\n\nTailscale y el ecosistema mesh de WireGuard maduraron considerablemente:\n\n- **Tailscale Funnel**: Exponer servicios específicos de tu tailnet al internet público con TLS automático.\n- **Taildrop**: File sharing encriptado entre nodos. Como AirDrop, pero a través de cualquier dispositivo en tu tailnet.\n- **Headscale 0.23+**: Compatibilidad completa con features del cliente Tailscale, incluyendo MagicDNS, subnet routing y exit nodes.\n- **Netbird y Nebula**: Proyectos alternativos de mesh networking con filosofías de diseño diferentes.\n\nEl espacio de VPN mesh pasó de \"pesadilla enterprise-only\" a \"instalar un binario y funciona.\" La simplicidad de WireGuard hizo esto posible, y Tailscale/Headscale lo hizo accesible. Para quienes todavía administran configs de OpenVPN o túneles SSH para conectividad interna, este approach vale la pena evaluar. El tiempo de setup es medible en minutos, no en días.\n\n## Preguntas frecuentes\n\n### ¿Qué es Tailscale?\n\nTailscale es un servicio de VPN mesh construido sobre WireGuard que crea una red segura entre tus dispositivos. Maneja NAT traversal, intercambio de claves y DNS automáticamente, para que los dispositivos puedan comunicarse directamente sin importar su ubicación de red.\n\n### ¿Qué es Headscale?\n\nHeadscale es una implementación open-source y self-hosted del servidor de coordinación de Tailscale. Te permite correr tu propia red compatible con Tailscale sin depender de la infraestructura de Tailscale.\n\n### ¿Qué son los servidores DERP?\n\nLos servidores DERP (Designated Encrypted Relay for Packets) son la infraestructura de relay de Tailscale. Cuando dos dispositivos no pueden establecer una conexión WireGuard directa (por NAT restrictivo), el tráfico se encripta y retransmite a través del servidor DERP más cercano.\n\n### ¿El tráfico de Tailscale siempre está encriptado?\n\nSí. Todo el tráfico usa encriptación WireGuard (ChaCha20-Poly1305) sin importar si es una conexión directa o relayeada por DERP. Los servidores DERP no pueden ver el texto plano, solo reenvían paquetes WireGuard encriptados.\n\n## Tips\n\n1. **Tip:** Ejecutar ` tailscale netcheck ` para diagnosticar problemas de conectividad. Te muestra tu tipo de NAT, la latencia al DERP y si UDP está siendo bloqueado. Si ves ` NAT type: hard ` en ambos lados, las conexiones directas son imposibles y el tráfico va a rutear por DERP.\n2. **Tip:** Cuando corrés Headscale, establecer ` dns_config.magic_dns: true ` y ` dns_config.base_domain: tu.dominio ` en la config. Esto te da resolución DNS automática para todos los nodos sin tocar ` /etc/hosts ` ni correr un servidor DNS separado.\n3. **Tip:** Utilizar ` tailscale status --json | jq '.Peer[] | select(.Relay != \"\") | .HostName' ` para encontrar qué peers están relayeando por DERP en vez de usar conexiones directas. Ese es son tus cuellos de botella de conectividad.\n4. **Tip:** El ` AllowedIPs ` de WireGuard es tanto tabla de ruteo como ACL. Setear ` AllowedIPs = 0.0.0.0/0 ` rutea TODO el tráfico por ese peer (modo exit node). Para split tunneling, incluir solo las subnets específicas que se necesita.\n\n- wireguard\n- tailscale\n- headscale\n- mesh-networking\n- nat-traversal\n- derp\n- vpn\n- networking\n\n[Volver al Blog](<https://lucioduran.com/es/blog>)","headings":[{"level":1,"text":"WireGuard Mesh Networking: Los Internals de Tailscale y Headscale Explicados","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#title"},{"level":2,"text":"WireGuard: La Base","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#wireguard-la-base"},{"level":2,"text":"La Arquitectura de Tailscale","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#la-arquitectura-de-tailscale"},{"level":2,"text":"NAT Traversal: La Parte Difícil","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#nat-traversal-la-parte-difcil"},{"level":3,"text":"STUN: Descubriendo Tu Dirección Pública","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#stun-descubriendo-tu-direccin-pblica"},{"level":3,"text":"Hole Punching","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#hole-punching"},{"level":3,"text":"Predicción de Puertos","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#prediccin-de-puertos"},{"level":2,"text":"DERP: Cuando las Conexiones Directas Fallan","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#derp-cuando-las-conexiones-directas-fallan"},{"level":2,"text":"MagicDNS: Nombres en Vez de IPs","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#magicdns-nombres-en-vez-de-ips"},{"level":2,"text":"Armando Tu Propia Red: Headscale","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#armando-tu-propia-red-headscale"},{"level":3,"text":"Configurando Headscale","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#configurando-headscale"},{"level":3,"text":"Registrar Nodos","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#registrar-nodos"},{"level":3,"text":"Políticas ACL","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#polticas-acl"},{"level":2,"text":"Avanzado: Subnet Routing y Exit Nodes","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#avanzado-subnet-routing-y-exit-nodes"},{"level":3,"text":"Subnet Router","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#subnet-router"},{"level":3,"text":"Exit Node","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#exit-node"},{"level":2,"text":"Monitoreo de Tu Mesh","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#monitoreo-de-tu-mesh"},{"level":2,"text":"Rendimiento: WireGuard vs OpenVPN vs IPSec","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#rendimiento-wireguard-vs-openvpn-vs-ipsec"},{"level":2,"text":"El Estado del Arte en 2026","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#el-estado-del-arte-en-2026"},{"level":2,"text":"Preguntas frecuentes","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#questions"},{"level":3,"text":"¿Qué es Tailscale?","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#question-1"},{"level":3,"text":"¿Qué es Headscale?","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#question-2"},{"level":3,"text":"¿Qué son los servidores DERP?","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#question-3"},{"level":3,"text":"¿El tráfico de Tailscale siempre está encriptado?","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#question-4"},{"level":2,"text":"Tips","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#article-tips"}],"sections":[{"heading":"WireGuard Mesh Networking: Los Internals de Tailscale y Headscale Explicados","level":1,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals","content":"Networking"},{"heading":"WireGuard Mesh Networking: Los Internals de Tailscale y Headscale Explicados","level":1,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#title","content":"2026-01-2810 min lectura\n\nLucio Durán\nEngineering Manager & AI Solutions Architect\n\nTambién disponible en: [English](<https://lucioduran.com/blog/wireguard-mesh-networking-tailscale-internals>)"},{"heading":"WireGuard: La Base","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#wireguard-la-base","content":"Todo arranca con [WireGuard](<https://www.wireguard.com/>). WireGuard es un protocolo de VPN que hace una cosa excepcionalmente bien: crear túneles encriptados punto a punto con configuración mínima.\n\nUna config completa de WireGuard se ve así:\n\n```ini\n# /etc/wireguard/wg0.conf en Nodo A\n[Interface]\nPrivateKey = yAnz5TF+lXXJte14tji3zlMNq+hd2rYUIgJBgB3fBmk=\nAddress = 10.0.0.1/24\nListenPort = 51820\n\n[Peer]\nPublicKey = xTIBA5rboUvnH4htodjb6e697QjLERt1NAB4mZqp8Dg=\nAllowedIPs = 10.0.0.2/32\nEndpoint = 203.0.113.50:51820\n```\n\nEso es todo. Sin certificados, sin autoridades certificantes, sin negociación HMAC. Solo pares de claves Curve25519 y encriptación ChaCha20-Poly1305. El protocolo cabe en unas 4.000 líneas de código del kernel.\n\nPero WireGuard crudo tiene un problema fundamental para uso real: **se necesita saber la dirección IP y el puerto de cada peer de antemano**. Si el Nodo B está detrás de un NAT, su endpoint público cambia. Si el Nodo C está en una red móvil, su IP cambia cada vez que cambia de antena. Con 50 nodos, tendrías que actualizar 2.450 configuraciones de peer cada vez que una IP cambia. Ahí es donde entra [Tailscale](<https://tailscale.com/>)."},{"heading":"La Arquitectura de Tailscale","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#la-arquitectura-de-tailscale","content":"Tailscale es, en esencia, un sistema de coordinación que resuelve el problema de configuración de WireGuard. A continuación, va la arquitectura:\n\n```\n┌─────────────────────────────────────────────┐\n│ Servidor de Coordinación │\n│ (Tailscale SaaS o Headscale self-hosted) │\n│ │\n│ • Registro de nodos (claves púb, endpoints) │\n│ • Motor de políticas ACL │\n│ • Configuración DNS │\n│ • Autenticación OIDC │\n└──────────────┬───────────────────────────────┘\n │ HTTPS (solo plano de control)\n ┌──────────┼──────────┐\n ▼ ▼ ▼\n┌────────┐ ┌────────┐ ┌────────┐\n│ Nodo A │ │ Nodo B │ │ Nodo C │\n│agente │ │agente │ │agente │\n│tailsca │ │tailsca │ │tailsca │\n└───┬────┘ └───┬────┘ └───┬────┘\n │ │ │\n └──────────┼──────────┘\n Túneles WireGuard\n (directos, peer-to-peer)\n```\n\nEl servidor de coordinación nunca ve tu tráfico de datos. Solo maneja:\n\n1. Registro de nodos y sus claves públicas\n2. Distribución de información de endpoints (direcciones IP, puertos)\n3. Evaluación de políticas ACL\n4. Coordinación de NAT traversal\n\nTodo el flujo de datos real va directamente entre nodos sobre WireGuard. El servidor de coordinación es un plano de control, no un plano de datos."},{"heading":"NAT Traversal: La Parte Difícil","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#nat-traversal-la-parte-difcil","content":"Hacer que dos dispositivos detrás de NAT se hablen directamente es el problema de networking más difícil que Tailscale resuelve. Hay varios tipos de NAT, y cada uno requiere estrategias diferentes:"},{"heading":"STUN: Descubriendo Tu Dirección Pública","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#stun-descubriendo-tu-direccin-pblica","content":"El primer paso es averiguar tu propia IP pública y puerto. Tailscale usa STUN (Session Traversal Utilities for NAT):\n\n```\nNodo A (detrás de NAT) Servidor STUN Nodo B (detrás de NAT)\n │ │ │\n │── STUN Binding Request ────→ │ │\n │ │ │\n │←── Tu IP:puerto público ─────│ │\n │ (203.0.113.50:34567) │ │\n │ │ │\n │ │ ←── STUN Request ────│\n │ │ │\n │ │── Tu IP pública ───→ │\n │ │ (198.51.100.22: │\n │ │ 45678) │\n```"},{"heading":"Hole Punching","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#hole-punching","content":"Una vez que ambos nodos conocen sus direcciones públicas (por STUN), intentan UDP hole punching:\n\n```\nNodo A (NAT: 203.0.113.50:34567) Nodo B (NAT: 198.51.100.22:45678)\n │ │\n │── paquete UDP a 198.51.100.22:45678 ─→│ (puede ser descartado por el NAT de B)\n │ │\n │←── paquete UDP a 203.0.113.50:34567 ──│ (puede ser descartado por el NAT de A)\n │ │\n │── paquete UDP (retransmit) ──────────→│ (AHORA el NAT de B tiene un mapping)\n │ │\n │←── paquete UDP (retransmit) ──────────│ (AHORA el NAT de A tiene un mapping)\n │ │\n │◄═══════ túnel WireGuard ═══════════►│ (¡conexión directa!)\n```\n\nAmbos lados simultáneamente envían paquetes UDP a la dirección pública del otro. Los primeros paquetes pueden ser perdidos porque el NAT no vio tráfico de esa fuente todavía. Pero el paquete saliente crea un mapping NAT, así que cuando el paquete del otro lado llega, el NAT lo deja pasar.\n\nEsto funciona para full cone, restricted cone y port-restricted NAT. Para symmetric NAT (donde el puerto cambia por destino), el hole punching falla porque el puerto descubierto por STUN no coincide con el puerto usado para la conexión al peer."},{"heading":"Predicción de Puertos","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#prediccin-de-puertos","content":"Para tipos de NAT más difíciles, Tailscale intenta predicción de puertos. Si un NAT asigna puertos secuenciales (muchos lo hacen), se puede predecir el siguiente puerto:\n\n```go\n// Lógica simplificada de predicción de puertos\nfunc predictPorts(observedPorts []uint16) []uint16 {\n if len(observedPorts) < 2 {\n return nil\n }\n // Chequear patrón secuencial\n delta := observedPorts[1] - observedPorts[0]\n predicted := observedPorts[len(observedPorts)-1] + delta\n\n // Retornar un rango alrededor del puerto predicho\n candidates := make([]uint16, 0, 32)\n for i := predicted - 16; i <= predicted + 16; i++ {\n candidates = append(candidates, i)\n }\n return candidates\n}\n```\n\nCuando la predicción de puertos no es posible, Tailscale usa un approach de \"ataque de cumpleaños\", ambos lados simultáneamente prueban muchos puertos, esperando una colisión. Con 256 pruebas de cada lado, hay aproximadamente un 50% de probabilidad de pegar con la combinación de puerto correcta (matemática de la paradoja del cumpleaños)."},{"heading":"DERP: Cuando las Conexiones Directas Fallan","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#derp-cuando-las-conexiones-directas-fallan","content":"Cuando el hole punching falla (NAT simétrico en ambos lados, o UDP bloqueado completamente), Tailscale cae a DERP, Designated Encrypted Relay for Packets.\n\nLos servidores DERP son esencialmente relays WebSocket que reenvían paquetes WireGuard encriptados:\n\n```\nNodo A Servidor DERP Nodo B\n │ │ │\n │── paquete WG ───────→│ │\n │ encriptado/HTTPS │── paquete WG ────────→ │\n │ │ encriptado/HTTPS │\n │ │ │\n │←── paquete WG ───────│←── paquete WG ────────│\n │ encriptado/HTTPS │ encriptado/HTTPS │\n```\n\nPuntos clave sobre DERP:\n\n- **Los servidores DERP no pueden desencriptar tráfico**. Solo reenvían paquetes encriptados de WireGuard. El servidor DERP ve blobs encriptados.\n- **DERP corre sobre HTTPS (TCP puerto 443)**. Funciona a través de firewalls corporativos y portales cautivos que bloquean UDP.\n- **Tailscale corre servidores DERP globalmente**. El tráfico rutea por el servidor DERP más cercano basado en latencia.\n- **DERP es un fallback, no el default**. Tailscale continuamente intenta establecer conexiones directas y solo usa DERP cuando es necesario.\n\nSe puede correr tu propio servidor DERP:\n\n```bash\n# Compilar el servidor DERP\ngo install tailscale.com/cmd/derper@latest\n\n# Correrlo\nderper \\\n --hostname=derp.example.com \\\n --certmode=letsencrypt \\\n --certdir=/var/lib/derper/certs \\\n --stun \\\n --verify-clients\n```"},{"heading":"MagicDNS: Nombres en Vez de IPs","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#magicdns-nombres-en-vez-de-ips","content":"MagicDNS es el sistema DNS automático de Tailscale. Cada nodo recibe un nombre legible en tu tailnet:\n\n```\nlaptop.tail12345.ts.net → 100.64.0.1\nserver.tail12345.ts.net → 100.64.0.2\nnas.tail12345.ts.net → 100.64.0.3\n```\n\nPor debajo, Tailscale corre un resolver DNS local (generalmente en ` 100.100.100.100 `) que intercepta queries DNS para tu dominio tailnet, los resuelve de la lista de nodos provista por el servidor de coordinación, y reenvía todas las demás queries a tu DNS upstream configurado."},{"heading":"Armando Tu Propia Red: Headscale","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#armando-tu-propia-red-headscale","content":"[Headscale](<https://github.com/juanfont/headscale>) es una implementación open-source del servidor de coordinación de Tailscale. Es compatible con el cliente oficial de Tailscale, así que se tiene toda la magia del NAT traversal y WireGuard sin depender de la infraestructura de Tailscale."},{"heading":"Configurando Headscale","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#configurando-headscale","content":"```bash\n# Instalar Headscale\nwget https://github.com/juanfont/headscale/releases/download/v0.23.0/headscale_0.23.0_linux_amd64.deb\nsudo dpkg -i headscale_0.23.0_linux_amd64.deb\n```\n\nConfigurarlo:\n\n```yaml\n# /etc/headscale/config.yaml\nserver_url: https://headscale.example.com:443\nlisten_addr: 0.0.0.0:443\n\ntls_cert_path: /etc/headscale/tls/cert.pem\ntls_key_path: /etc/headscale/tls/key.pem\n\ndb_type: sqlite3\ndb_path: /var/lib/headscale/db.sqlite\n\nip_prefixes:\n - 100.64.0.0/10\n - fd7a:115c:a1e0::/48\n\ndns_config:\n nameservers:\n - 1.1.1.1\n - 8.8.8.8\n magic_dns: true\n base_domain: mesh.example.com\n\nderp:\n server:\n enabled: true\n region_id: 999\n region_code: \"custom\"\n region_name: \"Mi DERP\"\n stun_listen_addr: 0.0.0.0:3478\n urls: []\n auto_update_enabled: false\n\noidc:\n issuer: https://auth.example.com\n client_id: headscale\n client_secret: tu-secreto\n scope: [\"openid\", \"profile\", \"email\"]\n```"},{"heading":"Registrar Nodos","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#registrar-nodos","content":"```bash\n# Crear un usuario (namespace)\nheadscale users create engineering\n\n# Generar una pre-auth key\nheadscale preauthkeys create --user engineering --reusable --expiration 24h\n# Output: key-abc123def456...\n\n# En el nodo cliente, unirse usando el cliente oficial de Tailscale\ntailscale up --login-server https://headscale.example.com --authkey key-abc123def456\n```"},{"heading":"Políticas ACL","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#polticas-acl","content":"Headscale soporta el formato de políticas ACL de Tailscale:\n\n```json\n{\n \"acls\": [\n {\n \"action\": \"accept\",\n \"src\": [\"group:engineering\"],\n \"dst\": [\"tag:production:443\", \"tag:production:22\"]\n },\n {\n \"action\": \"accept\",\n \"src\": [\"group:ops\"],\n \"dst\": [\"*:*\"]\n }\n ],\n \"groups\": {\n \"group:engineering\": [\"user1@example.com\", \"user2@example.com\"],\n \"group:ops\": [\"admin@example.com\"]\n },\n \"tagOwners\": {\n \"tag:production\": [\"group:ops\"],\n \"tag:staging\": [\"group:engineering\"]\n }\n}\n```"},{"heading":"Avanzado: Subnet Routing y Exit Nodes","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#avanzado-subnet-routing-y-exit-nodes","content":""},{"heading":"Subnet Router","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#subnet-router","content":"Un subnet router expone una red entera a tu tailnet sin instalar Tailscale en cada dispositivo:\n\n```bash\n# En el nodo subnet router\necho 'net.ipv4.ip_forward = 1' | sudo tee -a /etc/sysctl.conf\necho 'net.ipv6.conf.all.forwarding = 1' | sudo tee -a /etc/sysctl.conf\nsudo sysctl -p\n\n# Anunciar la subnet local\ntailscale up --advertise-routes=192.168.1.0/24,10.0.0.0/8\n\n# En el servidor headscale, aprobar las rutas\nheadscale routes enable --route 192.168.1.0/24\nheadscale routes enable --route 10.0.0.0/8\n```\n\nAhora cada nodo en tu tailnet puede alcanzar ` 192.168.1.0/24 ` a través del subnet router, sin ningún cambio en los dispositivos de esa subnet."},{"heading":"Exit Node","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#exit-node","content":"Un exit node rutea todo el tráfico de internet a través de un nodo específico, útil para acceder a servicios con restricción regional o rutear por una red confiable:\n\n```bash\n# En el exit node\ntailscale up --advertise-exit-node\n\n# En headscale, aprobarlo\nheadscale routes enable --route 0.0.0.0/0\nheadscale routes enable --route ::/0\n\n# En el cliente, usar el exit node\ntailscale up --exit-node=server.mesh.example.com\n```"},{"heading":"Monitoreo de Tu Mesh","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#monitoreo-de-tu-mesh","content":"A continuación, un script para monitorear la salud de la mesh:\n\n```bash\n#!/bin/bash\n# mesh-health.sh - Monitorear conectividad de la mesh Tailscale/Headscale\n\necho \"=== Reporte de Salud de la Mesh ===\"\necho \"Fecha: $(date -u +%Y-%m-%dT%H:%M:%SZ)\"\necho \"\"\n\nSTATUS=$(tailscale status --json)\n\nDIRECT=$(echo \"$STATUS\" | jq '[.Peer[] | select(.CurAddr != \"\")] | length')\nRELAY=$(echo \"$STATUS\" | jq '[.Peer[] | select(.Relay != \"\" and .CurAddr == \"\")] | length')\nOFFLINE=$(echo \"$STATUS\" | jq '[.Peer[] | select(.Online == false)] | length')\nTOTAL=$(echo \"$STATUS\" | jq '.Peer | length')\n\necho \"Peers: $TOTAL total, $DIRECT directos, $RELAY relayeados, $OFFLINE offline\"\necho \"\"\n\necho \"=== Peers Relayeados (subóptimo) ===\"\necho \"$STATUS\" | jq -r '.Peer[] | select(.Relay != \"\" and .CurAddr == \"\") |\n \"\\(.HostName)\\t\\(.TailscaleIPs[0])\\trelay: \\(.Relay)\"'\n```"},{"heading":"Rendimiento: WireGuard vs OpenVPN vs IPSec","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#rendimiento-wireguard-vs-openvpn-vs-ipsec","content":"Estos benchmarks se corrieron en dos máquinas conectadas por un link de 1Gbps a través de un NAT:\n\n| Protocolo | Throughput | Overhead de Latencia | Uso de CPU |\n| --- | --- | --- | --- |\n| Sin VPN (baseline) | 940 Mbps | 0ms | - |\n| WireGuard | 890 Mbps | 0.3ms | 2% |\n| OpenVPN (UDP) | 620 Mbps | 1.2ms | 15% |\n| OpenVPN (TCP) | 410 Mbps | 2.8ms | 22% |\n| IPSec (IKEv2) | 820 Mbps | 0.5ms | 5% |\n\nLa ventaja de rendimiento de WireGuard viene de ejecución en kernel-space, criptografía moderna, overhead de protocolo mínimo y headers de tamaño fijo."},{"heading":"El Estado del Arte en 2026","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#el-estado-del-arte-en-2026","content":"Tailscale y el ecosistema mesh de WireGuard maduraron considerablemente:\n\n- **Tailscale Funnel**: Exponer servicios específicos de tu tailnet al internet público con TLS automático.\n- **Taildrop**: File sharing encriptado entre nodos. Como AirDrop, pero a través de cualquier dispositivo en tu tailnet.\n- **Headscale 0.23+**: Compatibilidad completa con features del cliente Tailscale, incluyendo MagicDNS, subnet routing y exit nodes.\n- **Netbird y Nebula**: Proyectos alternativos de mesh networking con filosofías de diseño diferentes.\n\nEl espacio de VPN mesh pasó de \"pesadilla enterprise-only\" a \"instalar un binario y funciona.\" La simplicidad de WireGuard hizo esto posible, y Tailscale/Headscale lo hizo accesible. Para quienes todavía administran configs de OpenVPN o túneles SSH para conectividad interna, este approach vale la pena evaluar. El tiempo de setup es medible en minutos, no en días."},{"heading":"Preguntas frecuentes","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#questions","content":""},{"heading":"¿Qué es Tailscale?","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#question-1","content":"Tailscale es un servicio de VPN mesh construido sobre WireGuard que crea una red segura entre tus dispositivos. Maneja NAT traversal, intercambio de claves y DNS automáticamente, para que los dispositivos puedan comunicarse directamente sin importar su ubicación de red."},{"heading":"¿Qué es Headscale?","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#question-2","content":"Headscale es una implementación open-source y self-hosted del servidor de coordinación de Tailscale. Te permite correr tu propia red compatible con Tailscale sin depender de la infraestructura de Tailscale."},{"heading":"¿Qué son los servidores DERP?","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#question-3","content":"Los servidores DERP (Designated Encrypted Relay for Packets) son la infraestructura de relay de Tailscale. Cuando dos dispositivos no pueden establecer una conexión WireGuard directa (por NAT restrictivo), el tráfico se encripta y retransmite a través del servidor DERP más cercano."},{"heading":"¿El tráfico de Tailscale siempre está encriptado?","level":3,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#question-4","content":"Sí. Todo el tráfico usa encriptación WireGuard (ChaCha20-Poly1305) sin importar si es una conexión directa o relayeada por DERP. Los servidores DERP no pueden ver el texto plano, solo reenvían paquetes WireGuard encriptados."},{"heading":"Tips","level":2,"url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#article-tips","content":"1. **Tip:** Ejecutar ` tailscale netcheck ` para diagnosticar problemas de conectividad. Te muestra tu tipo de NAT, la latencia al DERP y si UDP está siendo bloqueado. Si ves ` NAT type: hard ` en ambos lados, las conexiones directas son imposibles y el tráfico va a rutear por DERP.\n2. **Tip:** Cuando corrés Headscale, establecer ` dns_config.magic_dns: true ` y ` dns_config.base_domain: tu.dominio ` en la config. Esto te da resolución DNS automática para todos los nodos sin tocar ` /etc/hosts ` ni correr un servidor DNS separado.\n3. **Tip:** Utilizar ` tailscale status --json | jq '.Peer[] | select(.Relay != \"\") | .HostName' ` para encontrar qué peers están relayeando por DERP en vez de usar conexiones directas. Ese es son tus cuellos de botella de conectividad.\n4. **Tip:** El ` AllowedIPs ` de WireGuard es tanto tabla de ruteo como ACL. Setear ` AllowedIPs = 0.0.0.0/0 ` rutea TODO el tráfico por ese peer (modo exit node). Para split tunneling, incluir solo las subnets específicas que se necesita.\n\n- wireguard\n- tailscale\n- headscale\n- mesh-networking\n- nat-traversal\n- derp\n- vpn\n- networking\n\n[Volver al Blog](<https://lucioduran.com/es/blog>)"}],"links":[{"text":"English","url":"https://lucioduran.com/blog/wireguard-mesh-networking-tailscale-internals"},{"text":"WireGuard","url":"https://www.wireguard.com/"},{"text":"Tailscale","url":"https://tailscale.com/"},{"text":"Headscale","url":"https://github.com/juanfont/headscale"},{"text":"Volver al Blog","url":"https://lucioduran.com/es/blog"}],"structuredData":[{"@context":"https://schema.org","@graph":[{"@type":"BlogPosting","@id":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals#article","mainEntityOfPage":{"@type":"WebPage","@id":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals"},"headline":"WireGuard Mesh Networking: Los Internals de Tailscale y Headscale Explicados","description":"Cómo Tailscale construye una red mesh encima de WireGuard. Servidores DERP relay, NAT traversal, MagicDNS, y una guía práctica para armar tu propia red privada overlay con Headscale.","datePublished":"2026-01-28","author":{"@type":"Person","@id":"https://lucioduran.com/#person","name":"Lucio Durán","url":"https://lucioduran.com"},"publisher":{"@type":"Person","@id":"https://lucioduran.com/#person","name":"Lucio Durán","url":"https://lucioduran.com"},"image":"https://statics.lucioduran.com/images/lucioduran-social-card.jpg","url":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals","inLanguage":"es","isPartOf":{"@id":"https://lucioduran.com/blog#blog"},"articleSection":"Networking","keywords":"wireguard, tailscale, headscale, mesh-networking, nat-traversal, derp, vpn, networking","wordCount":1770,"timeRequired":"PT10M","workTranslation":[{"@type":"BlogPosting","inLanguage":"en","url":"https://lucioduran.com/blog/wireguard-mesh-networking-tailscale-internals"}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Inicio","item":"https://lucioduran.com/"},{"@type":"ListItem","position":2,"name":"Blog","item":"https://lucioduran.com/es/blog"},{"@type":"ListItem","position":3,"name":"WireGuard Mesh Networking: Los Internals de Tailscale y Headscale Explicados","item":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals"}]},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"¿Qué es Tailscale?","acceptedAnswer":{"@type":"Answer","text":"Tailscale es un servicio de VPN mesh construido sobre WireGuard que crea una red segura entre tus dispositivos. Maneja NAT traversal, intercambio de claves y DNS automáticamente, para que los dispositivos puedan comunicarse directamente sin importar su ubicación de red."}},{"@type":"Question","name":"¿Qué es Headscale?","acceptedAnswer":{"@type":"Answer","text":"Headscale es una implementación open-source y self-hosted del servidor de coordinación de Tailscale. Te permite correr tu propia red compatible con Tailscale sin depender de la infraestructura de Tailscale."}},{"@type":"Question","name":"¿Qué son los servidores DERP?","acceptedAnswer":{"@type":"Answer","text":"Los servidores DERP (Designated Encrypted Relay for Packets) son la infraestructura de relay de Tailscale. Cuando dos dispositivos no pueden establecer una conexión WireGuard directa (por NAT restrictivo), el tráfico se encripta y retransmite a través del servidor DERP más cercano."}},{"@type":"Question","name":"¿El tráfico de Tailscale siempre está encriptado?","acceptedAnswer":{"@type":"Answer","text":"Sí. Todo el tráfico usa encriptación WireGuard (ChaCha20-Poly1305) sin importar si es una conexión directa o relayeada por DERP. Los servidores DERP no pueden ver el texto plano, solo reenvían paquetes WireGuard encriptados."}}]}]}],"contentHash":"5d6f4b25894694a89d4b854cd3241dd026f8221d4c8e4d35677ccfce2fb20d7a","provenance":{"method":"Deterministic serialization of the server-rendered main element","source":"https://lucioduran.com/es/blog/wireguard-mesh-networking-tailscale-internals","hashAlgorithm":"sha256","hashScope":"JSON document fields before contentHash and provenance","sourceHTMLBytes":77911,"contentBytes":16530}}