VPN не є продуктом. Це дві роботи, скручені докупи, і на твоїй машині вже є програма для кожної з них.

Перша робота: створити віртуальний канал, тобто інтерфейс, який виглядає як мережева карта, приймає IP-пакети й передає їх кудись іще. Друга: перенести байти цього каналу з кінця в кінець. Купи VPN-пристрій, і ти купиш обидві роботи з пришпиленою ліцензією; зроби сам, і кожна з них буде однією вже встановленою програмою. Є два способи виконати першу роботу в Linux, і цей допис будує обидва: pppd, який приносить цілий канальний протокол з узгодженими адресами, перевіркою живучості та кадруванням, і tap-пристрій, який не приносить нічого й є діркою в ядрі, куди ти штовхаєш кадри. Це різні компроміси, а не конкуренти, і друга половина ставить їх поруч.

Цей протокол називається PPP, і причина, з якої це працює, записана в його першому абзаці: PPP є канальним протоколом для каналів «точка-точка»1, і він не визначає, з чого зроблено канал. Першою відповіддю були модем і телефонна лінія. Єдиною вони ніколи не були. PPTP поклав PPP усередину GRE2. L2TP поклав його всередину UDP3. PPPoE поклав його всередину кадрів Ethernet. Кожен із них є тим самим протоколом з іншим кур’єром, і жодному не довелося для цього змінювати PPP.

Тож питання не в тому, чи можна запустити PPP поверх сокета TCP або UDP, а в тому, поверх якого і чого це коштує. Коротка відповідь, з показаним розрахунком: використовуй UDP. Запускати потоковий протокол усередині надійного потоку є тією єдиною помилкою тут, яка на твоєму столі виглядає нормально, а на справжньому каналі розвалюється.

VPN складається з двох робіт. Обидві в тебе вже є.

Зніми з будь-якого тунелю маркетинг, і відбуваються три речі: щось подає віртуальний інтерфейс і перетворює пакети на потік байтів, щось переносить цей потік через мережу, яка вже працює, і щось його шифрує, або ніщо не шифрує.

Кожен тунель має канальну половину, носій і трохи криптографіїЩоразу ті самі три частини. Змінюються лише носій і криптографія.ТУНЕЛЬКАНАЛЬНА ПОЛОВИНАНОСІЙКРИПТОКомутований PPP, 1994PPPмодем і телефонна лініянемаєPPPoEPPPкадри EthernetнемаєPPTPPPPGREMPPE: зламане, не требаL2TP через IPsecPPPUDPIPsecЦей допис, збірка першаPPP через ptyUDP-сокет, через netcatDTLSЦей допис, збірка другаtun- або tap-пристрійUDP-сокет, через socatDTLSWireGuardінтерфейс ядраUDPNoise, і нічого узгоджувати
Кожен тунель у цьому списку має ту саму форму. Різниця лише в тому, в який носій ідуть байти і чи щось їх шифрує. PPP виконує канальну половину з 1994 року, тому він трапляється під трьома з них, не будучи переробленим під жоден. Пристрій tun або tap виконує ту саму половину зовсім без протоколу, і це друга збірка в цьому дописі.

PPP виконує канальну половину як слід: узгодження адрес, перевірка живучості, стиснення заголовків, кілька протоколів мережевого рівня через один канал, крок автентифікації, якщо він тобі потрібен. Ціла купа готової роботи, що лежить у /usr/sbin без діла. Чого він не робить, то це не переймається носієм: дай йому файловий дескриптор, який переносить байти в обидва боки, і він працюватиме поверх нього. Netcat є програмою, вся мета якої полягає в тому, щоб бути цим файловим дескриптором.

Шифрування є тією частиною, якої тобі ніхто не дасть, і саме на те, щоб її заробити, витрачено більшу частину цього допису, бо netcat не має на неї відповіді, а вдавати протилежне означає саме той спосіб, у який люди будують те, чого не слід.

Етапи і чому вони йдуть у такому порядку

Усе нижче побудовано етапами, кожен додає одну річ до попереднього. Це не навчальний прийом. Саме так це і слід будувати, бо коли зламається шостий етап, тобі треба знати, чи досі працює другий, а знаєш ти це лише тоді, коли другий етап колись був річчю, яку ти запускав окремо.

Шість етапів, кожен додає одну річ, яку можна перевірити окремоЗбирай у такому порядку, і ти завжди зможеш спуститися назад1Сирий, через TCPpppd із pty або tap-пристрій і простий слухач netcat.Працює на стенді. Розвалюється на справжньому шляху: два таймери повторів б’ються.2Сирий, через UDPТой самий канал, датаграмний носій. Втрачена датаграма є одним втраченим пакетом.Це фундамент. Усе вище за нього необов’язкове; він ні.3TLS, через TCPncat, stunnel або openssl обгортають носій. Перевіряй сертифікат на обох кінцях,інакше маєш шифрування без ідентичності й узагалі без контролю доступу.4DTLS, через UDPsocat або openssl, і форма, до якої варто прагнути: шифровано, автентифіковано, датаграми.Втрачений пакет лишається втраченим, а не стає суперечкою двох стеків.5Стисненняzstd між інтерфейсом і носієм. Зберігай вікно між кадрами там, де носійдоставляє по порядку; де ні, один самодостатній кадр на датаграму плюс словник.6Обидва, у такому порядкуСтисни, потім зашифруй. Ніколи навпаки: шифротекст не стискається.Знай компроміс: стиснення перед шифруванням видає довжину. На своєму трафіку годиться.
Шість етапів, кожен додає одну річ до того, що нижче. Із сирого TCP всі починають, і це єдиний щабель, що веде в глухий кут: він працює на стенді й розвалюється на справжньому шляху. Сирий UDP є фундаментом, на якому стоїть усе інше. Потім шифрування, потім стиснення, потім обидва разом. Кожен етап є каналом, який можна підняти, пропінгувати й залишити працювати, тож коли верх драбини поводиться не так, ти можеш спускатися нею вниз по одному щаблю.

Сам канал будується так само, і на цьому стоїть односекундний розгін далі в тексті: тунель піднімається сирим, доводить, що може перенести кадр, і лише потім стає розумним. Збірка, що вмикає все одразу, падає однією грудкою, і ти проводиш вечір, гадаючи, який рівень це зробив.

Насправді pppd хоче файловий дескриптор

pppd писали для послідовних портів, тож наївне прочитання каже, що він потребує такого порту. Ні. Він потребує термінального пристрою, і він створить його собі сам:

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

Перечитай це: уся збірка там. pppd створює псевдотермінал, лишає собі підлеглу сторону й передає головну сторону команді як stdin і stdout. Що ця команда робить із байтами, pppd не обходить. Запусти там nc, і вони підуть у сокет.

pppd, псевдотермінал, netcat і сокетОдин пакет від ppp0 до ppp0 і кожні руки, крізь які він проходитьХОСТ AХОСТ Bppp0інтерфейс ядраpppdкадрування HDLCпара ptyпідлегла до pppdголовна до нащадкаncatstdin and stdoutпара ptyголовна до нащадкапідлегла до pppdncatstdin and stdoutpppdкадрування HDLCppp0інтерфейс ядрасокет: TCP або UDPДві коробки посередині є єдиною частиною, яку ти обираєш. Усе з обох боків незмінне, чи носій телефонна лінія,послідовна консоль, потік TCP, потік датаграм UDP чи сеанс TLS, тому заміна носія пізніше коштує одне слово.Псевдотермінал не має контакту виявлення несучої, тож pppd чекає її вічно. Це зупиняє опція `local`.
pppd говорить асинхронним HDLC у підлеглу сторону псевдотерміналу, який він виділив собі сам. Команда, названа в pty, успадковує головну сторону як stdin і stdout. Netcat копіює stdin у сокет, а сокет у stdout, тож два екземпляри pppd розмовляють один з одним через пару pty і мережу, і жоден із них не знає, що існує сокет.

Є й другий шлях, notty, що використовує власні stdin і stdout pppd. Але він породжує процес-перекидач символів, крізь який проходить кожен байт, тож це «increases the latency and CPU overhead»4. Використовуй pty, якщо не маєш причини цього не робити.

Три практичні факти перед першою командою, усі перевірені на машині, де це писалося, 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

Потрібен root. Ніяк не обійти. Двійковий файл у Fedora не має setuid, /dev/ppp має режим 0600 і належить root, а потрібні тобі опції однаково привілейовані. Це те, що запускають від root або через unit-файл, а не те, що користувач робить знічев’я. Це важить пізніше, коли ми дійдемо до того, що це означає для твоєї політики вихідного трафіку.

Ядерна частина модульна. ppp_generic робить інтерфейс, ppp_async кадрування з байтовим заповненням, якого потребує pty, а ppp_deflate/bsd_comp/ppp_mppe стиснення й шифрування; вони завантажуються на вимогу. Якщо ppp_async бракує в урізаному образі контейнера, канал піднімається й нічого не переносить. Жахливі пів години, якщо не знаєш, куди дивитися.

На pty немає ліній керування модемом. Без контакту виявлення несучої pppd чекає несучу, яка ніколи не прийде. Виправлення складається з одного слова, local, яке велить йому ігнорувати лінії керування модемом4. Пропусти його, і нічого не станеться, без жодної помилки, яку варто читати.

Netcat не є однією програмою

Перед збиранням пастка, яка з’їдає найбільше часу: «netcat» означає щонайменше чотири програми з несумісними прапорцями, і яку ти отримаєш, залежить від твого дистрибутива. На цій машині /usr/bin/nc є символьним посиланням на /usr/bin/ncat, переписаний варіант від Nmap. Тож команда, скопійована з п’ятнадцятирічної вікі-сторінки, не працює з причин, які не мають нічого спільного з PPP.

