Conectar Surfshark VPN protocolo WireGuard FreeBSD 14.4

2. FreeBSD 14.4 Wireguard VPN Surfshark

Surfshark (Países Bajos)no ofrece port forwarding Varias fuentes coinciden (incluida la propia respuesta de Surfshark a sus usuarios): Surfshark VPN no soporta "port forwarding". Split tunneling (Bypasser de Surfshark): saca qBittorrent de la VPN para que use tu IP real directamente. Si lo que buscas es privacidad + port forwarding, la solución no está en el split tunneling ni en el jail, sino en un proveedor de VPN que sí ofrezca reenvío de puertos (por ejemplo, ProtonVPN)

Países de los Catorce Ojos La alianza de vigilancia de los Catorce Ojos son servicios de inteligencia estatales que vigilan y comparten la actividad de las personas en Internet. Estados Unidos, Reino Unido, Canadá, Nueva Zelanda, Australia, Dinamarca, Francia, Países Bajos, Noruega, Alemania, Bélgica, Italia, Suecia y España forman parte de esta alianza.

Elegir una ubicación y descargar el archivo de configuración. Asegurarse de generar el par de claves con anticipación de modo que la clave privada se agregue al archivo de configuración.

Descargar el archivo de configuración

Archivo /etc/rc.conf

wireguard_enable="YES"
wireguard_interface="wg0"

Copiar el archivo de configuración descargado y renombrado como wg0

cp fr-par.conf /usr/local/etc/wireguard/wg0.conf

Luego ejecutar

wg-quick up wg0

comprobar dirección IP VPN

 curl ifconfig.me
 82.102.18.210

FreeBSD es genial!.

FreeBSD 14.4 WireGuard VPN Surfshark

1. Conectar Surfshark VPN WireGuard FreeBSD 14.4

Análisis de la tabla de rutas

ifconfig

  em0: flags=8842<BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
	options=4e524bb<RXCSUM,TXCSUM,VLAN_MTU,VLAN_HWTAGGING,JUMBO_MTU,VLAN_HWCSUM,LRO,WOL_MAGIC,VLAN_HWFILTER,VLAN_HWTSO,RXCSUM_IPV6,TXCSUM_IPV6,HWSTATS,MEXTPG>
	ether e4:b9:7a:6b:96:cd
	media: Ethernet autoselect
	status: no carrier
	nd6 options=29<PERFORMNUD,IFDISABLED,AUTO_LINKLOCAL>
lo0: flags=1008049<UP,LOOPBACK,RUNNING,MULTICAST,LOWER_UP> metric 0 mtu 16384
	options=680003<RXCSUM,TXCSUM,LINKSTATE,RXCSUM_IPV6,TXCSUM_IPV6>
	inet 127.0.0.1 netmask 0xff000000
	inet6 ::1 prefixlen 128
	inet6 fe80::1%lo0 prefixlen 64 scopeid 0x2
	groups: lo
	nd6 options=21<PERFORMNUD,AUTO_LINKLOCAL>
wlan0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
	options=0
	ether 18:56:80:f8:98:e6
	inet 192.168.88.51 netmask 0xffffff00 broadcast 192.168.88.255
	groups: wlan
	ssid MikroTik-39F9C0 channel 1 (2412 MHz 11g) bssid c4:ad:34:39:f9:c0
	regdomain FCC country US authmode WPA2/802.11i privacy ON
	deftxkey UNDEF AES-CCM 2:128-bit AES-CCM 3:128-bit
	AES-CCM ucast:128-bit txpower 30 bmiss 10 scanvalid 60 protmode CTS
	wme roaming MANUAL
	parent interface: iwm0
	media: IEEE 802.11 Wireless Ethernet OFDM/54Mbps mode 11g
	status: associated
	nd6 options=29<PERFORMNUD,IFDISABLED,AUTO_LINKLOCAL>
pflog0: flags=1000141<UP,RUNNING,PROMISC,LOWER_UP> metric 0 mtu 33152
	options=0
	groups: pflog
wg0: flags=10080c1<UP,RUNNING,NOARP,MULTICAST,LOWER_UP> metric 0 mtu 1420
	options=80000<LINKSTATE>
	inet 10.14.0.2 netmask 0xffff0000
	groups: wg
	nd6 options=109<PERFORMNUD,IFDISABLED,NO_DAD>
