VPN to nie produkt. To dwie roboty skręcone ze sobą, a twoja maszyna ma już program do każdej z nich.

Pierwsza robota to stworzenie łącza wirtualnego: interfejsu, który wygląda jak karta sieciowa, przyjmuje pakiety IP i oddaje je gdzie indziej. Druga to przeniesienie bajtów tego łącza z jednego końca na drugi. Kupujesz urządzenie VPN i kupujesz obie roboty z licencją przypiętą zszywaczem; robisz to sam i każda z nich to jeden program, który już jest zainstalowany. Na Linuksie pierwszą robotę można zrobić na dwa sposoby i ten wpis buduje oba: pppd, który przynosi cały protokół łącza (negocjowane adresy, sprawdzanie, czy druga strona żyje, ramkowanie), oraz urządzenie tap, które nie przynosi niczego i jest dziurą w jądrze, w którą wpychasz ramki. Różne kompromisy, nie konkurenci, a druga połowa wpisu stawia je obok siebie.

Ten protokół to PPP, a powód, dla którego to działa, jest zapisany w jego pierwszym akapicie: PPP to protokół łącza dla połączeń punkt-punkt1 i nie określa, z czego to łącze jest zrobione. Modem i linia telefoniczna były pierwotną odpowiedzią. Nigdy nie były jedyną. PPTP włożył PPP do GRE2. L2TP włożył je do UDP3. PPPoE włożył je do ramek Ethernetu. Każde z nich to ten sam protokół z innym kurierem i żadne nie wymagało zmiany PPP.

Pytanie nie brzmi więc, czy da się puścić PPP po gnieździe TCP albo UDP, tylko po którym i ile to kosztuje. Krótka odpowiedź, z pokazanym rachunkiem: używaj UDP. Puszczanie protokołu strumieniowego wewnątrz niezawodnego strumienia to jedyny błąd w tym wpisie, który na biurku wygląda dobrze, a na prawdziwym łączu się rozsypuje.

VPN to dwie roboty. Obie już masz.

Zdejmij marketing z dowolnego tunelu i zostają trzy rzeczy: coś wystawia interfejs wirtualny i zamienia pakiety w strumień bajtów, coś przenosi ten strumień przez sieć, która już działa, a coś go szyfruje albo nic go nie szyfruje.

Każdy tunel to połowa łącza, nośnik i trochę kryptografiiZa każdym razem te same trzy części. Zmienia się tylko nośnik i kryptografia.TUNELPOŁOWA ŁĄCZANOŚNIKKRYPTOGRAFIAPPP dial-up, 1994PPPmodem i linia telefonicznabrakPPPoEPPPramki EthernetubrakPPTPPPPGREMPPE: złamane, nie używajL2TP po IPsecPPPUDPIPsecTen wpis, budowa pierwszaPPP po ptygniazdo UDP, przez netcataDTLSTen wpis, budowa drugaurządzenie tun albo tapgniazdo UDP, przez socatDTLSWireGuardinterfejs jądraUDPNoise, bez negocjacji
Każdy tunel na tej liście ma ten sam kształt. Różnice są w tym, do jakiego nośnika trafiają bajty i czy cokolwiek je szyfruje. PPP robi połowę łącza od 1994 roku, i dlatego pojawia się pod trzema z nich, choć dla żadnego nie zostało przeprojektowane. Urządzenie tun albo tap robi tę samą połowę bez żadnego protokołu i to jest druga budowa w tym wpisie.

PPP robi połowę łącza porządnie: negocjację adresów, sprawdzanie żywotności, kompresję nagłówków, kilka protokołów warstwy sieci na jednym łączu, krok uwierzytelnienia, jeśli go chcesz. Mnóstwo skończonej roboty, która leży w /usr/sbin i nic nie robi. Czego nie robi, to przejmować się nośnikiem: daj mu deskryptor pliku, który przenosi bajty w obie strony, i będzie po nim działać. Netcat to program, którego jedynym celem jest bycie takim deskryptorem.

Szyfrowanie to część, której nikt ci nie poda na tacy, i to na nie idzie większość tego wpisu, bo netcat nie ma na nie odpowiedzi, a udawanie, że ma, to sposób, w jaki ludzie budują rzeczy, których nie powinni.

Etapy i dlaczego idą w tej kolejności

Wszystko poniżej jest budowane etapami, a każdy dodaje jedną rzecz do poprzedniego. To nie jest chwyt dydaktyczny. Tak właśnie należy to budować, bo kiedy psuje się etap szósty, musisz wiedzieć, czy etap drugi nadal działa, a wiesz to tylko wtedy, gdy etap drugi był kiedyś czymś, co uruchomiłeś osobno.

Sześć etapów, każdy dodaje jedną rzecz do osobnego sprawdzeniaBuduj w tej kolejności, a zawsze zejdziesz z powrotem1Surowo, po TCPpppd z pty albo urządzenie tap i zwykły nasłuch netcata.Działa na stole. Rozpada się na prawdziwej ścieżce: dwa liczniki retransmisji walczą.2Surowo, po UDPTo samo łącze, nośnik datagramowy. Zgubiony datagram to jeden zgubiony pakiet.To fundament. Wszystko powyżej jest opcjonalne; to nie.3TLS, po TCPncat, stunnel albo openssl owijają nośnik. Weryfikuj certyfikat na obu końcach,inaczej masz szyfrowanie bez tożsamości i żadnej kontroli dostępu.4DTLS, po UDPsocat albo openssl, kształt docelowy: szyfrowany, uwierzytelniony, wciąż datagramy.Zgubiony pakiet zostaje zgubionym pakietem, zamiast kłótni dwóch stosów.5Kompresjazstd między interfejsem a nośnikiem. Trzymaj okno przez ramki, gdy nośnikdostarcza po kolei; gdy nie, jedna samodzielna ramka na datagram plus słownik.6Oba, po koleiKompresuj, potem szyfruj. Nigdy odwrotnie: szyfrogram się nie kompresuje.I znaj koszt: kompresja przed szyfrowaniem zdradza długość tekstu. Dla własnego ruchu w porządku.
Sześć etapów, każdy dodaje jedną rzecz do tego pod nim. Surowo po TCP to miejsce, od którego zaczynają wszyscy, i jedyny szczebel, który jest ślepą uliczką: działa na stole, a na prawdziwej ścieżce się rozpada. Surowo po UDP to fundament, na którym stoi cała reszta. Potem szyfrowanie, potem kompresja, potem jedno i drugie. Każdy etap to łącze, które możesz podnieść, przepingować i zostawić działające, więc kiedy szczyt drabiny źle się zachowuje, możesz po niej schodzić szczebel po szczeblu.

Samo łącze jest budowane w ten sam sposób i na tym opiera się jednosekundowa rozgrzewka opisana niżej: tunel wstaje na surowo, udowadnia, że potrafi przenieść ramkę, i dopiero wtedy zaczyna kombinować. Budowa, która włącza wszystko naraz, wysypuje się jako jedna bryła, a ty spędzasz wieczór na zgadywaniu, która warstwa to zrobiła.

Czego pppd naprawdę chce: deskryptora pliku

pppd został napisany dla portów szeregowych, więc naiwne odczytanie jest takie, że potrzebuje portu. Nie potrzebuje. Potrzebuje urządzenia terminala i zrobi je sobie sam:

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

Przeczytaj to jeszcze raz, bo cała budowa jest właśnie tam. pppd tworzy pseudoterminal, zatrzymuje stronę slave, a stronę master oddaje poleceniu jako stdin i stdout. Co to polecenie robi z bajtami, to już nie sprawa pppd. Uruchom tam nc i pójdą do gniazda.

pppd, pseudoterminal, netcat i gniazdoJeden pakiet, od ppp0 do ppp0, i każde ręce, przez które przechodziHOST AHOST Bppp0interfejs jądrapppdramkowanie HDLCpara ptyslave dla pppdmaster dla potomkancatstdin i stdoutpara ptymaster dla potomkaslave dla pppdncatstdin i stdoutpppdramkowanie HDLCppp0interfejs jądragniazdo: TCP albo UDPDwa pola w środku to jedyna część, którą wybierasz. Wszystko po bokach jest takie samo, czy nośnikiem jest linia telefoniczna,konsola szeregowa, strumień TCP, datagramy UDP czy sesja TLS, i dlatego późniejsza zmiana nośnika kosztuje jedno słowo.Pseudoterminal nie ma pinu wykrywania nośnej, więc pppd czeka na nośną, która nie przyjdzie. Zatrzymuje to opcja `local`.
pppd mówi asynchronicznym HDLC do strony slave pseudoterminala, który sam sobie przydzielił. Polecenie wskazane przez pty dziedziczy stronę master jako stdin i stdout. Netcat kopiuje stdin do gniazda, a gniazdo na stdout, więc dwie instancje pppd rozmawiają ze sobą przez parę pty i sieć, a żadna nie wie, że istnieje jakieś gniazdo.

Jest druga droga, notty, która zamiast tego używa własnego stdin i stdout pppd. Ale uruchamia ona proces pośredniczący, przez który przechodzi każdy bajt, więc „increases the latency and CPU overhead”4. Używaj pty, chyba że masz powód, by tego nie robić.

Trzy praktyczne fakty przed pierwszym poleceniem, wszystkie sprawdzone na maszynie, na której to pisałem: 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

Potrzebuje roota. Nie da się tego obejść. Binarka na Fedorze nie ma setuid, /dev/ppp ma tryb 0600 i należy do roota, a opcje, których potrzebujesz, i tak są uprzywilejowane. To coś, co uruchamiasz jako root albo z pliku unit, a nie coś, co użytkownik robi od niechcenia. Ma to znaczenie później, kiedy dojdziemy do tego, co to oznacza dla twojej polityki ruchu wychodzącego.

Strona jądra jest modułowa. ppp_generic obsługuje interfejs, ppp_async ramkowanie z wypychaniem bajtów, którego potrzebuje pty, a ppp_deflate/bsd_comp/ppp_mppe kompresję i szyfrowanie; ładują się na żądanie. Jeśli w okrojonym obrazie kontenera brakuje ppp_async, łącze wstaje i nie przenosi nic. Paskudne pół godziny, jeśli nie wiesz, gdzie patrzeć.

Na pty nie ma linii sterujących modemu. Bez pinu wykrywania nośnej pppd czeka na nośną, która nigdy nie przyjdzie. Poprawka to jedno słowo, local, które każe mu ignorować linie sterujące modemu4. Pomiń je i nic się nie dzieje, bez żadnego błędu wartego czytania.

Netcat to nie jeden program

Przed budową pułapka, która zjada najwięcej czasu: „netcat” to co najmniej cztery programy z niezgodnymi flagami, a to, który dostaniesz, zależy od dystrybucji. Na tej maszynie /usr/bin/nc to dowiązanie symboliczne do /usr/bin/ncat, przepisanej wersji z Nmapa. Więc polecenie skopiowane z piętnastoletniej strony wiki pada z powodów, które nie mają nic wspólnego z PPP.