РеалізаціяСлухати портUDPЛишатися живим після відключення співрозмовника
Ncat (Nmap)ncat -l 443-u-k / --keep-open
OpenBSD netcatnc -l 443-u-k
Традиційний netcatnc -l -p 443-uні
GNU netcatnc -l -p 443-uні

Як таке, перевір, який у тебе, перш ніж звинувачувати pppd:

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

Нижче я явно використовую ncat. Саме він має вбудований TLS, що важить пізніше, а явність означає, що команди не означатимуть мовчки щось інше на твоїй машині.

Етап перший: TCP-збірка, бо саме її всі пробують першою

Один кінець слухає, другий підключається. Адреси тут із документаційного діапазону, тож вставляй їх прямо в лабораторію, і нічого маршрутизованого не постраждає. Порт усюди 443, і це навмисно: вихідний 443 за замовчуванням відкритий майже в кожній мережі. Обгорни носій у TLS кількома етапами нижче, і трафік на ньому не відрізнити від будь-якого сеансу HTTPS. Щоб прив’язати слухача до цього порту, потрібен root, який дальній кінець, власна машина зловмисника або ретранслятор, має. Це весь аргумент про вихідний трафік в одному номері порту, і я до нього повернуся.

На кінці, що слухає:

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'

На кінці, що підключається:

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'

Кожне слово тут виконує роботу, і одне з них, noauth, тихо шкодить. Тунель не має контролю доступу, і цьому присвячено окремий розділ далі.

Кожне слово в рядку pppd і що воно робитьКомандний рядок UDP-збірки, слово за словомnodetachпередній план, щоб бачити вивід і поставити під наглядачаnoauthбез автентифікації співрозмовника: ось дірка; контролю доступу немаєlocalігнорувати лінії керування модемом, яких pty не має. Без неї нічого не підніметьсяpassiveчекати дійсний пакет LCP замість виходу: поведінка серверного сокетаnodefaultrouteне захоплювати маршрут за замовчуванням після IPCP. Потрібний маршрут додай самnoipdefaultне пропонувати власну адресу машини як локальний кінець192.0.2.1:192.0.2.2local:remote, зафіксовано: pppd відкидає будь-яку іншу відповідь під час IPCPlcp-echo-interval / -failureперевірка живучості: окремий розділ нижчеmtu / mru 1400лишити місце для того, чим носій обгортає кожен кадрpty '...'команда, чиї stdin і stdout стають каналом: тут сокет netcatКінець, що підключається, має той самий рядок без `passive`: він ініціює, а не чекає.
Кожна опція в рядку і що вона робить. Стежити варто за noauth: вона вимикає автентифікацію співрозмовника, тож слухач приймає будь-кого, хто прийде. nodefaultroute і noipdefault не дають каналу тихо переписати твою маршрутизацію, local взагалі дає йому піднятися на pty, а зафіксована пара local:remote не дає pppd прийняти іншу відповідь під час IPCP. Кінець, що підключається, має той самий рядок без passive.

Підніми обидва кінці, і отримаєш ppp0 на кожному, маршрут «точка-точка» до дальньої адреси та інтерфейс, який можна пінгувати, через який можна маршрутизувати й на якому можна запускати tcpdump. Це VPN: жоден пакет не встановлено, жоден демон не налаштовано, жодним ключем не обмінялися, і в цьому проблема, до якої я повернуся.

Що він узгодив і як за цим стежити

Додай debug, і pppd журналює обмін керівного протоколу, який варто прочитати хоч раз, навіть якщо більше ніколи цього не робитимеш. Канал піднімається етапами, і кожен етап може впасти сам по собі.

LCP, потім автентифікація, потім по керівному протоколу на родину адресТри етапи, і кожен ламається зі своєї причини1LCP: сам каналMRU, мапа керівних символів, магічнечисло для закільцьованої лінії і чи хочеякийсь кінець, щоб інший автентифікувався.Збій тут означає, що носій не передає байтичисто в обидва боки. Перевір сокет,а не опції PPP.2Автентифікація: необов’язковаPAP шле пароль відкритим текстом. CHAPробить виклик і відповідь MD5. Пропущено.Обидва доводять, хто співрозмовник. Жоденне шифрує жодного байта після.3aIPCPАдреса IPv4на кожному кінці.3bIPV6CP64-бітні IDінтерфейсів.Ці два незалежні. IPv6 може піднятися, поки IPv4 ще сперечається,а збій в одному не валить інший. Інтерфейс починає переносити трафікродини щойно завершиться керівний протокол цієї родини.
LCP домовляється про сам канал: наскільки великим може бути кадр, які керівні символи треба екранувати, і магічне число, що виявляє закільцьовану лінію. Автентифікація необов’язкова й тут пропущена. Потім один керівний протокол на кожен мережевий рівень: IPCP для IPv4, IPV6CP для IPv6. Вони незалежні, тож канал може переносити IPv6, поки IPv4 ще сперечається, а збій в одному не валить інший.

Два корисні засоби налагодження вже встановлено, і ними ніхто не користується:

# 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 пише позначений часом запис кожного байта, pppdump перетворює його на щось читабельне4, а з tcpdump -ni ppp0 ти бачиш обидва боки: кадрування внизу й пакети зверху.

Кадр на дроті і чому 0x7E усюди

PPP через послідовну лінію, а pty для pppd нею і є, використовує асинхронне кадрування HDLC, і розуміння його відрізняє налаштування від гадання. Кожен кадр починається й закінчується тим самим байтом: «Each frame begins and ends with a Flag Sequence, which is the binary sequence 01111110 (hexadecimal 0x7e)»5. Якщо 0x7e позначає межу, він не може з’явитися всередині кадру, тож його екранують. Так само екранують байт екранування 0x7d і все інше, про що попросив будь-який із кінців.

Кадр, байт-прапорець і чого коштує екрануванняОдин кадр і два байти, які ніколи не можуть з’явитися всередині0x7Eпрапорець0xFFадреса0x03керуванняпротокол1 або 2 байтинавантаження: твій IP-пакетдо узгодженого максимального розміру прийомуFCS16-бітний CRC0x7EпрапорецьЕКРАНУВАННЯ, ЄДИНЕ ПРАВИЛОБудь-який байт, який можна сплутати з межею, замінюється на 0x7D, за яким іде початковий байт, XOR із 0x20.байт 0x7E передається як 0x7D 0x5Eбайт 0x7D передається як 0x7D 0x5DЦі два обов’язкові. Усе інше вирішує асинхронна мапа керівних символів: 32 біти, по одному на символ.Мапа нульова: типове значення pppd, і правильне на сокетіДва байти з 256 екрановано. Накладних витрат ти ніколи не виміряєш. Сокет є чистим 8-бітним шляхом.Позначено всі 32: консервативне налаштування модемаНа стиснених чи зашифрованих даних кожен восьмий байт менший за 0x20 і подвоюється. Близько 12 % каналу задарма.
Кадр складається з прапорця, адреси, керування, протоколу, корисного навантаження, контрольної послідовності кадру й прапорця. Будь-який байт усередині, який можна сплутати з межею, замінюється на 0x7D, за яким іде початковий байт XOR 0x20. ACCM вирішує, скільки інших байтів отримують те саме: нуль на чистому 8-бітному шляху, тридцять два, якщо будь-який кінець просить консервативне значення за замовчуванням, яке припускає модем, що з’їдає керівні символи.

Правило екранування точне: «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.

Остання частина і є ручкою налаштування. ACCM має 32 біти, по одному на керівний символ, і 1 означає «екрануй це». Попроси всі, і на зашифрованому навантаженні, де байти фактично випадкові, приблизно кожен восьмий байт менший за 0x20: близько 12 % накладних витрат задарма.

Сучасний pppd уже робить тут правильно. Читай сторінку man, а не фольклор:

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

Тож asyncmap 0 є значенням за замовчуванням, а не хитрощами, а сокет є чистим 8-бітним шляхом, який не потребує екранування понад два обов’язкові байти. Не чіпай це; вмикай біти лише тоді, коли щось посередині справді з’їдає керівні символи: термінальний сервер, послідовний концентратор, поганий консольний проксі. Контрольна послідовність кадру наприкінці є 16-бітним CRC, і саме на ній тримається UDP-збірка, до якої ми зараз і перейдемо.

TCP поверх TCP є неправильним носієм

Збірка вище працює. На лабораторному стенді, через loopback чи тиху LAN, вона працює чудово, і саме тому люди її й випускають.

Потім вона зустрічає справжній шлях зі справжніми втратами. І падає так, що виглядає як усе що завгодно, окрім того, чим воно є.

Проблема в двох незалежних таймерах повторної передачі, поставлених один на одного, де зовнішній ховає втрати від внутрішнього. Олаф Тітц (Olaf Titz) написав остаточне пояснення, яке відкривається саме цією збіркою:

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

