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.

Ogni tunnel è una metà di collegamento, un trasporto e un po' di crittografiaSempre le stesse tre parti. Cambiano solo il trasporto e la crittografia.TUNNELCOLLEGAMENTOTRASPORTOCRITTOGRAFIAPPP dial-up, 1994PPPmodem e linea telefonicanessunaPPPoEPPPframe EthernetnessunaPPTPPPPGREMPPE: rotto, lascia stareL2TP su IPsecPPPUDPIPsecQui, costruzione unoPPP su una ptysocket UDP, via netcatDTLSQui, costruzione duedispositivo tun o tapsocket UDP, via socatDTLSWireGuardinterfaccia del kernelUDPNoise, niente da negoziare
Ogni tunnel di questa lista ha la stessa forma. Le differenze sono in quale trasporto finiscono i byte, e se qualcosa li cifra. PPP fa la metà del collegamento dal 1994, ed è per questo che compare sotto tre di questi senza essere stato riprogettato per nessuno. Un dispositivo tun o tap fa la stessa metà senza alcun protocollo, ed è la seconda costruzione di questo articolo.

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.

Sei fasi, ognuna aggiunge una cosa che puoi provare da solaCostruiscila in quest'ordine, e puoi sempre ridiscenderla1Raw, su TCPpppd con una pty, o un dispositivo tap, e un semplice listener netcat.Funziona sul banco. Si scioglie su un percorso vero: due timer di ritrasmissione in lotta.2Raw, su UDPStesso link, trasporto a datagrammi. Un datagramma perso è un pacchetto perso e basta.Questa è la base. Tutto quello che sta sopra è facoltativo; questa no.3TLS, su TCPncat, stunnel o openssl attorno al trasporto. Verifica il certificato su entrambi i capi,o hai cifratura senza identità e nessun controllo d'accesso.4DTLS, su UDPsocat o openssl, e la forma a cui puntare: cifrata, autenticata, ancora a datagrammi.Un pacchetto perso resta perso invece di far litigare due stack.5Compressozstd tra l'interfaccia e il trasporto. Tieni la finestra tra i frame dove iltrasporto consegna in ordine; un frame autonomo per datagramma, più un dizionario, dove no.6Entrambi, in quest'ordinePrima comprimi, poi cifri. Mai il contrario: il testo cifrato non si comprime.E conosci il prezzo: comprimere prima di cifrare rivela la lunghezza. Va bene sul tuo traffico.
Sei fasi, ognuna aggiunge una cosa a quella sotto. Il raw su TCP è da dove partono tutti, ed è l’unico gradino che è un vicolo cieco: funziona sul banco e si scioglie su un percorso vero. Il raw su UDP è la base su cui poggia tutto il resto. Poi la cifratura, poi la compressione, poi tutte e due insieme. Ogni fase è un collegamento che puoi tirare su, pingare e lasciare acceso, così quando la cima della scala si comporta male puoi ridiscenderla un gradino alla volta.

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 script is 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.

pppd, uno pseudo-terminale, netcat e un socketUn pacchetto, da ppp0 a ppp0, e ogni mano da cui passaHOST AHOST Bppp0interfaccia del kernelpppdframing HDLCcoppia ptyslave a pppdmaster al figlioncatstdin e stdoutcoppia ptymaster al figlioslave a pppdncatstdin e stdoutpppdframing HDLCppp0interfaccia del kernelil socket: TCP o UDPI due riquadri in mezzo sono l'unica parte che scegli. Tutto il resto non cambia che il trasporto sia una linea telefonica, unaconsole seriale, un flusso TCP, datagrammi UDP o una sessione TLS: per questo cambiare trasporto dopo costa una parola.Uno pseudo-terminale non ha il pin di carrier-detect, quindi pppd aspetta una portante che non arriva. L'opzione `local` lo evita.
pppd parla HDLC asincrono nel lato slave di uno pseudo-terminale che si è allocato da solo. Il comando indicato da 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.