ImplementacjaNasłuch na porcieUDPDziała dalej po rozłączeniu drugiej strony
Ncat (Nmap)ncat -l 443-u-k / --keep-open
OpenBSD netcatnc -l 443-u-k
Tradycyjny netcatnc -l -p 443-unie
GNU netcatnc -l -p 443-unie

Zanim więc zrzucisz winę na pppd, sprawdź, który masz:

readlink -f "$(command -v nc)"
nc --version 2>&1 | head -1 || nc -h 2>&1 | head -1

Poniżej będę używał ncat wprost. To ten z wbudowanym TLS, co ma znaczenie później, a jawność oznacza, że polecenia nie znaczą po cichu czegoś innego na twojej maszynie.

Etap pierwszy: budowa po TCP, bo to ją każdy próbuje najpierw

Jeden koniec nasłuchuje, drugi się łączy. Adresy są tu z zakresu dokumentacyjnego, więc wklej je prosto do laboratorium i nic routowalnego nie ucierpi. Port przez cały czas to 443 i to celowe: ruch wychodzący na 443 jest domyślnie otwarty niemal w każdej sieci. Owiń nośnik w TLS kilka etapów dalej, a ruchu na nim nie da się odróżnić od żadnej sesji HTTPS. Postawienie tam nasłuchu wymaga roota, a daleki koniec, czyli własna maszyna atakującego albo przekaźnik, go ma. To cały argument o egressie w jednym numerze portu i jeszcze do niego wrócę.

Na stronie nasłuchującej:

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'

Na stronie łączącej się:

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'

Każde słowo robi tu swoją robotę, a jedno z nich, noauth, po cichu robi szkodę. Tunel nie ma kontroli dostępu, o czym jest osobna sekcja dalej.

Każde słowo w linii pppd i co robiLinia poleceń budowy po UDP, słowo po słowienodetachpierwszy plan: widzisz wyjście i możesz dać go nadzorcynoauthbrak uwierzytelnienia rozmówcy: to jest dziura, tunel nie ma kontroli dostępulocalignoruj linie sterujące modemu, których pty nie ma. Bez tego nic nie wstaniepassiveczekaj na poprawny pakiet LCP, zamiast kończyć: jak gniazdo serweranodefaultroutenie zabieraj trasy domyślnej po IPCP. Dodaj potrzebną trasę samnoipdefaultnie proponuj własnego adresu maszyny jako lokalnego końca192.0.2.1:192.0.2.2local:remote, przypięte: pppd odrzuca inną odpowiedź w IPCPlcp-echo-interval / -failuresprawdzanie żywotności: osobna sekcja niżejmtu / mru 1400zostaw miejsce na to, czym nośnik owinie każdą ramkępty '...'polecenie, którego stdin i stdout stają się łączem: tu gniazdo netcataStrona łącząca się to ta sama linia bez `passive`: inicjuje, zamiast czekać.
Każda opcja w linii i co robi. Uważaj na noauth: wyłącza uwierzytelnianie drugiej strony, więc nasłuch przyjmuje każdego, kto przyjdzie. nodefaultroute i noipdefault nie pozwalają łączu po cichu przepisać twojego routingu, local sprawia, że na pty w ogóle wstaje, a przypięta para local:remote nie pozwala pppd przyjąć innej odpowiedzi podczas IPCP. Strona łącząca się to ta sama linia bez passive.

Podnieś oba końce, a dostaniesz ppp0 na każdym, trasę punkt-punkt do dalekiego adresu i interfejs, który możesz pingować, przez który możesz routować i na którym możesz puścić tcpdump. To jest VPN: bez instalowania pakietu, bez konfigurowania demona, bez wymiany kluczy, i właśnie w tym problem, do którego jeszcze wrócę.

Co wynegocjował i jak to obserwować

Dodaj debug, a pppd zaloguje wymianę protokołu sterującego, którą warto raz przeczytać, nawet jeśli nigdy więcej do niej nie zajrzysz. Łącze wstaje etapami i każdy etap może zawieść sam.

LCP, potem uwierzytelnienie, potem protokół sterujący na rodzinę adresówTrzy etapy, a każdy zawodzi z własnego powodu1LCP: samo łączeMRU, mapa znaków sterujących,magiczna liczba na zapętloną linięi czy któraś strona chce uwierzytelnienia.Awaria tutaj: nośnik nie przenosi bajtówczysto w obie strony. Sprawdź gniazdo,a nie opcje PPP.2Uwierzytelnienie: opcjonalnePAP wysyła hasło otwartym tekstem. CHAP robiwyzwanie i odpowiedź MD5. Tu pominięte.Oba dowodzą, kim jest rozmówca. Żaden nie szyfrujeani bajtu z tego, co dalej.3aIPCPAdres IPv4na każdym końcu.3bIPV6CP64-bitowe IDinterfejsu.Te dwa są niezależne. IPv6 może wstać, gdy IPv4 jeszcze się kłóci,a awaria jednego nie kładzie drugiego. Interfejs zaczyna przenosić ruchdanej rodziny w chwili, gdy kończy się jej protokół sterujący.
LCP ustala samo łącze: jak duża może być ramka, które znaki sterujące trzeba escapować, oraz magiczną liczbę, która wykrywa zapętloną linię. Uwierzytelnienie jest opcjonalne i tu pominięte. Potem jeden protokół sterujący na każdą warstwę sieci: IPCP dla IPv4, IPV6CP dla IPv6. Są od siebie niezależne, więc łącze może przenosić IPv6, gdy IPv4 jeszcze się kłóci, a awaria jednego nie kładzie drugiego.

Dwa przydatne narzędzia do debugowania są już zainstalowane i nikt ich nie używa:

# 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 zapisuje ze znacznikami czasu zrzut każdego bajtu, pppdump zamienia go w coś czytelnego4, a z tcpdump -ni ppp0 widzisz obie strony: ramkowanie pod spodem i pakiety na wierzchu.

Ramka na kablu i dlaczego 0x7E jest wszędzie

PPP po linii szeregowej (a pty jest nią z punktu widzenia pppd) używa asynchronicznego ramkowania HDLC i zrozumienie go to różnica między strojeniem a zgadywaniem. Każda ramka zaczyna się i kończy tym samym bajtem: „Each frame begins and ends with a Flag Sequence, which is the binary sequence 01111110 (hexadecimal 0x7e)”5. Skoro 0x7e oznacza granicę, nie może pojawić się wewnątrz ramki, więc jest escapowany. Tak samo bajt escape 0x7d i wszystko inne, o co poprosi którykolwiek koniec.

Ramka, bajt flagi i ile kosztuje escapowanieJedna ramka i dwa bajty, które nigdy nie mogą pojawić się w środku0x7Eflaga0xFFadres0x03sterowanieprotokół1 lub 2 bajtyładunek: twój pakiet IPdo uzgodnionego maksymalnego MRUFCS16-bitowe CRC0x7EflagaESCAPOWANIE, JEDYNA REGUŁAKażdy bajt, który można wziąć za granicę, zastępuje 0x7D, a po nim oryginalny bajt XOR 0x20.ładunek 0x7E wysłany jako 0x7D 0x5Eładunek 0x7D wysłany jako 0x7D 0x5DTe dwa są obowiązkowe. Resztę decyduje mapa asynchronicznych znaków sterujących: 32 bity, po jednym na znak.Mapa na zero: domyślne w pppd i poprawne na gnieździeDwa escapowane bajty z 256. Narzut, którego nie zmierzysz. Gniazdo to czysta ścieżka 8-bitowa i nic więcej nie trzeba.Wszystkie 32 oznaczone: ostrożne ustawienie modemowePrzy ładunku skompresowanym lub szyfrowanym co ósmy bajt jest poniżej 0x20, więc się podwaja. Około 12% łącza za nic.
Ramka to flaga, adres, pole sterujące, protokół, ładunek, sekwencja kontrolna ramki, flaga. Każdy bajt w środku, który można by wziąć za granicę, zastępowany jest przez 0x7D, a po nim oryginalny bajt XOR 0x20. ACCM decyduje, ile innych bajtów potraktować tak samo: zero na czystej ścieżce 8-bitowej, trzydzieści dwa, jeśli któryś koniec poprosi o ostrożne ustawienie domyślne, zakładające modem zjadający znaki sterujące.

Reguła escapowania jest dokładna: „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.

Ta ostatnia część to pokrętło do strojenia. ACCM ma 32 bity, po jednym na każdy znak sterujący, a 1 oznacza „escapuj to”. Poproś o wszystkie, a przy zaszyfrowanym ładunku, gdzie bajty są w praktyce losowe, mniej więcej co ósmy bajt jest poniżej 0x20: około 12% narzutu za nic.

Współczesny pppd robi tu już to, co trzeba. Czytaj stronę man, a nie legendy:

If no asyncmap option is given, the default is zero, so pppd will ask the peer not to escape any control characters.4

Więc asyncmap 0 to ustawienie domyślne, a nie sztuczka, a gniazdo to czysta ścieżka 8-bitowa, która nie potrzebuje escapowania poza dwoma obowiązkowymi bajtami. Zostaw to w spokoju; ustawiaj bity tylko wtedy, gdy coś po drodze naprawdę zjada znaki sterujące: serwer terminali, koncentrator szeregowy, kiepskie proxy konsoli. Sekwencja kontrolna ramki na końcu to 16-bitowe CRC i to dzięki niej działa budowa po UDP, która jest następna.

TCP po TCP to zły nośnik

Powyższa budowa działa. Na stole laboratoryjnym, po loopbacku albo w cichej sieci LAN działa pięknie, i właśnie dlatego ludzie ją wdrażają.

Potem trafia na prawdziwą ścieżkę z prawdziwymi stratami. I przewraca się w sposób, który wygląda na wszystko, tylko nie na to, czym jest.

Problem to dwa niezależne liczniki retransmisji położone jeden na drugim, przy czym zewnętrzny ukrywa stratę przed wewnętrznym. Olaf Titz napisał rozstrzygające wyjaśnienie, które otwiera dokładnie ta budowa:

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