Один втрачений пакет, два носії, два дуже різні наслідкиОдин пакет зникає. Що кожен носій робить далі.TCP-НОСІЙ: тунель ховає втрату1Носій губить сегмент.2Носій передає його повторно. Байти приходять пізно,а не зникають, і в цьому вся проблема.3Тунельований TCP не бачить носія. Він читаєзатримку як перевантаження, подвоює таймер іповторно шле дані, що вже в дорозі під ним.4Тепер носій винен оригінал і дублікат,каналом, що щойно довів, що губить пакети.Черга росте швидше, ніж рівні її розбирають.Пропускна здатність падає задовго до каналу.UDP-НОСІЙ: втрата доходить до свого рівня1Носій відкидає пакет і нічого не каже.2Кадр PPP усередині не проходить контрольнусуму й відкидається. Наступний прапорець синхронізує.3Тунельований TCP бачить справжню втрату, бонарешті йому сказали правду про шлях.4Він зменшує вікно вдвічі й повторює один раз.Контроль перевантаження робить саме ту роботу,для якої створений. Один пакет коштує один пакет.
TCP-носій гарантує доставку, тож втрачений сегмент передається повторно, і байти приходять пізно, а не не приходять зовсім. Тунельований TCP усередині бачить лише затримку, вирішує, що мережа перевантажена, відступає й повторно передає ті самі дані, які тепер носій теж мусить доставити. Таймер кожного рівня намагається виправити проблему, якою вже володіє інший рівень, і черга росте швидше, ніж будь-який із них може її розібрати. UDP-носій відкидає пакет, внутрішній TCP бачить справжню втрату, і його контроль перевантаження робить роботу, для якої його створено.

Ось форма. Обидва TCP встановлюють таймер повторної передачі за своїм часом проходження туди й назад. Коли носій втрачає сегмент, він передає його повторно, тож дані внутрішнього з’єднання приходять пізно. А внутрішній TCP, який не бачить носія, читає запізнення як перевантаження й теж передає повторно. Тепер носій має доставити оригінал і дублікат каналом, який уже губить пакети. Внутрішній таймер подвоюється, зовнішня черга росте, і пропускна здатність падає задовго до того, як падає канал. Ніщо в журналах не каже чому.

Це не тонкий момент щодо ефективності. Це різниця між тунелем, що деградує м’яко, і тунелем, що перестає пропускати трафік десь при 2 % втрат, поки ping тим самим шляхом досі виглядає нормально. Ось причина використовувати UDP, а TCP тримати в запасі лише для шляху, який не пропустить нічого іншого.

Тож використовуй UDP як типовий вибір, а не як уподобання.

Етап другий: UDP-збірка, яка є фундаментом

Той самий pppd, інший носій. Єдина зміна в команді pty.

Кінець, що слухає:

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'

Кінець, що підключається:

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'

Дві речі щодо UDP-слухача, які тебе підловлять, і жодна з них не є проблемою PPP.

Слухач не може відповісти, доки до нього не заговорять. UDP-сокет не має з’єднання, яке можна прийняти, тож netcat не може знати, куди слати відповіді, доки не прийде датаграма. Він чіпляється за першу адресу й порт джерела, які почує, і говорить із ними. Це означає, що кінець, що підключається, мусить надіслати першим, і pppd робить це сам, бо непасивний кінець одразу починає слати запити конфігурації LCP. Це також означає, що якщо порт джерела клієнта зміниться, носій мовчки говоритиме не туди. За NAT із коротким тайм-аутом UDP це тунель, що помирає кожні кілька хвилин без видимої причини.

--keep-open на UDP робить не те, чого ти хочеш. -k у Ncat тримає TCP-слухача таким, що приймає з’єднання, після того як співрозмовник пішов. На UDP приймати нічого, тож відновлення означає перезапуск носія, і саме для цього існують persist і holdoff, про які далі.

Обидва пункти є аргументами на користь socat, який обережніше поводиться з UDP-співрозмовниками, і на користь наглядача замість віри в те, що воно лишиться живим.

Чому PPP переживає втрачену датаграму

Очевидне заперечення проти UDP-носія: PPP очікує потік байтів, а UDP ним не є. Датаграми приходять цілими або зовсім не приходять і можуть прийти не по черзі. Але це однаково працює, завдяки двом байтам, які кадрування носило весь цей час.

Втрачена датаграма коштує кадр, а наступний прапорець відновлює каналМежі не збігаються, і це не важитьКАДРИ PPP, ЯК ЇХ ЗАПИСАВ pppd7Eкадр A + FCS7Eкадр B + FCS7Eкадр C + FCS7Eкадр D + FCSЩО НОСІЙ НАСПРАВДІ НАДІСЛАВ: netcat читає буфер, а не кадрдатаграма 1датаграма 2: втраченадатаграма 3датаграма 4Кадр B втрачає середину, контрольна сума не сходиться, і його відкидають. Кадр C втрачає початок і йде тим самим шляхом.Два втрачені кадри є двома втраченими IP-пакетами. Рівень вище передає їх повторно, знаючи, що шлях щось загубив.Саме цей сигнал TCP-носій сховав би, доставивши їх із запізненням.
Netcat читає все, що є в буфері, і пише це в датаграму, тож межі кадрів і межі датаграм не мають нічого спільного. Втрать датаграму, і отримувач бачить кадр, у якому бракує байтів: контрольна послідовність кадру не сходиться, і кадр відкидається, так само як на зашумленій послідовній лінії. Наступний 0x7E знову синхронізує потік. Один відкинутий кадр коштує один пакет, і рівень вище передає його повторно. Це і є той сигнал втрати, якого внутрішній TCP потребував і ніколи не отримував через TCP-носій.

PPP через асинхронний HDLC проєктували для лінії, що псує байти. Кожен кадр несе 16-бітну контрольну послідовність кадру; кадр, що її не проходить, відкидається, а наступний байт-прапорець знову синхронізує отримувача. Перестановки трапляються рідше за втрати й дають той самий результат: погана FCS, відкинутий кадр, ресинхронізація.

Тож втрачена датаграма коштує один кадр PPP, один IP-пакет, що є звичайним станом кожної мережі, яку будь-коли збудували. Власник пакета передає його повторно, а контроль перевантаження бачить справжню втрату й реагує правильно. Ось і весь аргумент за UDP: він дає трафіку всередині тунелю дізнатися правду про шлях.

Але не дозволяй кадрам ставати настільки великими, щоб носієві доводилося їх фрагментувати. Тоді один втрачений фрагмент убиває всю датаграму, і твій фактичний рівень втрат множиться. Тримай MTU PPP добре нижче MTU шляху.

Адреси, маршрути і IPv6 як слід

ppp0 є інтерфейсом «точка-точка», без підмережі й без ARP, тож local:remote і є вся адресація, а маршрутизуєш ти через нього явно. Для одного хоста, що досягає однієї мережі за дальнім кінцем:

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

Щоб дальній кінець пересилав від імені клієнта, звичайні два кроки:

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

proxyarp змусить сервер відповідати на ARP за клієнта у своєму сегменті4, що зручно, доки другий клієнт не захоче того самого. Тоді зроби частину, яку більшість пропускає. Запусти через нього IPv6: канал «точка-точка» без NAT, без широкомовного домену й без дефіциту адрес є найпростішим місцем у твоїй мережі, щоб зробити IPv6 як слід:

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 вмикає IPV6CP; ipv6 <local>,<remote> задає два 64-бітні ідентифікатори інтерфейсів4, канал піднімається з локальними адресами каналу, а глобальну /64 ти додаєш зверху7. IPV6CP незалежний від IPCP8, тож noip не переносить нічого, крім IPv6. Цілком розумна річ, щоб збудувати 2026 року, одним словом.

Як утримати канал, коли носій тихо помирає

Це той збій, що марнує пів дня, тож він отримує окремий розділ.

TCP-носій, що помер погано, коли дальній кінець вимкнули, запис у таблиці NAT застарів чи проміжний пристрій перестав пересилати, не закривається. Немає FIN, немає RST, нічого. Netcat сидить, тримаючи сокет, що більше ніколи не доставить жодного байта, pppd сидить, тримаючи pty, що більше ніколи не побачить жодного кадру, а ip link бадьоро повідомляє, що ppp0 в стані UP. UDP-носій узагалі не має стану з’єднання, тож він ніколи нічого не помічає.

PPP має вбудовану відповідь, і вона за замовчуванням вимкнена:

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

Це надсилає ехо LCP кожні десять секунд і розриває канал, коли три лишилися без відповіді4. Це тридцять секунд, щоб упіймати мертвий носій, саме у випадку, який називає сторінка man, «no hardware modem control lines»4, а це кожен pty, який будь-коли створили. Потім виріши, що станеться далі:

persist maxfail 0 holdoff 5
Виявити мертвий носій за тридцять секунд і відбудувати йогоНосій може померти, не закрившись. Ось як PPP це помічає й відновлюється.Носій тихо помираєкінець вимкнено · запис NAT зник ·посередник не пересилаєНіхто не повідомляєні FIN, ні RST · ip link досікаже ppp0 UP · UDP без стануДетекторlcp-echo-interval 10 lcp-echo-failure 3ехо кожні 10s, вниз після 3 пропусків: 30sВідбудоваpersist maxfail 0 holdoff 5перезапуск, не здаватися, 5s між спробамиОдин наглядачunit systemd, Restart=always,pppd перезапускає pty-команду:свіжі netcat і сокет разомУвімкни ехо на обох кінцях. Ехо доводить лише шлях, яким повернулася відповідь.Поклади `ip route` в /etc/ppp/ip-up.d/, а маршрути IPv6 в /etc/ppp/ipv6-up.d/, щоб маршрутизація поверталася з каналом,а не задавалася раз вручну й не губилася при першому ж перепідключенні.
lcp-echo-interval 10 lcp-echo-failure 3 є детектором: ехо кожні десять секунд, канал вниз після трьох пропущених. persist maxfail 0 holdoff 5 є відбудовою: перезапуск, ніколи не здаватися, чекати п’ять секунд, щоб нестабільний шлях не став fork-бомбою, а pppd перезапускає команду pty, тож разом із нею приходять свіжий netcat і сокет. Увімкни ехо на обох кінцях; один наглядач, unit systemd з Restart=always, кращий за два процеси, що сперечаються. Поклади ip route в /etc/ppp/ip-up.d/, щоб маршрутизація поверталася разом із каналом.