ImplementazioneIn ascolto su una portaUDPResta su dopo che il peer si disconnette
Ncat (Nmap)ncat -l 443-u-k / --keep-open
netcat di OpenBSDnc -l 443-u-k
netcat tradizionalenc -l -p 443-uno
GNU netcatnc -l -p 443-uno

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.

Ogni parola della riga di pppd, e cosa faLa riga di comando della costruzione UDP, parola per parolanodetachprimo piano: vedi l'output e puoi metterlo sotto un supervisorenoauthniente autenticazione del peer: è questo il buco; il tunnel non ha controllo d'accessolocalignora le linee di controllo del modem che una pty non ha. Senza, non sale nientepassiveaspetta un pacchetto LCP valido invece di uscire: comportamento da socket servernodefaultroutenon prendere la route di default quando IPCP finisce. La route che vuoi la aggiungi tunoipdefaultnon offrire l'indirizzo della macchina come capo locale192.0.2.1:192.0.2.2locale:remoto, fissati: pppd rifiuta ogni altra risposta durante IPCPlcp-echo-interval / -failureil controllo di vitalità: ha una sezione sua più sottomtu / mru 1400lascia spazio a quello che il trasporto avvolge attorno a ogni framepty '...'il comando il cui stdin e stdout diventano il link: qui, un socket netcatIl capo che si connette usa la stessa riga senza `passive`: inizia invece di aspettare.
Ogni opzione della riga, e cosa fa. Quella da tenere d’occhio è 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.

LCP, poi l'autenticazione, poi un protocollo di controllo per famiglia di indirizziTre fasi, e ognuna fallisce per un motivo suo1LCP: il collegamento stessoMRU, la mappa dei caratteri di controllo,un magic number contro il loopback, ese uno dei due capi vuole che l'altro si autentichi.Se fallisce qui, il trasporto non passa i bytein modo pulito nelle due direzioni. Controlla il socket,non le opzioni PPP.2Autenticazione: facoltativaPAP manda una password in chiaro. CHAP fa unasfida e una risposta MD5. Qui saltata.Entrambi provano chi è il peer. Nessuno cifraun solo byte di quello che segue.3aIPCPL'indirizzo IPv4a ciascun capo.3bIPV6CPGli identificatoridi interfaccia a 64 bit.Questi due sono indipendenti. IPv6 può salire mentre IPv4 sta ancora discutendo, eun errore in uno non butta giù l'altro. L'interfaccia comincia a portaretraffico per una famiglia appena il suo protocollo di controllo ha finito.
LCP sistema il collegamento stesso: quanto può essere grande un frame, quali caratteri di controllo vanno sottoposti a escape, e un magic number che rileva una linea in loopback. L’autenticazione è facoltativa e qui viene saltata. Poi un protocollo di controllo per ogni livello di rete: IPCP per IPv4, IPV6CP per IPv6. Sono indipendenti, quindi un collegamento può portare IPv6 mentre IPv4 sta ancora discutendo, e un guasto in uno non butta giù l’altro.

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.

Il frame, il byte di flag, e quanto costa l'escapeUn frame, e i due byte che non possono mai comparire al suo interno0x7Eflag0xFFindirizzo0x03controlloprotocollo1 o 2 bytepayload: il tuo pacchetto IPfino alla maximum receive unit concordataFCSCRC a 16 bit0x7EflagL'ESCAPE, L'UNICA REGOLA CHE C'ÈOgni byte scambiabile per un confine diventa 0x7D seguito dal byte originale in XOR con 0x20.payload 0x7E trasmesso come 0x7D 0x5Epayload 0x7D trasmesso come 0x7D 0x5DQuei due sono obbligatori. Il resto lo decide la mappa asincrona dei caratteri di controllo: 32 bit, uno per carattere.Mappa a zero: il default di pppd, e corretto su un socketEscape di due byte su 256. Un overhead che non misurerai mai. Un socket è un percorso pulito a 8 bit e non serve altro.Tutti e 32 segnati: l'impostazione prudente da modemSu payload compressi o cifrati circa un byte su otto è sotto 0x20, e raddoppia. Circa il 12% del link, per niente.
Il frame è flag, indirizzo, controllo, protocollo, payload, frame check sequence, flag. Ogni byte al suo interno che potrebbe essere scambiato per un confine viene sostituito da 0x7D seguito dal byte originale in XOR con 0x20. L’ACCM decide quanti altri byte ricevono lo stesso trattamento: zero su un percorso pulito a 8 bit, trentadue se uno dei due capi chiede il default prudente che presume un modem che si mangia i caratteri di controllo.

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