Jeden zgubiony pakiet, dwa nośniki, dwa bardzo różne wynikiGinie jeden pakiet. Co dalej robi każdy nośnik.NOŚNIK TCP: tunel ukrywa stratę1Nośnik gubi segment.2Nośnik go retransmituje. Bajty przychodzą późno,a nie wcale: i w tym cały problem.3Tunelowane TCP nie widzi nośnika. Odczytujeopóźnienie jako przeciążenie, podwaja liczniki retransmituje dane, które już lecą niżej.4Teraz nośnik winien jest oryginał i duplikat,po łączu, które właśnie dowiodło, że gubi pakiety.Kolejka rośnie szybciej, niż warstwy ją opróżniają.Przepustowość pada dużo wcześniej niż łącze.NOŚNIK UDP: strata trafia do warstwy, do której należy1Nośnik gubi pakiet i nic nie mówi.2Ramka PPP w środku nie przechodzi sumy kontrolneji idzie do kosza. Następna flaga resynchronizuje.3Tunelowane TCP widzi prawdziwą stratę, bo choćraz usłyszało prawdę o ścieżce.4Zmniejsza okno o połowę i retransmituje raz.Kontrola przeciążenia robi dokładnie to, do czegoją zaprojektowano. Zgubiony pakiet kosztuje pakiet.
TCP nośnika gwarantuje dostarczenie, więc zgubiony segment jest retransmitowany, a bajty przychodzą późno, a nie wcale. Tunelowane TCP w środku widzi tylko opóźnienie, uznaje, że sieć jest zatłoczona, zwalnia i retransmituje te same dane, które nośnik teraz też musi dostarczyć. Licznik każdej warstwy próbuje naprawić problem, który już należy do drugiej warstwy, a kolejka rośnie szybciej, niż którakolwiek zdąży ją opróżnić. Nośnik UDP gubi pakiet, wewnętrzne TCP widzi prawdziwą stratę, a jego kontrola przeciążenia robi to, do czego została zaprojektowana.

Tak to wygląda. Oba TCP ustawiają licznik retransmisji na podstawie czasu podróży w obie strony. Kiedy nośnik zgubi segment, retransmituje go, więc dane wewnętrznego połączenia przychodzą późno. A wewnętrzne TCP, które nie widzi nośnika, odczytuje spóźnienie jako przeciążenie i też retransmituje. Teraz nośnik ma do dostarczenia oryginał i duplikat, po łączu, które już gubi pakiety. Wewnętrzny licznik się podwaja, zewnętrzna kolejka rośnie, a przepustowość zapada się na długo przed samym łączem. Nic w logach nie mówi dlaczego.

To nie jest subtelna kwestia wydajności. To różnica między tunelem, który degraduje się łagodnie, a takim, który przestaje przepuszczać ruch przy może 2% strat, podczas gdy ping po tej samej ścieżce wciąż wygląda dobrze. To jest powód, by używać UDP, a TCP trzymać w odwodzie tylko dla ścieżki, która nie przepuści niczego innego.

Więc używaj UDP, i to jako ustawienia domyślnego, a nie preferencji.

Etap drugi: budowa po UDP, czyli fundament

Ten sam pppd, inny nośnik. Jedyna zmiana jest w poleceniu pty.

Strona nasłuchująca:

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'

Strona łącząca się:

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'

Dwie rzeczy w nasłuchu UDP, które cię zaskoczą, i żadna nie jest problemem PPP.

Nasłuch nie może odpowiedzieć, dopóki ktoś się do niego nie odezwie. Gniazdo UDP nie ma połączenia do przyjęcia, więc netcat nie wie, dokąd wysyłać odpowiedzi, dopóki nie przyjdzie datagram. Przywiązuje się do pierwszego adresu i portu źródłowego, od którego coś usłyszy, i rozmawia z nim. To oznacza, że strona łącząca się musi nadać pierwsza, co pppd robi sam, bo koniec niepasywny od razu zaczyna strzelać żądaniami konfiguracji LCP. Oznacza to też, że jeśli zmieni się port źródłowy klienta, nośnik po cichu rozmawia z niewłaściwym miejscem. Za NAT-em z krótkim limitem czasu dla UDP to tunel, który umiera co kilka minut bez widocznego powodu.

--keep-open nie robi na UDP tego, czego chcesz. Ncatowe -k utrzymuje nasłuch TCP w gotowości do przyjmowania po odejściu drugiej strony. Na UDP nie ma czego przyjmować, więc odzyskanie oznacza restart nośnika, i do tego służą persist i holdoff, opisane niżej.

Oba punkty przemawiają za socat, który ostrożniej obchodzi się z rozmówcami UDP, i za nadzorcą procesu, zamiast ufać, że samo się utrzyma.

Dlaczego PPP przeżywa zgubiony datagram

Oczywisty zarzut wobec nośnika UDP jest taki, że PPP oczekuje strumienia bajtów, a UDP nim nie jest: datagramy przychodzą w całości albo wcale i mogą przyjść w złej kolejności. Mimo to działa, dzięki dwóm bajtom, które ramkowanie niosło od zawsze.

Zgubiony datagram kosztuje ramkę, a następny bajt flagi naprawia łączeGranice się nie pokrywają i nie ma to znaczeniaRAMKI PPP TAK, JAK ZAPISAŁ JE pppd7Eramka A + FCS7Eramka B + FCS7Eramka C + FCS7Eramka D + FCSCO NOŚNIK NAPRAWDĘ WYSŁAŁ: netcat czyta bufor, nie ramkędatagram 1datagram 2: zgubionydatagram 3datagram 4Ramka B traci środek, więc suma kontrolna się nie zgadza i ramka idzie do kosza. Ramka C traci początek i kończy tak samo.Dwie zgubione ramki to dwa zgubione pakiety IP. Warstwa wyżej je retransmituje, wiedząc, że ścieżka coś zgubiła,a to dokładnie ten sygnał, który nośnik TCP ukryłby, dostarczając je po prostu później.
Netcat czyta to, co jest w buforze, i zapisuje to do datagramu, więc granice ramek i granice datagramów nie mają ze sobą nic wspólnego. Zgub datagram, a odbiorca widzi ramkę, w której brakuje bajtów: sekwencja kontrolna się nie zgadza i ramka jest odrzucana, dokładnie tak jak na zaszumionej linii szeregowej. Następne 0x7E resynchronizuje strumień. Jedna utracona ramka kosztuje jeden pakiet, a warstwa wyżej go retransmituje. To jest sygnał straty, którego wewnętrzne TCP potrzebowało i którego po nośniku TCP nigdy nie dostało.

PPP po asynchronicznym HDLC zostało zaprojektowane dla linii, która psuje bajty. Każda ramka niesie 16-bitową sekwencję kontrolną; ramka, która jej nie przejdzie, jest odrzucana, a następny bajt flagi resynchronizuje odbiorcę. Zmiana kolejności zdarza się rzadziej niż strata i daje ten sam wynik: złe FCS, odrzucona ramka, resynchronizacja.

Zgubiony datagram kosztuje więc jedną ramkę PPP, czyli jeden pakiet IP, a to normalny stan każdej sieci, jaką kiedykolwiek zbudowano. Właściciel pakietu go retransmituje, a kontrola przeciążenia widzi prawdziwą stratę i reaguje poprawnie. To cały argument za UDP: pozwala ruchowi w tunelu poznać prawdę o ścieżce.

Nie pozwól jednak, by ramki urosły na tyle, że nośnik musiałby je fragmentować. Wtedy jeden zgubiony fragment zabija cały datagram, a twoja efektywna stopa strat się mnoży. Trzymaj MTU PPP wyraźnie poniżej MTU ścieżki.

Adresy, trasy i porządne IPv6

ppp0 to interfejs punkt-punkt, bez podsieci i bez ARP, więc local:remote to cała adresacja, a routujesz przez niego jawnie. Dla pojedynczego hosta, który ma sięgnąć do jednej sieci za dalekim końcem:

# on the client, after the link is up
ip route add 203.0.113.0/24 via 192.0.2.1 dev ppp0

Żeby daleki koniec przekazywał ruch w imieniu klienta, standardowe dwa kroki:

sysctl -w net.ipv4.ip_forward=1
nft add rule inet nat postrouting oifname "eth0" ip saddr 192.0.2.2/32 masquerade

proxyarp sprawi, że serwer będzie odpowiadał na ARP za klienta we własnym segmencie4, co jest zgrabne, dopóki drugi klient nie zechce tego samego. Potem zrób to, co większość ludzi pomija. Puść po tym IPv6: łącze punkt-punkt bez NAT-u, bez domeny rozgłoszeniowej i bez niedoboru adresów to najłatwiejsze miejsce w twojej sieci, żeby zrobić IPv6 porządnie:

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 włącza IPV6CP; ipv6 <local>,<remote> ustawia dwa 64-bitowe identyfikatory interfejsu4, łącze wstaje z adresami link-local, a ty dokładasz na wierzch globalne /647. IPV6CP jest niezależne od IPCP8, więc noip nie przenosi nic poza IPv6. Rozsądna rzecz do zbudowania w 2026 roku, jednym słowem.

Utrzymanie łącza, gdy nośnik umiera po cichu

To awaria, która marnuje całe popołudnie, więc dostaje własną sekcję.

Nośnik TCP, który umiera brzydko (daleki koniec wyłączony, wygasły wpis w tablicy NAT, urządzenie pośrednie, które przestało przekazywać), nie zamyka się. Nie ma FIN, nie ma RST, nie ma nic. Netcat siedzi z gniazdem, które nigdy nie dostarczy kolejnego bajtu, pppd siedzi z pty, które nigdy nie zobaczy kolejnej ramki, a ip link radośnie raportuje ppp0 jako UP. Nośnik UDP nie ma w ogóle stanu połączenia, więc niczego nie zauważa.

PPP ma wbudowaną odpowiedź, i jest ona domyślnie wyłączona:

lcp-echo-interval 10 lcp-echo-failure 3

To wysyła echo LCP co dziesięć sekund i rozbiera łącze, gdy trzy pozostaną bez odpowiedzi4: trzydzieści sekund na wykrycie martwego nośnika, dokładnie w przypadku, który wymienia strona man, „no hardware modem control lines”4, czyli w każdym pty, jakie kiedykolwiek powstało. Potem zdecyduj, co dzieje się dalej:

persist maxfail 0 holdoff 5
Wykrycie martwego nośnika w trzydzieści sekund i odbudowaNośnik może umrzeć bez zamknięcia. Tak PPP to zauważa i wraca.Nośnik umiera po cichudaleki koniec wyłączony · brak wpisu NAT ·pośrednik przestaje przekazywaćNic tego nie zgłaszabrak FIN, brak RST · ip link nadalmówi ppp0 UP · UDP nie ma stanuDetektorlcp-echo-interval 10 lcp-echo-failure 3echo co 10 s, w dół po 3 brakach: 30 sOdbudowapersist maxfail 0 holdoff 5restart, bez poddawania się, 5 s między próbamiJeden nadzorcaunit systemd, Restart=always,pppd ponownie uruchamia pty:świeży netcat i gniazdoUstaw echo na obu końcach. Echo dowodzi tylko ścieżki, którą wróciła odpowiedź.Włóż `ip route` do /etc/ppp/ip-up.d/, a trasy IPv6 do /etc/ppp/ipv6-up.d/, żeby routing wracał przy każdym powrocie łącza,a nie był ustawiony raz ręcznie i stracony przy pierwszym ponownym połączeniu.
lcp-echo-interval 10 lcp-echo-failure 3 to detektor: echo co dziesięć sekund, łącze w dół po trzech nieodebranych. persist maxfail 0 holdoff 5 to odbudowa: restart, nigdy się nie poddawaj, odczekaj pięć sekund, żeby migocząca ścieżka nie stała się fork bombą. pppd ponownie uruchamia polecenie pty, więc razem z nim przychodzi świeży netcat i świeże gniazdo. Ustaw echo na obu końcach; jeden nadzorca, unit systemd z Restart=always, jest lepszy niż dwa kłócące się procesy. Włóż ip route do /etc/ppp/ip-up.d/, żeby routing wracał razem z łączem.