Він не має ні шифрування, ні автентифікації

Усе вище є робочим тунелем. Безпечним він не є, і ця прогалина не дрібниця.

Шифрування немає. Не слабке шифрування. Жодного. Кожен пакет, який ти через це пропускаєш, іде дротом відкритим текстом, загорнутий у кадр HDLC, який будь-який засіб захоплення декодує з першого погляду. tcpdump покаже тобі вміст чужого тунелю так само охоче, як і твого.

Автентифікації співрозмовника немає. noauth так і каже. Слухач netcat приймає все, що приходить на порт: перше з’єднання чи датаграму звідки завгодно. Хто прийшов першим, той отримує маршрутизований канал у твою мережу. PPP має автентифікацію (PAP відкритим текстом, CHAP як виклик-відповідь9), і обидві доводять, хто такий співрозмовник, не шифруючи жодного байта того, що йде далі: CHAP тут дає тобі тунель, який знає, з ким говорить, і досі публікує вміст будь-кому на шляху.

У родині PPP є опція шифрування, MPPE10, модуль, що лежить у ppp_mppe.ko. Не тягнися до неї: це RC4 з ключем від обміну MS-CHAPv2, публічно зламаний понад десять років тому, і причина, з якої PPTP мертвий. Будувати на ньому новий тунель 2026 року означає вибрати відомо зламаний шифр замість робочого, що нічого не коштує.

Тож чесний підсумок на цей момент: маршрутизований канал без конфіденційності й без контролю доступу. Годиться для лабораторії, годиться всередині каналу, що вже зашифрований, не годиться більше ніде. Виправлення полягає в тому, щоб зашифрувати носій. Про це два наступні розділи, і це причина використовувати ncat, а не той netcat, який постачав твій дистрибутив.

Етап третій: обгортаємо носій у TLS

Чиста відповідь лишає pppd точно таким, як є, і замінює носій на такий, що вміє TLS. pppd так і не дізнається, що щось змінилося.

Спершу сертифікат. Самопідписаного досить, якщо клієнт його перевіряє. Неперевірений сеанс TLS є зашифрованою розмовою з кимось, кого ти не ідентифікував, і це не зупиняє нікого:

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 має вбудований TLS. Він також уміє йти ланцюжком через проксі, --proxy host:port --proxy-type http|socks4|socks511, тож носій може закінчуватися на ретрансляторі, а не на дальньому кінці тунелю. Саме на цьому тримається розділ про вихідний трафік. Кінець, що слухає:

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'

Кінець, що підключається:

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 є тим словом, яке важить. Без нього --ssl дає тобі шифрування проти пасивного слухача й нічого проти того, хто першим відповість на порт; з ним Ncat перевіряє довіру й доменне ім’я за файлом довіри12. Проте Ncat не має перевірки клієнтського сертифіката на боці сервера, тож сервер не може ідентифікувати клієнта. Поєднай це з CHAP або використай один із двох наступних.

Stunnel

Традиційна обгортка, і та, що робить взаємну автентифікацію як слід:

[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 вимагає клієнтського сертифіката, підписаного CA з CAfile. Це той контроль доступу, якого збірка з netcat ніколи не мала. Клієнт запускає stunnel у клієнтському режимі, а команда pty в pppd підключається до локальної відкритої сторони.

Socat

socat робить усе одним процесом на кожному кінці, з перевіркою, увімкненою за замовчуванням:

# 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 не встановлено на машині, де це писалося, тож це з його документації. Перевір прапорці у себе. Саме до нього я б і потягнувся, бо він єдиний із чотирьох, що також говорить DTLS.

Openssl, коли більше нічого немає

openssl є на кожній машині, де взагалі є TLS, і s_server/s_client перенесуть канал:

# 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 пригнічує банер, який інакше потрапив би в твій потік PPP, а -verify_return_error змушує збій перевірки закривати з’єднання замість того, щоб попередити й працювати далі. Це засоби налагодження, які так і поводяться, але на машині, де нічого не можна встановити, вони піднімуть канал.

Простий, TLS через TCP чи DTLS через UDPТа сама канальна половина на обох кінцях. Змінюється лише середина.pppd або tap0простий netcat, UDPncat --udp --listen 6000pppd або tap0Відкритим текстом на дроті, і слухач бере того, хто першим дістався порту. Ні конфіденційності, ні контролю доступу.pppd або tap0TLS через TCP: ncat, stunnel або opensslncat --ssl --ssl-verify --ssl-trustfile tunnel.crt host 6000pppd або tap0Захищено, і сертифікат каже, хто дальній кінець. Але носій знову TCP, і лише ця форма вміє потокове стиснення.pppd або tap0DTLS через UDP: socat або opensslsocat - OPENSSL-DTLS-CLIENT:host:6000,cafile=tunnel.crt,verify=1pppd або tap0Шифровано, автентифіковано й досі датаграми. Втрачений пакет лишається втраченим, без суперечки двох стеків. Цілься сюди.
На обох кінцях увесь час той самий pppd, змінюється лише команда pty. Простий netcat дає канал, який ніщо не захищає. TLS через TCP захищає байти й повертає проблему TCP-носія. DTLS через UDP є формою, до якої варто прагнути: зашифровано, автентифіковано, і досі датаграмний носій, тож втрачений пакет лишається втраченим пакетом, а не перетворюється на бійку повторних передач між двома стеками.

Етап четвертий: DTLS, бо носій має лишатися UDP

Ось незручна частина і причина, з якої цей розділ окремий. Кожен варіант TLS вище працює через TCP, тож обгортання носія в TLS скасовує аргумент за UDP і повертає тобі розвал. Шифрування й правильний транспорт не повинні бути компромісом. DTLS є TLS через датаграми, і саме цього ти хочеш: він зберігає захист рівня записів, відкидає гарантії порядку й повторної передачі та лишає втрачені пакети втраченими, а саме це контрольна послідовність кадру PPP і створена поглинати.

Ncat цього не вміє. socat і openssl уміють:

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

І лише з openssl, де -dtls вибирає будь-яку версію 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'

Стеж за розміром кадрів. Запис DTLS не можна фрагментувати так, як запис TLS розтягується по TCP-потоку, тож усе мусить уміститися в MTU шляху за один раз.

Стос накладних витрат і внутрішній MTU, що лишаєтьсяРахуй униз від MTU шляху й використовуй те, що лишилосязаголовок IP20 (v4) / 40 (v6)заголовок UDP8запис DTLS + тег≈ 30кадрування PPP / Ethernetкількавнутрішній MTU, що може перенести тунель: ціль 1400, мінімум 1280Запис DTLS не можна фрагментувати так, як запис TLS розтягується по потоку TCP, тож усе це мусить влізти в MTU шляху.Та сама форма, що в OpenVPN з 2001 року: датаграмний носій, DTLS, віртуальний інтерфейс зверху. Не дивацтво; просто розібрано.
Рахуй униз від 1500: 20 байтів заголовка IPv4 або 40 IPv6, 8 UDP, приблизно 30 на запис DTLS і його тег, кілька на кадрування, а решта є внутрішнім MTU, який тунель може перенести. Цілься в 1400 на звичайному шляху; 1280 є безпечним мінімумом, якщо щось посередині само є тунелем. Ця форма, датаграмний носій, DTLS, віртуальний інтерфейс зверху, майже те саме, що OpenVPN робить з 2001 року. Не дивацтво; просто розібране на частини.

Налаштування PPP-збірки: MTU, стиснення і що справді допомагає

Чотири ручки, усі опції pppd. Tap-збірка в наступному розділі не має жодної з них, бо не має жодного з механізмів, які вони налаштовують.

Чотири ручки pppd: одну задати, одну лишити, дві вимкнутиОдну задати, одну лишити, дві вимкнутиЗАДАЙMTU і MRUОбидва кінці, із запасом: 1400 просто, 1280 під тунелем. Фрагментований кадр губить цілий пакет.ЛИШИACCMУже нуль за замовчуванням, що правильно на чистому сокеті. Чіпай, лише якщо щось з’їдає керівні символи.ВИМКНИnovjСтиснення заголовків Ван ЯкобсонаЗаощаджує похибку округлення, коштує CPU на пакет і ламається при втратах. Вимкни понад модемну швидкість.ВИМКНИnodeflate nobsdcompНавантаження вже TLS/DTLS: стиснення шифротексту є марною роботою, а через межу безпеки ще й атакою.Ніщо з цього не робить тунель швидшим. PPP не є вузьким місцем: PPPoE дає 2 Gbit тим самим демоном, бо його шлях даних лишаєтьсяв ядрі. Ціна тут у pty: кожен байт переходить у простір користувача й назад. Це належить псевдотерміналу, а не PPP.
MTU і MRU є тим, що важить: задай обидва на обох кінцях із запасом, бо кадр, який носієві доводиться фрагментувати, втрачає цілий пакет при будь-якій втраті. ACCM уже нульовий і правильний на чистому сокеті. Вимкни стиснення заголовків Ван Якобсона через novj на швидкостях вище модемних. Воно заощаджує похибку округлення, коштує процесорного часу на кожен пакет і ламається при втратах. Вимкни deflate/bsdcomp: навантаження вже зашифроване, а стиснення через межу безпеки є атакою, а не функцією.

Ніщо з цього не робить тунель швидшим, і причина важить, бо за це звинувачують PPP, а не слід. PPP не є вузьким місцем. PPPoE переносить 2 Gbit тим самим демоном, бо його шлях даних ніколи не залишає ядра: ppp_generic і pppoe роблять кадрування й пересилання, а pppd обробляє лише площину керування. Що тобі тут коштує, так це pty: кожен байт переходить у простір користувача, через netcat, у сокет і назад, і в такий обхід PPPoE ніколи не ходить. Це належить псевдотерміналу, а не PPP.

І це добрий момент, щоб поглянути на інший спосіб, де pty немає зовсім.

Інший шлях: tap-пристрій і зовсім без PPP

Усе дотепер використовувало PPP для канальної половини. Є другий спосіб створити віртуальний інтерфейс, і йому не потрібен жоден протокол.

Драйвер TUN/TAP ядра дає тобі інтерфейс і файловий дескриптор, зв’язані разом: запиши пакет у дескриптор, і він з’явиться на інтерфейсі, ніби з дроту; прочитай, і отримаєш пакет, який ядро хотіло надіслати. Ось і весь інтерфейс13, і в Linux він є з 1999 року.

ip tuntap add dev tap0 mode tap user damien group damien
ip link set tap0 mtu 1400 up
ip addr add 192.0.2.1/30 dev tap0
Tap-пристрій є інтерфейсом з одного боку й файловим дескриптором з іншогоНі демона, ні протоколу, ні псевдотерміналу. Один файловий дескриптор.ЯДРОtap0звичайний інтерфейс,з адресою й маршрутом/dev/net/tunTUNSETIFF задає назвупристрою, який отримаєштвій процесsocat або п’ятдесят рядківPython, що тримають fdUDP-сокетодин кадр на датаграмумережаі дальній кінецьодне читання = один кадрЧого бракує порівняно з PPP-збіркою: узгодженого розміру кадру, перевірки живучості, обміну адресами, автентифікації.Обидва кінці налаштовуєш вручну, і вони нічого з цього не обговорюють. Ніщо не стежить за каналом, ніщо не скаже, що він помер.
Ні демона, ні протоколу. Ядро подає tap0 як звичайний інтерфейс і віддає його другий бік тому процесу, який відкрив /dev/net/tun. Одне читання повертає рівно один кадр Ethernet; один запис вставляє рівно один. Усе, що pppd узгоджував, адреси, розміри кадрів, живучість, ти тепер налаштовуєш вручну на обох кінцях, і два кінці ніколи нічого з цього не обговорюють.

Дві подробиці в тій першій команді варті більшого, ніж здається.

user damien робить пристрій постійним і непривілейованим. Створений так, він переживає процес, що ним користується, а названий користувач може його відкрити, не будучи root. Root створює пристрій один раз; те, що перекидає кадри, root зовсім не потребує. Запам’ятай це до розділу про вихідний трафік.

mode tun є другою половиною того самого драйвера, і саме вона потрібна більшості людей. Tun переносить IP-пакети. Tap переносить кадри Ethernet. Різниця настільки важлива, що нижче має окремий розділ.

Чим ти поступаєшся порівняно з PPP, так це всім, що PPP узгоджує: немає LCP, тож немає узгодженого розміру кадру й перевірки живучості, немає IPCP/IPV6CP, тож обидва кінці налаштовуються вручну, немає автентифікації, немає стиснення заголовків. Tap-пристрій є діркою в ядрі, і протокол крізь неї такий, який ти туди поклав. Що ти отримуєш, так це повну відсутність накладних витрат на кадрування, жодного екранування, жодного каналу керування й інтерфейс, який можна включити в міст.

Tap через UDP, де одна датаграма дорівнює одному кадру

Це найчистіша відповідність у всьому дописі, і вона випливає з конструкції. Tap-пристрій є датаграмним пристроєм, один read() повертає рівно один кадр, а UDP-сокет є датаграмним сокетом, один sendto() на датаграму. Тож кадр іде в датаграму, приходить як кадр, і немає нічого, що треба розмежовувати, буферизувати чи ресинхронізувати. Втрать датаграму, і ти втратив один кадр, а саме так відкинутий пакет і виглядає.

Із socat кожен кінець є однією командою:

# 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 не встановлено на машині, де це писалося, тож ці дві команди з його документації, а не з запуску тут. Перевір назви адрес у своїй збірці, перш ніж їм довіряти. Мати його варто: це єдиний засіб у цьому дописі, що робить tun, tap, TLS і DTLS в одному процесі.

Там, де нічого не можна встановити, уся робота займає десь п’ятдесят рядків без жодних залежностей, крім стандартної бібліотеки. Її серце, IFF_NO_PI, вимикає чотирибайтовий заголовок, який драйвер інакше додав би спереду:

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)