Un pacchetto perso, due trasporti, due esiti molto diversiUn pacchetto sparisce. Cosa fa dopo ciascun trasporto.TRASPORTO TCP: il tunnel nasconde la perdita1Il trasporto perde un segmento.2Il trasporto lo ritrasmette. I byte arrivano tardi,non mancano: ed è tutto il problema.3Il TCP incapsulato non vede il trasporto. Leggeil ritardo come congestione, raddoppia il timer eritrasmette dati già in viaggio sotto di lui.4Ora il trasporto deve l'originale e un duplicato,su un link che ha appena dimostrato di perdere pacchetti.La coda cresce più in fretta di quanto gli strati la svuotino.Il throughput crolla molto prima del link.TRASPORTO UDP: la perdita arriva allo strato che ne è padrone1Il trasporto scarta il pacchetto e non dice niente.2Il frame PPP dentro non supera il checksum e vienescartato. Il prossimo byte di flag risincronizza.3Il TCP incapsulato vede una perdita vera, perchéper una volta gli è stata detta la verità sul percorso.4Dimezza la finestra e ritrasmette una volta.Il controllo di congestione fa esattamente il lavoroper cui è nato. Un pacchetto perso costa un pacchetto.
Il TCP di trasporto garantisce la consegna, quindi un segmento perso viene ritrasmesso e i byte arrivano tardi invece di non arrivare. Il TCP incapsulato dentro vede solo il ritardo, decide che la rete è congestionata, rallenta e ritrasmette gli stessi dati, che ora il trasporto deve consegnare anch’essi. Il timer di ogni strato cerca di risolvere un problema che appartiene già all’altro, e la coda cresce più in fretta di quanto entrambi riescano a svuotarla. Un trasporto UDP scarta il pacchetto, il TCP interno vede una perdita vera, e il suo controllo di congestione fa il lavoro per cui è stato progettato.

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.

Un datagramma perso costa un frame, e il prossimo byte di flag recupera il linkI confini non si allineano, e non importaFRAME PPP COME LI HA SCRITTI pppd7Eframe A + FCS7Eframe B + FCS7Eframe C + FCS7Eframe D + FCSCOSA HA MANDATO DAVVERO IL TRASPORTO: netcat legge un buffer, non un framedatagramma 1datagramma 2: persodatagramma 3datagramma 4Il frame B perde il centro, il checksum fallisce e viene scartato. Il frame C perde i byte iniziali e fa la stessa fine.Due frame persi sono due pacchetti IP persi. Lo strato sopra li ritrasmette, e sa che il percorso ha perso qualcosa:proprio il segnale che un trasporto TCP avrebbe nascosto consegnandoli in ritardo.
Netcat legge quello che c’è nel buffer e lo scrive in un datagramma, quindi i confini dei frame e quelli dei datagrammi non hanno niente a che fare tra loro. Perdi un datagramma e il ricevente vede un frame a cui mancano dei byte: la frame check sequence fallisce e il frame viene scartato, esattamente come su una linea seriale rumorosa. Il prossimo 0x7E risincronizza il flusso. Un frame perso costa un pacchetto, e lo strato sopra lo ritrasmette: è il segnale di perdita di cui il TCP interno aveva bisogno e che su un trasporto TCP non ha mai ricevuto.

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
Rilevare un trasporto morto in trenta secondi, e ricostruirloUn trasporto può morire senza chiudersi. Ecco come PPP se ne accorge, e riparte.Il trasporto muore in silenziocapo lontano spento · voce NAT sparita ·un middlebox smette di inoltrareNessuno lo segnalaniente FIN, niente RST · ip link diceancora ppp0 UP · UDP non ha statoIl rilevatorelcp-echo-interval 10 lcp-echo-failure 3echo ogni 10 s, giù dopo 3 mancati: 30 sLa ricostruzionepersist maxfail 0 holdoff 5riparti, mai arrendersi, 5 s tra un tentativo e l'altroUn solo supervisoreunit systemd, Restart=always,pppd rilancia il comando pty:netcat e socket nuovi insiemeImposta l'echo su entrambi i capi. Un echo dimostra solo il percorso da cui è tornata la risposta.Metti `ip route` in /etc/ppp/ip-up.d/ e le route IPv6 in /etc/ppp/ipv6-up.d/, così l'instradamento si riapplica a ogni ritorno del link,invece di impostarlo una volta a mano e perderlo alla prima riconnessione.
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.