tailscale0: flags=1008003<UP,BROADCAST,MULTICAST,LOWER_UP> metric 0 mtu 1280
	options=4080000<LINKSTATE,MEXTPG>
	groups: tun
	nd6 options=109<PERFORMNUD,IFDISABLED,NO_DAD>
	Opened by PID 1452

netstat -rn

Routing tables

Internet:
Destination        Gateway            Flags         Netif Expire
0.0.0.0/1          link#5             US              wg0
default            192.168.88.1       UGS           wlan0
10.14.0.2          link#2             UH              lo0
85.204.70.87       192.168.88.1       UGHS          wlan0
128.0.0.0/1        link#5             US              wg0
192.168.88.0/24    link#3             U             wlan0
192.168.88.51      link#2             UHS             lo0

Ruta por defecto

Ruta por defecto (default) 192.168.88.1 por wlan0 es la ruta genérica, pero no es la que se usa para la mayoría del tráfico.

Rutas VPN (Wireguard)

0.0.0.0/1 y 128.0.0.0/1 ambas apuntan a wg0

Estas dos rutas cubren todo el rango IPv4 (0.0.0.0/1 y 128.0.0.0/1 = 0.0.0.0/0).

Como son más específicas que default, todo el tráfico (excepto las excepciones) se envía por wg0, es decir, por la VPN

Excepción para el servidor VPN

85.204.70.87 va directamente por wlan0 (gateway local)

Esa IP es el endpoint de WireGuard de Surfshark. Sin esta ruta, el tráfico del túnel intetaría pasar por el propio túnel (bucle) y fallaría.

Red local

192.168.88.0/24 por wlan0. Así puedes acceder a tu router, impresoras, etc., sin pasar por la VPN.

IP propia (loopback)

192.168.88.51 y 10.14.0.2 están en lo0 como direcciones locales (para evitar enrutamiento externo).

¿Qué significa esto en la práctica?

Tu IP pública (la que ven los sitios web) es la de Surfshark, no la de tu router.

El tráfico de navegación (HTTP/HTTPS, DNS, etc.) pasa por el túnel WireGuard.

El tráfico local (a tu router, otros PCs en 192.168.88.x) no pasa por la VPN.

El servidor VPN se alcanza directamente por WiFi, sin pasar por el túnel (para evitar bucles).

Tailscale está presente pero no parece estar enrutando tráfico por defecto (quizás solo para acceso a otros nodos).

Destruir lagg0 y limpiar wlan0

sudo ifconfig lagg0 destroy
sudo ifconfig wlan0 destroy

Crear wlan0 limpio con la configuración correcta

sudo ifconfig wlan0 create wlandev iwm0 country ES
sudo ifconfig wlan0 up

Archivo /etc/wpa_supplicant

 
/etc/wpa_supplicant.conf written by wifimgr(8)
ctrl_interface=/var/run/wpa_supplicant
eapol_version=2
fast_reauth=1

network={
	ssid="MikroTik-39F9C0"
	psk=755862a5b1a4ef59e9e62590977a75f5317193637a8629dccb18c40e8638a68e
}

Iniciar wpa_supplicant (si no está corriendo)

sudo wpa_supplicant -B -i wlan0 -c /etc/wpa_supplicant.conf

Esperar a que se asocie (opcional, pero recomendado)

sleep 5
ifconfig wlan0 | grep status

Asignar IP fija y ruta por defecto

sudo ifconfig wlan0 inet 192.168.88.51 netmask 255.255.255.0
sudo route add default 192.168.88.1

Reiniciar WireGuard para que use la nueva interfaz

sudo wg-quick down wg0 && wg-quick up wg0 # 0 sudo service wireguard restart

Archivo /etc/pf.conf

/etc/pf.conf
ext_if="wlan0"
torrent="53541"
vpn_if="wg0"
wireguard="51820"
lan_net="192.168.88.0/24"

set block-policy return
set skip on lo

scrub in on $ext_if all fragment reassemble

table <jails> persist

nat on $ext_if from <jails> to any -> ($ext_if:0)
rdr-anchor "rdr/*"

block in all

antispoof for $ext_if inet

# Salida: todo el tráfico local permitido y trackeado
pass out quick keep state

# Entrada SSH
pass in quick inet proto tcp from $lan_net to any port ssh flags S/SA keep state

# Entrada VPN WireGuard (túnel Surfshark)
pass in quick on $vpn_if all keep state
pass out quick on $vpn_if all keep state

# Entrada qBittorrent
pass in quick on $ext_if inet proto { tcp } to port $torrent