Повний файл, з розбором аргументів, IPv6 через getaddrinfo, датаграмою нульової довжини, яка каже UDP-слухачеві, куди відповідати, і стисненням, яке додає наступний розділ, лежить у пакеті:

tapcat.py: усе разом, близько сотні рядків tapcat.py · 6 kB

peer = src на кожній датаграмі є частиною, яку варто прочитати двічі. Хто останнім надіслав кадр, той і стає співрозмовником. Зручно за NAT, де порт джерела весь час рухається, і відчинені двері в ненадійній мережі, де будь-хто, хто може надіслати одну датаграму на порт, перехоплює тунель. Годиться всередині сеансу DTLS, куди це все й веде; не годиться саме по собі. Сокетну половину скрипта тут перевірено через loopback IPv6: відкривальна датаграма приходить, слухач дізнається співрозмовника, кадр переходить, і відповідь повертається; tap-половина потребує root, і це єдина частина, яку я не зміг запустити.

Через TCP кадрування доводиться вигадувати самому

Тепер заміни носій на TCP і подивися, як з’являється ціла проблема, яку PPP тихо розв’язав 1994 року.

TCP є потоком байтів без меж записів і без жодної обіцянки щодо того, як байти згруповано при прибутті: два кадри, записані один за одним, можуть прийти одним читанням, а один кадр трьома. Отримувач тримає купу байтів, не маючи уявлення, де закінчується один кадр, а tap-пристрій приймає лише цілі кадри.

Одна датаграма на кадр або префікс довжини, який треба вигадатиОдне читання з tap-пристрою є одним кадром. Зберегти це є роботою носія.ЧЕРЕЗ UDP: межа задармадатаграма = кадр Aдатаграма = кадр Bдатаграма = кадр Cдатаграма = кадр DОдне читання, одна датаграма, один запис на дальньому кінці. Нічого розмежовувати, буферизувати чи ресинхронізувати.ЧЕРЕЗ TCP: межі зникли, і їх треба повернутиодин потік байтів: два кадри можуть прийти одним читанням, один кадр трьомаlenкадр Alenкадр Blenкадр Clenкадр DДва байти довжини big-endian перед кожним кадром і отримувач, що читає довжину, а потім рівно стільки байтів.Це працює й не вміє відновлюватися. HDLC синхронізується на наступному 0x7E, бо прапорець однозначний; потік із префіксами,що збився, читає кожну наступну довжину з середини кадру. Додай маркер і контрольну суму, і ти відбудував HDLC.
Через UDP один кадр є однією датаграмою, і межа дістається задарма. Через TCP межі зникають, тож відправник мусить додати до кожного кадру префікс довжини, а отримувач мусить за ним складати кадри. PPP цієї проблеми не має, бо приносить власне кадрування, байт-прапорець на кожному кінці й контрольну суму, і саме це дає йому ресинхронізуватися після пошкодження. Потік із префіксами довжини цього не може: зсунься на один байт, і кожен кадр після цього неправильний.

Тож через TCP ти пишеш власне кадрування. Два байти довжини в порядку big-endian перед кожним кадром є звичайною відповіддю:

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

Це працює, і це суворо гірше за UDP-версію. Це знову проблема TCP поверх TCP; вона додає два байти й цикл складання на кожен кадр; і вона не має шляху назад після помилки, бо потік із префіксами довжини, що збився з місця, читає кожну наступну довжину з середини кадру. HDLC ресинхронізується на наступному 0x7E; це так не вміє, хіба що заново винайти HDLC, тільки гірше. Третій аргумент за UDP, і найсильніший: через датаграмний носій проблеми кадрування немає, бо носій уже має єдину функцію, яка тобі була потрібна.

Tun чи tap: рівень 3, якщо тобі справді не потрібен рівень 2

Той самий драйвер дає тобі два пристрої, і люди постійно вибирають не той, бо підручник сказав tap.

tuntap
Що переходитьIP-пакетикадри Ethernet
Накладні витрати на пакетжодних14-байтовий заголовок Ethernet
ARP, DHCP, широкомовленнянітак, усе це, через тунель
Протоколи не IPнітак
Може входити в містнітак
Відповідаєканалу «точка-точка», як ppp0мережевому кабелю

Tun є маршрутизованим каналом, як інтерфейс PPP з першої половини: дві адреси, маршрут, пакети туди й назад. Tap є віртуальним кабелем Ethernet, тож кожне широкомовлення, запит ARP і кожен шматок групового шуму в сегменті тепер переходить твоїм тунелем і палить пропускну здатність.

Зміни один рядок у скрипті, щоб перемкнутися:

IFF_TUN = 0x0001            # instead of IFF_TAP

Використовуй tap, коли тобі справді потрібен рівень 2. Справжні причини є: протокол, що не є IP, кластерний heartbeat, що очікує бачити широкомовлення, сервер DHCP, що мусить досягати клієнтів через тунель, або об’єднання двох сегментів в один мостом.

Останнє є поширеним випадком, і саме з ним треба бути обережним:

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