In chiaro, TLS su TCP, o DTLS su UDPStessa metà di collegamento ai due capi. Cambia solo il mezzo.pppd o tap0netcat liscio, UDPncat --udp --listen 6000pppd o tap0In chiaro sul filo, e il listener prende chi arriva per primo alla porta. Niente riservatezza, niente controllo d'accesso.pppd o tap0TLS su TCP: ncat, stunnel o opensslncat --ssl --ssl-verify --ssl-trustfile tunnel.crt host 6000pppd o tap0Protetto, e il certificato dice chi è il capo lontano. Ma il trasporto è di nuovo TCP, ed è l'unica forma che comprime il flusso.pppd o tap0DTLS su UDP: socat o opensslsocat - OPENSSL-DTLS-CLIENT:host:6000,cafile=tunnel.crt,verify=1pppd o tap0Cifrato, autenticato, e ancora a datagrammi. Un pacchetto perso resta perso invece di far litigare due stack. Punta qui.
Lo stesso pppd su entrambi i capi dall’inizio alla fine: cambia solo il comando pty. Netcat liscio ti dà un collegamento senza niente a proteggerlo. TLS su TCP protegge i byte e reintroduce il problema del TCP di trasporto. DTLS su UDP è la forma a cui puntare: cifrato, autenticato, e ancora un trasporto a datagrammi, così un pacchetto perso resta un pacchetto perso invece di diventare una lotta di ritrasmissioni tra due stack.

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.

La pila dell'overhead, e l'MTU interno che restaScendi dall'MTU del percorso, e usa quello che restaintestazione IP20 (v4) / 40 (v6)intestazione UDP8record DTLS + tag≈ 30framing PPP / EthernetpochiMTU interno, quello che il tunnel può portare: punta a 1400, minimo 1280Un record DTLS non si frammenta come un record TLS su un flusso TCP, quindi tutto questo deve stare nell'MTU del percorso.Stessa forma di OpenVPN dal 2001: trasporto a datagrammi, DTLS, interfaccia virtuale sopra. Non eccentrico; solo scomposto.
Scendi da 1500: 20 byte di intestazione IPv4 o 40 di IPv6, 8 di UDP, circa 30 per il record DTLS e il suo tag, qualcuno per il framing, e il resto è l’MTU interno che il tunnel può portare. Punta a 1400 su un percorso normale; 1280 è il minimo sicuro se qualcosa nel mezzo è a sua volta un tunnel. Questa forma (un trasporto a datagrammi, DTLS, un’interfaccia virtuale sopra) è più o meno quello che OpenVPN fa dal 2001. Non è eccentrica; è solo scomposta.

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.