Nie ma szyfrowania ani uwierzytelniania

Wszystko powyżej to działający tunel. Nie jest to tunel bezpieczny, a ta luka to nie szczegół.

Nie ma szyfrowania. Nie słabe szyfrowanie. Żadne. Każdy pakiet, który przez to przepuścisz, leci po kablu otwartym tekstem, owinięty w ramkę HDLC, którą każde narzędzie do przechwytywania rozkoduje od ręki. tcpdump pokaże ci zawartość cudzego tunelu równie chętnie jak twojego.

Nie ma uwierzytelnienia drugiej strony. noauth mówi to wprost. Nasłuch netcata przyjmuje wszystko, co przyjdzie na port: pierwsze połączenie albo datagram skądkolwiek. Kto pierwszy, ten dostaje routowane łącze do twojej sieci. PPP ma uwierzytelnianie (PAP otwartym tekstem, CHAP jako wyzwanie i odpowiedź9) i oba udowadniają, kim jest druga strona, nie szyfrując ani jednego bajtu tego, co potem. CHAP daje ci tu tunel, który wie, z kim rozmawia, i nadal publikuje zawartość każdemu na ścieżce.

W rodzinie PPP jest opcja szyfrowania: MPPE10, moduł siedzący w ppp_mppe.ko. Nie sięgaj po nią: to RC4 kluczowane z wymiany MS-CHAPv2, publicznie złamane od ponad dekady, i powód, dla którego PPTP nie żyje. Budowanie na tym nowego tunelu w 2026 roku to wybór znanego jako złamany szyfru zamiast działającego, który nic nie kosztuje.

Uczciwe podsumowanie na tę chwilę: routowane łącze bez poufności i bez kontroli dostępu. Dobre do laboratorium, dobre wewnątrz łącza, które już jest szyfrowane, niedobre nigdzie indziej. Poprawka to zaszyfrować nośnik. O tym są dwie następne sekcje i to jest powód, by używać ncat, a nie tego netcata, którego akurat dostarczyła twoja dystrybucja.

Etap trzeci: owinięcie nośnika w TLS

Czysta odpowiedź zostawia pppd dokładnie takim, jaki jest, a nośnik zastępuje takim, który robi TLS. pppd nigdy się nie dowie, że cokolwiek się zmieniło.

Najpierw certyfikat. Wystarczy samopodpisany, pod warunkiem że klient go weryfikuje. Niezweryfikowana sesja TLS to szyfrowana rozmowa z kimś, kogo nie zidentyfikowałeś, a to nikogo nie zatrzyma:

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 ma wbudowany TLS. Potrafi też łączyć się przez proxy, --proxy host:port --proxy-type http|socks4|socks511, więc nośnik może kończyć się na przekaźniku, a nie na dalekim końcu tunelu. Na tym punkcie obraca się sekcja o egressie. Strona nasłuchująca:

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'

Strona łącząca się:

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 to słowo, które się liczy. Bez niego --ssl daje ci szyfrowanie przeciw biernemu podsłuchowi i nic przeciw temu, kto pierwszy odpowie na porcie; z nim Ncat weryfikuje zaufanie i nazwę domeny względem pliku zaufania12. Ncat nie ma jednak po stronie serwera sprawdzania certyfikatu klienta, więc serwer nie potrafi zidentyfikować klienta. Połącz to z CHAP albo użyj jednego z dwóch następnych.

Stunnel

Tradycyjna nakładka i ta, która porządnie robi wzajemne uwierzytelnienie:

[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 wymaga certyfikatu klienta podpisanego przez CA z CAfile: to kontrola dostępu, której budowa na netcacie nigdy nie miała. Klient uruchamia stunnel w trybie klienta, a polecenie pty w pppd łączy się z lokalną stroną otwartego tekstu.

Socat

socat robi całość w jednym procesie na każdym końcu, z weryfikacją włączoną domyślnie:

# 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 nie jest zainstalowany na maszynie, na której to pisałem, więc to jest z jego dokumentacji. Sprawdź własne flagi. To ten, po który sięgnąłbym ja, bo jako jedyny z czterech mówi też DTLS.

Openssl, kiedy nie ma nic innego

openssl jest na każdej maszynie, która w ogóle ma TLS, a s_server/s_client przeniosą potok:

# 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 tłumi baner, który inaczej wylądowałby w twoim strumieniu PPP, a -verify_return_error sprawia, że nieudana weryfikacja zamyka połączenie, zamiast ostrzec i jechać dalej. To narzędzia do debugowania i tak się zachowują, ale na maszynie, na której nie możesz niczego zainstalować, podniosą łącze.

Zwykły, TLS po TCP albo DTLS po UDPTa sama połowa łącza na obu końcach. Zmienia się tylko środek.pppd albo tap0zwykły netcat, UDPncat --udp --listen 6000pppd albo tap0Otwartym tekstem po kablu, a nasłuch bierze tego, kto pierwszy dotrze do portu. Bez poufności i kontroli dostępu.pppd albo tap0TLS po TCP: ncat, stunnel albo opensslncat --ssl --ssl-verify --ssl-trustfile tunnel.crt host 6000pppd albo tap0Chronione, a certyfikat mówi, kim jest daleki koniec. Ale nośnik to znów TCP, i tylko ten kształt kompresuje strumień.pppd albo tap0DTLS po UDP: socat albo opensslsocat - OPENSSL-DTLS-CLIENT:host:6000,cafile=tunnel.crt,verify=1pppd albo tap0Szyfrowany, uwierzytelniony i wciąż datagramy. Zgubiony pakiet zostaje zgubionym, bez kłótni dwóch stosów. Celuj tutaj.
Przez cały czas ten sam pppd na obu końcach; zmienia się tylko polecenie pty. Zwykły netcat daje łącze, którego nic nie chroni. TLS po TCP chroni bajty i przywraca problem TCP w nośniku. DTLS po UDP to kształt, do którego warto dążyć: szyfrowany, uwierzytelniony i wciąż datagramowy, więc zgubiony pakiet pozostaje zgubionym pakietem, zamiast stać się walką o retransmisje między dwoma stosami.

Etap czwarty: DTLS, bo nośnik nadal powinien być UDP

Tu zaczyna się niewygodna część i powód, dla którego ta sekcja jest osobna. Każda opcja TLS powyżej działa po TCP, więc owinięcie nośnika w TLS unieważnia argument za UDP i oddaje ci z powrotem rozpad. Szyfrowanie i właściwy transport nie powinny być wyborem jedno albo drugie. DTLS to TLS po datagramach i właśnie tego chcesz: zachowuje ochronę warstwy rekordów, porzuca gwarancje kolejności i retransmisji i zostawia zgubione pakiety zgubionymi, a to dokładnie to, co sekwencja kontrolna ramki PPP ma wchłaniać.

Ncat tego nie potrafi. socat i openssl potrafią:

# 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'

A z samym openssl, gdzie -dtls wybiera dowolną wersję 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'

Pilnuj rozmiaru ramek. Rekordu DTLS nie da się podzielić tak, jak rekord TLS rozkłada się po strumieniu TCP, więc wszystko musi zmieścić się w MTU ścieżki naraz.

Stos narzutów i pozostałe wewnętrzne MTULicz w dół od MTU ścieżki i użyj tego, co zostanienagłówek IP20 (v4) / 40 (v6)nagłówek UDP8rekord DTLS + znacznik≈ 30ramkowanie PPP / Ethernetkilkawewnętrzne MTU, czyli co tunel przeniesie: cel 1400, minimum 1280Rekordu DTLS nie da się podzielić jak rekordu TLS w strumieniu TCP, więc wszystko to musi zmieścić się w MTU ścieżki naraz.Ten sam kształt co OpenVPN od 2001: nośnik datagramowy, DTLS, interfejs wirtualny. Nic dziwacznego, tylko rozebrane.
Licz w dół od 1500: 20 bajtów nagłówka IPv4 albo 40 IPv6, 8 na UDP, mniej więcej 30 na rekord DTLS i jego znacznik, kilka na ramkowanie, a reszta to wewnętrzne MTU, które tunel może przenieść. Celuj w 1400 na zwykłej ścieżce; 1280 to bezpieczne minimum, jeśli coś po drodze samo jest tunelem. Ten kształt (nośnik datagramowy, DTLS, interfejs wirtualny na wierzchu) to mniej więcej to, co OpenVPN robi od 2001 roku. Nic dziwacznego, po prostu rozebrane na części.

Strojenie budowy PPP: MTU, kompresja i co naprawdę pomaga

Cztery pokrętła, wszystkie to opcje pppd. Budowa na tap w następnej sekcji nie ma żadnego z nich, bo nie ma żadnej maszynerii, którą one konfigurują.

Cztery pokrętła pppd: jedno ustaw, jedno zostaw, dwa wyłączJedno ustaw, jedno zostaw, dwa wyłączUSTAWMTU i MRUOba końce, z zapasem: 1400 zwykle, 1280 pod tunelem. Pofragmentowana ramka gubi cały pakiet.ZOSTAWACCMDomyślnie zero, co jest dobre na czystym gnieździe. Ruszaj tylko, gdy coś zjada znaki sterujące.WYŁĄCZnovjkompresja nagłówków Van JacobsonaOszczędza błąd zaokrąglenia, kosztuje CPU na pakiet i psuje się przy stratach. Wyłącz powyżej modemu.WYŁĄCZnodeflate nobsdcompŁadunek to już TLS/DTLS: kompresja szyfrogramu to czysta praca, a przez granicę bezpieczeństwa atak.Nic z tego nie przyspiesza tunelu. PPP nie jest wąskim gardłem: PPPoE robi 2 Gbit na tym samym demonie, bo ścieżka danychzostaje w jądrze. Kosztem jest tu pty: każdy bajt idzie do przestrzeni użytkownika i z powrotem. To wina pty, nie PPP.
MTU i MRU to to, co się liczy: ustaw oba na obu końcach z zapasem, bo ramka, którą nośnik musi fragmentować, przy każdej stracie traci cały pakiet. ACCM jest już zerowe i poprawne na czystym gnieździe. Kompresję nagłówków Van Jacobsona wyłącz przez novj powyżej prędkości modemu: oszczędza błąd zaokrąglenia, kosztuje CPU na każdy pakiet i psuje się przy stratach. Wyłącz deflate/bsdcomp: ładunek jest już zaszyfrowany, a kompresja przez granicę bezpieczeństwa to atak, a nie funkcja.

Nic z tego nie przyspiesza tunelu, a powód ma znaczenie, bo obwinia się za to PPP, a nie powinno. PPP nie jest wąskim gardłem. PPPoE przenosi 2 Gbit na tym samym demonie, bo jego ścieżka danych nigdy nie opuszcza jądra: ppp_generic i pppoe robią ramkowanie i przekazywanie, a pppd obsługuje tylko płaszczyznę sterowania. To, co cię tu kosztuje, to pty: każdy bajt przechodzi do przestrzeni użytkownika, przez netcata, do gniazda i z powrotem, a PPPoE nigdy tej drogi nie robi. To sprawa pseudoterminala, nie PPP.

To dobry moment, żeby spojrzeć na drugi sposób, w którym pty w ogóle nie ma.

Drugi sposób: urządzenie tap i w ogóle bez PPP

Wszystko do tej pory używało PPP do połowy łącza. Jest drugi sposób na zrobienie interfejsu wirtualnego i nie potrzebuje on żadnego protokołu.

Sterownik TUN/TAP w jądrze daje ci interfejs i deskryptor pliku związane ze sobą: zapisz pakiet do deskryptora, a pojawi się na interfejsie, jakby przyszedł z kabla; czytaj, a dostaniesz pakiet, który jądro chciało wysłać. To cały interfejs13 i jest w Linuksie od 1999 roku.

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
Urządzenie tap to interfejs z jednej strony i deskryptor pliku z drugiejBez demona, bez protokołu, bez pseudoterminala. Jeden deskryptor pliku.JĄDROtap0zwykły interfejs,z adresem i trasą/dev/net/tunTUNSETIFF nazywaotrzymane urządzenietwój processocat albo pięćdziesiąt liniiPythona trzymających fdgniazdo UDPjedna ramka na datagramsieći daleki koniecjeden odczyt = jedna ramkaCzego brak względem PPP: negocjowanego rozmiaru ramki, sprawdzania żywotności, wymiany adresów, uwierzytelniania.Oba końce ustawiasz ręcznie i nigdy o tym nie rozmawiają. Nic nie pilnuje łącza, więc nic nie powie, że umarło.
Bez demona i bez protokołu. Jądro wystawia tap0 jako zwykły interfejs, a jego drugą stronę oddaje temu procesowi, który otworzył /dev/net/tun. Jeden odczyt zwraca dokładnie jedną ramkę Ethernetu; jeden zapis wstrzykuje dokładnie jedną. Wszystko, co negocjował pppd (adresy, rozmiary ramek, żywotność), konfigurujesz teraz ręcznie na obu końcach, a te dwa końce nigdy o niczym z tego nie rozmawiają.

Dwa szczegóły w tym pierwszym poleceniu są warte więcej, niż na to wyglądają.

user damien sprawia, że urządzenie jest trwałe i nieuprzywilejowane. Utworzone w ten sposób przeżywa proces, który go używa, a wskazany użytkownik może je otworzyć, nie będąc rootem. Root tworzy urządzenie raz; to, co przerzuca ramki, w ogóle nie potrzebuje roota. Zapamiętaj to do sekcji o egressie.

mode tun to druga połowa tego samego sterownika i to ją większość ludzi naprawdę chce. Tun przenosi pakiety IP. Tap przenosi ramki Ethernetu. Różnica jest na tyle ważna, że dostaje własną sekcję niżej.

W porównaniu z PPP tracisz wszystko, co PPP negocjuje: nie ma LCP, więc nie ma uzgodnionego rozmiaru ramki ani sprawdzania żywotności; nie ma IPCP/IPV6CP, więc oba końce konfigurujesz ręcznie; nie ma uwierzytelniania, nie ma kompresji nagłówków. Urządzenie tap to dziura w jądrze, a protokół, który przez nią idzie, to cokolwiek tam włożysz. Zyskujesz brak jakiegokolwiek narzutu ramkowania, brak escapowania, brak kanału sterującego i interfejs, który można zmostkować.

Tap po UDP, gdzie jeden datagram to jedna ramka

To najczystsze odwzorowanie w całym wpisie i wynika wprost z konstrukcji. Urządzenie tap jest urządzeniem datagramowym (jeden read() zwraca dokładnie jedną ramkę), a gniazdo UDP jest gniazdem datagramowym, jeden sendto() na datagram. Ramka idzie więc do datagramu, przychodzi jako ramka i nie ma czego rozgraniczać, buforować ani resynchronizować. Zgub datagram, a zgubiłeś jedną ramkę, i tak właśnie wygląda zgubiony pakiet.

Z socat każdy koniec to jedno polecenie:

# 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 nie jest zainstalowany na maszynie, na której to pisałem, więc te dwa polecenia są z jego dokumentacji, a nie z uruchomienia tutaj. Sprawdź nazwy adresów we własnej wersji, zanim im zaufasz. Warto go mieć: to jedyne narzędzie w tym wpisie, które robi tun, tap, TLS i DTLS w jednym procesie.

Tam, gdzie nie możesz niczego zainstalować, cała robota to około pięćdziesięciu linii bez zależności poza biblioteką standardową. Serce tego, z IFF_NO_PI wyłączającym czterobajtowy nagłówek, który sterownik inaczej by doklejał:

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)