# Entrada ICMP básico (diagnóstico)
pass in quick on $ext_if inet proto { icmp } all icmp-type { echoreq, unreach }

Verificar

¿La ruta por defecto apunta a wlan0 y las rutas VPN cubren el resto?

netstat -rn | grep -E "(default|wg0|wlan0)"

¿WireGuard está activo?

wg show 
interface: wg0
  public key: pkpZvkWaVDd6DmEb3cl9DEvsnOKl9dvZVAP+KMJLZCs=
  private key: (hidden)
  listening port: 58461

peer: AsvLuvKKAGdc67aA/vHA3vb61S6YnDGx2Pd4aP4wal8=
  endpoint: 82.102.18.179:51820
  allowed ips: 0.0.0.0/0
  latest handshake: 1 minute, 14 seconds ago
  transfer: 1.39 MiB received, 1.51 MiB sent

ping -c 8.8.8.8

Mostrar la IP pública (la IP de Surfshark)

curl -s ifconfig.me

FreeBSD es genial!.

Alternativas cuando el Router no Permite el Reenvío de Puertos

Bibliografía:

Tailscale

En la página de Tailscale "Regístrese con su proveedor de identidad", inicie sesión con una cuenta de proveedor de identidad de inicio de sesión único (SSO).

como habilitar acceso remoto a un servidor local (FreeBSD 14.3), que está detrás de un NAT (una red doméstica donde el ISP no permite abrir puertos), sin necesidad de un dominio publico.

Tailscale, un servicio P2P basado en wireguard que implementa NAT traversal para crear una red VPN segura y privada. Permite conectar dispositivos de forma directa (P2P) cuando es posible, o a través de relays (DEP servers) si el NAT es estricto. No expone puertos públicos ni requiere configuraciones complejas en routers. Tailscale es gratuito para uso personal (hasta 3 usuarios y 100 dispositivos).

Tailscale no necesita dominio público porque el acceso se realiza a través de IPs privadas de Tailscale (en el rango 100.64.0.0/10 conocidas como CGNAT) o nombre de host automáticos en tu "tailnet" (red privada de Tailscale). 

Instalación, configuración, NAT traversal y acceso a servicios locales. Asumido que tiene acceso root en el servidor FreeBSD 14.3 y que el sistema está actualizado (pkg update && pkg upgrade).

Wireguard es el protocolo subyacente, un VPN moderno, ligero y seguro que usa criptografía de curva elíptica para túneles cifrados.

Nat Travesal. Tailscale utiliza técnicas como STUN (para descubrir IPs públicas y puertos), ICE (para negociar conexiones P2P) y relays DERP (servidores de Tailscale que actúan como intermediariso si el P2P falla debido a NAT simétrico o firewalls estrictos).

Tailnet. Su red privada virtual. Todos los dispositivos autenticados en su cuenta forman parte de ella.

Servicios locales. Para acceder a un servicio en el servidor (por ejemplo web en 80), el cliente se conecta a la IP de Tailscale + puerto, como si estuvieran en la misma LAN.

Dispositivo cliente (PC, teléfono móvil, etc.) desde donde se accederá instalando Tailscale (disponible para Windows, macOS, FreeBSD, iOS, Android, Linux).

Firewall en FreeBSD. Si usa PF (Packet Filter), asegurarse de que permita tráfico saliente (por defecto lo hace). No necesita reglas entrantes especiales para Tailscale, ya que utiliza la interfaz tailscale0.

Instalar Tailscale en el servidor local (FreeBSD 14.3)

pkg install tailscale

Esto instala tailscaled (el demonio) y tailscale (la CLI). Dependencias como Wireguard se instalan automáticamente.

Habilitar el servicio para que inicie al inicio

sysrc tailscaled_enable="YES"

Iniciar el servicio

service tailscaled start

Comprobar el estado

service tailscaled status

Autenticar el servidor en tu tailnet

tailscale up

