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.
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.
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
scriptis to be used to communicate rather than a specific terminal device. Pppd will allocate itself a pseudo-tty master/slave pair and use the slave as its terminal device. The script will be run in a child process with the pseudo-tty master as its standard input and output.4
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.
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.
| Implementacja | Nasłuch na porcie | UDP | Działa dalej po rozłączeniu drugiej strony |
|---|---|---|---|
| Ncat (Nmap) | ncat -l 443 | -u | -k / --keep-open |
| OpenBSD netcat | nc -l 443 | -u | -k |
| Tradycyjny netcat | nc -l -p 443 | -u | nie |
| GNU netcat | nc -l -p 443 | -u | nie |
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.
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.
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.
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
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.
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
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.
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.
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ą.
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
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:
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.
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.
| tun | tap | |
|---|---|---|
| Co przechodzi | pakiety IP | ramki Ethernetu |
| Narzut na pakiet | żaden | 14-bajtowy nagłówek Ethernetu |
| ARP, DHCP, rozgłoszenia | nie | tak, wszystko, przez tunel |
| Protokoły inne niż IP | nie | tak |
| Może wejść do mostka | nie | tak |
| Odpowiednik | łącze punkt-punkt, jak ppp0 | kabel 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.
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 tunelu | strumień, FLUSH_BLOCK | na pakiet, FLUSH_FRAME | na pakiet z wytrenowanym słownikiem |
|---|---|---|---|
| Powtarzalne wywołania API i telemetria | 5,0% | 14,8% | 5,3% |
| Linie logów | 7,5% | 24,2% | 15,1% |
| Zwykły tekst i pliki konfiguracyjne | 37,8% | 51,3% | 45,3% |
| Losowe bajty, w zastępstwie TLS | 100%+ | 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ździe | tap albo tun po gnieździe | |
|---|---|---|
| Ramkowanie | wbudowane (HDLC, resynchronizuje się po uszkodzeniu) | po UDP żadne, bo żadne nie jest potrzebne; po TCP do wymyślenia |
| Ustawienie adresów | negocjowane przez IPCP i IPV6CP | konfigurowane ręcznie na obu końcach |
| Żywotność | echo LCP, wbudowane | brak; dodajesz sam albo łącze umiera po cichu |
| Uwierzytelnianie | dostępne PAP albo CHAP, oba słabe | żadne |
| Warstwa | tylko 3 | 3 z tun, 2 z tap |
| Mostkowanie | nie | tak, z tap |
| Narzut | flaga, nagłówek i FCS na ramkę, plus escapowanie | nic, albo 14 bajtów z tap |
| Kompresja | deflate i BSD, domyślnie włączone, z 1996 roku | żadna, albo zstd na ramkę, które dodajesz i kontrolujesz |
| Potrzebny root | tak, przez cały czas | do utworzenia urządzenia; nie do używania |
| Ruchome części | jeden demon, trzydziestoletni | jeden 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.
pppdnie 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ę.
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.
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.
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ą. ↩︎
RFC 2637 — Point-to-Point Tunneling Protocol (PPTP), który przenosi PPP wewnątrz GRE. ↩︎
RFC 3931 — Layer Two Tunneling Protocol w wersji 3, standardowy potomek protokołu, który przenosi PPP wewnątrz UDP. ↩︎
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 zman pppdw ppp 2.5.1. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎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).” ↩︎ ↩︎
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. ↩︎
RFC 5072 — IP Version 6 over PPP. IPV6CP i 64-bitowe identyfikatory interfejsu, niezależne od IPCP. ↩︎
RFC 1332 — The PPP Internet Protocol Control Protocol (IPCP), który negocjuje adresy IPv4 na każdym końcu łącza. ↩︎
RFC 1994 — PPP Challenge Handshake Authentication Protocol (CHAP). Udowadnia tożsamość drugiej strony; niczego nie szyfruje. ↩︎
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ą. ↩︎
Ncat Users’ Guide — connecting through a proxy —
--proxyi--proxy-typedla HTTP CONNECT i SOCKS 4/5, więc nośnik TLS kończy się na proxy, a nie na dalekim końcu tunelu. ↩︎Ncat Users’ Guide — opcje
--ssl,--ssl-verifyi--ssl-trustfileoraz tryby nasłuchu i UDP. Wersja testowana tutaj: Ncat 7.92. ↩︎Universal TUN/TAP device driver — własna dokumentacja jądra dla
/dev/net/tun,TUNSETIFFi różnicy między tun a tap. ↩︎PEP 784 — Adding Zstandard to the standard library, i dlatego
compression.zstdnie wymaga żadnego pakietu w Pythonie 3.14. Mierzone tutaj na Pythonie 3.14.7 i zstd 1.5.7. ↩︎zstd(1) — tryb
--traini--maxdict, do budowania słownika, który muszą załadować oba końce. ↩︎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. ↩︎
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ę. ↩︎