Pełny plik (parsowanie argumentów, IPv6 przez getaddrinfo, datagram o zerowej długości, który mówi nasłuchowi UDP, dokąd odpowiadać, i kompresja, którą dodaje następna sekcja) jest w paczce:

tapcat.py: całość, około stu linii tapcat.py · 6 kB

peer = src przy każdym datagramie to część do przeczytania dwa razy. Kto ostatni wysłał ramkę, ten staje się rozmówcą. Wygodne za NAT-em, którego port źródłowy ciągle się przesuwa, i otwarte drzwi w niezaufanej sieci, gdzie każdy, kto potrafi wysłać jeden datagram na ten port, przejmuje tunel. W porządku wewnątrz sesji DTLS, a tam to zmierza; nie w porządku samo w sobie. Część skryptu od gniazd została tu przećwiczona po loopbacku IPv6: otwierający datagram dociera, nasłuch poznaje rozmówcę, ramka przechodzi, a odpowiedź wraca. Część od tap wymaga roota i to jedyna część, której nie mogłem uruchomić.

Po TCP ramkowanie musisz wymyślić sam

Teraz zamień nośnik na TCP i patrz, jak pojawia się cały problem, który PPP po cichu rozwiązało w 1994 roku.

TCP to strumień bajtów bez granic rekordów i bez żadnej obietnicy co do tego, jak bajty zostaną pogrupowane po dotarciu: dwie ramki zapisane jedna po drugiej mogą przyjść w jednym odczycie, a jedna ramka w trzech. Odbiorca trzyma stertę bajtów, nie mając pojęcia, gdzie kończy się jedna ramka, a urządzenie tap przyjmuje tylko całe ramki.

Jeden datagram na ramkę albo prefiks długości do wymyśleniaJeden odczyt z urządzenia tap to jedna ramka. Utrzymanie tego to robota nośnika.PO UDP: granica za darmodatagram = ramka Adatagram = ramka Bdatagram = ramka Cdatagram = ramka DJeden odczyt, jeden datagram, jeden zapis na dalekim końcu. Nic do rozgraniczania, buforowania ani resynchronizacji.PO TCP: granic nie ma i musisz je przywrócićjeden strumień bajtów: dwie ramki w jednym odczycie, jedna ramka w trzechdł.ramka Adł.ramka Bdł.ramka Cdł.ramka DDwa bajty długości big-endian przed każdą ramką i odbiorca, który czyta długość, a potem dokładnie tyle bajtów.Działa, ale nie umie się odzyskać. HDLC resynchronizuje się na następnym 0x7E, bo flaga jest jednoznaczna; strumień z prefiksem,który zgubi miejsce, czyta każdą dalszą długość ze środka ramki. Dodaj znacznik i sumę kontrolną, a odbudujesz HDLC.
Po UDP jedna ramka to jeden datagram i granica przychodzi za darmo. Po TCP granic nie ma, więc nadawca musi dodać prefiks długości do każdej ramki, a odbiorca musi na jego podstawie ją złożyć. PPP nie ma tego problemu, bo przynosi własne ramkowanie (bajt flagi na każdym końcu i sumę kontrolną), i to też pozwala mu się resynchronizować po uszkodzeniu. Strumień z prefiksem długości tego nie potrafi: przesuń się o jeden bajt, a każda następna ramka jest zła.

Po TCP piszesz więc własne ramkowanie. Dwa bajty długości w kolejności big-endian przed każdą ramką to zwykła odpowiedź:

# 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)

To działa i jest bezwzględnie gorsze od wersji po UDP. To znowu problem TCP po TCP; dodaje dwa bajty i pętlę składania na każdą ramkę; i nie ma powrotu po błędzie, bo strumień z prefiksem długości, który zgubi miejsce, czyta każdą kolejną długość ze środka ramki. HDLC resynchronizuje się na następnym 0x7E; to tutaj nie potrafi, chyba że wymyślisz HDLC od nowa i gorzej. Trzeci argument za UDP i najmocniejszy: po nośniku datagramowym nie ma problemu ramkowania, bo nośnik ma już jedyną funkcję, której potrzebowałeś.

Tun czy tap: warstwa 3, chyba że naprawdę potrzebujesz warstwy 2

Ten sam sterownik daje ci dwa urządzenia, a ludzie ciągle wybierają złe, bo jakiś poradnik kazał użyć tap.

tuntap
Co przechodzipakiety IPramki Ethernetu
Narzut na pakietżaden14-bajtowy nagłówek Ethernetu
ARP, DHCP, rozgłoszenianietak, wszystko, przez tunel
Protokoły inne niż IPnietak
Może wejść do mostkanietak
Odpowiednikłącze punkt-punkt, jak ppp0kabel sieciowy

Tun to łącze routowane, jak interfejs PPP z pierwszej połowy: dwa adresy, trasa, pakiety tam i z powrotem. Tap to wirtualny kabel Ethernet, więc każde rozgłoszenie, zapytanie ARP i każdy kawałek szumu multicastowego w segmencie przechodzi teraz przez twój tunel i pali pasmo.

Zmień jedną linię w skrypcie, żeby się przełączyć:

IFF_TUN = 0x0001            # instead of IFF_TAP

Używaj tap, gdy naprawdę potrzebujesz warstwy 2. Są prawdziwe powody: protokół, który nie jest IP, heartbeat klastra, który oczekuje rozgłoszeń, serwer DHCP, który musi dosięgnąć klientów przez tunel, albo zmostkowanie dwóch segmentów w jeden.

Ten ostatni to częsty przypadek i ten, przy którym trzeba uważać:

ip link add br0 type bridge
ip link set tap0 master br0
ip link set eth1 master br0
ip link set br0 up

Teraz zdalny segment jest częścią twojego lokalnego: jego rozgłoszenia, jego drzewo rozpinające, jego rotacja adresów MAC i, jeśli ktoś był niedbały, jego serwer DHCP. Zmostkowanie dwóch lokalizacji, które obie używają 192.168.1.0/24, to złe popołudnie; takie, które zapętla się z powrotem do tego samego segmentu, to zły tydzień. Domyślnie wybieraj tun, sięgaj po tap, gdy potrafisz nazwać rzecz z warstwy 2, której potrzebujesz, i mostkuj dopiero po sprawdzeniu, co nadaje rozgłoszenia po obu stronach.

Te same nakładki, jeden proces na koniec

Budowa na tap ma tę samą dziurę co budowa na PPP: nośnik idzie otwartym tekstem, a nasłuch przyjmuje tego, kto przyjdzie pierwszy. Poprawka jest ta sama, a z socat sprowadza się do jednego polecenia na koniec, bo tworzy on urządzenie i kończy sesję DTLS w jednym procesie:

# 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

To najkrótsza poprawna budowa w tym wpisie. Interfejs wirtualny, nośnik datagramowy, wzajemne uwierzytelnienie certyfikatami i szyfrowanie. Dwa polecenia. Bez demona, bez negocjacji protokołu.

verify=1 nie jest opcjonalne. To ten sam punkt co --ssl-verify, a przy opisanym wyżej zachowaniu peer = src niezidentyfikowany ktoś jest jeden datagram od przejęcia twojego tunelu. Jeśli utknąłeś ze skryptem w Pythonie, nie doklejaj do niego TLS: skieruj go na port na loopbacku i postaw nakładkę przed nim, albo użyj socat. Ręcznie skręcona nakładka TLS wokół ręcznie skręconego tunelu to dwie szanse, żeby pomylić się w ciekawej części.

Etap piąty: kompresja strumienia przez zstd

Jest jeszcze jedna rzecz warta włożenia do zaplecza i w przeciwieństwie do opcji kompresji w pppd może się naprawdę opłacić: kompresuj ramki przez zstd, zanim trafią do nośnika.

Ważne słowo to ramki, w liczbie mnogiej. Kompresuj strumień, a nie każdy pakiet osobno. To pojedynczy największy zmierzony efekt w tym wpisie.

Ruch sieciowy jest powtarzalny w sposób, który widać dopiero między pakietami: te same nagłówki, nazwy hostów i klucze JSON, w kółko. Kompresor, który zaczyna od zera na każdej 1400-bajtowej ramce, nie widzi nic z tego; taki, który trzyma okno przez kolejne ramki, widzi wszystko.

Kompresuj przed szyfrowaniem i trzymaj okno, jeśli nośnik pozwalaKolejność jest stała. Decyzją jest tryb.tap0jeden odczyt, jedna ramkakompresjazstd, poziom 1szyfrowanieDTLS albo TLSnośnikUDP albo TCPNigdyodwrotnie.FLUSH_BLOCK: zachowaj oknoWypycha wszystko dotąd, trzyma historię. Każda ramkakodowana względem wszystkich wcześniejszych. Bez opóźnień:ramka na wejściu, ramka na wyjściu.5,0%na ruchu powtarzalnym · 7,5% na logachWymaga dostarczenia każdej ramki, po kolei.Czyli: TCP albo TLS po TCP. Nie UDP, nie DTLS.FLUSH_FRAME: wyrzuć przy każdym pakiecieKażdy datagram to pełna ramka zstd i dekoduje sięsam, więc datagram N działa, choć zginęły 1 do N-1.Jedyny tryb dla nośnika datagramowego.14,8%na tym samym ruchu · 24,2% na logachWytrenowany słownik odzyskuje większość:5,3% i 15,1%, wciąż odporny na straty.
Kompresja siedzi między urządzeniem tap a nośnikiem i przed szyfrowaniem, bo szyfrogram się nie kompresuje. FLUSH_BLOCK to tryb, który się liczy: wypycha wszystko do tej pory, więc jedna ramka na wejściu daje jedną ramkę na wyjściu bez dodatkowego opóźnienia, a historia kompresji zostaje dla następnej ramki. FLUSH_FRAME wyrzuca tę historię przy każdym pakiecie i to czyni go bezpiecznym na nośniku ze stratami, i to samo czyni go trzy razy gorszym na kablu.

Na aktualnej Fedorze nie trzeba niczego instalować: Python 3.14 wprowadził zstd do biblioteki standardowej14; ta maszyna ma 3.14.7 z 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)

Jeden kompresor na kierunek, żywy przez cały czas istnienia łącza. Jeden FLUSH_BLOCK na ramkę, więc ramka wychodzi w chwili, gdy przyjdzie, bez buforowania, a daleki koniec oddaje jedną ramkę na blok.

Ile jest warte okno, zmierzone

Liczby z tej maszyny. Te same 1400-bajtowe ramki, ten sam poziom 1, a jedyna różnica to, czy kompresor zachowuje historię:

Ruch w tunelustrumień, FLUSH_BLOCKna pakiet, FLUSH_FRAMEna pakiet z wytrenowanym słownikiem
Powtarzalne wywołania API i telemetria5,0%14,8%5,3%
Linie logów7,5%24,2%15,1%
Zwykły tekst i pliki konfiguracyjne37,8%51,3%45,3%
Losowe bajty, w zastępstwie TLS100%+100,7%n/d

Przepustowość na poziomie 1 wyniosła 205 MB/s na tekście i ponad 1 GB/s na ruchu powtarzalnym: im bardziej kompresowalne, tym szybciej, bo jest mniej do zakodowania.

Ruch logów spada do 7,5% pierwotnego rozmiaru, wobec 24,2% na pakiet: trzykrotnie, te same dane, ten sam poziom, dzięki jednej fladze. A poziom 1 to właściwy poziom: poziom 3 dał mniej więcej jeden punkt procentowy, poziom 9 kolejny, zbijając przepustowość z 211 MB/s do 61.

Haczyk, i to ten sam haczyk co we wszystkim tutaj

Wspólne okno oznacza, że każda ramka zależy od poprzednich: zgub jedną, a historia dekompresora przestaje się zgadzać i nic po niej się nie rozkoduje. Dlatego kompresja strumienia potrzebuje nośnika, który dostarcza wszystko i po kolei: TCP albo TLS po TCP, nie UDP ani DTLS. To jedyny uczciwy argument za nośnikiem TCP w całym tym wpisie. Jeśli to, co przechodzi przez twój tunel, naprawdę dobrze się kompresuje (syslog, replikacja bazy danych otwartym tekstem, telemetria, gadatliwe API), sesja TLS ze skompresowanym strumieniem przenosi jedną trzecią bajtów, które przeniósłby nośnik datagramowy, a na przyzwoitej ścieżce to może przebić karę za retransmisje. Zmierz to na własnym ruchu.

Po UDP słownik robi to, co robiłoby okno

Tam, gdzie nośnikiem jest UDP albo DTLS, a domyślnie powinien być, okna utrzymać się nie da: każdy datagram stoi sam, czyli FLUSH_FRAME i słabsza kolumna powyżej. Wytrenowany słownik daje kompresorowi kontekst między pakietami, który dałoby okno, bez żadnej zależności między datagramami15:

# 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)

Na ruchu powtarzalnym to sprowadziło kompresję na pakiet z 14,8% do 5,3%, odzyskując 96% różnicy względem pełnej kompresji strumienia przy zachowaniu odporności na straty; na liniach logów 55% różnicy, na zwykłym tekście 44%.

Idą z tym trzy zasady. Oba końce muszą załadować ten sam słownik, inaczej nic się nie rozkoduje; sprawdzone tutaj: ramka skompresowana ze słownikiem rzuca bez niego ZstdError. Trenuj na zrzucie prawdziwego ruchu, bo słownik to założenie wstępne, a złe kosztuje: słownik tekstowy pogorszył inny tekst odrobinę. I załaduj go raz do długo żyjącego kompresora; przekazywanie go przy każdym wywołaniu dało w pomiarze 5 MB/s i to nie jest literówka.

Bajt nagłówka i jednosekundowa rozgrzewka

Dwie drobne rzeczy, które sprawiają, że to nie jest kruche.

Każdy datagram niesie jednobajtowy nagłówek, który nazywa tryb, a nie tylko mówi „skompresowane”: 0x00 ramka taka, jaka jest, 0x01 samodzielna ramka zstd, 0x02 blok z ciągnącego się strumienia. Odbiorca może wtedy rozkodować cokolwiek wybrał daleki koniec, bez konfigurowania go pod to, i już samo to jest warte tego bajtu.

W trybie ramek nadawca wysyła postać skompresowaną tylko wtedy, gdy jest faktycznie mniejsza, bo kompresja nie zawsze się opłaca: losowe bajty wyszły na 100,7%, a 64-bajtowe ACK TCP kompresuje się do 73, czyli dziesięciobajtowy nagłówek zstd na pakiecie, w którym nie ma czego ścisnąć. Na prawdziwym łączu w liczbie pakietów dominują małe pakiety, więc bez tego sprawdzenia nadmuchałbyś większość ruchu, żeby zmniejszyć mniejszość. W trybie strumienia zawsze wysyła postać skompresowaną, bo pominięcie jednej rozjechałoby oba okna.

A łącze startuje na surowo: przez pierwszą sekundę każda ramka wychodzi bez kompresji, niezależnie od ustawień, a każdy kierunek rozgrzewa się sam:

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

To idea etapów z początku wpisu zastosowana do pojedynczego łącza. Tunel wstaje najprostszą drogą, jaką ma, udowadnia, że potrafi przenieść ramkę, i dopiero wtedy zaczyna robić cokolwiek sprytnego. Kiedy się zepsuje, wiesz, w której sekundzie.

Etap szósty: skompresowane i zaszyfrowane, i ile kosztuje kolejność

Kolejność ma znaczenie i działa tylko jedna: najpierw kompresja, potem szyfrowanie. Szyfrogram się nie kompresuje, co pokazuje wiersz ze 100,7%, i dlatego też TLS 1.3 usunął własną kompresję, zostawiając twoją warstwę jako jedyne miejsce, gdzie można to zrobić. Ta kolejność ma znany problem, ten sam, który podniosłem przeciw deflate: kompresja przed szyfrowaniem przecieka otwarty tekst przez długość szyfrogramu, a tam, gdzie atakujący może wstrzyknąć wybrane dane obok sekretu i obserwować rozmiary, ten przeciek nieraz był działającym atakiem: CRIME i BREACH przeciw TLS16 oraz VORACLE przeciw dokładnie takiemu kształtowi17.