Quattro manopole di pppd: una da impostare, una da lasciare, due da spegnereUna da impostare, una da lasciare, due da spegnereIMPOSTALAMTU e MRUEntrambi i capi, con margine: 1400 semplice, 1280 sotto un tunnel. Un frame frammentato perde un pacchetto intero.LASCIALAACCMGià a zero di default, giusto su un socket pulito. Toccala solo se qualcosa mangia i caratteri di controllo.SPEGNILEnovjcompressione delle intestazioni Van JacobsonRisparmia un arrotondamento su un link veloce, costa CPU per pacchetto, si rompe con le perdite. Spenta sopra il modem.SPEGNILEnodeflate nobsdcompIl payload è già TLS/DTLS: comprimere testo cifrato è lavoro puro e, oltre un confine di sicurezza, un attacco.Nessuna rende il tunnel più veloce. PPP non è il collo di bottiglia: PPPoE fa 2 Gbit con lo stesso demone, perché i suoi dati restanonel kernel. Qui il costo è la pty: ogni byte va nello spazio utente e torna. È colpa dello pseudo-terminale, non di PPP.
MTU e MRU è quella che conta: impostali entrambi su entrambi i capi con un margine, perché un frame che il trasporto deve frammentare perde un intero pacchetto a ogni perdita. L’ACCM è già a zero e corretto su un socket pulito. Spegni la compressione delle intestazioni di Van Jacobson con 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
Un dispositivo tap è un'interfaccia da un lato e un file descriptor dall'altroNessun demone, nessun protocollo, nessuno pseudo-terminale. Un file descriptor.KERNELtap0un'interfaccia normale,con indirizzo e route/dev/net/tunTUNSETIFF dà il nomeal dispositivoil tuo processosocat, o cinquanta righedi Python che tengono il fdsocket UDPun frame per datagrammala retee il capo lontanouna lettura = un frameCosa manca rispetto a PPP: nessuna dimensione di frame negoziata, nessun controllo di vitalità, niente indirizzi, niente autenticazione.Configuri a mano entrambi i capi e non ne discutono mai. Nessuno sorveglia il link, quindi nessuno ti dirà che è morto.
Nessun demone e nessun protocollo. Il kernel presenta tap0 come un’interfaccia normale e passa l’altro lato al processo che ha aperto /dev/net/tun. Una lettura restituisce esattamente un frame Ethernet; una scrittura ne inietta esattamente uno. Tutto quello che pppd negoziava (indirizzi, dimensioni dei frame, vitalità) ora lo configuri a mano su entrambi i capi, e i due capi non ne discutono mai.

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:

tapcat.py: tutto quanto, un centinaio di righe tapcat.py · 6 kB

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.

Un datagramma per frame, o un prefisso di lunghezza da inventareUna lettura da un dispositivo tap è un frame. Mantenerlo così è compito del trasporto.SU UDP: il confine è gratisdatagramma = frame Adatagramma = frame Bdatagramma = frame Cdatagramma = frame DUna lettura, un datagramma, una scrittura dall'altra parte. Niente da delimitare, da bufferizzare o da risincronizzare.SU TCP: i confini spariscono e devi rimetterli tuun flusso di byte: due frame possono arrivare in una lettura, un frame in trelenframe Alenframe Blenframe Clenframe DDue byte di lunghezza big-endian davanti a ogni frame, e un ricevente che legge la lunghezza e poi esattamente quei byte.Funziona, ma non si riprende. HDLC si risincronizza al prossimo 0x7E perché un flag non è ambiguo; un flusso a lunghezza cheperde il segno legge ogni lunghezza successiva in mezzo a un frame. Aggiungi marcatore e checksum per rimediare e hai rifatto HDLC.
Su UDP, un frame è un datagramma e il confine viene gratis. Su TCP i confini spariscono, quindi chi manda deve aggiungere un prefisso di lunghezza a ogni frame e chi riceve deve ricomporli in base a quello. PPP non ha questo problema perché si porta il suo framing (un byte di flag a ogni capo e un checksum), che è anche ciò che gli permette di risincronizzarsi dopo un danno. Un flusso con prefisso di lunghezza non può: sfasa un byte e ogni frame dopo è sbagliato.

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.

