
NAT Tunnel: para servir sin esfuerzo desde detrás de NAT
NOTA: La versión antigua en Python es definitiva y no tiene mantenimiento. Las instrucciones para ella están al final de este archivo. Es incompatible con la versión actual en C. Use solo C.
Si tiene acceso a un servidor con IP pública y puertos sin filtrar, puede ejecutar el servidor NAT Tunnel (NT) en el servidor y el cliente NT en su equipo detrás de NAT. El servidor requiere 2 puertos abiertos: uno para la comunicación con el cliente NT (--admin), el otro para que los clientes habituales se conecten (--public: este es el puerto que desea que usen sus usuarios).
El cliente NT abre una conexión con la ip/puerto de administración del servidor. Tan pronto como el servidor recibe una nueva conexión, avisa al cliente NT, que entonces crea una nueva conexión de túnel hacia el servidor, la cual se conecta después al servicio deseado en el lado del cliente NT (--local)
La conexión entre el cliente NT y el servidor NT en la interfaz de administración está protegida mediante un secreto compartido contra el uso no autorizado. Un adversario que pueda interceptar paquetes podría descifrar el secreto si este no tiene la complejidad suficiente. Se recomiendan al menos 10 caracteres aleatorios y números.
Ejemplo: Tiene un servidor HTTP escuchando en su máquina local en el puerto 80. Desea hacerlo disponible en la IP pública de su servidor en la nube/VPS/etc. en el puerto 8000. Usamos el puerto 7000 en el servidor en la nube para el canal de control.
Servidor:
./natsrv --mode server --secret-file secret.txt --server-key server.key --public 0.0.0.0:8000 --admin 0.0.0.0:7000
Cliente:
./natsrv --mode client --secret-file secret.txt --server-pubkey PUBKEY_HEX --local localhost:80 --admin example.com:7000
Tanto IPv4 como IPv6 funcionan en todas partes. La sintaxis de dirección es host:port. Para literales IPv6 use corchetes: [::1]:8080, [2001:db8::1]:7000. Una dirección IPv6 sin corchetes se rechaza, ya que los dos puntos hacen ambiguo el puerto. Para nombres de host se prefiere IPv4 y IPv6 es la alternativa; un literal numérico explícito siempre prevalece para su propia familia. La dirección de escucha 0.0.0.0 significa IPv4 en todas las interfaces, :: significa IPv6 en todas las interfaces. En el cable, el servidor informa de un par como ip:port para IPv4 y [ip]:port para IPv6, y ambos lados analizan ambas formas.
Genere la clave de firma del servidor una vez:
./natsrv --genkey server.key
Esto escribe la clave privada con permisos 0600 e imprime la clave pública en hexadecimal. Proporcione esa cadena hexadecimal al cliente como --server-pubkey. El servidor requiere --server-key, el cliente requiere --server-pubkey. Prefiera --secret-file PATH en lugar de --secret en equipos compartidos, ya que --secret se filtra a través de ps aux.
Compile con GNU Make simple (3.82 o posterior):
make
Esto produce ./natsrv. El Makefile comienza con -include config.mak antes del primer objetivo, por lo que un config.mak local puede establecer permanentemente CFLAGS, CPPDFGS, LDFLAGS, y similares. El Makefile añade sus propios valores predeterminados con CFLAGS += -Wall -std=c99. Las opciones en la línea de comandos de Make también se pasan:
make CPPFLAGS=-DHAVE_GETRANDOM
make CFLAGS="-Wall -Wextra -std=c99 -pedantic"
make USE_SODIUM=1
make clean
HAVE_GETRANDOM: de forma predeterminada, la aleatoriedad proviene de /dev/urandom. Defina HAVE_GETRANDOM para usar en su lugar la llamada al sistema getrandom() (Linux 3.17+ / glibc 2.25+). Ambas rutas fallan de forma segura. El enlazado es -lpthread de forma predeterminada, más -lsodium con USE_SODIUM=1. El código en sí es C99 y portable sin extensiones GNU99. Se usan tabulaciones para la indentación, siguiendo el estilo de código de microsocks.
El cifrado del túnel usa XSalsa20. De forma predeterminada lo proporciona el código TweetNaCl incluido (tweetnacl.c, tweetnacl.h). Con USE_SODIUM=1 se enlaza libsodium en su lugar. El código sha256 en sha256.c está escrito desde cero; no se necesita ninguna biblioteca criptográfica para la compilación predeterminada.
En x86 con extensiones Intel SHA, sha256.c usa los intrínsecos SHA-NI automáticamente cuando el compilador define SHA y SSSE3. La implementación escalar sigue siendo la alternativa. Actívela sin -march=native:
make CPPFLAGS="-msha -msse4.1"
Eso compila un binario que necesita cualquier CPU x86 con soporte de SHA-NI y SSE4.1, sin otras características de -march=native. Un make simple sin esos flags sigue funcionando en todas partes.
Medido en un i7-1160G7, SHA256 en bruto de bloques de 16 KiB: scalar -O2 es de unos 257 MB/s, SHA-NI -O2 es de unos 1574 MB/s (unas 6 veces más rápido).
Los sockets de túnel tienen tiempos de espera de envío y recepción, establecidos con --timeout SECS (por defecto 1800, 0 los desactiva). El valor por defecto es deliberadamente conservador: un servidor lento como llama.cpp por debajo de 10 tokens por segundo, o una carga enorme de prompt de sistema, puede bloquear legítimamente durante muchos minutos. Valores más cortos matan dichos túneles; valores más largos retrasan la detección de sockets muertos. Los sockets de control nunca reciben el tiempo de espera, por lo que una conexión de control inactiva no se mata.
Todos los sockets usan TCP keepalive con sondeos cada 30 segundos de inactividad (intervalo de 5 segundos, 3 sondeos), por lo que un par silenciosamente muerto se detecta en unos 45 segundos en lugar del valor predeterminado de 2 horas.
El cliente y el servidor ejecutan ambos un bucle de poll. Ninguno de los dos extremos se bloquea en accept. El cliente sondea el socket de control y el socket de repuesto juntos, y vuelve a armar el repuesto cuando el repuesto muestra datos, un error, o falla la comprobación de muerte cada 5 segundos. El servidor sondea el listener de administración, el listener público, el socket de control y el socket de repuesto juntos. Como resultado, el servidor atiende el puerto público mientras no tiene repuesto, y nunca deja de vigilar el socket de control.
Una conexión pública que llega cuando no existe ningún repuesto vivo se reinicia de inmediato. El par ve un fallo, no un cuelgue. Un repuesto que ya muestra FIN o RST se descarta y se vuelve a armar antes de emparejarse, por lo que un repuesto muerto nunca llega a un túnel. Los datos legibles por sí solos no se tratan como muerte en un repuesto que está a punto de emparejarse, ya que los bytes del túnel pueden legítimamente estar en tránsito.
Ejecuta toda la suite con:
make test
Esto necesita python3 y compila natsrv primero. La suite inicia procesos reales de servidor y cliente en puertos de loopback. Cada prueba obtiene sus propios puertos, directorio de trabajo y registros, por lo que un fallo nunca se filtra a la siguiente prueba.
Las pruebas se pueden seleccionar por nombre y listar:
python3 tests/natt.py --list
python3 tests/natt.py spare_rst control_rst
La inyección de fallos usa un proxy TCP delante del puerto de administración (tests/natt.py, clase FaultProxy). Cada conexión aceptada obtiene un id en orden de aceptación y un rol leído de su saludo de cliente, por lo que el socket de control y el socket de repuesto se distinguen. Una prueba puede descartar uno con RST, descartarlo con FIN, o congelarlo, es decir, dejar de reenviar bytes mientras ambos sockets permanecen abiertos. Una congelación en el socket de control modela una ruta silenciosamente muerta. El kernel del par sigue respondiendo a los sondeos de keepalive en loopback, por lo que la prueba control_blackhole descarta los paquetes con iptables en su lugar. Esa prueba necesita root y se omite en caso contrario.