Esto genera un URL de autenticación (ej. https://login.tailscale.com/a/65831eb3ddff0). Copiar y pegar en un navegador en cualquier dispositivo. Iniciar sesión con su cuenta de Tailscale para aprobar el dispositivo. Una vez aprobado, el comando completará y el servidor se unirá a su tailnet.

Recomendación de mantenimiento

Nunca vuelva a ejecutar tailscale up sin --hostname o sin haber hecho tailscale logout antes. Uso correcto:

tailscale logout
tailscale up --hostname=tornado

tailscale status
100.115.10.68   tormenta  nombreusuario@  freebsd

Se muestra el servidor con una IP de Tailscale y estado online

ifconfig tailscale0 para la interfaz VPN.

ifconfig tailscale0

tailscale0: flags=1008043< <UP,BROADCAST,RUNNING,MULTICAST,LOWER_UP> metric 0 mtu 1280
	options=4080000< <LINKSTATE,MEXTPG>
	inet 100.115.10.68 netmask 0xffffffff broadcast 100.115.10.68
	inet6 fd7a:115c:a1e0::cd01:687 prefixlen 48
	groups: tun
	nd6 options=101 <PERFORMNUD,NO_DAD>
	Opened by PID 27732

You are about to connect the device tormenta to the nombreususario@gmail.com tailnet.

Public key 		nodekey:af18fa705771d20c28856057767cafc...

Hostname    		tormenta

Operating system	freebsd (14.3-RELEASE-p7)

Tailscale version	1.94.1

tormenta		100.115.10.68

No es necesario configurar nada extra en su router o firewall.

Exponer Servicios Locales

Por defecto, Tailscale permite acceso a cualquer puerto en la IP de Tailscale del servidor, siempre que el servicio escuche en 0.0.0.0 o la interfaz tailscale0

Ejemplo para un servidor web (por ejemplo, Nginx en el puerto 80) se configura para escuchar en 0.0.0.0:80

Archivo de configuración /usr/local/etc/nginx/nginx.conf

---
server {
        listen       8000; #poudriere
        server_name  localhost;
        root /usr/local/share/poudriere/html;

        location /data {
            alias  /usr/local/poudriere/data/logs/bulk;
            autoindex on;
        }

        location /packages {
                root /usr/local/poudriere/data;
                autoindex on;
        }

        location / {
                index index.html index.htm;
        }

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   /usr/local/www/nginx-dist;
        }
}

# Servidor web principal en el puerto 80
server {
        listen 0.0.0.0:80; #nginx
        server_name localhost;

        root /usr/local/www/nginx;
        index index.html index.htm;

        # Paginas de error para el servidor principal
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   /usr/local/www/nginx-dist;
        }
    }

}
---

Si se quiere acceder a toda la subred local (otros dispositivos en la red 192.168.88.0/24), se tiene que habilitar subnet routes:

tailscale up --advertise-routes=192.168.88.0/24. Posteriormenta se aprueba en el 

admin console.

Seguridad adicional

Usar ACLs (Access Control Lists) en el admin console para restringir accesos (por ejemplo, solo ciertos usuarios pueden acceder al servidor).

Habilitar MagicDNS. En el admin console, ir a DNS > Enable MagicDNS. Para usar nombre como fsb143 en lugar de IPs.

Para headless (sin interacción): Usar pre-auth keys

Acceso desde Internet (lado cliente)

Instalar Tailscale en el dispositivo
Ejecutar tailscale up y autenticar con el mismo URL/login utilizado para el servidor 

(unirse al mismo tailnet)

Una vez conectado acceder al servidor

Web:
abrir http://100.115.10.68:80 (reemplazar con la IP de Tailscale del servidor 

obtenida de tailscale status).

Bienvenido al servidor FreeBSD nginx!
Si ve esta pagina, el servidor web nginx se instalo correctamente y funciona 

correctamente. Se requiere configuracion adicional.

Para obtener documentacion y soporte en linea, consulte nginx.org.

Gracias por usar nginx.

FreeBSD es genial!.

Cifrado por Envoltorio (túnel) del tráfico NFSv4 con Wireguard FreeBSD 14.3

Implementar cifrado por envoltorio (Wireguard) y proteger conexiones NFS entre un servidor y su(s) cliente(s).

Objetivos:

NFSv4 puro y limpio (solo puerto 2049).
Acceso exclusivo a través del túnel WireGuard (cifrado punto a punto).
Imposible acceder a los recursos desde la LAN física (bloqueado por PF).
Montajes persistentes y estables en el cliente.
Todo seguro, mínimo y sin componentes innecesarios corriendo.

Cómo implementar el cifrado por envoltorio: WireGuard

El servidor NFSv4 corre FreeBSD 14.3 ZFS, red 192.168.88.0/24, dominio local.com, nombre de host tormenta.local.com, dirección IP 192.168.88.160, interfaz re0, cortafuegos PF.