tuntap
Cosa passapacchetti IPframe Ethernet
Overhead per pacchettonessunointestazione Ethernet di 14 byte
ARP, DHCP, broadcastnosì, tutto quanto, attraverso il tunnel
Protocolli non IPnosì
Può entrare in un bridgenosì
Equivale aun collegamento punto-punto, come ppp0un 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.

Comprimi prima di cifrare, e tieni la finestra se il trasporto lo consenteL'ordine è fisso. La modalità è la scelta.tap0una lettura, un framecomprimizstd, livello 1cifraDTLS, o TLStrasportoUDP, o TCPMai alcontrario.FLUSH_BLOCK: tieni la finestraEmette tutto finora, tiene la storia. Ogni frame ècodificato rispetto a quelli prima. Nessuna latenza in più:un frame dentro, un frame fuori.5,0%sul traffico ripetitivo · 7,5% sui logServe ogni frame consegnato, in ordine.Quindi: TCP, o TLS su TCP. Non UDP, non DTLS.FLUSH_FRAME: buttala a ogni pacchettoOgni datagramma è un frame zstd completo e si decodificada solo: il datagramma N va anche se da 1 a N-1 sono persi.L'unica modalità per un trasporto a datagrammi.14,8%sullo stesso traffico · 24,2% sui logUn dizionario addestrato ne recupera gran parte:5,3% e 15,1%, e resta tollerante alle perdite.
La compressione va tra il dispositivo tap e il trasporto, e prima della cifratura, perché il testo cifrato non si comprime. FLUSH_BLOCK è la modalità che conta: emette tutto quello che c’è finora, quindi un frame dentro dà un frame fuori senza latenza aggiunta, mantenendo la storia della compressione per il frame successivo. FLUSH_FRAME butta via quella storia a ogni pacchetto, ed è ciò che lo rende sicuro su un trasporto con perdite e ciò che lo rende tre volte peggiore sul filo.

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 tunnelflusso, FLUSH_BLOCKper pacchetto, FLUSH_FRAMEper pacchetto con dizionario addestrato
Chiamate API e telemetria ripetitive5,0%14,8%5,3%
Righe di log7,5%24,2%15,1%
Testo semplice e file di configurazione37,8%51,3%45,3%
Byte casuali, al posto di TLS100%+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 sockettap o tun su un socket
Framingintegrato (HDLC, si risincronizza dopo un danno)nessuno su UDP perché non serve; da inventare su TCP
Impostazione degli indirizzinegoziata da IPCP e IPV6CPconfigurata a mano su entrambi i capi
Vitalitàecho LCP, integratonessuna; la aggiungi tu o il collegamento muore in silenzio
AutenticazionePAP o CHAP disponibili, entrambi debolinessuna
Livellosolo 33 con tun, 2 con tap
Bridgingnosì, con tap
Overheadflag, intestazione e FCS per frame, più l’escapeniente, o 14 byte con tap
Compressionedeflate e BSD, attive di default, del 1996nessuna, o zstd per frame che aggiungi e controlli tu
Serve rootsì, sempreper creare il dispositivo; non per usarlo
Parti in movimentoun demone, vecchio di trent’anniun 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 pppd non 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.

