
NAT Tunnel: per servire facilmente da dietro NAT
NOTA: la vecchia versione Python è definitiva e non più mantenuta. Le istruzioni per essa si trovano alla fine di questo file. È incompatibile con l'attuale versione C. Usare solo la versione C.
Se hai accesso a un server con IP pubblico e porte non filtrate puoi eseguire il server NAT Tunnel (NT) sul server, e il client NT sulla tua macchina dietro NAT. Il server richiede 2 porte aperte: una per la comunicazione con il client NT (--admin), l'altra per la connessione dei client regolari (--public: questa è la porta che vuoi che i tuoi utenti utilizzino).
Il client NT apre una connessione verso l'ip/porta admin del server. Non appena il server riceve una nuova connessione, segnala al client NT, che crea quindi una nuova connessione tunnel verso il server, che viene poi collegata al servizio desiderato sul lato del client NT (--local)
La connessione tra NT Client e NT Server sull'interfaccia admin è protetta da un segreto condiviso contro l'uso non autorizzato. Un avversario in grado di intercettare i pacchetti potrebbe decifrare il segreto se non è sufficientemente complesso. Si raccomandano almeno 10 caratteri casuali e numeri.
Esempio: Hai un server HTTP in ascolto sulla tua macchina locale sulla porta 80. Vuoi renderlo disponibile sull'IP pubblico del tuo cloud server/VPS/ecc. sulla porta 8000. Usiamo la porta 7000 sul cloud server per il canale di controllo.
Server:
./natsrv --mode server --secret-file secret.txt --server-key server.key --public 0.0.0.0:8000 --admin 0.0.0.0:7000
Client:
./natsrv --mode client --secret-file secret.txt --server-pubkey PUBKEY_HEX --local localhost:80 --admin example.com:7000
Sia IPv4 che IPv6 funzionano ovunque. La sintassi degli indirizzi è host:porta. Per i letterali IPv6 usare le parentesi quadre: [::1]:8080, [2001:db8::1]:7000. Un indirizzo IPv6 nudo senza parentesi quadre viene rifiutato, poiché i due punti rendono ambigua la porta. Per i nomi host IPv4 è preferito e IPv6 è il fallback; un letterale numerico esplicito prevale sempre per la propria famiglia. L'indirizzo di ascolto 0.0.0.0 significa IPv4 su tutte le interfacce, :: significa IPv6 su tutte le interfacce. Sul filo il server riporta un peer come ip:porta per IPv4 e [ip]:porta per IPv6, ed entrambi i lati analizzano entrambe le forme.
Genera una volta la chiave di firma del server:
./natsrv --genkey server.key
Questo scrive la chiave privata con permessi 0600 e stampa la chiave pubblica in esadecimale. Fornisci quella stringa esadecimale al client come --server-pubkey. Il server richiede --server-key, il client richiede --server-pubkey. Preferisci --secret-file PATH a --secret su macchine condivise, poiché --secret è visibile tramite ps aux.
Compila con GNU Make semplice (3.82 o successivo):
make
Questo produce ./natsrv. Il Makefile inizia con -include config.mak prima del primo target, così un config.mak locale può impostare permanentemente CFLAGS, CPPDFGS, LDFLAGS, e simili. Il Makefile aggiunge i propri valori predefiniti con CFLAGS += -Wall -std=c99. Anche le opzioni sulla riga di comando di Make vengono passate:
make CPPFLAGS=-DHAVE_GETRANDOM
make CFLAGS="-Wall -Wextra -std=c99 -pedantic"
make USE_SODIUM=1
make clean
HAVE_GETRANDOM: per impostazione predefinita la casualità proviene da /dev/urandom. Definisci HAVE_GETRANDOM per usare invece la syscall getrandom() (Linux 3.17+ / glibc 2.25+). Entrambi i percorsi falliscono in modo sicuro. Il linking è -lpthread per impostazione predefinita, più -lsodium con USE_SODIUM=1. Il codice stesso è C99 e portabile senza estensioni GNU99. Per l'indentazione si usano tab, seguendo lo stile di codice di microsocks.
La cifratura del tunnel usa XSalsa20. Per impostazione predefinita è fornita dal codice TweetNaCl incluso (tweetnacl.c, tweetnacl.h). Con USE_SODIUM=1 si collega invece libsodium. Il codice sha256 in sha256.c è scritto da zero; nessuna libreria crittografica è necessaria per la build predefinita.
Su x86 con estensioni Intel SHA, sha256.c usa automaticamente gli intrinsics SHA-NI quando il compilatore definisce SHA e SSSE3. L'implementazione scalare rimane il fallback. Abilitala senza -march=native:
make CPPFLAGS="-msha -msse4.1"
Questo costruisce un binario che richiede qualsiasi CPU x86 con supporto SHA-NI e SSE4.1, senza altre funzionalità di -march=native. Un semplice make senza quei flag funziona comunque ovunque.
Misurato su un i7-1160G7, SHA256 grezzo di blocchi da 16 KiB: scalar -O2 è circa 257 MB/s, SHA-NI -O2 è circa 1574 MB/s (circa 6 volte più veloce).
I socket del tunnel hanno timeout di invio e ricezione, impostati con --timeout SECS (predefinito 1800, 0 li disabilita). Il valore predefinito è deliberatamente conservativo: un server lento come llama.cpp sotto i 10 token al secondo, o il caricamento di un enorme system prompt, può legittimamente bloccarsi per molti minuti. Valori più brevi uccidono tali tunnel; valori più lunghi ritardano il rilevamento di socket morti. I socket di controllo non ricevono mai il timeout, quindi una connessione di controllo inattiva non viene terminata.
Tutti i socket usano TCP keepalive con probe ogni 30 secondi di inattività (intervallo di 5 secondi, 3 probe), così un peer silenziosamente morto viene rilevato in circa 45 secondi invece che con il valore predefinito di 2 ore.
Il client e il server eseguono entrambi un ciclo di poll. Nessuna delle due estremità si blocca in accept. Il client fa polling del socket di controllo e del socket di riserva insieme, e riarma la riserva quando la riserva mostra dati, un errore, o fallisce il controllo di morte ogni 5 secondi. Il server fa polling del listener admin, del listener pubblico, del socket di controllo e del socket di riserva insieme. Di conseguenza, il server serve la porta pubblica mentre non ha una riserva, e non smette mai di sorvegliare il socket di controllo.
Una connessione pubblica che arriva mentre non esiste una riserva viva viene reimpostata immediatamente. Il peer vede un fallimento, non un blocco. Una riserva che mostra già FIN o RST viene scartata e riarmata prima di essere accoppiata, così una riserva morta non raggiunge mai un tunnel. I soli dati leggibili non sono trattati come morte su una riserva che sta per essere accoppiata, poiché i byte del tunnel possono legittimamente essere in transito.
Esegui l'intera suite con:
make test
Questo richiede python3 e compila prima natsrv. La suite avvia processi server e client reali su porte di loopback. Ogni test ottiene le proprie porte, directory di lavoro e log, così un fallimento non si propaga mai al test successivo.
I test possono essere selezionati per nome, ed elencati:
python3 tests/natt.py --list
python3 tests/natt.py spare_rst control_rst
L'iniezione di guasti usa un proxy TCP davanti alla porta admin (tests/natt.py, classe FaultProxy). Ogni connessione accettata riceve un id in ordine di accept e un ruolo letto dal suo client hello, così il socket di controllo e il socket di riserva vengono distinti. Un test può eliminarne uno con RST, eliminarlo con FIN, o congelarlo, cioè smettere di inoltrare byte mentre entrambi i socket restano aperti. Un congelamento sul socket di controllo modella un percorso silenziosamente morto. Il kernel del peer continua a rispondere ai probe keepalive sul loopback, quindi il test control_blackhole elimina i pacchetti con iptables. Quel test richiede root e viene saltato altrimenti.
I test lenti rilevano un blackhole tramite TCP keepalive, che richiede circa 45 secondi. Vengono eseguiti solo su richiesta:
make test-slow
Scopri gli strumenti più utilizzati dalla nostra community.
Nessun dato di popolarità ancora.