El cliente es un portátil con sistema operativo FreeBSD 14.3 ZFS, dirección IP 192.168.88.51, nombre de host solaris.local.com, interfaz de red em0. El archivo /etc/exports actual

V4: /nfsv4 -tls
/nfsv4/dellhome     -maproot=root -network 192.168.88.0/24 
/nfsv4/poolrecovery -maproot=root -network 192.168.88.0/24 
/nfsv4/docs         -maproot=root -network 192.168.88.0/24 
/nfsv4/confsolaris  -maproot=root -network 192.168.88.0/24 
/nfsv4/conftormenta -maproot=root -network 192.168.88.0/24

root@tormenta:~ # zfs list | grep /nfsv4 
zroot/nfsv4 103G 212G 7.80G /nfsv4 
zroot/nfsv4/confsolaris 283M 212G 4.76M /nfsv4/confsolaris 
zroot/nfsv4/conftormenta 916K 212G 852K /nfsv4/conftormenta 
zroot/nfsv4/dellhome 56.6G 212G 56.6G /nfsv4/dellhome 
zroot/nfsv4/docs 7.80G 212G 7.80G /nfsv4/docs 
zroot/nfsv4/poolrecovery 1.88G 212G 1.88G /nfsv4/poolrecovery 

La idea es crear un túnel VPN punto a punto entre el servidor (tormenta.local.com, 192.168.88.160) y el cliente (solaris.local.com, 192.168.88.51). De esta forma, el tráfico NFS se enruta exclusivamente a través del túnel encriptado de WireGuard, y configurar el servidor NFS para que solo escuche en la IP del túnel (evitando accesos directos por la LAN).

Forzar el cifrado para NFS, ya que ambos hosts están en la misma red LAN (192.168.88.0/24). Usar IPs privadas para el túnel: 10.66.66.1/32 para el servidor y 10.66.66.2/32 para el cliente. No es necesario forwarding ni NAT, ya que es un túnel simple para cifrar el tráfico local.

Verificar que no haya conflictos con reglas PF existentes. Si se usa NFSv4 puro, no se necesita rpcbind ni mountd, lo que simplifica las cosas

Detener servicios TLS

root@tormenta:/home/carlos # service tlsservd status
tlsservd is running as pid 1278.
root@tormenta:/home/carlos # service tlsservd stop
Stopping tlsservd.
Waiting for PIDS: 1278.

root@solaris:~# service tlsclntd status
tlsclntd is running as pid 1596.
root@solaris:~# service tlsclntd stop
Stopping tlsclntd.
Waiting for PIDS: 1596, 1596.

Desactivar TLS

root@tormenta:/home/carlos # sysrc tlsservd_enable="NO"
tlsservd_enable: YES -> NO

root@solaris:~# sysrc tlsclntd_enable="NO"
tlsclntd_enable: YES -> NO

Instalar wireguard-tools en el servidor tormenta y el cliente solaris

pkg install wireguard-tools
sysrc wireguard_enable="YES"
sysrc wireguard_interfaces="wg0"

En el servidor tormenta Generar claves privadas y públicas

mkdir /usr/local/etc/wireguard
cd /usr/local/etc/wireguard

umask 077
wg genkey | tee server_priv.key | wg pubkey > server_pub.key
wg genkey | tee client_priv.key | wg pubkey > client_pub.key

ls -l /usr/local/etc/wireguard
-rw-------  1 root wheel  45 Dec 11 18:28 client_priv.key
-rw-r--r--  1 root wheel  45 Dec 11 18:28 client_pub.key
-rw-------  1 root wheel  45 Dec 11 18:27 server_priv.key
-rw-r--r--  1 root wheel  45 Dec 11 18:27 server_pub.key

Esto genera claves para servidor y cliente

Transferir las claves al cliente solaris (IP 192.168.88.51), usando scp

scp root@tormenta:/usr/local/etc/wireguard/client_priv.key /usr/local/etc/wireguard/client_priv.key
scp root@tormenta:/usr/local/etc/wireguard/client_pub.key /usr/local/etc/wireguard/client_pub.key

Asegurar permisos estrictos (chmod 600 *.key)

cd /usr/local/etc/wireguard/
chmod 600 *.key

ls -l /usr/local/etc/wireguard/
-rw-------  1 root wheel  45 Dec 11 18:30 client_priv.key
-rw-------  1 root wheel  45 Dec 11 18:31 client_pub.key

Configurar WireGuard en el servidor tormenta

Archivo /usr/local/etc/wireguard/wg0.conf