Тепер віддалений сегмент є частиною твого локального: його широкомовлення, його spanning tree, його мерехтіння MAC-адрес і, якщо хтось був недбалим, його сервер DHCP. Об’єднати мостом два майданчики, що обидва працюють на 192.168.1.0/24, означає поганий вечір; міст, що закільцьовується на той самий сегмент, означає поганий тиждень. За замовчуванням бери tun, тягнися до tap, коли можеш назвати ту річ рівня 2, яка тобі потрібна, і об’єднуй мостом лише після того, як перевіриш, що веде широкомовлення з обох боків.

Ті самі обгортки, один процес на кінець

Tap-збірка має ту саму дірку, що й PPP-збірка: носій відкритий, а слухач приймає того, хто прийшов першим. Виправлення те саме, і з socat воно згортається в одну команду на кінець, бо він створює пристрій і завершує сеанс DTLS в одному процесі:

# 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

Це найкоротша правильна збірка в цьому дописі. Віртуальний інтерфейс, датаграмний носій, взаємна автентифікація сертифікатами й шифрування. Дві команди. Ні демона, ні узгодження протоколу.

verify=1 не є необов’язковим. Це той самий момент, що й --ssl-verify, а з поведінкою peer = src вище неідентифікована сторона за одну датаграму від того, щоб володіти твоїм тунелем. Якщо ти застряг зі скриптом на Python, не прикручуй TLS усередину нього: спрямуй його на порт loopback і постав обгортку спереду, або використай socat. Саморобна обгортка TLS навколо саморобного тунелю означає два шанси зробити цікаву частину неправильно.

Етап п’ятий: стискаємо потік за допомогою zstd

Є ще одна річ, яку варто покласти в бекенд, і, на відміну від опцій стиснення в pppd, вона справді може окупитися: стискати кадри за допомогою zstd, перш ніж вони підуть у носій.

Важливе слово тут кадри, у множині. Стискай потік, а не кожен пакет окремо. Це найбільший виміряний ефект у цьому дописі.

Мережевий трафік повторюється так, що це видно лише між пакетами: ті самі заголовки, імена хостів і ключі JSON, знову й знову. Компресор, що починає з нуля на кожному кадрі в 1400 байтів, не бачить нічого з цього; той, що зберігає своє вікно між кадрами, бачить усе.

Стисни до шифрування й зберігай вікно, якщо носій дозволяєПорядок фіксований. Рішення полягає в режимі.tap0одне читання, один кадрстисненняzstd, рівень 1шифруванняDTLS або TLSносійUDP або TCPНіколи ненавпаки.FLUSH_BLOCK: зберігає вікноВидає все, що є, і зберігає історію. Кожен кадркодується з урахуванням усіх попередніх. Без затримки:один кадр на вході, один на виході.5,0 %на повторюваному трафіку · 7,5 % на журналахПотрібна доставка кожного кадру, по порядку.Отже: TCP або TLS через TCP. Не UDP, не DTLS.FLUSH_FRAME: викидає його на кожному пакетіКожна датаграма є цілим кадром zstd і декодуєтьсясама, тож датаграма N працює, навіть якщо 1…N-1 втрачено.Єдиний режим, доступний датаграмному носію.14,8 %на тому самому трафіку · 24,2 % на журналахНавчений словник повертає більшу частину:5,3 % і 15,1 %, і лишається стійким до втрат.
Стиснення стоїть між tap-пристроєм і носієм, і перед шифруванням, бо шифротекст не стискається. FLUSH_BLOCK є режимом, який важить: він видає все, що є на цей момент, тож один кадр на вході дає один кадр на виході без додаткової затримки, і водночас зберігає історію стиснення для наступного кадру. FLUSH_FRAME викидає цю історію на кожному пакеті, і саме це робить його безпечним через носій із втратами і саме це робить його втричі гіршим на дроті.

На сучасній Fedora для цього не треба нічого встановлювати: Python 3.14 приніс zstd у стандартну бібліотеку14; на цій машині 3.14.7 і 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)

Один компресор на напрямок, живий упродовж усього життя каналу. Один FLUSH_BLOCK на кадр, тож кадр іде щойно приходить, нічого не буферизується, а дальній кінець повертає по одному кадру на блок.

Скільки варте вікно, виміряно

Цифри з цієї машини. Ті самі кадри по 1400 байтів, той самий рівень 1, і єдина різниця в тому, чи зберігає компресор свою історію:

Трафік у тунеліпотік, FLUSH_BLOCKна пакет, FLUSH_FRAMEна пакет із навченим словником
Повторювані виклики API й телеметрія5,0 %14,8 %5,3 %
Рядки журналів7,5 %24,2 %15,1 %
Звичайний текст і конфігураційні файли37,8 %51,3 %45,3 %
Випадкові байти, замість TLS100 %+100,7 %н/д

Пропускна здатність на рівні 1 становила 205 MB/s на тексті й понад 1 GB/s на повторюваному трафіку: що краще стискається, то швидше, бо менше треба кодувати.

Трафік журналів зменшується до 7,5 % початкового розміру, проти 24,2 % на пакет: утричі, ті самі дані, той самий рівень, від одного прапорця. І рівень 1 і є тим рівнем: рівень 3 дав десь один відсоток, рівень 9 ще один, знизивши пропускну здатність з 211 MB/s до 61.

Підступ, і це той самий підступ, що й з усім іншим тут

Спільне вікно означає, що кожен кадр залежить від попередніх: втрать один, і історія декомпресора вже не збігається, і ніщо після цього не декодується. Тож потокове стиснення потребує носія, що доставляє все й по порядку: TCP або TLS через TCP, а не UDP чи DTLS. Це єдиний чесний аргумент на користь TCP-носія в усьому дописі. Якщо те, що йде твоїм тунелем, справді добре стискається, syslog, реплікація бази даних відкритим текстом, телеметрія, балакучий API, то сеанс TLS із потоковим стисненням переносить третину байтів, які переніс би датаграмний носій, і на пристойному шляху це може переважити штраф за повторні передачі. Виміряй це на власному трафіку.

Через UDP, де словник робить роботу вікна

Там, де носій є UDP або DTLS, а за замовчуванням так і має бути, вікно тримати не можна: кожна датаграма стоїть сама по собі, а це означає FLUSH_FRAME і слабший стовпчик вище. Навчений словник дає компресору той міжпакетний контекст, який дало б вікно, без жодної залежності між датаграмами15:

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

На повторюваному трафіку це покращило стиснення на пакет з 14,8 % до 5,3 %, повернувши 96 % розриву до повного потокового стиснення й водночас лишаючись стійким до втрат; на рядках журналів 55 % розриву, на загальному тексті 44 %.

З цим ідуть три правила. Обидва кінці мусять завантажити той самий словник, інакше нічого не декодується: тут перевірено, кадр, стиснений зі словником, без нього кидає ZstdError. Навчай на захопленні справжнього трафіку, бо словник є апріорним знанням, і хибне тобі коштує: текстовий словник зробив інший текст трохи гіршим. І завантажуй його один раз у довгоживучий компресор; передача його в кожному виклику дала 5 MB/s, і це не друкарська помилка.

Байт заголовка й односекундний розгін

Дві дрібниці, що не дають цьому бути крихким.

Кожна датаграма несе однобайтовий заголовок, і він називає режим, а не просто каже «стиснено»: 0x00 кадр як є, 0x01 самодостатній кадр zstd, 0x02 блок із неперервного потоку. Тоді отримувач може декодувати все, що вибрав дальній кінець, не будучи налаштованим під нього, і вже одне це варте байта.

У режимі кадрів відправник надсилає стиснену форму лише тоді, коли вона справді менша, бо стиснення не завжди виграш: випадкові байти дали 100,7 %, а 64-байтовий TCP ACK стискається до 73, бо це десятибайтовий заголовок zstd на пакеті, в якому нічого стискати. Кількість пакетів на справжньому каналі визначають малі пакети, тож без цієї перевірки ти роздував би більшість свого трафіку, щоб стиснути меншість. У потоковому режимі він завжди надсилає стиснену форму, бо пропуск одного розсинхронізував би два вікна.

І канал стартує сирим: першу секунду кожен кадр іде нестисненим, хоч би що казали налаштування, і кожен напрямок розганяється сам:

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

Це ідея етапів з початку допису, застосована до одного каналу. Тунель піднімається найпростішим шляхом, який має, доводить, що може перенести кадр, і лише потім починає робити щось розумне. Коли він ламається, ти знаєш, у якій секунді.

Етап шостий: стиснено й зашифровано, і чого коштує порядок

Порядок важить, і працює лише один: стиснути, потім зашифрувати. Шифротекст не стискається, як показує рядок зі 100,7 %, і саме тому TLS 1.3 прибрав власне стиснення, лишивши твій рівень єдиним місцем, де це можна зробити. Цей порядок має відому проблему, ту саму, яку я закидав deflate: стиснення перед шифруванням видає відкритий текст через довжину шифротексту, і там, де зловмисник може підкинути вибрані дані поруч із секретом і стежити за розмірами, цей витік не раз ставав робочою атакою: CRIME і BREACH проти TLS16, і VORACLE саме проти такої форми17.

Це не причина ніколи не стискати. Це причина знати, в якому ти випадку:

  • Канал, що переносить твій власний трафік між двома твоїми машинами, реплікацію, резервні копії, журнали, телеметрію, не має відкритого тексту, вибраного зловмисником, що мандрує разом із секретами. Стискай його, і стискай потік.
  • Канал, що переносить довільний перегляд вебу користувачами, де чужий вебвміст і твої облікові дані йдуть разом, є тим випадком, про який написано VORACLE. Лиши стиснення вимкненим.