To nie jest powód, żeby nigdy nie kompresować. To powód, żeby wiedzieć, w którym przypadku jesteś:

  • Łącze niosące twój własny ruch między dwiema maszynami, które są twoje (replikacja, kopie zapasowe, logi, telemetria) nie ma wybranego przez atakującego otwartego tekstu podróżującego razem z sekretami. Kompresuj, i to strumień.
  • Łącze niosące dowolne przeglądanie użytkowników, gdzie cudze treści webowe idą razem z twoimi danymi logowania, to przypadek, o którym napisano VORACLE. Zostaw to wyłączone.

Powód, dla którego spokojnie wkładam to do budowy na tap, a nie do budowy na PPP, to nie zasada: tutaj świadomie wybierasz nowoczesny algorytm, dla ruchu, któremu się przyjrzałeś, a deflate w pppd domyślnie kompresuje wszystko algorytmem z 1996 roku, czy przypadek do tego pasuje, czy nie.

Co budowa na tap zyskuje, a z czego rezygnuje

Postaw obie połowy obok siebie, bo nie konkurują. To różne kompromisy.

pppd po gnieździetap albo tun po gnieździe
Ramkowaniewbudowane (HDLC, resynchronizuje się po uszkodzeniu)po UDP żadne, bo żadne nie jest potrzebne; po TCP do wymyślenia
Ustawienie adresównegocjowane przez IPCP i IPV6CPkonfigurowane ręcznie na obu końcach
Żywotnośćecho LCP, wbudowanebrak; dodajesz sam albo łącze umiera po cichu
Uwierzytelnianiedostępne PAP albo CHAP, oba słabeżadne
Warstwatylko 33 z tun, 2 z tap
Mostkowanienietak, z tap
Narzutflaga, nagłówek i FCS na ramkę, plus escapowanienic, albo 14 bajtów z tap
Kompresjadeflate i BSD, domyślnie włączone, z 1996 rokużadna, albo zstd na ramkę, które dodajesz i kontrolujesz
Potrzebny roottak, przez cały czasdo utworzenia urządzenia; nie do używania
Ruchome częścijeden demon, trzydziestoletnijeden deskryptor pliku

PPP daje ci wynegocjowane, samo się pilnujące łącze i każe za to zapłacić protokołem. Urządzenie tap daje ci surową dziurę za nic, a brakujące części dostarczasz sam albo się bez nich obywasz. Dla tunelu zostawionego w działaniu tym, co gryzie, jest brak sprawdzania żywotności: pppd zauważa martwy nośnik w trzydzieści sekund i go odbudowuje, a budowa na tap nie zauważa niczego, bo nic w niej nie pilnuje. Dodaj keepalive, uruchom to pod czymś, co to restartuje, albo użyj budowy, która już to ma.

Kiedy to właściwe narzędzie, a kiedy nie

To nigdy tak naprawdę nie jest właściwe narzędzie i nie zamierzam udawać, że jest inaczej. Wszystko powyżej działa i nic z tego nie jest tym, co powinieneś puścić na produkcji. Uczciwa wersja poradnika zawiera część, w której odkładasz narzędzie, i to jest ta część.

Do czego to naprawdę się nadaje, to pokazanie ci, jak coś działa. VPN rozebrany na części, a w następnej sekcji to, jak naprawdę zachowuje się egress, gdy ktoś jest w twojej sieci z rootem. To są powody, dla których warto było to przeczytać. Wąskie przypadki poniżej są prawdziwe, ale to nie dla nich ten wpis istnieje.

Sięgnij po budowę na PPP, gdy:

  • Nośnik w ogóle nie jest IP: konsola szeregowa, gadżet USB, łącze radiowe, nazwany potok, kanał SSH. pppd nie obchodzi, po czym jadą bajty, a urządzenie tap tu ci nie pomoże.
  • Coś ratujesz: maszynę z konsolą szeregową, bez sieci i z robotą, którą trzeba skończyć dziś w nocy. PPP po tej konsoli to routowane łącze, zainstalowane na obu końcach, bez niczego do kopiowania.
  • Chcesz, żeby łącze samo o siebie dbało. Echo LCP, negocjacja adresów i restart są za darmo; pisanie ich samemu to sposób, w jaki budowa na tap staje się małym, zawodnym produktem.

Sięgnij po budowę na tap, gdy:

  • Potrzebujesz warstwy 2: protokołu innego niż IP, heartbeatu klastra, który chce rozgłoszeń, DHCP przez tunel albo dwóch segmentów, które muszą być jednym.
  • Chcesz jak najmniej ruchomych części: po UDP z DTLS to dwa polecenia, bez demona, bez negocjacji, bez niczego do escapowania.
  • Roota jest mało. Utwórz urządzenie raz z user, a proces przerzucający ramki już nigdy nie potrzebuje uprawnień.

Oba są właściwym narzędziem, kiedy się uczysz. Każda warstwa jest widoczna i osobno wymienialna, i nie ma lepszego sposobu, by zrozumieć, co robi produkt VPN, niż zbudować go z części i patrzeć, jak każda wstaje.

Żadne nie jest właściwym narzędziem, kiedy chcesz VPN. Do tego użyj WireGuard. Jest w jądrze, to ułamek kodu, robi kryptografię porządnie, bez niczego do negocjowania i bez niczego, co można popsuć, i jest protokołem datagramowym z założenia. ssh -w daje ci urządzenie tun po istniejącej sesji SSH jednym poleceniem, a OpenVPN to dojrzała, audytowana wersja opisanego wyżej kształtu DTLS po tap. Wszystkie trzy robią to lepiej niż cokolwiek zbudowanego tutaj.

Buduj to, bo chcesz wiedzieć, co jest w środku rzeczy, którą kupujesz. Nie dlatego, że to było sprytne.

Co to naprawdę pokazuje: egress od strony atakującego

To jest powód, by przeczytać wpis o budowie, której właśnie kazano ci nie używać. Odwróć to i spójrz z wnętrza własnej sieci, jako osoba, która właśnie tam wylądowała z rootem. Każde prawdziwe włamanie tam się kończy: przez ukradziony klucz, ucieczkę z kontenera, niezałataną usługę, kogoś z wewnątrz. Pytanie, które wtedy decyduje, jak zły będzie ten dzień, nie brzmi „co mogą uruchomić”, bo mogą uruchomić wszystko. Brzmi: „co może wyjść i czy zdecydowałeś o tym, zanim przyszli”.

Jeśli ruch wychodzący jest domyślnie otwarty, odpowiedź brzmi: wszystko, i niewiele możesz już zrobić. Nic tu nie było egzotyczne. pppd, ncat, socat i ip to podpisane pakiety dystrybucji, które już są na maszynie; nakładka tap to pięćdziesiąt linii biblioteki standardowej. Jeden dozwolony port wychodzący (a jest to 443, ten, który każda sieć domyślnie otwiera) i masz routowane łącze z twojej sieci do cudzej: szyfrowane, uwierzytelnione, przeżywające restarty, niosące IPv4 i IPv6 i nie do odróżnienia na twojej granicy od dowolnej sesji HTTPS, jaką twoi użytkownicy otwierają dziesięć tysięcy razy dziennie. Zrób to na tap i zmostkuj, a to, co opuściło budynek, nie jest trasą. To jest segment.

Skaner nie ma tu czego złapać: nie ma sygnatury malware, bo nie ma malware, nie ma dziwnego protokołu, bo to zwykły uścisk dłoni TLS na 443, nie ma nietypowej binarki, bo każdą zainstalował twój własny menedżer pakietów. Proxy loguje połączenie i liczbę bajtów, a jedno i drugie wygląda jak praca.

A cel nie jest nawet stały. Gniazdo nie musi kończyć się tam, gdzie lądują pakiety, bo nośnik można skierować przez proxy: przekaźnik, który jest niczym więcej niż dwoma połączeniami i potokiem, a następna sekcja buduje go w jednej linii powłoki. ncat przyjmuje --proxy z --proxy-type http, socks4 albo socks5, więc sesja TLS, którą widzi twoja granica, kończy się tam, przez co atakujący kazał jej się połączyć (wewnętrzny jump host, dozwolony punkt końcowy SaaS, który akurat przekazuje CONNECT, przekaźnik w chmurze), a tunel jedzie stamtąd dalej, gdzieś, czego nigdy nie zobaczysz. HTTP CONNECT i SOCKS robią to z założenia, bo do tego jest proxy. Wpis na liście dozwolonych dla celu, któremu ufasz, jest więc zawsze zaufaniem do tego celu i do wszystkiego, do czego on przekaże ruch, a tego nie kontrolujesz i nie potrafisz wyliczyć. Punkt końcowy w logu twojej zapory to proxy. Nigdy nie był to daleki koniec.

Niewygodna prawda jest więc taka: gdy ktoś jest w środku z rootem, a ruch wychodzący jest liberalny, tunel nie jest czymś, czemu możesz zapobiec. Części są zainstalowane, wyjście jest otwarte i nawet nie prowadzi tam, gdzie się wydaje. Twoja jedyna szansa, żeby to utrudnić, była zanim atakujący przyszedł, na granicy, przez zdecydowanie, co może wyjść.

To jest egress z domyślną blokadą i to jest cała lekcja. Ruch wychodzący domyślnie zablokowany; krótka, nazwana lista dozwolonych, na której ktoś uzasadnił każdy cel i port; wszystko inne odrzucane, logowane i alarmowane. Nie dlatego, że to od razu zatrzyma zdeterminowanego atakującego (dozwolony cel to dozwolony tunel), ale dlatego, że alternatywą jest brak jakiejkolwiek decyzji do egzekwowania. Polityka ruchu wychodzącego zapisana jako lista dozwolonych portów to polityka o numerach portów. Nigdy nie była polityką o tym, co wychodzi, a gdy ktoś ma roota, numery portów to wszystko, co chroni.

To ten sam wniosek co w wpisie o pingu, który buduje tunel z ICMP echo, i w wpisie o pomocnikach protokołów, gdzie twoja zapora sama otwiera dziury. Trzy drogi do środka, jeden wniosek: kontrola, którą myślałeś, że masz, dotyczyła protokołów, a żaden z tych protokołów nie jest tym, za co się podaje. Granica, zdecydowana z góry i z domyślną blokadą, to jedyna kontrola, która kiedykolwiek była prawdziwa.

Proxy to dwa połączenia i potok

Warto zobaczyć, jak niewiele znaczy przekaźnik, bo to wyjaśnia, dlaczego z bliskiego końca nie da się wnioskować o dalekim. Proxy to nie jest specjalne oprogramowanie. To jedno połączenie dołączone do drugiego potokiem. Najstarsza forma używa nazwanego potoku, FIFO, do przenoszenia kierunku powrotnego: jeden ncat nasłuchuje, drugi łączy się dalej, a FIFO spina między nimi drogę odpowiedzi.

mkfifo backpipe
ncat -l 7000 0<backpipe | ncat farend.example.net 7100 1>backpipe