###########################################
[Interface]
Address = 10.66.66.1/32
PrivateKey = <contenido de server_priv.key>
ListenPort = 51820

[Peer]
PublicKey = <contenido de client_pub.key>
AllowedIPs = 10.66.66.2/32

Reemplazar las claves por las claves reales

[Interface]
Address = 10.66.66.1/32
PrivateKey = oPtSkHSk8zNe9d3Z6gExZro9Cf8BELoahgZDsrc/7mk=
ListenPort = 51820

# conexion con clientes
[Peer]
PublicKey = tuu6a6EAPrQTC0tPatWJx2qcS6fEPcg4Z0u/8vY1pTs= 
AllowedIPs = 10.66.66.2/32
###########################################

Habilitar e iniciar el servicio

sysrc wireguard_interfaces="wg0"
sysrc wireguard_enable="YES"
service wireguard start

|

Acvitar desactivar interfaz wg0

wg-quick up wg0
wg-quick down wg0

Comprobar con wg show, debería mostrar la interfaz wg0 levantada

root@tormenta:/home/carlos # wg show
interface: wg0
  public key: UYbDhuNsq0geqJdsVKThSnNLzdc2oHWgUT8Gb0G3VXU=
  private key: (hidden)
  listening port: 51820

peer: tuu6a6EAPrPTC0tPatWJx2qcS6fEPcg4Z0u/8vY1pTs=
  allowed ips: 10.66.66.2/32

Configurar WireGuard en el cliente (solaris)

Archivo /usr/local/etc/wireguard/wg0.conf
###########################################
[Interface]
Address = 10.66.66.2/32
PrivateKey = <contenido de client_priv.key>

[Peer]
PublicKey = <contenido de server_pub.key>
AllowedIPs = 10.66.66.1/32
Endpoint = 192.168.88.160:51820

Reemplazar con las claves reales

[Interface]
Address = 10.66.66.2/32
PrivateKey = sAvZnwh/8xrLLNTxBu75UfvUPB/AhFQTJsUGqYTfUU0=

[Peer]
PublicKey = UYbDhuNsq0geqWdsVKXhSnNLzdc2oHWgUT8Zb0G3VXU=
AllowedIPs = 10.66.66.1/32
Endpoint = 192.168.88.160:51820
###########################################

sysrc wireguard_interfaces="wg0"
sysrc wireguard_enable="YES"
service wireguard start

Levantar interfaz wg0

