
NAT Tunnel: para servir sem esforço por trás do NAT
NOTA: A versão antiga em Python está finalizada e sem manutenção. As instruções para ela estão no final deste arquivo. Ela é incompatível com a versão atual em C. Use apenas a versão em C.
Se você tem acesso a um servidor com IP público e portas sem filtragem, você pode executar o servidor NAT Tunnel (NT) no servidor e o cliente NT na sua máquina atrás de NAT. O servidor requer 2 portas abertas: uma para comunicação com o cliente NT (--admin), a outra para clientes regulares se conectarem (--public: esta é a porta que você quer que seus usuários usem).
O cliente NT abre uma conexão com o ip/porta admin do servidor. Assim que o servidor recebe uma nova conexão, ele sinaliza o cliente NT, que então cria uma nova conexão de túnel com o servidor, que por sua vez é conectada ao serviço desejado do lado do cliente NT (--local)
A conexão entre o Cliente NT e o Servidor NT na interface admin é protegida por um segredo compartilhado contra uso não autorizado. Um adversário que consiga interceptar pacotes poderia quebrar o segredo se ele não tiver complexidade suficiente. Recomenda-se pelo menos 10 caracteres aleatórios e números.
Exemplo: Você tem um servidor HTTP escutando na sua máquina local na porta 80. Você quer disponibilizá-lo no IP público do seu servidor na nuvem/VPS/etc na porta 8000. Usamos a porta 7000 no servidor na nuvem para o canal de controle.
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 quanto IPv6 funcionam em todos os lugares. A sintaxe de endereço é host:porta. Para literais IPv6 use colchetes: [::1]:8080, [2001:db8::1]:7000. Um endereço IPv6 sem colchetes é rejeitado, pois os dois-pontos tornam a porta ambígua. Para nomes de host, IPv4 é preferido e IPv6 é o fallback; um literal numérico explícito sempre prevalece para sua própria família. O endereço de escuta 0.0.0.0 significa IPv4 em todas as interfaces, :: significa IPv6 em todas as interfaces. No protocolo, o servidor reporta um par como ip:porta para IPv4 e [ip]:porta para IPv6, e ambos os lados interpretam ambas as formas.
Gere a chave de assinatura do servidor uma vez:
./natsrv --genkey server.key
Isso grava a chave privada com permissões 0600 e imprime a chave pública em hexadecimal. Passe essa string hexadecimal ao cliente como --server-pubkey. O servidor requer --server-key, o cliente requer --server-pubkey. Prefira --secret-file PATH em vez de --secret em máquinas compartilhadas, pois --secret vaza via ps aux.
Compile com GNU Make simples (3.82 ou mais recente):
make
Isso produz ./natsrv. O Makefile começa com -include config.mak antes do primeiro alvo, então um config.mak local pode definir permanentemente CFLAGS, CPPDFGS, LDFLAGS, e afins. O Makefile acrescenta seus próprios padrões com CFLAGS += -Wall -std=c99. Opções na linha de comando do Make também são repassadas:
make CPPFLAGS=-DHAVE_GETRANDOM
make CFLAGS="-Wall -Wextra -std=c99 -pedantic"
make USE_SODIUM=1
make clean
HAVE_GETRANDOM: por padrão a aleatoriedade vem de /dev/urandom. Defina HAVE_GETRANDOM para usar a syscall getrandom() em vez disso (Linux 3.17+ / glibc 2.25+). Ambos os caminhos falham de forma segura. A vinculação é -lpthread por padrão, mais -lsodium com USE_SODIUM=1. O código em si é C99 e portável, sem extensões GNU99. Tabs são usados para indentação, seguindo o estilo de código do microsocks.
A criptografia do túnel usa XSalsa20. Por padrão ela é fornecida pelo código TweetNaCl incluído (tweetnacl.c, tweetnacl.h). Com USE_SODIUM=1 ele vincula libsodium em vez disso. O código sha256 em sha256.c é escrito do zero; nenhuma biblioteca de criptografia é necessária para a compilação padrão.
Em x86 com extensões Intel SHA, sha256.c usa os intrínsecos SHA-NI automaticamente quando o compilador define SHA e SSSE3. A implementação escalar permanece como fallback. Habilite-a sem -march=native:
make CPPFLAGS="-msha -msse4.1"
Isso compila um binário que precisa de qualquer CPU x86 com suporte a SHA-NI e SSE4.1, sem outras funcionalidades de -march=native. O make simples sem essas flags ainda funciona em qualquer lugar.
Medido em um i7-1160G7, SHA256 bruto de blocos de 16 KiB: scalar -O2 é cerca de 257 MB/s, SHA-NI -O2 é cerca de 1574 MB/s (cerca de 6 vezes mais rápido).
Os sockets de túnel têm timeouts de envio e recebimento, definidos com --timeout SECS (padrão 1800, 0 os desabilita). O padrão é deliberadamente conservador: um servidor lento como o llama.cpp abaixo de 10 tokens por segundo, ou um upload enorme de prompt de sistema, pode legitimamente bloquear por muitos minutos. Valores menores matam tais túneis; valores maiores atrasam a detecção de sockets mortos. Sockets de controle nunca recebem o timeout, então uma conexão de controle ociosa não é morta.
Todos os sockets usam TCP keepalive com sondagens a cada 30 segundos de tempo ocioso (intervalo de 5 segundos, 3 sondagens), então um par silenciosamente morto é detectado em cerca de 45 segundos em vez do padrão de 2 horas.
O cliente e o servidor executam um loop de poll. Nenhuma extremidade bloqueia em accept. O cliente faz poll do socket de controle e do socket reserva juntos, e ele rearma o reserva quando o reserva mostra dados, um erro, ou falha na verificação de morte a cada 5 segundos. O servidor faz poll do listener de admin, do listener público, do socket de controle e do socket reserva juntos. Como resultado, o servidor atende a porta pública enquanto não tem reserva, e nunca para de observar o socket de controle.
Uma conexão pública que chega enquanto nenhum reserva vivo existe é resetada imediatamente. O par vê uma falha, não um travamento. Um reserva que já mostra FIN ou RST é descartado e rearmado antes de ser emparelhado, então um reserva morto nunca chega a um túnel. Dados legíveis sozinhos não são tratados como morte em um reserva que está prestes a ser emparelhado, já que bytes de túnel podem legitimamente estar em trânsito.
Execute toda a suíte com:
make test
Isso precisa de python3 e compila natsrv primeiro. A suíte inicia processos reais de servidor e cliente em portas de loopback. Cada teste recebe suas próprias portas, diretório de trabalho e logs, então uma falha nunca vaza para o próximo teste.
Os testes podem ser selecionados por nome, e listados:
python3 tests/natt.py --list
python3 tests/natt.py spare_rst control_rst
A injeção de falhas usa um proxy TCP na frente da porta de admin (tests/natt.py, classe FaultProxy). Cada conexão aceita recebe um id na ordem de accept e um papel lido do seu client hello, então o socket de controle e o socket reserva são distinguidos. Um teste pode derrubar um com RST, derrubá-lo com FIN, ou congelá-lo, ou seja, parar de encaminhar bytes enquanto ambos os sockets permanecem abertos. Um congelamento no socket de controle modela um caminho silenciosamente morto. O kernel do par continua respondendo a sondagens keepalive no loopback, então o teste control_blackhole descarta os pacotes com iptables. Esse teste precisa de root e é ignorado caso contrário.
Testes lentos detectam um blackhole através do TCP keepalive, o que leva cerca de 45 segundos. Eles só são executados sob solicitação:
make test-slow
Toda a saída do console vai para stderr, através de uma única chamada dprintf() por linha (macro dolog, portada do microsocks sockssrv.c). stderr não é line buffered, e dprintf escreve diretamente no fd. Nenhum dos dois precisa de um lock de stdio, então dolog é seguro de qualquer thread e nenhum fflush é necessário após uma linha. Direcione o log com 2> file.
Descubra as ferramentas mais usadas pela nossa comunidade.
Sem dados de popularidade ainda.