Причина, з якої я спокійно кладу це в tap-збірку, а не в PPP-збірку, не принципова: тут ти свідомо вибираєш сучасний алгоритм, для трафіку, який ти роздивився, тоді як deflate у pppd за замовчуванням стискає все алгоритмом 1996 року, підходить випадок чи ні.

Що tap-збірка виграє і чим поступається

Постав дві половини поруч, бо вони не змагаються. Це різні компроміси.

pppd через сокетtap або tun через сокет
Кадруваннявбудоване (HDLC, ресинхронізується після пошкодження)через UDP жодного, бо не потрібне; через TCP вигадай сам
Налаштування адресузгоджуються IPCP і IPV6CPналаштовуються вручну на обох кінцях
Живучістьехо LCP, вбудованежодної; додай сам, або канал помре мовчки
Автентифікаціяє PAP або CHAP, обидві слабкіжодної
Рівеньлише 33 з tun, 2 з tap
Мостинітак, із tap
Накладні витратипрапорець, заголовок і FCS на кадр, плюс екрануваннянічого, або 14 байтів із tap
Стисненняdeflate і BSD, увімкнені за замовчуванням, з 1996 рокужодного, або zstd на кадр, яке ти додаєш і контролюєш
Потрібен rootтак, увесь часщоб створити пристрій; не щоб ним користуватися
Рухомі частиниодин демон, тридцять роківодин файловий дескриптор

PPP дає тобі узгоджений канал, що сам себе контролює, і бере за це плату протоколом. Tap-пристрій дає тобі сиру дірку задарма, а відсутні частини ти докладаєш сам або обходишся без них. Для тунелю, що лишається працювати, кусається саме відсутня перевірка живучості: pppd помічає мертвий носій за тридцять секунд і відбудовує його, а tap-збірка не помічає нічого, бо в ній ніщо не стежить. Додай keepalive, запусти її під чимось, що її перезапускає, або використай збірку, в якій це вже є.

Коли це правильний інструмент, а коли ні

Насправді це ніколи не правильний інструмент, і я не вдаватиму протилежного. Усе вище працює, і ніщо з цього не є тим, що слід запускати в продакшені. Чесна версія інструкції містить частину, де ти відкладаєш інструмент, і це вона.

Для чого це справді добре, так це щоб показати тобі, як річ працює. VPN, розібраний на частини, і, в наступному розділі, як вихідний трафік насправді поводиться, коли хтось опинився у твоїй мережі з root. Ось причини, щоб це прочитати. Вузькі випадки нижче справжні, але не через них існує цей допис.

Тягнися до PPP-збірки, коли:

  • Носій зовсім не IP: послідовна консоль, USB-гаджет, радіоканал, іменований канал, канал SSH. pppd не переймається тим, чим подорожують байти, а tap-пристрій тут не допоможе.
  • Ти щось рятуєш: машина з послідовною консоллю, без мережі, і робота, яку треба закінчити сьогодні ввечері. PPP через цю консоль є маршрутизованим каналом, встановленим на обох кінцях, і нічого не треба копіювати.
  • Ти хочеш, щоб канал дбав про себе сам. Ехо LCP, узгодження адрес і перезапуск дістаються задарма; писати їх самому означає перетворити tap-збірку на маленький ненадійний продукт.

Тягнися до tap-збірки, коли:

  • Тобі потрібен рівень 2: протокол не IP, кластерний heartbeat, що хоче широкомовлення, DHCP через тунель, або два сегменти, що мусять бути одним.
  • Ти хочеш найменше рухомих частин: через UDP з DTLS це дві команди, ні демона, ні узгодження, нічого екранувати.
  • Root у дефіциті. Створи пристрій один раз із user, і процесові, що переносить кадри, більше ніколи не потрібні привілеї.

Обидві є правильним інструментом, коли ти вчишся. Кожен рівень видно, і кожен можна замінити окремо, і немає кращого способу зрозуміти, що робить VPN-продукт, ніж зібрати його з частин і дивитися, як кожна піднімається.

Жодна не є правильним інструментом, коли тобі потрібен VPN. Для цього використовуй WireGuard. Він у ядрі, це частка коду, він робить криптографію як слід, без нічого, що треба узгоджувати, і без нічого, що можна зіпсувати, і він датаграмний протокол за задумом. ssh -w дає тобі tun-пристрій через наявний сеанс SSH однією командою, а OpenVPN є зрілою, перевіреною аудитом версією форми DTLS поверх tap, описаної вище. Усі три кращі в цьому за будь-що, збудоване тут.

Будуй це, бо хочеш знати, що всередині речі, яку купуєш. Не тому, що це було дотепно.

Що це насправді показує: вихідний трафік з боку зловмисника

Ось причина читати допис про збирання, яким тобі щойно сказали не користуватися. Розверни його й подивися зсередини власної мережі, як людина, що щойно туди потрапила з root. Кожне справжнє проникнення закінчується там, через вкрадений ключ, втечу з контейнера, невиправлений сервіс, інсайдера. Питання, яке тоді вирішує, наскільки поганим буде день, не «що вони можуть запустити», бо запустити вони можуть що завгодно. Воно звучить так: «що може вийти назовні, і чи вирішив ти це до того, як вони прийшли».

Якщо вихід відкритий за замовчуванням, відповідь: усе, і тепер ти мало що можеш зробити. Нічого тут не було екзотичним. pppd, ncat, socat і ip є підписаними пакетами дистрибутива, вже наявними на машині; tap-прокладка є п’ятдесятьма рядками стандартної бібліотеки. Один дозволений вихідний порт, і це 443, той, що кожна мережа відкриває за замовчуванням, і є маршрутизований канал з твоєї мережі до чиєїсь іншої, зашифрований, автентифікований, що переживає перезапуски, переносить IPv4 і IPv6 і на твоїй межі не відрізняється від будь-якого сеансу HTTPS, які твої користувачі відкривають десять тисяч разів на день. Зроби його tap і з’єднай мостом, і те, що покинуло будівлю, вже не маршрут. Це сегмент.

Сканерові нема чого ловити: немає сигнатури шкідливого коду, бо немає шкідливого коду, немає дивного протоколу, бо це звичайне рукостискання TLS на 443, немає незвичного двійкового файлу, бо кожен встановив твій власний менеджер пакетів. Проксі журналює з’єднання й кількість байтів, і обидва виглядають як робота.

І місце призначення навіть не фіксоване. Сокет не мусить закінчуватися там, куди врешті потрапляють пакети, бо носій можна спрямувати через проксі, ретранслятор, який є нічим іншим, як двома з’єднаннями й каналом між ними, і наступний розділ збирає його одним рядком shell. ncat приймає --proxy з --proxy-type http, socks4 або socks5, тож сеанс TLS, який бачить твоя межа, закінчується там, через що зловмисник велів йому підключатися: внутрішній проміжний хост, дозволена кінцева точка SaaS, яка випадково пересилає CONNECT, хмарний ретранслятор, а тунель їде звідти далі кудись, чого ти ніколи не бачиш. HTTP CONNECT і SOCKS обидва роблять це за задумом, бо саме для цього проксі й існує. Тож запис у списку дозволених для місця призначення, якому ти довіряєш, завжди є лише довірою до місця призначення і до всього, куди воно перешле, а цього ти не контролюєш і не можеш перелічити. Кінцева точка в журналі твого міжмережевого екрана є проксі. Дальнім кінцем вона ніколи не була.

Тож незручна правда: щойно хтось усередині з root, а вихід дозвільний, тунель уже не та річ, якій ти можеш запобігти. Частини встановлено, вихід відчинено, і він навіть не веде туди, куди здається. Твій єдиний шанс зробити це важким був до того, як прийшов зловмисник, на межі, коли ти вирішував, що може виходити.

Це заборона вихідного трафіку за замовчуванням, і в цьому весь урок. Вихід заблокований за замовчуванням; короткий, поіменний список дозволених, де людина обґрунтувала кожне місце призначення й порт; усе інше відхилено, записано в журнал і супроводжено тривогою. Не тому, що це намертво зупиняє рішучого зловмисника, бо дозволене місце призначення є дозволеним тунелем, а тому, що альтернатива означає не мати взагалі жодного рішення, яке можна застосовувати. Політика вихідного трафіку, записана як список дозволених портів, є політикою про номери портів. Вона ніколи не була політикою про те, що виходить, і щойно хтось має root, номери портів є всім, що вона захищає.

Це той самий висновок, що й у дописі про ping, який будує тунель з ехо ICMP, і в дописі про протокольні помічники, де твій міжмережевий екран сам відкриває дірки. Три шляхи всередину, один висновок: контроль, який ти, як думав, мав, був над протоколами, і жоден із цих протоколів не є тим, чим себе називає. Межа, вирішена заздалегідь і з забороною за замовчуванням, є єдиним засобом контролю, який колись був справжнім.

Проксі є двома з’єднаннями й каналом між ними

Варто побачити, як мало важить ретранслятор, бо це пояснює, чому про дальній кінець не можна судити з ближнього. Проксі не є особливим програмним забезпеченням. Це одне з’єднання, приєднане до іншого каналом. Найстаріша форма використовує іменований канал, FIFO, щоб переносити зворотний напрямок: один ncat слухає, другий підключається далі, а FIFO прокладає між ними шлях відповіді.

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

Читай це як сантехніку: вихід слухача тече в другий ncat і далі до дальнього кінця, а відповіді повертаються через FIFO до клієнта. Два сокети, один канал, обидва напрямки, і з’єднання клієнта закінчується тут, на ретрансляторі, тоді як пакети їдуть далі до farend і назад. Я запустив саме це через loopback із третім ncat, що відлунював на дальньому кінці, і рядок, надісланий усередину, повернувся, пройшовши весь шлях.