Czytaj to jak hydraulikę: wyjście nasłuchu płynie do drugiego ncat i dalej do dalekiego końca, a odpowiedzi wracają przez FIFO do klienta. Dwa gniazda, jeden potok, oba kierunki, a połączenie klienta kończy się tutaj, na przekaźniku, podczas gdy pakiety jadą dalej do farend i z powrotem. Uruchomiłem dokładnie to na loopbacku z trzecim ncat odbijającym echo na dalekim końcu i wysłana linia wróciła, przebywszy całą drogę.

Przekaźnik to dwa gniazda połączone potokiem, więc punkt końcowy się przesuwaJedno połączenie wchodzi, drugie wychodzi, potok pomiędzy. To jest proxy.klientotwiera sesję TLSPRZEKAŹNIK: cel, który loguje twoja granicancat -l 7000kończy połączenie klientancat farendzaczyna nowy skokdaleki koniecprawdziwa druga stronastdoutbackpipe (FIFO) niesie odpowiedzi z powrotemklient → przekaźnikprzekaźnik → daleki koniecPołączenie klienta kończy się na przekaźniku. Pakiety nie.Twoja zapora zalogowała połączenie do tej maszyny. Dokąd ono idzie dalej, decyduje się w środku, a łańcuch trzech takichodsuwa daleki koniec o trzy potoki: log każdego skoku pokazuje tylko schludne lokalne połączenie do następnego.
Przekaźnik to dwa gniazda i potok. Nasłuch kończy połączenie klienta. Drugi netcat nawiązuje nowe połączenie dalej, a FIFO przenosi między nimi kierunek powrotny. Sesja TLS klienta kończy się tutaj, na przekaźniku, i zaczyna się nowy skok, więc cel zalogowany przez twoją granicę to ta maszyna, a pakiety jadą dalej, dokądkolwiek ona je przekaże. Połącz trzy w łańcuch, a daleki koniec jest trzy potoki dalej, a zapora każdego skoku widzi tylko schludne lokalne połączenie do następnego.

Ncat zrobi to samo w jednym procesie, uruchamiając połączenie dalej dla każdego klienta, który przyjdzie:

ncat -l 7000 --keep-open --sh-exec 'ncat farend.example.net 7100'

Ten sam kształt, mniej części: gniazdo nasłuchu jest połączone z gniazdem uruchomionego ncat potokiem, który powłoka stawia między nimi. Połącz trzy w łańcuch, a tunel przechodzi przez trzy sieci, kończąc się i zaczynając na nowo na każdej, a zapora każdego skoku loguje schludne lokalne połączenie do następnego i nic dalej.

To cały trik i to dlatego log granicy nie jest dowodem na cel. Każdy przekaźnik jest dalekim końcem, na ile maszyna przed nim jest w stanie stwierdzić, a prawdziwy drugi koniec jest tyle potoków dalej, ile ich było, i nikt ich nie pilnował.

Teraz postaw te przekaźniki na maszynach, które nie należą do atakującego.

Łańcuch przekaźników na przejętych hostach pierze punkt końcowyKażdy skok to cudza maszyna, a każdy właściciel widzi tylko środekatakującyjedyna jego maszynaprzekaźnik 1sieć innej firmyprzekaźnik 2porwany VPSprzekaźnik 3domowy routerceldokąd to szłowidzi: 1←→2widzi: 2←→3widzi: 3←→celŻaden skok nie widzi dalej niż swoich dwóch sąsiadów. Bez źródła, bez celu, tylko środek.Ruch jest prany przez ciąg cudzych systemów, na każdym ten sam przekaźnik z dwóch gniazd i potoku pod kontroląatakującego. Dlatego ruch z przejętego hosta tak często prowadzi do kolejnej ofiary, a nie do atakującego: 20 lat C2.
Każdy skok to przejęty host (maszyna innej firmy, porwany VPS, domowy router), na którym działa ten sam przekaźnik z dwóch gniazd i potoku pod dowodzeniem i kontrolą atakującego. Żaden skok nie widzi dalej niż swoich dwóch sąsiadów: właściciel przekaźnika 2 widzi połączenie od przekaźnika 1 i jedno do przekaźnika 3, i nic więcej. Ruch jest prany przez ciąg cudzych systemów i dlatego ruch wychodzący z przejętego hosta tak często prowadzi do kolejnej ofiary, a nie do atakującego.

Każdy właściciel w tym łańcuchu widzi tylko połączenie od skoku przed nim do skoku po nim: bez źródła, bez celu, tylko środek. To nie jest nowy pomysł, którym kogoś obdarowuję. Tak od dwudziestu lat działają łańcuchy pivotowania i sieci C2, i dlatego ruch wychodzący z przejętego hosta tak często prowadzi do kolejnej ofiary, a nie do atakującego. Twoje logi pokazują, że rozmawiałeś z maszyną gdzieś w jakimś centrum danych. Czyja jest i dokąd przekazuje, tego w nich nigdy nie było.

Obronny ciężar mieści się w jednej linii: nie możesz przypisać ani zaufać celowi, którego nie ograniczyłeś z góry. Zanim ruch wychodzi, adres, do którego wychodzi, mówi ci prawie nic, bo to przekaźnik na cudzej maszynie, a prawdziwy punkt końcowy jest wyprany za nim.

Łącze nigdy nie było produktem

Co mnie uderza, po rozebraniu tego na części, to jak mało w tym nowego i jak wiele z tego się sprzedaje.

RFC 1661 jest z 1994 roku. pppd jest w każdej dystrybucji Linuksa od trzydziestu lat, moduły jądra to osiem plików w jednym katalogu, a całość tego, co czyni VPN VPN-em (interfejs wirtualny, wynegocjowane łącze, szyfrowany nośnik, trasa), to cztery programy i certyfikat. Nic z tego nie jest trudne ani tajne. Udokumentowali każdy bajt i oddali to za darmo, a między tobą a tym wyrosła cała branża, sprzedająca te same cztery części w pudełku z licencją na stanowisko i umową wsparcia, która wygasa. Części nie stały się lepsze. Zostały opakowane.

To nie jest argument za puszczaniem tego na produkcji. Właśnie ci powiedziałem, żebyś tego nie robił. To argument za tym, żeby wiedzieć, co jest w pudełku, które kupujesz, bo w dniu, w którym dostawca zmieni licencjonowanie, zostanie przejęty albo wygasi twój model, różnica między złym kwartałem a złym rokiem polega na tym, czy ktokolwiek u ciebie wie, z czego ta rzecz była zrobiona.

Poświęć wieczór i zbuduj tunel z części. Patrz, jak negocjuje LCP, zerwij łącze i patrz, jak wraca, wyciągnij certyfikat i zobacz, co staje. Potem przeczytaj jeszcze raz kartę katalogową swojego dostawcy VPN i zobacz, ile z niej rozpoznajesz.

Ten sam wieczór kupuje drugą połowę. Jeśli routowane łącze z twojej sieci to cztery zainstalowane programy i certyfikat, osoby, która właśnie dostała roota na jednej z twoich maszyn, nie powstrzymuje to, jak trudno zbudować tunel. To nie jest trudne. Powstrzymuje ją tylko to, co zdecydowałeś, zanim przyszła, że może wyjść. Zbuduj to raz, a przestaniesz myśleć o egressie jako o czymś, co egzekwuje produkt, i zaczniesz myśleć o nim jako o decyzji, którą albo podjąłeś, albo nie.

Niewiele z tego to magia. Większość to rok 1994 z warstwą farby, a z rokiem 1994 nie ma nic złego. Działał, był udokumentowany i nadal chodzi.


  1. RFC 1661 — The Point-to-Point Protocol (PPP), 1994. Definiuje łącze, LCP i rodzinę protokołów sterujących warstwy sieci, które na nim siedzą. ↩︎

  2. RFC 2637 — Point-to-Point Tunneling Protocol (PPTP), który przenosi PPP wewnątrz GRE. ↩︎

  3. RFC 3931 — Layer Two Tunneling Protocol w wersji 3, standardowy potomek protokołu, który przenosi PPP wewnątrz UDP. ↩︎

  4. pppd(8) — strona podręcznika demona PPP. Źródło dla pty, notty, local, passive, noipdefault, proxyarp, record, receive-all, opcji echa LCP i domyślnej wartości asyncmap: „If no asyncmap option is given, the default is zero, so pppd will ask the peer not to escape any control characters.” Cytaty odczytane z man pppd w ppp 2.5.1. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  5. RFC 1662 — PPP in HDLC-like Framing. Sekwencja flagi, reguła wypychania oktetów i 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 — standardowe wyjaśnienie nakładania się retransmisji, otwierające się dokładnie tą budową. Pierwotny adres już nie serwuje artykułu; to zrzut z Internet Archive. ↩︎

  7. RFC 5072 — IP Version 6 over PPP. IPV6CP i 64-bitowe identyfikatory interfejsu, niezależne od IPCP. ↩︎

  8. RFC 1332 — The PPP Internet Protocol Control Protocol (IPCP), który negocjuje adresy IPv4 na każdym końcu łącza. ↩︎

  9. RFC 1994 — PPP Challenge Handshake Authentication Protocol (CHAP). Udowadnia tożsamość drugiej strony; niczego nie szyfruje. ↩︎

  10. RFC 3079 — Deriving Keys for use with Microsoft Point-to-Point Encryption (MPPE). Konstrukcja RC4 kluczowana z wymiany MS-CHAP i powód, dla którego PPTP nie jest żywą opcją. ↩︎

  11. Ncat Users’ Guide — connecting through a proxy — --proxy i --proxy-type dla HTTP CONNECT i SOCKS 4/5, więc nośnik TLS kończy się na proxy, a nie na dalekim końcu tunelu. ↩︎

  12. Ncat Users’ Guide — opcje --ssl, --ssl-verify i --ssl-trustfile oraz tryby nasłuchu i UDP. Wersja testowana tutaj: Ncat 7.92. ↩︎

  13. Universal TUN/TAP device driver — własna dokumentacja jądra dla /dev/net/tun, TUNSETIFF i różnicy między tun a tap. ↩︎

  14. PEP 784 — Adding Zstandard to the standard library, i dlatego compression.zstd nie wymaga żadnego pakietu w Pythonie 3.14. Mierzone tutaj na Pythonie 3.14.7 i zstd 1.5.7. ↩︎

  15. zstd(1) — tryb --train i --maxdict, do budowania słownika, który muszą załadować oba końce. ↩︎

  16. RFC 7457 — Summarizing Known Attacks on TLS and DTLS, który omawia CRIME i ogólny kształt przecieku długości przy kompresji przed szyfrowaniem. ↩︎

  17. OpenVPN — the VORACLE attack — ten sam przeciek przeciw VPN-owi, który kompresuje przed szyfrowaniem, i powód, dla którego OpenVPN odradza teraz kompresję. ↩︎