Un relay sono due socket uniti da una pipe, quindi l'endpoint si spostaUna connessione entra, un'altra esce, una pipe in mezzo. Questo è un proxy.clientapre una sessione TLSRELAY: la destinazione registrata al confinencat -l 7000termina il clientncat farendapre un nuovo saltocapo lontanoil vero altro latostdoutbackpipe (FIFO) riporta indietro le risposteclient → relayrelay → capo lontanoLa connessione del client finisce sul relay. I pacchetti no.Il tuo firewall ha registrato una connessione a questa macchina. Dove inoltra lo decide lei, e concatenarne tre metteil vero capo lontano a tre pipe di distanza: ogni log mostra solo una connessione locale ordinata verso il successivo.
Un relay sono due socket e una pipe. Il listener termina la connessione del client. Un secondo netcat apre una connessione nuova in avanti, e la FIFO porta la direzione di ritorno tra i due. La sessione TLS del client finisce qui, sul relay, e comincia un nuovo salto: quindi la destinazione che il tuo confine ha registrato è questa macchina, e i pacchetti proseguono dovunque lei li inoltri. Concatenane tre e il capo lontano è a tre pipe di distanza, con il firewall di ogni salto che vede solo un’ordinata connessione locale verso il successivo.

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.

Relay in catena su host compromessi ripuliscono l'endpointOgni salto è la macchina di qualcun altro, e ogni proprietario vede solo il mezzoattaccantel'unica macchina suarelay 1rete di un'altra aziendarelay 2una VPS dirottatarelay 3un router di casadestinazionedove era direttovede: 1←→2vede: 2←→3vede: 3←→destNessun salto vede oltre i suoi due vicini. Nessuna origine, nessuna destinazione, solo il mezzo.Il traffico si ripulisce attraverso una fila di sistemi altrui, ognuno con lo stesso relay di due socket e una pipe sotto ilcontrollo dell'attaccante. Per questo l'uscita di un host compromesso porta spesso a un'altra vittima: vent'anni di C2.
Ogni salto è un host compromesso (la macchina di un’altra azienda, una VPS dirottata, un router di casa) che fa girare lo stesso relay di due socket e una pipe sotto il comando e controllo dell’attaccante. Nessun salto può vedere oltre i suoi due vicini: il proprietario del relay 2 vede una connessione dal relay 1 e una verso il relay 3, e nient’altro. Il traffico viene ripulito attraverso una fila di sistemi di altre persone, ed è per questo che l’uscita di un host compromesso porta così spesso a un’altra vittima invece che all’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.


  1. 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. ↩︎

  2. RFC 2637 — Point-to-Point Tunneling Protocol (PPTP), che porta PPP dentro GRE. ↩︎

  3. RFC 3931 — Layer Two Tunneling Protocol versione 3, il discendente in standards track del protocollo che porta PPP dentro UDP. ↩︎

  4. 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 da man pppd su ppp 2.5.1. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  5. 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).» ↩︎ ↩︎

  6. 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. ↩︎

  7. RFC 5072 — IP Version 6 over PPP. IPV6CP e gli identificatori di interfaccia a 64 bit, indipendenti da IPCP. ↩︎

  8. RFC 1332 — The PPP Internet Protocol Control Protocol (IPCP), che negozia gli indirizzi IPv4 ai due capi del collegamento. ↩︎

  9. RFC 1994 — PPP Challenge Handshake Authentication Protocol (CHAP). Dimostra l’identità del peer; non cifra niente. ↩︎

  10. 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. ↩︎

  11. Ncat Users’ Guide — connecting through a proxy — --proxy e --proxy-type per HTTP CONNECT e SOCKS 4/5, così il trasporto TLS termina sul proxy, non sul capo lontano del tunnel. ↩︎

  12. Ncat Users’ Guide — le opzioni --ssl, --ssl-verify e --ssl-trustfile, e le modalità di ascolto e UDP. Versione provata qui: Ncat 7.92. ↩︎

  13. Universal TUN/TAP device driver — la documentazione del kernel stesso per /dev/net/tun, TUNSETIFF e la differenza tra tun e tap. ↩︎

  14. PEP 784 — Adding Zstandard to the standard library, ed è per questo che compression.zstd non richiede alcun pacchetto su Python 3.14. Misurato qui con Python 3.14.7 e zstd 1.5.7. ↩︎

  15. zstd(1) — la modalità --train e --maxdict, per costruire il dizionario che entrambi i capi devono caricare. ↩︎

  16. 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. ↩︎

  17. 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. ↩︎