Una VPN non è un prodotto. Sono due lavori imbullonati insieme, e la tua macchina ha già un programma per ciascuno.
Il primo lavoro è creare un collegamento virtuale: un’interfaccia che sembra una scheda di rete, prende pacchetti IP e li consegna altrove. Il secondo è portare i byte di quel collegamento da un capo all’altro. Compri un’appliance VPN e compri entrambi i lavori con una licenza pinzata sopra; fallo da te e ognuno è un programma già installato. Su Linux ci sono due modi per fare il primo lavoro, e questo articolo li costruisce tutti e due: pppd, che porta con sé un intero protocollo di collegamento (indirizzi negoziati, un controllo di vitalità, il framing), e un dispositivo tap, che non porta niente ed è un buco nel kernel in cui spingi dei frame. Compromessi diversi, non concorrenti, e la seconda metà li mette fianco a fianco.
Quel protocollo è PPP, e il motivo per cui funziona è scritto nel suo primo paragrafo: PPP è un protocollo di collegamento per link punto-punto1, e non specifica di cosa sia fatto il link. Un modem e una linea telefonica erano la risposta originale. Non sono mai stati l’unica. PPTP ha messo PPP dentro GRE2. L2TP lo ha messo dentro UDP3. PPPoE lo ha messo dentro frame Ethernet. Ognuno di questi è lo stesso protocollo con un corriere diverso, e a nessuno è servito cambiare PPP per farlo.
Quindi la domanda non è se puoi far girare PPP su un socket TCP o UDP, ma su quale, e quanto costa. La risposta breve, con i passaggi mostrati: usa UDP. Far girare un protocollo a flusso dentro un flusso affidabile è l’unico errore qui che sulla scrivania sembra a posto e su un collegamento vero va in pezzi.
Una VPN sono due lavori. Li hai già entrambi.
Togli il marketing da qualsiasi tunnel e succedono tre cose: qualcosa presenta un’interfaccia virtuale e trasforma i pacchetti in un flusso di byte, qualcosa porta quel flusso attraverso una rete che già funziona, e qualcosa lo cifra, oppure niente lo fa.
PPP fa la metà del collegamento come si deve: negoziazione degli indirizzi, un controllo di vitalità, compressione delle intestazioni, più protocolli di livello rete su un solo link, un passo di autenticazione se lo vuoi. Un sacco di lavoro finito che se ne sta in /usr/sbin a non fare niente. Quello che non fa è preoccuparsi del trasporto: dagli un file descriptor che muove byte in entrambe le direzioni e ci gira sopra. Netcat è un programma il cui unico scopo è essere quel file descriptor.
La cifratura è la parte che nessuno ti regala, ed è la parte su cui si spende la maggior parte di questo articolo, perché netcat non ha risposta e far finta del contrario è il modo in cui la gente costruisce cose che non dovrebbe.
Le fasi, e perché vanno in quest’ordine
Tutto quello che segue è costruito per fasi, ognuna aggiunge una cosa a quella prima. Non è un espediente didattico. È così che dovresti costruirlo, perché quando la fase sei si rompe devi sapere se la fase due funziona ancora, e lo sai solo se la fase due è stata, almeno una volta, una cosa che hai fatto girare da sola.
Il collegamento stesso si costruisce allo stesso modo, ed è il ragionamento dietro la rampa di un secondo più avanti: un tunnel parte raw, dimostra di saper portare un frame, e solo dopo diventa furbo. Una costruzione che accende tutto insieme si rompe come un blocco unico, e passi la serata a indovinare quale strato è stato.
Quello che pppd vuole davvero è un file descriptor
pppd è stato scritto per le porte seriali, quindi la lettura ingenua è che gliene serva una. Non è così. Gli serve un dispositivo terminale, e se ne crea uno da solo:
pty script — Specifies that the command
scriptis to be used to communicate rather than a specific terminal device. Pppd will allocate itself a pseudo-tty master/slave pair and use the slave as its terminal device. The script will be run in a child process with the pseudo-tty master as its standard input and output.4
Rileggilo: c’è dentro tutta la costruzione. pppd crea uno pseudo-terminale, tiene lo slave e passa il master a un comando come stdin e stdout. Cosa fa quel comando con i byte non è affare di pppd. Fai girare lì nc e finiscono in un socket.
pty eredita il lato master come stdin e stdout. Netcat copia lo stdin in un socket e il socket nello stdout, così le due istanze di pppd parlano tra loro attraverso la coppia pty e la rete senza che nessuna delle due sappia che esiste un socket.C’è una seconda strada, notty, che usa invece lo stdin e lo stdout di pppd stesso. Ma avvia un processo di smistamento dei caratteri da cui passa ogni byte, quindi «increases the latency and CPU overhead»4. Usa pty, a meno che tu non abbia un motivo per non farlo.
Tre fatti pratici prima del primo comando, tutti verificati sulla macchina su cui è stato scritto questo articolo, Fedora 44, ppp-2.5.1-7.fc44:
$ pppd --version
pppd version 2.5.1
$ ls -l /usr/bin/pppd /dev/ppp
-rwxr-xr-x. 1 root root 393784 Jan 17 2026 /usr/bin/pppd
crw-------. 1 root root 108, 0 Sep 14 08:34 /dev/ppp
$ pppd noauth nodetach pty 'true'
pppd: using the noauth option requires root privilege
Serve root. Non c’è modo di evitarlo. Su Fedora il binario non è setuid, /dev/ppp ha modo 0600 ed è di root, e comunque le opzioni che ti servono sono privilegiate. È una cosa che fai girare come root o sotto un file unit, non qualcosa che un utente fa così, per caso. Questo conta più avanti, quando arriviamo a cosa significa per la tua politica di egress.
Il lato kernel è modulare. ppp_generic fa l’interfaccia, ppp_async il framing con byte-stuffing che serve a una pty, e ppp_deflate/bsd_comp/ppp_mppe la compressione e la cifratura; si caricano su richiesta. Se ppp_async manca da un’immagine container ridotta all’osso, il collegamento sale e non porta niente: una mezz’ora pessima se non sai dove guardare.
Le linee di controllo del modem non esistono su una pty. Senza un pin di carrier-detect, pppd aspetta una portante che non arriva mai. Il rimedio è una parola, local, che gli dice di ignorare le linee di controllo del modem4. Lasciala fuori e non succede niente, senza un errore che valga la pena leggere.
Netcat non è un programma solo
Prima della costruzione, la trappola che mangia più tempo: «netcat» sono almeno quattro programmi con opzioni incompatibili, e quale ti tocca dipende dalla distribuzione. Su questa macchina /usr/bin/nc è un link simbolico a /usr/bin/ncat, la riscrittura di Nmap. Quindi un comando copiato da una pagina wiki di quindici anni fa fallisce per motivi che con PPP non c’entrano niente.
| Implementazione | In ascolto su una porta | UDP | Resta su dopo che il peer si disconnette |
|---|---|---|---|
| Ncat (Nmap) | ncat -l 443 | -u | -k / --keep-open |
| netcat di OpenBSD | nc -l 443 | -u | -k |
| netcat tradizionale | nc -l -p 443 | -u | no |
| GNU netcat | nc -l -p 443 | -u | no |
Per questo, controlla quale hai prima di dare la colpa a pppd:
readlink -f "$(command -v nc)"
nc --version 2>&1 | head -1 || nc -h 2>&1 | head -1
Qui sotto userò ncat in modo esplicito. È quello con TLS integrato, il che conta più avanti, ed essere espliciti vuol dire che i comandi non significano in silenzio qualcos’altro sulla tua macchina.
Fase uno: la costruzione su TCP, perché è quella che provano tutti per prima
Un capo ascolta, l’altro si connette. Gli indirizzi qui sono dell’intervallo per la documentazione, quindi incollali dritti in un laboratorio e niente di instradabile si fa male. La porta è la 443 dall’inizio alla fine, ed è voluto: la 443 in uscita è aperta di default su quasi ogni rete. Avvolgi il trasporto in TLS qualche fase più giù e il traffico che ci passa sopra non si distingue da una qualsiasi sessione HTTPS. Mettere un listener lì richiede root, che il capo lontano (la macchina dell’attaccante, o un relay) ha. È tutto l’argomento dell’egress in un numero di porta, e ci tornerò.
Sul capo in ascolto:
pppd nodetach noauth local passive \
nodefaultroute noipdefault \
192.0.2.1:192.0.2.2 \
lcp-echo-interval 10 lcp-echo-failure 3 \
mtu 1400 mru 1400 \
pty 'ncat --listen --keep-open 443'
Sul capo che si connette:
pppd nodetach noauth local \
nodefaultroute noipdefault \
192.0.2.2:192.0.2.1 \
lcp-echo-interval 10 lcp-echo-failure 3 \
mtu 1400 mru 1400 \
pty 'ncat 198.51.100.10 443'
Ogni parola lì sopra fa un lavoro, e una di loro, noauth, fa danni in silenzio. Il tunnel non ha controllo d’accesso, e la cosa ha una sezione tutta sua più avanti.
noauth: elimina l’autenticazione del peer, quindi il listener accetta chiunque arrivi. nodefaultroute e noipdefault evitano che il collegamento riscriva di nascosto il tuo instradamento, local lo fa salire su una pty, e la coppia local:remote fissata impedisce a pppd di accettare una risposta diversa durante IPCP. Il capo che si connette usa la stessa riga senza passive.Tira su entrambi i capi e ottieni un ppp0 su ciascuno, una route punto-punto verso l’indirizzo lontano, e un’interfaccia che puoi pingare, attraverso cui puoi instradare e su cui puoi fare tcpdump. Quella è una VPN: nessun pacchetto installato, nessun demone configurato, nessuna chiave scambiata. Che è proprio il problema, e ci tornerò.
Cosa ha negoziato, e come guardarlo
Aggiungi debug e pppd registra lo scambio del protocollo di controllo, che vale la pena leggere una volta anche se non lo rileggerai mai più. Il collegamento sale per fasi, e ogni fase può fallire per conto suo.
I due strumenti di debug utili sono già installati e non li usa nessuno:
# log every frame in both directions to a file
pppd ... debug record /tmp/ppp-trace
# then read it back in a human-readable form
pppdump -h /tmp/ppp-trace | less
record scrive una cattura con timestamp di ogni byte, pppdump la trasforma in qualcosa di leggibile4, e con tcpdump -ni ppp0 vedi entrambi i lati: il framing sotto e i pacchetti sopra.
Il frame sul filo, e perché 0x7E è dappertutto
PPP su una linea seriale (e per pppd una pty lo è) usa il framing HDLC asincrono, e capirlo fa la differenza tra mettere a punto la cosa e tirare a indovinare. Ogni frame comincia e finisce con lo stesso byte: «Each frame begins and ends with a Flag Sequence, which is the binary sequence 01111110 (hexadecimal 0x7e)»5. Se 0x7e segna un confine non può comparire dentro un frame, quindi viene sottoposto a escape. Lo stesso vale per il byte di escape 0x7d, e per qualsiasi altra cosa che uno dei due capi abbia chiesto.
La regola dell’escape è precisa: «Each Flag Sequence, Control Escape octet, and any octet which is flagged in the sending Async-Control-Character-Map (ACCM), is replaced by a two octet sequence consisting of the Control Escape octet followed by the original octet exclusive-or’d with hexadecimal 0x20»5.
Quell’ultima parte è la manopola di regolazione. L’ACCM è di 32 bit, uno per carattere di controllo, e un 1 significa «fai l’escape di questo». Chiedili tutti e, su payload cifrati dove i byte sono di fatto casuali, circa un byte su otto è sotto 0x20: più o meno il 12% di overhead per niente.
Il pppd moderno qui fa già la cosa giusta. Leggi la pagina di manuale invece del folklore:
If no asyncmap option is given, the default is zero, so pppd will ask the peer not to escape any control characters.4
Quindi asyncmap 0 è il default, non un trucco, e un socket è un percorso pulito a 8 bit che non ha bisogno di escape oltre ai due byte obbligatori. Lascialo stare; imposta dei bit solo quando qualcosa nel mezzo si mangia davvero i caratteri di controllo: un terminal server, un concentratore seriale, un proxy di console fatto male. La frame check sequence alla fine è un CRC a 16 bit, ed è la cosa che fa funzionare la costruzione su UDP, che è la prossima.
TCP su TCP è il trasporto sbagliato
La costruzione qui sopra funziona. Su un banco di laboratorio, in loopback o su una LAN tranquilla, funziona benissimo, ed è proprio per questo che la gente la mette in produzione.
Poi incontra un percorso vero con perdite vere. E crolla in un modo che sembra qualsiasi cosa tranne quello che è.
Il problema sono due timer di ritrasmissione indipendenti impilati uno sull’altro, con quello esterno che nasconde la perdita a quello interno. Olaf Titz ha scritto la spiegazione definitiva, e comincia proprio da questa costruzione:
A frequently occurring idea for IP tunneling applications is to run a protocol like PPP, which encapsulates IP packets in a format suited for a stream transport (like a modem line), over a TCP-based connection. […] Unfortunately, it doesn’t work well. Long delays and frequent connection aborts are to be expected.6
Ecco la forma. Entrambi i TCP impostano un timer di ritrasmissione dal loro tempo di andata e ritorno. Quando il trasporto perde un segmento lo ritrasmette, così i dati della connessione interna arrivano in ritardo. E il TCP interno, che non può vedere il trasporto, legge il ritardo come congestione e ritrasmette anche lui. Ora il trasporto ha l’originale e un duplicato da consegnare su un collegamento che sta già perdendo pacchetti. Il timer interno raddoppia, la coda esterna cresce, e il throughput crolla molto prima del collegamento. Niente nei log dice perché.
Non è una sottigliezza di efficienza. È la differenza tra un tunnel che si degrada con garbo e uno che smette di passare traffico forse al 2% di perdita mentre ping sullo stesso percorso sembra ancora a posto. È il motivo per usare UDP, e per tenere TCP di riserva solo per un percorso che non lascia passare nient’altro.
Quindi usa UDP, come default, non come preferenza.
Fase due: la costruzione su UDP, che è la base
Stesso pppd, trasporto diverso. L’unico cambiamento è nel comando pty.
Capo in ascolto:
pppd nodetach noauth local passive \
nodefaultroute noipdefault \
192.0.2.1:192.0.2.2 \
lcp-echo-interval 10 lcp-echo-failure 3 \
mtu 1400 mru 1400 \
pty 'ncat --udp --listen 198.51.100.10 443'
Capo che si connette:
pppd nodetach noauth local \
nodefaultroute noipdefault \
192.0.2.2:192.0.2.1 \
lcp-echo-interval 10 lcp-echo-failure 3 \
mtu 1400 mru 1400 \
pty 'ncat --udp 198.51.100.10 443'
Due cose di un listener UDP che ti fregheranno, e nessuna delle due è un problema di PPP.
Il listener non può rispondere finché nessuno gli parla. Un socket UDP non ha una connessione da accettare, quindi netcat non può sapere dove mandare le risposte finché non arriva un datagramma. Si aggancia al primo indirizzo e porta sorgente che sente e parla con quello. Questo significa che il capo che si connette deve mandare per primo, e pppd lo fa da solo, perché il capo non passivo comincia subito a sparare configure-request LCP. Significa anche che se la porta sorgente del client cambia, il trasporto sta parlando in silenzio con il posto sbagliato. Dietro un NAT con un timeout UDP breve, è un tunnel che muore ogni pochi minuti senza un motivo visibile.
--keep-open non fa quello che vuoi su UDP. Il -k di Ncat mantiene un listener TCP pronto ad accettare dopo che un peer se n’è andato. Su UDP non c’è niente da accettare, quindi ripartire vuol dire riavviare il trasporto, ed è a questo che servono persist e holdoff, più giù.
Entrambe sono argomenti a favore di socat, che gestisce i peer UDP con più cura, e di un supervisore invece di fidarsi che resti su da solo.
Perché PPP sopravvive a un datagramma perso
L’obiezione ovvia a un trasporto UDP è che PPP si aspetta un flusso di byte e UDP non lo è: i datagrammi arrivano interi o non arrivano, e possono arrivare fuori ordine. Funziona lo stesso, grazie a due byte che il framing si è sempre portato dietro.
PPP su HDLC asincrono è stato progettato per una linea che corrompe i byte. Ogni frame porta una frame check sequence a 16 bit; un frame che non la supera viene scartato, e il prossimo byte di flag risincronizza il ricevente. Il riordino è più raro della perdita e produce lo stesso risultato: una FCS sbagliata, un frame scartato, una risincronizzazione.
Quindi un datagramma perso costa un frame PPP, cioè un pacchetto IP, la condizione normale di ogni rete mai costruita. Il proprietario del pacchetto lo ritrasmette, e il controllo di congestione vede una perdita vera e reagisce correttamente. Questo è tutto l’argomento a favore di UDP: lascia che il traffico dentro il tunnel scopra la verità sul percorso.
Però non lasciare che i frame diventino così grandi da dover essere frammentati dal trasporto. A quel punto un frammento perso uccide l’intero datagramma e il tuo tasso di perdita effettivo si moltiplica. Tieni l’MTU di PPP ben sotto l’MTU del percorso.
Indirizzi, route, e IPv6 fatto come si deve
ppp0 è un’interfaccia punto-punto (niente subnet, niente ARP), quindi local:remote è tutto l’indirizzamento e attraverso di essa instradi in modo esplicito. Per un singolo host che deve raggiungere una rete dietro il capo lontano:
# on the client, after the link is up
ip route add 203.0.113.0/24 via 192.0.2.1 dev ppp0
Perché il capo lontano inoltri per conto del client, i soliti due passi:
sysctl -w net.ipv4.ip_forward=1
nft add rule inet nat postrouting oifname "eth0" ip saddr 192.0.2.2/32 masquerade
proxyarp farà rispondere il server alle richieste ARP per il client sul suo stesso segmento4, cosa carina finché un secondo client non vuole lo stesso. Poi fai la parte che quasi tutti saltano. Fai girare IPv6 sopra: un collegamento punto-punto senza NAT, senza dominio di broadcast e senza scarsità di indirizzi è il posto più facile della tua rete per fare IPv6 come si deve:
pppd nodetach noauth local \
+ipv6 ipv6 ::1,::2 \
nodefaultroute noipdefault \
192.0.2.2:192.0.2.1 \
pty 'ncat --udp 198.51.100.10 443'
+ipv6 abilita IPV6CP; ipv6 <local>,<remote> imposta i due identificatori di interfaccia a 64 bit4, il collegamento sale con indirizzi link-local, e tu aggiungi un /64 globale sopra7. IPV6CP è indipendente da IPCP8, quindi noip non porta altro che IPv6: una cosa ragionevole da costruire nel 2026, in una parola.
Tenerlo su quando il trasporto muore in silenzio
Questo è il guasto che fa perdere un pomeriggio, quindi ha una sezione tutta sua.
Un trasporto TCP che muore male (il capo lontano spento, una voce della tabella NAT scaduta, un middlebox che ha smesso di inoltrare) non si chiude. Niente FIN, niente RST, niente di niente. Netcat se ne sta lì con un socket che non consegnerà mai più un byte, pppd se ne sta lì con una pty che non vedrà mai più un frame, e ip link riporta allegramente ppp0 come UP. Un trasporto UDP non ha alcuno stato di connessione, quindi non si accorge mai di niente.
PPP ha la risposta già dentro, ed è disattivata di default:
lcp-echo-interval 10 lcp-echo-failure 3
Questo manda un echo LCP ogni dieci secondi e butta giù il collegamento dopo tre senza risposta4: trenta secondi per accorgersi di un trasporto morto, esattamente nel caso che nomina la pagina di manuale, «no hardware modem control lines»4, cioè ogni pty mai creata. Poi decidi cosa succede dopo:
persist maxfail 0 holdoff 5
lcp-echo-interval 10 lcp-echo-failure 3 è il rilevatore: un echo ogni dieci secondi, collegamento giù dopo tre mancati. persist maxfail 0 holdoff 5 è la ricostruzione: riparti, non arrenderti mai, aspetta cinque secondi così un percorso che sfarfalla non diventa una fork bomb, e pppd rilancia il comando pty, quindi arrivano anche un netcat e un socket nuovi. Imposta l’echo su entrambi i capi; un solo supervisore, una unit systemd con Restart=always, è meglio di due processi che litigano. Metti ip route in /etc/ppp/ip-up.d/ così l’instradamento torna con il collegamento.Non ha cifratura e non ha autenticazione
Tutto quello che c’è sopra è un tunnel funzionante. Non è un tunnel sicuro, e la lacuna non è un dettaglio.
Non c’è cifratura. Non una cifratura debole. Nessuna. Ogni pacchetto che ci fai passare è sul filo in chiaro, avvolto in un frame HDLC che qualsiasi strumento di cattura decodifica a colpo d’occhio. tcpdump ti mostrerà il contenuto del tunnel di qualcun altro con la stessa facilità del tuo.
Non c’è autenticazione del peer. noauth lo dice chiaramente. Un listener netcat accetta qualsiasi cosa arrivi sulla porta: la prima connessione o il primo datagramma da qualunque parte. Chi arriva per primo si prende un collegamento instradato dentro la tua rete. PPP l’autenticazione ce l’ha (PAP in chiaro, CHAP come challenge-response9), ed entrambi dimostrano chi è il peer senza cifrare un solo byte di quello che segue: con CHAP qui ottieni un tunnel che sa con chi sta parlando e continua a pubblicarne il contenuto a chiunque stia sul percorso.
Nella famiglia PPP c’è un’opzione di cifratura: MPPE10, il modulo che sta in ppp_mppe.ko. Non prenderla in considerazione: è RC4 con la chiave derivata dallo scambio MS-CHAPv2, rotto pubblicamente da oltre dieci anni, ed è il motivo per cui PPTP è morto. Costruirci sopra un tunnel nuovo nel 2026 significa scegliere un cifrario notoriamente rotto al posto di uno funzionante che non costa niente.
Quindi il riassunto onesto, finora: un collegamento instradato senza riservatezza e senza controllo d’accesso. Va bene in laboratorio, va bene dentro un collegamento già cifrato, non va bene da nessun’altra parte. Il rimedio è cifrare il trasporto: le prossime due sezioni, e il motivo per usare ncat invece di qualsiasi netcat abbia messo la tua distribuzione.
Fase tre: avvolgere il trasporto in TLS
La risposta pulita lascia pppd esattamente com’è e sostituisce il trasporto con uno che fa TLS. pppd non viene mai a sapere che è cambiato qualcosa.
Prima il certificato. Uno autofirmato basta, a patto che il client lo verifichi. Una sessione TLS non verificata è una conversazione cifrata con qualcuno che non hai identificato, e questo non ferma nessuno:
openssl req -x509 -newkey rsa:4096 -days 825 -nodes \
-keyout tunnel.key -out tunnel.crt \
-subj "/CN=tunnel.example.net" \
-addext "subjectAltName=DNS:tunnel.example.net"
Ncat
Ncat ha TLS integrato. Sa anche concatenarsi attraverso un proxy, --proxy host:port --proxy-type http|socks4|socks511, quindi il trasporto può terminare su un relay invece che sul capo lontano del tunnel. È il punto su cui gira la sezione sull’egress. Capo in ascolto:
pppd nodetach noauth local passive \
nodefaultroute noipdefault 192.0.2.1:192.0.2.2 \
lcp-echo-interval 10 lcp-echo-failure 3 mtu 1400 mru 1400 \
pty 'ncat --listen --keep-open --ssl --ssl-cert tunnel.crt --ssl-key tunnel.key 443'
Capo che si connette:
pppd nodetach noauth local \
nodefaultroute noipdefault 192.0.2.2:192.0.2.1 \
lcp-echo-interval 10 lcp-echo-failure 3 mtu 1400 mru 1400 \
pty 'ncat --ssl --ssl-verify --ssl-trustfile tunnel.crt tunnel.example.net 443'
--ssl-verify è la parola che conta. Senza, --ssl ti dà cifratura contro chi ascolta passivamente e niente contro chi risponde per primo sulla porta; con essa, Ncat verifica la fiducia e il nome di dominio rispetto al file di trust12. Però Ncat non ha un controllo del certificato client lato server, quindi il server non può identificare il client. Abbinalo a CHAP, oppure usa uno dei due successivi.
Stunnel
Il wrapper tradizionale, e quello che fa l’autenticazione reciproca come si deve:
[ppp]
accept = 443
connect = 127.0.0.1:6001
cert = /etc/stunnel/tunnel.crt
key = /etc/stunnel/tunnel.key
CAfile = /etc/stunnel/clients.crt
verify = 2
verify = 2 richiede un certificato client firmato da una CA presente in CAfile: il controllo d’accesso che la costruzione con netcat non ha mai avuto. Il client fa girare stunnel in modalità client, e il comando pty di pppd si connette al lato in chiaro locale.
Socat
socat fa tutto in un solo processo per capo, con la verifica attiva di default:
# listening end
pppd ... pty 'socat - OPENSSL-LISTEN:443,reuseaddr,cert=tunnel.pem,cafile=clients.crt,verify=1'
# connecting end
pppd ... pty 'socat - OPENSSL:tunnel.example.net:443,cafile=tunnel.crt,verify=1'
socat non è installato sulla macchina su cui è stato scritto questo articolo, quindi quella parte viene dalla sua documentazione: controlla le tue opzioni. È quello che sceglierei io, perché è l’unico dei quattro che parla anche DTLS.
Openssl, quando non c’è nient’altro
openssl c’è su ogni macchina che abbia TLS, e s_server/s_client sanno portare una pipe:
# listening end
pppd ... pty 'openssl s_server -quiet -accept 443 -cert tunnel.crt -key tunnel.key'
# connecting end
pppd ... pty 'openssl s_client -quiet -verify_return_error -CAfile tunnel.crt -connect tunnel.example.net:443'
-quiet sopprime il banner che altrimenti finirebbe nel tuo flusso PPP, e -verify_return_error fa sì che un errore di verifica chiuda la connessione invece di avvisare e andare avanti. Sono strumenti di debug e si comportano da tali, ma su una macchina dove non puoi installare niente tirano su un collegamento.
Fase quattro: DTLS, perché il trasporto deve restare UDP
Ecco la parte scomoda, e il motivo per cui questa sezione è separata. Ogni opzione TLS qui sopra gira su TCP, quindi avvolgere il trasporto in TLS annulla l’argomento a favore di UDP e ti restituisce il crollo. Cifratura e trasporto giusto non dovrebbero essere un compromesso. DTLS è TLS su datagrammi, ed è quello che vuoi: mantiene la protezione del record layer, abbandona le garanzie di ordine e di ritrasmissione, e lascia persi i pacchetti persi, che è esattamente quello che la frame check sequence di PPP è fatta per assorbire.
Ncat non lo sa fare. socat e openssl sì:
# listening end
pppd ... pty 'socat - OPENSSL-DTLS-LISTEN:443,cert=tunnel.pem,cafile=clients.crt,verify=1'
# connecting end
pppd ... pty 'socat - OPENSSL-DTLS-CLIENT:tunnel.example.net:443,cafile=tunnel.crt,verify=1'
E con il solo openssl, dove -dtls seleziona qualsiasi versione di DTLS:
# listening end
pppd ... pty 'openssl s_server -quiet -dtls -accept 443 -cert tunnel.crt -key tunnel.key'
# connecting end
pppd ... pty 'openssl s_client -quiet -dtls -verify_return_error -CAfile tunnel.crt -connect tunnel.example.net:443'
Attento al dimensionamento dei frame. Un record DTLS non può essere frammentato come un record TLS si distribuisce su un flusso TCP, quindi tutto deve stare nell’MTU del percorso in un colpo solo.
Mettere a punto la costruzione PPP: MTU, compressione, e cosa aiuta davvero
Quattro manopole, tutte opzioni di pppd. La costruzione con tap nella prossima sezione non ne ha nessuna, perché non ha nessuno dei meccanismi che configurano.
novj oltre la velocità di un modem: fa risparmiare un errore di arrotondamento, costa CPU per pacchetto e si rompe con le perdite. Spegni deflate/bsdcomp: il payload è già cifrato, e comprimere attraverso un confine di sicurezza è un attacco, non una funzione.Niente di tutto questo rende il tunnel più veloce, e il motivo conta perché la colpa se la prende PPP e non dovrebbe. PPP non è il collo di bottiglia. PPPoE porta 2 Gbit con lo stesso demone, perché il suo percorso dati non lascia mai il kernel: ppp_generic e pppoe fanno il framing e l’inoltro, e pppd gestisce solo il piano di controllo. Quello che qui ti costa è la pty: ogni byte passa nello spazio utente, attraverso netcat, in un socket e ritorno, un giro che PPPoE non fa mai. Quello appartiene allo pseudo-terminale, non a PPP.
Che è un buon momento per guardare l’altro modo di farlo, dove una pty non c’è proprio.
L’altro modo: un dispositivo tap, e niente PPP
Tutto finora ha usato PPP per la metà del collegamento. C’è un secondo modo per creare un’interfaccia virtuale, e non serve alcun protocollo.
Il driver TUN/TAP del kernel ti dà un’interfaccia e un file descriptor legati insieme: scrivi un pacchetto nel descriptor e compare sull’interfaccia come se arrivasse da un cavo; leggi e ottieni un pacchetto che il kernel voleva mandare. Questa è l’intera interfaccia13, ed è in Linux dal 1999.
ip tuntap add dev tap0 mode tap user damien group damien
ip link set tap0 mtu 1400 up
ip addr add 192.0.2.1/30 dev tap0
Due dettagli in quel primo comando valgono più di quanto sembri.
user damien rende il dispositivo persistente e non privilegiato. Creato così, sopravvive al processo che lo usa, e un utente indicato può aprirlo senza essere root. Root crea il dispositivo una volta; la cosa che spala i frame non ha bisogno di root. Tieni a mente questo per la sezione sull’egress.
mode tun è l’altra metà dello stesso driver, ed è quella che la maggior parte della gente vuole davvero. Tun porta pacchetti IP. Tap porta frame Ethernet. La differenza conta abbastanza da avere una sezione sua, più giù.
Quello a cui rinunci rispetto a PPP è tutto ciò che PPP negozia: niente LCP, quindi nessuna dimensione di frame concordata e nessun controllo di vitalità, niente IPCP/IPV6CP, quindi entrambi i capi configurati a mano, niente autenticazione, niente compressione delle intestazioni. Un dispositivo tap è un buco nel kernel, e il protocollo che ci passa è quello che ci metti tu. Quello che guadagni è nessun overhead di framing, nessun escape, nessun canale di controllo, e un’interfaccia che si può mettere in bridge.
Tap su UDP, dove un datagramma è un frame
Questa è la corrispondenza più pulita di tutto l’articolo, e viene fuori dal progetto stesso. Un dispositivo tap è un dispositivo a datagrammi (una read() restituisce esattamente un frame) e un socket UDP è un socket a datagrammi, una sendto() per datagramma. Quindi un frame va in un datagramma, arriva come frame, e non c’è niente da delimitare, bufferizzare o risincronizzare. Perdi un datagramma e hai perso un frame, che è comunque l’aspetto di un pacchetto scartato.
Con socat, entrambi i capi sono un comando ciascuno:
# listening end
socat TUN:192.0.2.1/30,tun-type=tap,tun-name=tap0,iff-up UDP-LISTEN:443
# connecting end
socat TUN:192.0.2.2/30,tun-type=tap,tun-name=tap0,iff-up UDP:198.51.100.10:443
socat non è installato sulla macchina su cui è stato scritto questo articolo, quindi quei due vengono dalla sua documentazione e non da un’esecuzione qui: controlla i nomi degli indirizzi della tua versione prima di fidarti. Vale la pena averlo: è l’unico strumento in questo articolo che fa tun, tap, TLS e DTLS in un solo processo.
Dove non puoi installare niente, tutto il lavoro sta in una cinquantina di righe senza dipendenze oltre la libreria standard. Il cuore è questo, con IFF_NO_PI che spegne l’intestazione di quattro byte che il driver altrimenti metterebbe davanti:
TUNSETIFF, IFF_TAP, IFF_NO_PI = 0x400454CA, 0x0002, 0x1000 # IFF_TUN is 0x0001
def open_tap(name):
fd = os.open("/dev/net/tun", os.O_RDWR)
fcntl.ioctl(fd, TUNSETIFF, struct.pack("16sH", name.encode(), IFF_TAP | IFF_NO_PI))
return fd
# ... learn the peer from the first datagram (UDP has no accept), then shovel:
while True:
ready, _, _ = select.select([tap, sock], [], [])
if tap in ready and peer:
sock.sendto(os.read(tap, MTU), peer) # one read = one frame = one datagram
if sock in ready:
frame, src = sock.recvfrom(MTU)
peer = src # last speaker wins — see the note below
if frame:
os.write(tap, frame)
Il file completo (analisi degli argomenti, IPv6 tramite getaddrinfo, il datagramma di lunghezza zero che dice a un listener UDP dove rispondere, e la compressione che aggiunge la prossima sezione) è nel bundle:
peer = src a ogni datagramma è la parte da leggere due volte. Chi ha mandato l’ultimo frame diventa il peer. Comodo dietro un NAT la cui porta sorgente continua a spostarsi, e una porta aperta su una rete non fidata, dove chiunque possa mandare un datagramma alla porta si prende il tunnel. Va bene dentro una sessione DTLS, che è dove si va a parare; non va bene da solo. La metà socket dello script è stata provata qui in loopback IPv6: l’apertura arriva, il listener impara il peer, un frame attraversa e la risposta torna indietro; la metà tap richiede root, l’unica parte che non ho potuto far girare.
Su TCP il framing devi inventartelo da solo
Ora sostituisci il trasporto con TCP e guarda comparire un intero problema che PPP aveva risolto in silenzio nel 1994.
TCP è un flusso di byte senza confini di record e senza alcuna promessa su come i byte siano raggruppati all’arrivo: due frame scritti uno dopo l’altro possono arrivare in una sola lettura, un frame in tre. Il ricevente si ritrova con un mucchio di byte senza sapere dove finisce un frame, e un dispositivo tap accetta solo frame interi.
Quindi su TCP scrivi il tuo framing. Due byte di lunghezza big-endian davanti a ogni frame sono la risposta solita:
# sending
sock.sendall(struct.pack("!H", len(frame)) + frame)
# receiving
def recv_exactly(sock, n):
buf = b""
while len(buf) < n:
chunk = sock.recv(n - len(buf))
if not chunk:
raise ConnectionError("carrier closed")
buf += chunk
return buf
length = struct.unpack("!H", recv_exactly(sock, 2))[0]
frame = recv_exactly(sock, length)
Funziona, ed è strettamente peggio della versione UDP. È di nuovo il problema TCP su TCP; aggiunge due byte e un ciclo di riassemblaggio per frame; e non ha modo di riprendersi da un errore, perché un flusso con prefisso di lunghezza che perde il segno legge ogni lunghezza successiva in mezzo a un frame. HDLC si risincronizza al prossimo 0x7E; questo no, a meno di reinventare HDLC, e peggio. Terzo argomento a favore di UDP, e il più forte: su un trasporto a datagrammi non c’è un problema di framing, perché il trasporto ha già l’unica funzione che ti serviva.
Tun o tap: livello 3, a meno che tu non abbia davvero bisogno del livello 2
Lo stesso driver ti dà due dispositivi, e la gente sceglie continuamente quello sbagliato perché un tutorial ha detto tap.
| tun | tap | |
|---|---|---|
| Cosa passa | pacchetti IP | frame Ethernet |
| Overhead per pacchetto | nessuno | intestazione Ethernet di 14 byte |
| ARP, DHCP, broadcast | no | sì, tutto quanto, attraverso il tunnel |
| Protocolli non IP | no | sì |
| Può entrare in un bridge | no | sì |
| Equivale a | un collegamento punto-punto, come ppp0 | un cavo di rete |
Tun è un collegamento instradato, come l’interfaccia PPP della prima metà: due indirizzi, una route, pacchetti che entrano ed escono. Tap è un cavo Ethernet virtuale, quindi ogni broadcast, ogni richiesta ARP e ogni briciola di rumore multicast del segmento ora attraversa il tuo tunnel e brucia banda.
Cambia una riga nello script per passare dall’uno all’altro:
IFF_TUN = 0x0001 # instead of IFF_TAP
Usa tap quando hai davvero bisogno del livello 2. I motivi veri ci sono: un protocollo che non è IP, un heartbeat di cluster che si aspetta di vedere i broadcast, un server DHCP che deve raggiungere i client attraverso il tunnel, o mettere in bridge due segmenti per farne uno.
Quest’ultimo è il caso comune, e quello a cui stare attenti:
ip link add br0 type bridge
ip link set tap0 master br0
ip link set eth1 master br0
ip link set br0 up
Ora il segmento remoto fa parte di quello locale: i suoi broadcast, il suo spanning tree, il suo via vai di MAC e, se qualcuno è stato distratto, il suo server DHCP. Mettere in bridge due sedi che usano entrambe 192.168.1.0/24 è un brutto pomeriggio; uno che torna in loop sullo stesso segmento è una brutta settimana. Di default usa tun, passa a tap quando sai nominare la cosa di livello 2 che ti serve, e fai il bridge solo dopo aver controllato cosa fa broadcast su entrambi i lati.
Gli stessi wrapper, un processo per capo
La costruzione con tap ha lo stesso buco di quella con PPP: il trasporto è in chiaro e il listener accetta chi arriva per primo. Il rimedio è lo stesso, e con socat si riduce a un comando per capo, perché crea il dispositivo e termina la sessione DTLS in un solo processo:
# listening end
socat TUN:192.0.2.1/30,tun-type=tap,tun-name=tap0,iff-up \
OPENSSL-DTLS-LISTEN:443,cert=tunnel.pem,cafile=clients.crt,verify=1
# connecting end
socat TUN:192.0.2.2/30,tun-type=tap,tun-name=tap0,iff-up \
OPENSSL-DTLS-CLIENT:tunnel.example.net:443,cafile=tunnel.crt,verify=1
Questa è la costruzione corretta più corta di tutto l’articolo. Un’interfaccia virtuale, un trasporto a datagrammi, autenticazione reciproca con certificati e cifratura. Due comandi. Nessun demone, nessuna negoziazione di protocollo.
verify=1 non è facoltativo: è lo stesso punto di --ssl-verify, e con il comportamento di peer = src visto sopra, una parte non identificata è a un datagramma dal prendersi il tuo tunnel. Se sei bloccato con lo script Python, non ficcarci dentro TLS: puntalo su una porta di loopback e metti il wrapper davanti, oppure usa socat. Un wrapper TLS fatto a mano attorno a un tunnel fatto a mano sono due occasioni per sbagliare la parte interessante.
Fase cinque: comprimere il flusso con zstd
C’è un’altra cosa che vale la pena mettere nel backend, e a differenza delle opzioni di compressione di pppd può ripagare davvero: comprimere i frame con zstd prima che entrino nel trasporto.
La parola importante lì è frame, al plurale. Comprimi il flusso, non ogni pacchetto per conto suo. È l’effetto misurato più grande di tutto l’articolo.
Il traffico di rete è ripetitivo in un modo che si vede solo tra un pacchetto e l’altro: le stesse intestazioni, gli stessi nomi host e le stesse chiavi JSON, ancora e ancora. Un compressore che riparte da zero a ogni frame di 1.400 byte non vede niente di tutto ciò; uno che mantiene la sua finestra tra un frame e l’altro lo vede tutto.
Su una Fedora attuale non serve installare niente: Python 3.14 ha portato zstd nella libreria standard14; questa macchina ha la 3.14.7 con zstd 1.5.7:
from compression.zstd import ZstdCompressor, ZstdDecompressor # Python 3.14+
_c, _d = ZstdCompressor(level=1), ZstdDecompressor()
# FLUSH_BLOCK: emit everything so far, keep the window for the next frame.
out = _c.compress(frame, mode=ZstdCompressor.FLUSH_BLOCK)
frame = _d.decompress(out)
Un compressore per direzione, vivo per tutta la durata del collegamento. Un FLUSH_BLOCK per frame, così un frame esce nel momento in cui arriva senza niente in buffer, e il capo lontano restituisce un frame per blocco.
Quanto vale la finestra, misurato
Numeri da questa macchina. Stessi frame da 1.400 byte, stesso livello 1, e l’unica differenza è se il compressore mantiene la sua storia:
| Traffico nel tunnel | flusso, FLUSH_BLOCK | per pacchetto, FLUSH_FRAME | per pacchetto con dizionario addestrato |
|---|---|---|---|
| Chiamate API e telemetria ripetitive | 5,0% | 14,8% | 5,3% |
| Righe di log | 7,5% | 24,2% | 15,1% |
| Testo semplice e file di configurazione | 37,8% | 51,3% | 45,3% |
| Byte casuali, al posto di TLS | 100%+ | 100,7% | n/d |
Il throughput al livello 1 è stato di 205 MB/s sul testo e oltre 1 GB/s sul traffico ripetitivo: più è comprimibile, più è veloce, perché c’è meno da codificare.
Il traffico di log scende al 7,5% della sua dimensione originale, contro il 24,2% per pacchetto: un fattore tre, stessi dati, stesso livello, grazie a un’opzione. E il livello giusto è l'1: il livello 3 ha guadagnato circa un punto percentuale, il livello 9 un altro facendo scendere il throughput da 211 MB/s a 61.
Il rovescio, ed è lo stesso rovescio di tutto il resto qui
Una finestra condivisa significa che ogni frame dipende da quelli prima: perdine uno e la storia del decompressore non corrisponde più, e niente di quello che segue si decodifica. Quindi la compressione del flusso ha bisogno di un trasporto che consegni tutto in ordine: TCP, o TLS su TCP, non UDP né DTLS. È l’unico argomento onesto a favore del trasporto TCP in tutto l’articolo. Se quello che passa nel tuo tunnel è davvero comprimibile (syslog, replica di database in chiaro, telemetria, un’API chiacchierona), una sessione TLS con flusso compresso sposta un terzo dei byte che sposterebbe un trasporto a datagrammi, e su un percorso decente questo può battere la penalità delle ritrasmissioni. Misuralo sul tuo traffico.
Su UDP, dove un dizionario fa il lavoro della finestra
Dove il trasporto è UDP o DTLS, e di default dovrebbe esserlo, non puoi mantenere una finestra: ogni datagramma sta in piedi da solo, il che significa FLUSH_FRAME e la colonna più debole qui sopra. Un dizionario addestrato dà al compressore il contesto tra pacchetti che avrebbe dato una finestra, senza alcuna dipendenza tra datagrammi15:
# capture a few thousand real frames off the link first, one per file
zstd --train frames/* -o tunnel.dict --maxdict=110000
from compression.zstd import ZstdCompressor, ZstdDecompressor, ZstdDict
d = ZstdDict(open("tunnel.dict", "rb").read())
_c = ZstdCompressor(level=1, zstd_dict=d) # load it ONCE, not per frame
out = _c.compress(frame, mode=ZstdCompressor.FLUSH_FRAME)
Sul traffico ripetitivo questo ha portato la compressione per pacchetto dal 14,8% al 5,3%, recuperando il 96% del divario con la compressione del flusso completa pur restando tollerante alle perdite; sulle righe di log il 55% del divario, sul testo generico il 44%.
Ci sono tre regole che vengono con questo. Entrambi i capi devono caricare lo stesso dizionario o non si decodifica niente: verificato qui, un frame compresso con il dizionario solleva ZstdError senza di esso. Addestralo su una cattura del traffico vero, perché un dizionario è un’ipotesi a priori e una sbagliata ti costa: il dizionario del testo ha reso un testo diverso leggermente peggiore. E caricalo una volta in un compressore a lunga vita; passarlo a ogni chiamata ha misurato 5 MB/s, e non è un refuso.
Il byte di intestazione, e la rampa di un secondo
Due piccole cose che evitano che tutto questo sia fragile.
Ogni datagramma porta un’intestazione di un byte, e indica la modalità invece di dire solo «compresso»: 0x00 il frame così com’è, 0x01 un frame zstd autonomo, 0x02 un blocco di un flusso che continua. Un ricevente può allora decodificare qualunque cosa abbia scelto il capo lontano senza essere configurato per corrispondere, e già questo vale il byte.
In modalità frame chi manda invia la forma compressa solo quando è davvero più piccola, perché comprimere non è sempre un guadagno: i byte casuali sono usciti al 100,7%, e un ACK TCP di 64 byte si comprime a 73, cioè l’intestazione zstd di dieci byte su un pacchetto che non ha niente da spremere. Il conteggio dei pacchetti su un collegamento vero è dominato dai pacchetti piccoli, quindi senza quel controllo gonfieresti la maggior parte del traffico per rimpicciolirne la minoranza. In modalità flusso invia sempre la forma compressa, perché saltarne una manderebbe fuori passo le due finestre.
E il collegamento parte raw: per il primo secondo ogni frame esce non compresso, qualunque cosa dicano le impostazioni, e ogni direzione accelera per conto suo:
RAMP = 1.0 # seconds of raw frames before compression starts
def pack(self, frame):
if self.c is None or time.monotonic() - self.started < RAMP:
return RAW + frame
out = self.c.compress(frame, mode=ZstdCompressor.FLUSH_BLOCK)
return ZSTD + out if len(out) < len(frame) else RAW + frame
È l’idea delle fasi dall’inizio dell’articolo applicata a un singolo collegamento. Il tunnel sale sul percorso più semplice che ha, dimostra di saper portare un frame, e solo dopo comincia a fare qualcosa di furbo. Quando si rompe, sai in quale secondo si è rotto.
Fase sei: compresso e cifrato, e cosa costa l’ordine
L’ordine conta, e ne funziona solo uno: prima comprimi, poi cifri. Il testo cifrato non si comprime, come mostra la riga del 100,7%, ed è anche il motivo per cui TLS 1.3 ha tolto la propria compressione, lasciando il tuo strato come l’unico posto dove farla. Quell’ordine ha un problema noto, lo stesso che ho sollevato contro deflate: comprimere prima di cifrare fa trapelare il testo in chiaro attraverso la lunghezza del testo cifrato, e dove un attaccante può iniettare dati scelti da lui accanto a un segreto e osservare le dimensioni, quella fuga è stata un attacco funzionante più di una volta: CRIME e BREACH contro TLS16, e VORACLE esattamente contro questa forma17.
Non è un motivo per non comprimere mai. È un motivo per sapere in quale caso ti trovi:
- Un collegamento che porta il tuo traffico tra due macchine tue (replica, backup, log, telemetria) non ha testo in chiaro scelto dall’attaccante che viaggia insieme a dei segreti. Comprimilo, e comprimi il flusso.
- Un collegamento che porta la navigazione arbitraria degli utenti, dove i contenuti web di qualcun altro e le tue credenziali viaggiano insieme, è il caso per cui è stato scritto VORACLE. Lasciala spenta.
Il motivo per cui mi sento a mio agio a metterla nella costruzione con tap e non in quella con PPP non è di principio: qui scegli deliberatamente un algoritmo moderno, per traffico che hai guardato, mentre il deflate di pppd comprime tutto di default con uno del 1996, che il caso sia adatto o no.
Cosa guadagna la costruzione con tap, e a cosa rinuncia
Metti le due metà fianco a fianco, perché non sono in concorrenza. Sono compromessi diversi.
| pppd su un socket | tap o tun su un socket | |
|---|---|---|
| Framing | integrato (HDLC, si risincronizza dopo un danno) | nessuno su UDP perché non serve; da inventare su TCP |
| Impostazione degli indirizzi | negoziata da IPCP e IPV6CP | configurata a mano su entrambi i capi |
| Vitalità | echo LCP, integrato | nessuna; la aggiungi tu o il collegamento muore in silenzio |
| Autenticazione | PAP o CHAP disponibili, entrambi deboli | nessuna |
| Livello | solo 3 | 3 con tun, 2 con tap |
| Bridging | no | sì, con tap |
| Overhead | flag, intestazione e FCS per frame, più l’escape | niente, o 14 byte con tap |
| Compressione | deflate e BSD, attive di default, del 1996 | nessuna, o zstd per frame che aggiungi e controlli tu |
| Serve root | sì, sempre | per creare il dispositivo; non per usarlo |
| Parti in movimento | un demone, vecchio di trent’anni | un file descriptor |
PPP ti dà un collegamento negoziato che si sorveglia da solo e te lo fa pagare con un protocollo. Un dispositivo tap ti dà un buco grezzo gratis, e le parti che mancano le metti tu o ne fai a meno. Per un tunnel lasciato acceso, il controllo di vitalità mancante è quello che morde: pppd si accorge di un trasporto morto in trenta secondi e lo ricostruisce, la costruzione con tap non si accorge di niente perché niente al suo interno sta guardando. Aggiungi un keepalive, fallo girare sotto qualcosa che lo riavvia, oppure usa la costruzione che ne ha già uno.
Quando è lo strumento giusto, e quando no
Non è mai davvero lo strumento giusto, e non ho intenzione di far finta del contrario. Tutto quello che c’è sopra funziona, e niente di tutto ciò è quello che dovresti far girare in produzione. La versione onesta di una guida include la parte in cui metti giù l’attrezzo, e questa è quella parte.
Quello per cui è davvero buono è mostrarti come funziona una cosa. Una VPN smontata nei suoi pezzi e, nella prossima sezione, come si comporta davvero l’egress una volta che qualcuno è dentro la tua rete con root. Questi sono i motivi per averlo letto. I casi ristretti qui sotto sono reali, ma non sono il motivo per cui l’articolo esiste.
Prendi la costruzione con PPP quando:
- Il trasporto non è affatto IP: una console seriale, un USB gadget, un collegamento radio, una named pipe, un canale SSH. A
pppdnon importa su cosa viaggino i byte, e un dispositivo tap qui non ti può aiutare. - Stai salvando qualcosa: una macchina con una console seriale, niente rete, e un lavoro da finire stasera. PPP su quella console è un collegamento instradato, installato su entrambi i capi senza niente da copiare.
- Vuoi che il collegamento si arrangi da solo. Echo LCP, negoziazione degli indirizzi e riavvio sono gratis; scriverli tu è il modo in cui la costruzione con tap diventa un piccolo prodotto inaffidabile.
Prendi la costruzione con tap quando:
- Ti serve il livello 2: un protocollo non IP, un heartbeat di cluster che vuole i broadcast, DHCP attraverso il tunnel, o due segmenti che devono diventare uno.
- Vuoi il minor numero di parti in movimento: su UDP con DTLS sono due comandi, nessun demone, nessuna negoziazione, niente di cui fare l’escape.
- Root scarseggia. Crea il dispositivo una volta con
user, e il processo che sposta i frame non avrà mai più bisogno di privilegi.
Sono entrambi lo strumento giusto quando stai imparando. Ogni strato è visibile e sostituibile separatamente, e non c’è modo migliore di capire cosa fa un prodotto VPN che costruirne uno dai pezzi e guardare ognuno di essi salire.
Nessuno dei due è lo strumento giusto quando vuoi una VPN. Per quello, usa WireGuard. È nel kernel, una frazione del codice, fa la crittografia come si deve senza niente da negoziare e niente da sbagliare, ed è un protocollo a datagrammi per progetto. ssh -w ti dà un dispositivo tun su una sessione SSH esistente in un comando, e OpenVPN è la versione matura e verificata della forma DTLS-su-tap vista sopra. Tutti e tre fanno questo meglio di qualsiasi cosa costruita qui.
Costruisci queste cose perché vuoi sapere cosa c’è dentro la cosa che compri. Non perché fosse furbo.
Cosa mostra davvero: l’egress dal lato dell’attaccante
Questo è il motivo per leggere un articolo di costruzione che ti è appena stato detto di non usare. Giralo e guarda dall’interno della tua rete, come la persona che ci è appena atterrata con root. Ogni violazione vera finisce lì, con una chiave rubata, una fuga da un container, un servizio non aggiornato, un insider. La domanda che a quel punto decide quanto sarà brutta la giornata non è «cosa possono far girare», perché possono far girare qualsiasi cosa. È «cosa può uscire, e l’avevi deciso prima che arrivassero?»
Se l’uscita è aperta di default, la risposta è tutto, e ormai c’è poco che tu possa fare. Niente qui era esotico. pppd, ncat, socat e ip sono pacchetti firmati della distribuzione già presenti sulla macchina; lo shim per il tap sono cinquanta righe di libreria standard. Una porta in uscita consentita (ed è la 443, quella che ogni rete apre di default) e c’è un collegamento instradato dalla tua rete a quella di qualcun altro, cifrato, autenticato, che sopravvive ai riavvii, che porta IPv4 e IPv6, e che al tuo confine non si distingue da una qualsiasi sessione HTTPS che i tuoi utenti aprono diecimila volte al giorno. Fallo tap, mettilo in bridge, e quello che è uscito dall’edificio non è una route. È il segmento.
Non c’è niente che uno scanner possa prendere: nessuna firma di malware perché non c’è malware, nessun protocollo strano perché è un normale handshake TLS verso la 443, nessun binario insolito perché ognuno l’ha installato il tuo stesso gestore di pacchetti. Il proxy registra una connessione e un conteggio di byte, ed entrambi sembrano lavoro.
E la destinazione non è nemmeno fissa. Un socket non deve terminare dove finiscono i pacchetti, perché il trasporto può essere puntato attraverso un proxy: un relay che non è altro che due connessioni e una pipe, che la prossima sezione costruisce con una riga di shell. ncat accetta --proxy con --proxy-type http, socks4 o socks5, quindi la sessione TLS che vede il tuo confine termina dovunque l’attaccante le abbia detto di connettersi attraverso: un jump host interno, un endpoint SaaS consentito che per caso inoltra CONNECT, un relay nel cloud. E il tunnel prosegue da lì verso un posto che non vedi mai. HTTP CONNECT e SOCKS fanno entrambi questo per progetto, perché è a questo che serve un proxy. Quindi una voce della allow-list per una destinazione di cui ti fidi è sempre e solo fiducia nella destinazione e in tutto ciò verso cui inoltrerà, che non controlli e non puoi elencare. L’endpoint nel log del tuo firewall è il proxy. Non è mai stato il capo lontano.
Quindi la verità scomoda: una volta che qualcuno è dentro con root e l’uscita è permissiva, il tunnel non è la cosa che puoi impedire. I pezzi sono installati, l’uscita è aperta, e non porta nemmeno dove sembra. La tua unica occasione per renderlo difficile era prima che l’attaccante arrivasse, al confine, decidendo cosa può uscire.
Questo è l’egress default-deny, ed è tutta la lezione. Uscita bloccata di default; una allow-list corta e con nomi, dove una persona ha giustificato ogni destinazione e porta; tutto il resto rifiutato, registrato e segnalato. Non perché fermi di colpo un attaccante determinato (una destinazione consentita è un tunnel consentito) ma perché l’alternativa è non avere alcuna decisione da far rispettare. Una politica di egress scritta come una lista di porte consentite è una politica sui numeri di porta. Non è mai stata una politica su cosa esce, e una volta che qualcuno ha root, i numeri di porta sono tutto ciò che protegge.
È la stessa conclusione dell’articolo su ping, che costruisce il tunnel con l’echo ICMP, e dell’articolo sui protocol helper, dove è il tuo firewall ad aprire i buchi da solo. Tre vie d’ingresso, una conclusione: il controllo che pensavi di avere era sui protocolli, e nessuno di questi protocolli è quello che dice di essere. Il confine, deciso in anticipo e in default-deny, è l’unico controllo che sia mai stato reale.
Un proxy sono due connessioni e una pipe
Vale la pena vedere quanto poco sia un relay, perché spiega perché non puoi ragionare sul capo lontano partendo da quello vicino. Un proxy non è software speciale. È una connessione unita a un’altra da una pipe. La forma più antica usa una named pipe, una FIFO, per portare la direzione di ritorno: un ncat ascolta, un altro si connette in avanti, e la FIFO collega il percorso di risposta tra i due.
mkfifo backpipe
ncat -l 7000 0<backpipe | ncat farend.example.net 7100 1>backpipe
Leggila come un impianto idraulico: l’output del listener scorre nel secondo ncat e prosegue verso il capo lontano, e le risposte tornano attraverso la FIFO al client. Due socket, una pipe, entrambe le direzioni, e la connessione del client termina qui, sul relay, mentre i pacchetti proseguono verso farend e ritorno. Ho fatto girare esattamente questo in loopback con un terzo ncat che faceva da echo al capo lontano, e una riga mandata dentro è tornata indietro dopo aver fatto tutto il giro.
Ncat fa la stessa cosa in un solo processo, lanciando la connessione in avanti per ogni client che arriva:
ncat -l 7000 --keep-open --sh-exec 'ncat farend.example.net 7100'
Stessa forma, meno pezzi: il socket del listener è unito a quello dell’ncat lanciato tramite la pipe che la shell mette tra i due. Concatenane tre e il tunnel attraversa tre reti, terminando e ripartendo a ogni salto, con il firewall di ogni salto che registra un’ordinata connessione locale verso il successivo e niente oltre.
Questo è tutto il trucco, ed è il motivo per cui il log del confine non è una prova della destinazione. Ogni relay è il capo lontano per quanto può capire la macchina prima di lui, e il vero altro capo è a chissà quante pipe di distanza, dove nessuno guardava.
Ora metti quei relay su macchine che non sono dell’attaccante.
Ogni proprietario lungo quella catena vede solo una connessione dal salto prima al salto dopo: nessuna origine, nessuna destinazione, solo il mezzo. Non è un’idea nuova che sto regalando a qualcuno. È così che funzionano da vent’anni le catene di pivot e le reti C2, ed è il motivo per cui il traffico in uscita di un host compromesso porta così spesso a un’altra vittima invece che all’attaccante. I tuoi log mostrano che hai parlato con una macchina in un data center da qualche parte. Di chi sia, e verso cosa inoltri, non ci è mai stato scritto.
Il peso difensivo sta in una riga: non puoi attribuire né fidarti di una destinazione che non hai limitato in anticipo. Quando il traffico sta già uscendo, l’indirizzo verso cui esce non ti dice quasi niente, perché è un relay sulla macchina di qualcun altro e il vero endpoint è ripulito dietro di esso.
Il collegamento non è mai stato il prodotto
Quello che mi colpisce, dopo aver smontato tutto questo, è quanto poco ne sia nuovo e quanto ne venga venduto.
L’RFC 1661 è del 1994. pppd c’è in ogni distribuzione Linux da trent’anni, i moduli del kernel sono otto file in una directory, e tutto ciò che fa di una VPN una VPN (un’interfaccia virtuale, un collegamento negoziato, un trasporto cifrato, una route) sono quattro programmi e un certificato. Niente di tutto ciò è difficile o segreto. Hanno documentato ogni byte e l’hanno regalato, e tra te e quella roba è cresciuta un’industria che vende gli stessi quattro pezzi in una scatola con una licenza per postazione e un contratto di assistenza che scade. I pezzi non sono migliorati. Sono stati impacchettati.
Non è un argomento per far girare questa roba in produzione. Ti ho appena detto di non farlo. È un argomento per sapere cosa c’è nella scatola che compri, perché il giorno in cui il fornitore cambia le licenze, viene acquisito o mette fine al tuo modello, la differenza tra un brutto trimestre e un brutto anno è se qualcuno da voi sa di cosa era fatta quella cosa.
Prenditi una serata e costruisci il tunnel con i pezzi. Guarda LCP che negozia, rompi il collegamento e guardalo tornare, togli il certificato e guarda cosa si ferma. Poi rileggi la scheda tecnica del tuo fornitore di VPN e guarda quanta ne riconosci.
La stessa serata ti compra anche l’altra metà. Se un collegamento instradato fuori dalla tua rete sono quattro programmi installati e un certificato, la persona che ha appena preso root su una delle tue macchine non è frenata da quanto sia difficile costruire il tunnel. Non è difficile. È frenata solo da quello che tu hai deciso, prima che arrivasse, che poteva uscire. Costruiscilo una volta e smetti di pensare all’egress come a qualcosa che fa rispettare un prodotto, e cominci a pensarlo come una decisione che hai preso oppure no.
Non c’è molto di magico. Quasi tutto è il 1994 con una mano di vernice, e il 1994 non ha niente che non va. Funzionava, era documentato, e gira ancora.
RFC 1661 — The Point-to-Point Protocol (PPP), 1994. Definisce il collegamento, LCP e la famiglia di protocolli di controllo di rete che ci stanno sopra. ↩︎
RFC 2637 — Point-to-Point Tunneling Protocol (PPTP), che porta PPP dentro GRE. ↩︎
RFC 3931 — Layer Two Tunneling Protocol versione 3, il discendente in standards track del protocollo che porta PPP dentro UDP. ↩︎
pppd(8) — la pagina di manuale del demone PPP. Fonte per
pty,notty,local,passive,noipdefault,proxyarp,record,receive-all, le opzioni di echo LCP e il default di asyncmap: «If no asyncmap option is given, the default is zero, so pppd will ask the peer not to escape any control characters.» Le citazioni qui sono state lette daman pppdsu ppp 2.5.1. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎RFC 1662 — PPP in HDLC-like Framing. La flag sequence, la regola di octet-stuffing e l’Async-Control-Character-Map: «Each frame begins and ends with a Flag Sequence, which is the binary sequence 01111110 (hexadecimal 0x7e).» ↩︎ ↩︎
Olaf Titz, Why TCP Over TCP Is A Bad Idea — la spiegazione di riferimento dell’accumulo delle ritrasmissioni, che comincia proprio da questa costruzione. L’URL originale non serve più l’articolo; questa è una cattura dell’Internet Archive. ↩︎
RFC 5072 — IP Version 6 over PPP. IPV6CP e gli identificatori di interfaccia a 64 bit, indipendenti da IPCP. ↩︎
RFC 1332 — The PPP Internet Protocol Control Protocol (IPCP), che negozia gli indirizzi IPv4 ai due capi del collegamento. ↩︎
RFC 1994 — PPP Challenge Handshake Authentication Protocol (CHAP). Dimostra l’identità del peer; non cifra niente. ↩︎
RFC 3079 — Deriving Keys for use with Microsoft Point-to-Point Encryption (MPPE). La costruzione RC4 con chiave derivata dallo scambio MS-CHAP, e il motivo per cui PPTP non è un’opzione praticabile. ↩︎
Ncat Users’ Guide — connecting through a proxy —
--proxye--proxy-typeper HTTP CONNECT e SOCKS 4/5, così il trasporto TLS termina sul proxy, non sul capo lontano del tunnel. ↩︎Ncat Users’ Guide — le opzioni
--ssl,--ssl-verifye--ssl-trustfile, e le modalità di ascolto e UDP. Versione provata qui: Ncat 7.92. ↩︎Universal TUN/TAP device driver — la documentazione del kernel stesso per
/dev/net/tun,TUNSETIFFe la differenza tra tun e tap. ↩︎PEP 784 — Adding Zstandard to the standard library, ed è per questo che
compression.zstdnon richiede alcun pacchetto su Python 3.14. Misurato qui con Python 3.14.7 e zstd 1.5.7. ↩︎zstd(1) — la modalità
--traine--maxdict, per costruire il dizionario che entrambi i capi devono caricare. ↩︎RFC 7457 — Summarizing Known Attacks on TLS and DTLS, che copre CRIME e la forma generale di una fuga di lunghezza da compressione prima della cifratura. ↩︎
OpenVPN — the VORACLE attack — la stessa fuga contro una VPN che comprime prima di cifrare, e il motivo per cui OpenVPN ora sconsiglia la compressione. ↩︎