Ретранслятор є двома сокетами, з’єднаними каналом, тож кінцева точка зсуваєтьсяОдне з’єднання всередину, інше назовні, канал між ними. Це і є проксі.клієнтвідкриває сеанс TLSРЕТРАНСЛЯТОР: місце призначення в журналі межіncat -l 7000завершує клієнтаncat farendвідкриває новий перехіддальній кінецьсправжня інша сторонаstdoutbackpipe (FIFO) несе відповіді назадклієнт → ретрансляторретранслятор → дальній кінецьЗ’єднання клієнта закінчується на ретрансляторі. Пакети ні.Твій міжмережевий екран записав з’єднання з цією машиною. Куди вона пересилає, вирішується всередині, а три такі в ланцюжкуставлять справжній дальній кінець за три канали, і журнал кожного переходу показує лише охайне з’єднання з наступним.
Ретранслятор складається з двох сокетів і каналу між ними. Слухач завершує з’єднання клієнта. Другий netcat відкриває нове з’єднання далі, а FIFO переносить між ними зворотний напрямок. Сеанс TLS клієнта закінчується тут, на ретрансляторі, і починається новий перехід, тож місце призначення, яке записала твоя межа, є цією машиною, а пакети їдуть далі туди, куди вона пересилає. З’єднай три в ланцюжок, і дальній кінець за три канали звідси, а міжмережевий екран кожного переходу бачить лише охайне локальне з’єднання з наступним.

Ncat зробить те саме одним процесом, запускаючи через exec подальше з’єднання для кожного клієнта, що приходить:

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

Та сама форма, менше частин: сокет слухача з’єднано з сокетом запущеного ncat каналом, який shell прокладає між ними. З’єднай три в ланцюжок, і тунель перетинає три мережі, завершуючись і відкриваючись знову на кожній, а міжмережевий екран кожного переходу записує охайне локальне з’єднання з наступним і нічого далі.

Ось і весь фокус, і тому журнал межі не є доказом місця призначення. Кожен ретранслятор є дальнім кінцем, наскільки може судити машина перед ним, а справжній інший кінець за стількома каналами, скільки їх є, і за ними ніхто не стежив.

Тепер постав ці ретранслятори на машини, що не належать зловмисникові.

Ретранслятори в ланцюжку через скомпрометовані хости відмивають кінцеву точкуКожен перехід є чужою машиною, і кожен власник бачить лише серединузловмисникєдина його машинаретранслятор 1мережа іншої фірмиретранслятор 2захоплений VPSретранслятор 3домашній маршрутизаторпризначеннякуди все йшлобачить: 1←→2бачить: 2←→3бачить: 3←→цільЖоден перехід не бачить далі двох своїх сусідів. Ні джерела, ні призначення, лише середина.Трафік відмивається через ланцюжок чужих систем, і на кожній працює той самий ретранслятор із двох сокетів і каналу підкеруванням зловмисника. Тому вихідний трафік зламаного хоста так часто веде до іншої жертви: двадцять років C2.
Кожен перехід є скомпрометованим хостом, машиною іншої фірми, захопленим VPS, домашнім маршрутизатором, на якому працює той самий ретранслятор із двох сокетів і каналу під командою й керуванням зловмисника. Жоден перехід не бачить далі за двох своїх сусідів: власник ретранслятора 2 бачить з’єднання від ретранслятора 1 і з’єднання до ретранслятора 3, і нічого більше. Трафік відмивається через ланцюжок чужих систем, і саме тому вихідний трафік скомпрометованого хоста так часто веде до іншої жертви, а не до зловмисника.

Кожен власник уздовж цього ланцюжка бачить лише з’єднання від попереднього переходу до наступного: ні джерела, ні призначення, лише середину. Це не нова ідея, яку я комусь підкидаю. Так ланцюжки півотів і мережі C2 працюють уже двадцять років, і тому вихідний трафік скомпрометованого хоста так часто веде до іншої жертви, а не до зловмисника. Твої журнали показують, що ти говорив із машиною десь у центрі обробки даних. Чия вона і куди вона пересилає, в них ніколи не було.

Захисна вага вміщається в один рядок: ти не можеш ні встановити, ні довіряти місцю призначення, яке ти не обмежив заздалегідь. На той час, коли трафік виходить, адреса, на яку він виходить, не каже тобі майже нічого, бо це ретранслятор на чужій машині, а справжня кінцева точка відмита за ним.

Що мене вражає, коли я все це розібрав, так це як мало тут нового і як багато з цього продається.

RFC 1661 датований 1994 роком. pppd є в кожному дистрибутиві Linux уже тридцять років, модулі ядра є вісьмома файлами в одному каталозі, а все те, що робить VPN VPN-ом, віртуальний інтерфейс, узгоджений канал, зашифрований носій, маршрут, це чотири програми й сертифікат. Ніщо з цього не складне й не таємне. Вони задокументували кожен байт і віддали його задарма, а між тобою й цим виросла ціла галузь, що продає ті самі чотири частини в коробці з ліцензією на кожне робоче місце й контрактом підтримки, термін якого спливає. Частини не стали кращими. Їх загорнули.

Це не аргумент за те, щоб запускати це в продакшені. Я щойно сказав тобі цього не робити. Це аргумент за те, щоб знати, що в коробці, яку ти купуєш, бо того дня, коли постачальник змінить ліцензування, його куплять або він закриє твою модель, різниця між поганим кварталом і поганим роком полягатиме в тому, чи хтось у тебе знає, з чого ця штука була зроблена.

Виділи вечір і збери тунель з частин. Подивися, як LCP домовляється, розірви канал і подивися, як він повертається, забери сертифікат і подивися, що зупиняється. Потім знову прочитай технічний опис свого постачальника VPN і подивися, скільки з нього ти впізнаєш.

Той самий вечір купує й другу половину. Якщо маршрутизований канал із твоєї мережі є чотирма встановленими програмами й сертифікатом, людину, що щойно отримала root на одній із твоїх машин, не стримує те, наскільки важко збудувати тунель. Це не важко. Її стримує лише те, що ти вирішив, до її приходу, можна випускати назовні. Збери це один раз, і ти перестанеш думати про вихідний трафік як про щось, що забезпечує продукт, і почнеш думати про нього як про рішення, яке ти або ухвалив, або ні.

Магії тут небагато. Більша частина цього є 1994 роком під шаром фарби, і в 1994 році нема нічого поганого. Він працював, він був задокументований, і він досі працює.


  1. RFC 1661 — The Point-to-Point Protocol (PPP), 1994. Визначає канал, LCP і родину протоколів керування мережею, що стоять над ним. ↩︎

  2. RFC 2637 — Point-to-Point Tunneling Protocol (PPTP), що переносить PPP усередині GRE. ↩︎

  3. RFC 3931 — Layer Two Tunneling Protocol version 3, стандартний нащадок протоколу, що переносить PPP усередині UDP. ↩︎

  4. pppd(8) — сторінка довідки демона PPP. Джерело для pty, notty, local, passive, noipdefault, proxyarp, record, receive-all, опцій ехо LCP і значення asyncmap за замовчуванням: «If no asyncmap option is given, the default is zero, so pppd will ask the peer not to escape any control characters.» Цитати тут прочитано з man pppd у ppp 2.5.1. ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

  5. RFC 1662 — PPP in HDLC-like Framing. Послідовність-прапорець, правило заповнення октетів і 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 — стандартне пояснення накладання повторних передач, що відкривається саме цією збіркою. Початкова адреса більше не віддає статтю; це знімок з Internet Archive. ↩︎

  7. RFC 5072 — IP Version 6 over PPP. IPV6CP і 64-бітні ідентифікатори інтерфейсів, незалежно від IPCP. ↩︎

  8. RFC 1332 — The PPP Internet Protocol Control Protocol (IPCP), який узгоджує адреси IPv4 на кожному кінці каналу. ↩︎

  9. RFC 1994 — PPP Challenge Handshake Authentication Protocol (CHAP). Доводить особу співрозмовника; нічого не шифрує. ↩︎

  10. RFC 3079 — Deriving Keys for use with Microsoft Point-to-Point Encryption (MPPE). Конструкція RC4 з ключем від обміну MS-CHAP і причина, з якої PPTP не є живим варіантом. ↩︎

  11. Ncat Users’ Guide — connecting through a proxy — --proxy і --proxy-type для HTTP CONNECT і SOCKS 4/5, тож носій TLS закінчується на проксі, а не на дальньому кінці тунелю. ↩︎

  12. Ncat Users’ Guide — опції --ssl, --ssl-verify і --ssl-trustfile, а також режими слухання й UDP. Тут перевірено версію Ncat 7.92. ↩︎

  13. Universal TUN/TAP device driver — власна документація ядра для /dev/net/tun, TUNSETIFF і різниці між tun і tap. ↩︎

  14. PEP 784 — Adding Zstandard to the standard library, тому compression.zstd не потребує пакета в Python 3.14. Тут виміряно з Python 3.14.7 і zstd 1.5.7. ↩︎

  15. zstd(1) — режим --train і --maxdict для побудови словника, який мусять завантажити обидва кінці. ↩︎

  16. RFC 7457 — Summarizing Known Attacks on TLS and DTLS, що охоплює CRIME і загальну форму витоку довжини при стисненні перед шифруванням. ↩︎

  17. OpenVPN — the VORACLE attack — той самий витік проти VPN, що стискає перед шифруванням, і причина, з якої OpenVPN тепер радить не використовувати стиснення. ↩︎