# wg-quick up wg0
[#] ifconfig wg create name wg0
[#] wg setconf wg0 /dev/stdin
[#] ifconfig wg0 inet 10.66.66.2/32 alias
[#] ifconfig wg0 mtu 1420
[#] ifconfig wg0 up
[#] route -q -n add -inet 10.66.66.1/32 -interface wg0
[+] Backgrounding route monitor

Comprobar wg show debería mostrar el peer conectado.

wg show
interface: wg0
  public key: tuu6a6EAPrPTC0tPatWJx2qcS6fEPcg4Z0u/8vY1pTs=
  listening port: 26481

peer: UYbDhuNsq0geqWdsVKThSnNLzdc2oHWgUT8Gb0G3VXU=
  endpoint: 192.168.88.160:51820
  allowed ips: 10.66.66.1/32
  

Reglas cortafuegos PF (tormenta)

# Regla PF Wireguard antes Anti-spoofing + bogons - permite solo desde el cliente
pass in quick on $lan_if proto udp from 192.168.88.51 to 192.168.88.160 port 51820 keep state
# permite todo dentro del tunel
pass in quick on wg0 keep state # <-- esta es la importante <-p>

Recargar PF

service pf reload 
pfctl -f /etc/pf.conf

Verificar ping, desde el cliente solaris

root@solaris:~# ping 10.66.66.1
PING 10.66.66.1 (10.66.66.1): 56 data bytes
64 bytes from 10.66.66.1: icmp_seq=0 ttl=64 time=0.463 ms
64 bytes from 10.66.66.1: icmp_seq=1 ttl=64 time=0.524 ms

--- 10.66.66.1 ping statistics ---
2 packets transmitted, 2 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 0.463/0.494/0.524/0.031 ms

Verificar ping, desde el servidor tormenta

root@tormenta:~# ping -c2 10.66.66.2
PING 10.66.66.2 (10.66.66.2): 56 data bytes
64 bytes from 10.66.66.2: icmp_seq=0 ttl=64 time=0.429 ms
64 bytes from 10.66.66.2: icmp_seq=1 ttl=64 time=0.526 ms

--- 10.66.66.2 ping statistics ---
2 packets transmitted, 2 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 0.429/0.478/0.526/0.049 ms

ping bidireccional exitoso.

Configurar el cortafuegos PF en el servidor (tormenta)

Para permitir el tráfico WireGuard (UDP puerto 51820), agregar reglas a /etc/pf.conf. Asume que ya tienes PF configurado.

pass in quick on re0 proto udp from 192.168.88.51 to 192.168.88.160 port 51820 keep state

Recargar PF

service pf reload
pfctl -p /etc/pf.conf

Configurar NFSv4 para que solo escuche en la IP del túnel

En el servidor (tormenta), asegurar NFSv4 puro en /etc/rc.conf

nsf_server_enable="YES"
nfsv4_server_enable="YES"
nfs_server_flags="-h 10.66.66.1" # Bind sólo a la IP del túnel
nfsuserd_enable="YES" # necesario si se usa dominio

Iniciar servicios

service nfsd start
service nfsuserd start

Es es para que nfsd sólo escuche en 10.66.66.1, (no en 192.168.88.160).

Deshabilitar rpcbind_enable y mountd_enable, no son necesarios para NFSv4 puro.

Realizar los cambios en /etc/exports para restringir accesos sólo al cliente del túnel
(cambiar de red a host -network a -host).

############################################
V4: /nfsv4
/nfsv4/dellhome -maproot=root 10.66.66.2
/nfsv4/poolrecovery -maproot=root 10.66.66.2
/nfsv4/docs -maproot=root 10.66.66.2
/nfsv4/confsolaris -maproot=root 10.66.66.2
/nfsv4/conftormenta -maproot=root 10.66.66.2
############################################

Esto permite solo desde 10.66.66.2 (el cliente vía túnel).

Reiniciar NFS y nfsuserd

service nfsd restart
service nfsuserd restart

Montar NFS en el cliente (solaris) a través del tŕunel

En el cliente montar usando la IP del túnel del servidor, por ejemplo:

mount -t nfs -o nfsv4 10.66.66.1:/docs /mnt/docs

Para montajes persistentes, se utiliza /etc/fstab

10.66.66.1:/poolrecovery     /nisc4    nfs     rw,nfsv4,noatime,bg    0  	0
10.66.66.1:/confsolaris      /nics4    nfs     rw,nfsv4,noatime,bg	  0  	0
10.66.66.1:/conftormenta     /nits4    nfs     rw,nfsv4,noatime,bg	  0  	0
10.66.66.1:/docs             /nids4    nfs     rw,nfsv4,noatime,bg    0  	0
10.66.66.1:/dellhome 	     /nihs4    nfs     ro,nfsv4,noatime,bg	  0  	0

Consideraciones adicionales

Asi queda el archivo /etc/rc.conf (solaris)

$ gsed -e '/^#/d' -e '/^\s*$/d'

syslogd_flags="-ss"
clear_tmp_enable="YES"
hostname="solaris.local.com"
gateway_enable="NO"
ifconfig_em0="inet 192.168.88.51 netmask 255.255.255.0"
defaultrouter="192.168.88.1"
background_dhclient=YES
defaultroute_delay=3
defaultroute_carrier_delay=3
sshd_enable="NO"
ntpd_enable="YES"
ntpd_sync_on_start="YES"
powerd_enable="YES"
powerd_flags="-n hadp"
loader_conf_files="/boot/loader.conf /boot/loader.conf.local"
boot_efi_enable="YES"
webcamd_enable="YES"
moused_port=/dev/ums0
moused_enable="YES"
dumpdev="NO"
zfs_enable="YES"
dbus_enable="YES"
kld_list="i915kms"
nfs_client_enable="YES"
nfsuserd_enable="YES"
nfsv4_client_enable="YES"
nfsv4_domain="local.com"
tlsclntd_enable="NO"
hostid_enable="YES"
hostid_file="/etc/hostid"
autofs_enable="YES"
devd_enable="YES"
devfs_system_ruleset="system"
pf_enable="NO"
pf_rules="/etc/pf.conf"
pflog_enable="YES"
pflog_logfile="/var/log/pflog"
pflog_flags=""
wireguard_enable="YES"
wireguard_interface="wg0"
sendmail_enable="NO"
sendmail_submit_enable="NO"
sendmail_outbound_enable="NO"
sendmail_msp_queue_enable="NO"
lightdm_enable="YES"
zerotier_enable="YES"
vm_dir="zfs:zroot/vm"
vm_list=""
vm_delay="3"
poudriered_enable="YES"
nginx_enable="YES"
memcached_enable="YES"
memcached_flags="-l localhost -m 8192"
jackett_enable="YES"
linux_enable="NO"
ubuntu_enable="YES"

Asi queda /etc/pf.conf

lan_if   = "re0"
lan_net  = "192.168.88.0/24"
lan_ip   = "192.168.88.160"  
ssh_port     = "{ 22 }"
vpn_if="wg0"

set block-policy return         # responde ICMP/TCP-RST a paquetes bloqueados
set ruleset-optimization none   # en FreeBSD 14 no usa "basic" ni "high-latency"
set skip on lo0

match in all scrub (no-df random-id max-mss 1440)
table <bruteforce> persist       # aquí meterá sshguard, pf-badhost, etc.

pass in quick on $lan_if from $lan_net to $lan_ip keep state
pass in quick on $lan_if proto udp from 192.168.88.51 to 192.168.88.160 port 51820 keep state
pass in quick on wg0 keep state # <-- esta es la importante

block in quick on ! $lan_if from $lan_net to any
block in quick on ! $lan_if from 192.168.0.0/16 to any
block in quick on ! $lan_if from 172.16.0.0/12 to any
block in quick on ! $lan_if from 10.0.0.0/8 to any
block in quick from any to { 127.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12, 10.0.0.0/8, ::/128, 0.0.0.0/8 }
block in quick from <bruteforce>

pass quick on lo0all
pass out quick inet keep state
pass in on $lan_if inet proto icmp from $lan_net to $lan_ip icmp-type echoreq keep state
pass out on $lan_if inet proto icmp from $lan_ip to $lan_net icmp-type echorep keep state
pass in on $lan_if proto tcp from $lan_net to $lan_ip port $ssh_port flags S/SFRA keep state
pass quick on $lan_if proto { tcp udp } from $lan_net to $lan_ip port 53
pass out proto udp from any to port 123 keep state
block log all

Asi queda /etc/exports

$ gsed -e '/^#/d' -e '/^\s*$/d' /etc/exports
V4: /nfsv4
/nfsv4/dellhome		-maproot=root 10.66.66.2
/nfsv4/poolrecovery 	-maproot=root 10.66.66.2
/nfsv4/docs 		-maproot=root 10.66.66.2
/nfsv4/confsolaris 	-maproot=root 10.66.66.2
/nfsv4/conftormenta 	-maproot=root 10.66.66.2

Commprobaciones finales En el servidor tormenta no debe aparecer rpcbind ni statd

root@tormenta:/etc # ps aux | grep -E "(statd|rpcbind|nfs)"
root    1192   0.0  0.0 14140  2380  -  Is   09:34      0:00.00 nfsuserd: master (nfsuserd)
root    1194   0.0  0.0 14140  2384  -  I    09:34      0:00.02 nfsuserd: server (nfsuserd)
root    1195   0.0  0.0 14140  2384  -  S    09:34      0:00.02 nfsuserd: server (nfsuserd)
root    1196   0.0  0.0 14140  2380  -  I    09:34      0:00.00 nfsuserd: server (nfsuserd)
root    1197   0.0  0.0 14140  2384  -  I    09:34      0:00.01 nfsuserd: server (nfsuserd)
root    2398   0.0  0.0 13756  2472  -  Ss   12:23      0:00.01 nfsd: master (nfsd)
root    2399   0.0  0.0 13756  2756  -  S    12:23      0:00.08 nfsd: server (nfsd)

En el cliente solaris remontar directorios

root@solaris:~# umount /nisc4 /nics4 /nits4 /nids4 /nihs4
root@solaris:~# mount -a

root@solaris:~# mount | grep 10.66.66.1
10.66.66.1:/poolrecovery on /nisc4 (nfs, noatime, nfsv4acls)
10.66.66.1:/confsolaris on /nics4 (nfs, noatime, nfsv4acls)
10.66.66.1:/conftormenta on /nits4 (nfs, noatime, nfsv4acls)
10.66.66.1:/docs on /nids4 (nfs, noatime, nfsv4acls)

NFSv4 puro, solo puerto 2049 a través del túnel WireGuard, sin dependencias de rpcbind ni demonios extra.

FreeBSD es genial!.