VPN कोई प्रोडक्ट नहीं है। यह दो काम हैं जो एक साथ जोड़ दिए गए हैं, और आपकी मशीन के पास दोनों के लिए पहले से एक-एक प्रोग्राम है।
पहला काम है एक वर्चुअल लिंक बनाना: एक इंटरफ़ेस जो नेटवर्क कार्ड जैसा दिखे, IP पैकेट ले और उन्हें कहीं और पहुँचा दे। दूसरा काम है उस लिंक के बाइट्स को एक सिरे से दूसरे सिरे तक ढोना। VPN अप्लायंस खरीदिए तो आप दोनों काम खरीदते हैं, ऊपर से लाइसेंस चिपका हुआ; खुद कीजिए तो हर काम एक प्रोग्राम है जो पहले से इंस्टॉल है। Linux पर पहला काम करने के दो तरीके हैं, और यह पोस्ट दोनों बनाती है: pppd, जो पूरा लिंक प्रोटोकॉल साथ लाता है (नेगोशिएट किए गए एड्रेस, लाइवनेस चेक, फ़्रेमिंग), और एक tap डिवाइस, जो कुछ भी साथ नहीं लाता और kernel में एक छेद है जिसमें आप फ़्रेम धकेलते हैं। अलग-अलग सौदे हैं, प्रतियोगी नहीं, और पोस्ट का दूसरा हिस्सा दोनों को आमने-सामने रखता है।
वह प्रोटोकॉल PPP है, और यह क्यों काम करता है यह उसके पहले पैराग्राफ़ में लिखा है: PPP पॉइंट-टू-पॉइंट लिंक के लिए एक लिंक प्रोटोकॉल है1, और वह यह तय नहीं करता कि लिंक किस चीज़ से बना है। मॉडेम और फ़ोन लाइन मूल जवाब थे। वे कभी अकेले जवाब नहीं थे। PPTP ने PPP को GRE के अंदर रखा2। L2TP ने उसे UDP के अंदर रखा3। PPPoE ने उसे Ethernet फ़्रेम के अंदर रखा। इनमें से हर एक वही प्रोटोकॉल है, बस कूरियर अलग है, और किसी के लिए भी PPP को बदलना नहीं पड़ा।
तो सवाल यह नहीं है कि PPP को TCP या UDP सॉकेट पर चला सकते हैं या नहीं, बल्कि किस पर, और उसकी कीमत क्या है। छोटा जवाब, काम दिखाकर: UDP इस्तेमाल कीजिए। एक स्ट्रीम प्रोटोकॉल को एक भरोसेमंद स्ट्रीम के अंदर चलाना यहाँ वह अकेली गलती है जो आपकी डेस्क पर ठीक दिखती है और असली लिंक पर बिखर जाती है।
VPN दो काम है। दोनों आपके पास पहले से हैं।
किसी भी टनल से मार्केटिंग हटा दीजिए तो तीन चीज़ें होती हैं: कुछ एक वर्चुअल इंटरफ़ेस पेश करता है और पैकेट को बाइट स्ट्रीम में बदलता है, कुछ उस स्ट्रीम को ऐसे नेटवर्क के पार ले जाता है जो पहले से काम कर रहा है, और कुछ उसे एन्क्रिप्ट करता है, या कुछ भी नहीं करता।
PPP लिंक वाला आधा काम ठीक से करता है: एड्रेस नेगोशिएशन, लाइवनेस चेक, हेडर कम्प्रेशन, एक लिंक पर कई नेटवर्क-लेयर प्रोटोकॉल, और चाहें तो ऑथेंटिकेशन का एक कदम। ढेर सारा तैयार काम /usr/sbin में बेकार पड़ा है। वह कैरियर की परवाह नहीं करता: उसे एक file descriptor दीजिए जो दोनों तरफ़ बाइट्स ले जाए और वह उस पर चल पड़ता है। Netcat एक ऐसा प्रोग्राम है जिसका पूरा मकसद वही file descriptor बनना है।
एन्क्रिप्शन वह हिस्सा है जो कोई आपको थमाता नहीं, और इस पोस्ट का ज़्यादातर हिस्सा उसी को कमाने में जाता है, क्योंकि netcat के पास इसका कोई जवाब नहीं है और यह दिखावा करना कि है, वही तरीका है जिससे लोग ऐसी चीज़ें बना बैठते हैं जो उन्हें नहीं बनानी चाहिए।
चरण, और वे इसी क्रम में क्यों हैं
नीचे सब कुछ चरणों में बनाया गया है, हर चरण पिछले में एक चीज़ जोड़ता है। यह पढ़ाने की कोई तरकीब नहीं है। इसे बनाना ही ऐसे चाहिए, क्योंकि जब चरण छह टूटे तो आपको पता होना चाहिए कि चरण दो अब भी चलता है या नहीं, और यह आपको तभी पता चलेगा जब चरण दो कभी अपने आप में चलाई गई चीज़ रहा हो।
लिंक खुद भी इसी तरह बनता है, और नीचे वाले एक सेकंड के रैंप के पीछे यही तर्क है: टनल पहले raw चालू होता है, साबित करता है कि वह एक फ़्रेम ढो सकता है, और उसके बाद ही होशियारी दिखाता है। जो बिल्ड सब कुछ एक साथ चालू करता है वह एक गट्ठर की तरह फ़ेल होता है, और आपकी पूरी शाम यह अंदाज़ा लगाने में जाती है कि किस लेयर ने किया।
pppd को असल में एक file descriptor चाहिए
pppd सीरियल पोर्ट के लिए लिखा गया था, तो सीधी-सादी समझ यह है कि उसे सीरियल पोर्ट चाहिए। ऐसा नहीं है। उसे एक टर्मिनल डिवाइस चाहिए, और वह खुद एक बना लेगा:
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
इसे दोबारा पढ़िए, पूरा बिल्ड इसी में है। pppd एक pseudo-terminal बनाता है, slave अपने पास रखता है, और master एक कमांड को stdin और stdout के रूप में दे देता है। वह कमांड बाइट्स के साथ क्या करती है, यह pppd का मामला नहीं। वहाँ nc चलाइए और बाइट्स एक सॉकेट में चले जाते हैं।
pty में दी गई कमांड को master साइड stdin और stdout के रूप में मिलती है। Netcat stdin को सॉकेट में और सॉकेट को stdout में कॉपी करता है, तो दोनों pppd इंस्टेंस pty जोड़ी और नेटवर्क के ज़रिए आपस में बात कर रहे होते हैं, और किसी को पता भी नहीं होता कि कोई सॉकेट है।एक दूसरा रास्ता भी है, notty, जो pppd के अपने stdin और stdout इस्तेमाल करता है। लेकिन वह एक character-shunt प्रोसेस शुरू करता है जिसमें से हर बाइट गुज़रता है, तो वह “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 mode 0600 और root की है, और जो ऑप्शन आपको चाहिए वे वैसे भी privileged हैं। यह ऐसी चीज़ है जो आप root के रूप में या किसी unit फ़ाइल के तहत चलाते हैं, कोई यूज़र इसे यूँ ही नहीं करता। यह बात आगे मायने रखेगी, जब हम देखेंगे कि आपकी egress पॉलिसी के लिए इसका क्या मतलब है।
Kernel वाला हिस्सा मॉड्यूलर है। ppp_generic इंटरफ़ेस संभालता है, ppp_async वह byte-stuffed फ़्रेमिंग जो pty को चाहिए, और ppp_deflate/bsd_comp/ppp_mppe कम्प्रेशन और एन्क्रिप्शन; ये ज़रूरत पड़ने पर लोड होते हैं। अगर किसी छाँटी हुई कंटेनर इमेज में ppp_async नहीं है तो लिंक चालू हो जाता है और कुछ नहीं ढोता। अगर आपको पता न हो कि कहाँ देखना है तो आधा घंटा बहुत बुरा बीतता है।
pty पर मॉडेम कंट्रोल लाइनें होती ही नहीं। carrier-detect पिन के बिना pppd ऐसे कैरियर का इंतज़ार करता है जो कभी नहीं आता। इलाज एक शब्द है, local, जो उसे मॉडेम कंट्रोल लाइनों को अनदेखा करने को कहता है4। इसे छोड़ दीजिए तो कुछ नहीं होता, और कोई ऐसी एरर भी नहीं आती जो पढ़ने लायक हो।
Netcat एक प्रोग्राम नहीं है
बिल्ड से पहले, वह जाल जो सबसे ज़्यादा समय खाता है: “netcat” कम से कम चार प्रोग्राम हैं जिनके फ़्लैग आपस में मेल नहीं खाते, और आपको कौन सा मिलेगा यह आपके डिस्ट्रीब्यूशन पर निर्भर है। इस मशीन पर /usr/bin/nc एक symlink है /usr/bin/ncat का, जो Nmap का दोबारा लिखा हुआ वर्ज़न है। तो पंद्रह साल पुराने किसी विकी पेज से कॉपी की गई कमांड ऐसी वजहों से फ़ेल होती है जिनका PPP से कोई लेना-देना नहीं।
| इम्प्लीमेंटेशन | किसी पोर्ट पर listen | UDP | पीयर के डिसकनेक्ट होने के बाद भी चालू रहे |
|---|---|---|---|
| Ncat (Nmap) | ncat -l 443 | -u | -k / --keep-open |
| OpenBSD netcat | nc -l 443 | -u | -k |
| Traditional netcat | nc -l -p 443 | -u | नहीं |
| GNU netcat | nc -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 बिल्ड, क्योंकि हर कोई पहले यही आज़माता है
एक सिरा listen करता है, दूसरा कनेक्ट करता है। यहाँ के एड्रेस डॉक्यूमेंटेशन रेंज से हैं, तो इन्हें सीधे किसी लैब में पेस्ट कीजिए और किसी routable चीज़ का नुकसान नहीं होगा। पोर्ट पूरे समय 443 है, और यह जानबूझकर है: लगभग हर नेटवर्क पर आउटबाउंड 443 डिफ़ॉल्ट रूप से खुला है। कुछ चरण बाद कैरियर को TLS में लपेट दीजिए और उस पर का ट्रैफ़िक किसी भी HTTPS सेशन से अलग पहचाना नहीं जा सकता। वहाँ listener बाँधने के लिए root चाहिए, जो दूर वाले सिरे के पास है, चाहे वह अटैकर का अपना बॉक्स हो या कोई relay। एक पोर्ट नंबर में पूरा egress वाला तर्क यही है, और मैं इस पर वापस आऊँगा।
listen करने वाले सिरे पर:
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, चुपचाप नुकसान कर रहा है। टनल पर कोई एक्सेस कंट्रोल नहीं है, इसका आगे अपना अलग सेक्शन है।
noauth है: यह पीयर ऑथेंटिकेशन हटा देता है, तो listener जो भी आए उसे स्वीकार कर लेता है। nodefaultroute और noipdefault लिंक को आपकी रूटिंग चुपचाप बदलने से रोकते हैं, local की वजह से वह pty पर चालू ही हो पाता है, और तय की गई local:remote जोड़ी pppd को IPCP के दौरान कोई अलग जवाब लेने से रोकती है। कनेक्ट करने वाला सिरा वही लाइन है, बस passive के बिना।दोनों सिरे चालू कीजिए और हर तरफ़ एक ppp0 मिलता है, दूर वाले एड्रेस तक एक पॉइंट-टू-पॉइंट रूट, और एक इंटरफ़ेस जिसे आप ping कर सकते हैं, जिससे रूट कर सकते हैं और जिस पर tcpdump चला सकते हैं। यह एक VPN है: कोई पैकेज इंस्टॉल नहीं, कोई डेमन कॉन्फ़िगर नहीं, कोई की एक्सचेंज नहीं, और यही समस्या है, जिस पर मैं वापस आऊँगा।
इसने क्या नेगोशिएट किया, और इसे कैसे देखें
debug जोड़िए और pppd कंट्रोल प्रोटोकॉल की पूरी बातचीत लॉग करता है, जिसे एक बार पढ़ना फ़ायदेमंद है, चाहे दोबारा कभी न पढ़ें। लिंक चरणों में चालू होता है, और हर चरण अपने आप फ़ेल हो सकता है।
दो काम के डीबगिंग टूल पहले से इंस्टॉल हैं और कोई उन्हें इस्तेमाल नहीं करता:
# 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 (और pppd के लिए pty भी सीरियल लाइन ही है) async HDLC फ़्रेमिंग इस्तेमाल करता है, और इसे समझना ही ट्यूनिंग और अंदाज़े के बीच का फ़र्क है। हर फ़्रेम एक ही बाइट से शुरू और खत्म होता है: “Each frame begins and ends with a Flag Sequence, which is the binary sequence 01111110 (hexadecimal 0x7e)”5। अगर 0x7e एक सीमा का निशान है तो वह फ़्रेम के अंदर नहीं आ सकता, इसलिए उसे एस्केप किया जाता है। एस्केप बाइट 0x7d को भी, और उसे भी जो कोई भी सिरा माँगे।
एस्केप का नियम एकदम सटीक है: “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 bit का है, हर कंट्रोल कैरेक्टर के लिए एक, और 1 का मतलब है “इसे एस्केप करो”। सब माँग लीजिए तो एन्क्रिप्टेड payload पर, जहाँ बाइट्स असल में रैंडम होते हैं, लगभग आठ में से एक बाइट 0x20 से नीचे होता है: बिना किसी फ़ायदे के करीब 12% ओवरहेड।
आधुनिक pppd यहाँ पहले से सही काम करता है। सुनी-सुनाई बातों की जगह man page पढ़िए:
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-bit पाथ है जिसे दो अनिवार्य बाइट्स के अलावा किसी एस्केपिंग की ज़रूरत नहीं। इसे छेड़िए मत; bit तभी सेट कीजिए जब बीच में कोई चीज़ सच में कंट्रोल कैरेक्टर खाती हो: कोई टर्मिनल सर्वर, कोई सीरियल कॉन्सेंट्रेटर, कोई खराब कंसोल प्रॉक्सी। आखिर में frame check sequence एक 16-bit CRC है, और यही वह चीज़ है जिससे UDP बिल्ड काम करता है, जो अगला है।
TCP के ऊपर TCP गलत कैरियर है
ऊपर वाला बिल्ड काम करता है। लैब की बेंच पर, loopback या शांत LAN पर, यह शानदार चलता है, और ठीक इसीलिए लोग इसे शिप कर देते हैं।
फिर इसका सामना असली लॉस वाले असली पाथ से होता है। यह ऐसे गिरता है कि लगता है कुछ भी हुआ हो, सिवाय उसके जो असल में हुआ।
समस्या है दो स्वतंत्र retransmission टाइमर जो एक के ऊपर एक रखे हैं, और बाहर वाला अंदर वाले से लॉस छिपा लेता है। 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 अपने round-trip time से एक retransmission टाइमर सेट करते हैं। जब कैरियर एक सेगमेंट खोता है तो वह उसे दोबारा भेजता है, तो अंदर वाले कनेक्शन का डेटा देर से पहुँचता है। और अंदर वाला TCP, जो कैरियर को देख नहीं सकता, देरी को भीड़ समझता है और वह भी दोबारा भेजता है। अब कैरियर के पास मूल डेटा और एक डुप्लिकेट है डिलीवर करने को, ऐसे लिंक पर जो पहले से पैकेट खो रहा है। अंदर वाला टाइमर दोगुना होता है, बाहर वाली कतार बढ़ती है, और throughput लिंक के गिरने से बहुत पहले ढह जाता है। लॉग में कुछ नहीं बताता कि क्यों।
यह कोई बारीक efficiency वाली बात नहीं है। यह फ़र्क है एक ऐसे टनल के बीच जो धीरे-धीरे शालीनता से कमज़ोर पड़ता है, और एक ऐसे के बीच जो शायद 2% लॉस पर ट्रैफ़िक पास करना बंद कर देता है जबकि उसी पाथ पर ping अब भी ठीक दिखता है। यही वजह है UDP इस्तेमाल करने की, और TCP को सिर्फ़ उस पाथ के लिए बचाकर रखने की जो और कुछ पास ही न करे।
तो UDP इस्तेमाल कीजिए, डिफ़ॉल्ट के रूप में, पसंद के रूप में नहीं।
चरण दो: UDP बिल्ड, जो नींव है
वही pppd, अलग कैरियर। बदलाव सिर्फ़ pty कमांड में है।
listen करने वाला सिरा:
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 listener के बारे में दो बातें जो आपको फँसाएँगी, और दोनों में से कोई भी PPP की समस्या नहीं है।
listener तब तक जवाब नहीं दे सकता जब तक उससे बात न की जाए। UDP सॉकेट के पास स्वीकार करने को कोई कनेक्शन नहीं होता, तो netcat को तब तक नहीं पता कि जवाब कहाँ भेजे जब तक कोई datagram न आए। वह जिस पहले source एड्रेस और पोर्ट से सुनता है उसी पर टिक जाता है और उसी से बात करता है। इसका मतलब है कि कनेक्ट करने वाले सिरे को पहले भेजना होगा, जो pppd अपने आप करता है, क्योंकि non-passive सिरा तुरंत LCP configure-request दागना शुरू कर देता है। इसका यह भी मतलब है कि अगर क्लाइंट का source पोर्ट बदल जाए तो कैरियर चुपचाप गलत जगह से बात कर रहा होता है। छोटे UDP टाइमआउट वाले NAT के पीछे, यह ऐसा टनल है जो हर कुछ मिनट में बिना किसी दिखने वाली वजह के मर जाता है।
UDP पर --keep-open वह नहीं करता जो आप चाहते हैं। Ncat का -k पीयर के चले जाने के बाद भी TCP listener को स्वीकार करते रहने देता है। UDP पर स्वीकार करने को कुछ है ही नहीं, तो रिकवरी का मतलब है कैरियर को रीस्टार्ट करना, और persist और holdoff इसी के लिए हैं, आगे।
दोनों बातें socat के पक्ष में तर्क हैं, जो UDP पीयर को ज़्यादा सावधानी से संभालता है, और इस पर भरोसा करने की बजाय कि वह चालू रहेगा, एक supervisor के पक्ष में।
एक खोए datagram के बाद भी PPP क्यों बचा रहता है
UDP कैरियर पर सबसे सीधी आपत्ति यह है कि PPP बाइट स्ट्रीम की उम्मीद करता है और UDP वह नहीं है: datagram पूरे पहुँचते हैं या बिल्कुल नहीं, और गलत क्रम में भी पहुँच सकते हैं। फिर भी यह काम करता है, उन दो बाइट्स की वजह से जो फ़्रेमिंग शुरू से ढो रही है।
async HDLC पर PPP ऐसी लाइन के लिए डिज़ाइन किया गया था जो बाइट्स बिगाड़ देती है। हर फ़्रेम एक 16-bit frame check sequence ढोता है; जो फ़्रेम इसमें फ़ेल होता है वह फेंक दिया जाता है, और अगला flag बाइट रिसीवर को फिर से सिंक कर देता है। क्रम बिगड़ना लॉस से कम होता है और उसका नतीजा वही होता है: खराब FCS, फेंका गया फ़्रेम, फिर से सिंक।
तो एक खोया datagram एक PPP फ़्रेम की कीमत है: एक IP पैकेट, जो आज तक बने हर नेटवर्क की सामान्य हालत है। पैकेट का मालिक उसे दोबारा भेजता है, और congestion control असली लॉस देखता है और सही जवाब देता है। UDP के पक्ष में पूरा तर्क यही है: यह टनल के अंदर के ट्रैफ़िक को पाथ की सच्चाई जानने देता है।
फिर भी, फ़्रेम को इतना बड़ा मत होने दीजिए कि कैरियर को उसे fragment करना पड़े। तब एक खोया fragment पूरे datagram को मार देता है और आपकी असल लॉस दर कई गुना हो जाती है। PPP MTU को पाथ 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, बिना broadcast domain और बिना एड्रेस की कमी वाला पॉइंट-टू-पॉइंट लिंक आपके नेटवर्क में 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-bit इंटरफ़ेस आइडेंटिफ़ायर सेट करता है4, लिंक link-local पर चालू होता है, और आप ऊपर से एक ग्लोबल /64 जोड़ते हैं7। IPV6CP, IPCP8 से स्वतंत्र है, तो noip के साथ सिर्फ़ IPv6 ढोया जाता है। 2026 में बनाने लायक एक समझदार चीज़, एक शब्द में।
जब कैरियर चुपचाप मर जाए तब भी लिंक चालू रखना
यह वह फ़ेलियर है जो पूरी दोपहर बर्बाद करता है, इसलिए इसे अपना सेक्शन मिला है।
एक TCP कैरियर जो बुरी तरह मरता है (दूर वाला सिरा बंद हो गया, NAT टेबल की एंट्री एक्सपायर हो गई, किसी middlebox ने फ़ॉरवर्ड करना बंद कर दिया) वह बंद नहीं होता। न FIN, न RST, कुछ नहीं। Netcat एक ऐसा सॉकेट पकड़े बैठा रहता है जो कभी कोई और बाइट नहीं देगा, pppd एक ऐसा pty पकड़े बैठा रहता है जिसे कभी कोई और फ़्रेम नहीं दिखेगा, और ip link खुशी-खुशी ppp0 को UP बताता है। UDP कैरियर के पास तो कोई कनेक्शन स्टेट ही नहीं होता, तो उसे कभी कुछ पता नहीं चलता।
PPP में इसका जवाब अंदर ही है, और वह डिफ़ॉल्ट रूप से बंद है:
lcp-echo-interval 10 lcp-echo-failure 3
यह हर दस सेकंड में एक LCP echo भेजता है और तीन का जवाब न आने पर लिंक गिरा देता है4: मरे हुए कैरियर को पकड़ने में तीस सेकंड, ठीक उसी केस पर जिसका man page नाम लेता है, “no hardware modem control lines”4, जो आज तक बना हर pty है। फिर तय कीजिए कि उसके बाद क्या हो:
persist maxfail 0 holdoff 5
lcp-echo-interval 10 lcp-echo-failure 3 डिटेक्टर है: हर दस सेकंड में echo, तीन छूटें तो लिंक डाउन। persist maxfail 0 holdoff 5 दोबारा बनाने वाला हिस्सा है: रीस्टार्ट, कभी हार मत मानो, पाँच सेकंड रुको ताकि बार-बार गिरता पाथ fork bomb न बन जाए। और pppd pty कमांड दोबारा चलाता है, तो एक नया netcat और नया सॉकेट साथ आते हैं। echo दोनों सिरों पर सेट कीजिए; एक supervisor, Restart=always वाली systemd unit, आपस में बहस करते दो प्रोसेस से बेहतर है। ip route को /etc/ppp/ip-up.d/ में रखिए ताकि लिंक के साथ रूटिंग भी लौट आए।इसमें न एन्क्रिप्शन है, न ऑथेंटिकेशन
ऊपर का सब कुछ एक चलता हुआ टनल है। सुरक्षित टनल नहीं है, और यह कमी कोई छोटी बात नहीं।
कोई एन्क्रिप्शन नहीं है। कमज़ोर एन्क्रिप्शन नहीं। बिल्कुल नहीं। आप इसमें से जो भी पैकेट भेजते हैं वह तार पर खुला है, एक HDLC फ़्रेम में लिपटा जिसे कोई भी कैप्चर टूल देखते ही डिकोड कर देता है। tcpdump आपको किसी और के टनल की सामग्री उतनी ही आसानी से दिखाएगा जितनी आपके अपने की।
पीयर का कोई ऑथेंटिकेशन नहीं है। noauth यही कहता है। netcat listener पोर्ट पर जो भी आए उसे स्वीकार कर लेता है: कहीं से भी आया पहला कनेक्शन या datagram। जो पहले पहुँचता है उसे आपके नेटवर्क में एक रूट किया हुआ लिंक मिल जाता है। PPP में ऑथेंटिकेशन है (PAP खुले में, CHAP challenge-response के रूप में9), और दोनों साबित करते हैं कि पीयर कौन है, पर उसके बाद आने वाले एक भी बाइट को एन्क्रिप्ट नहीं करते: यहाँ CHAP से आपको ऐसा टनल मिलता है जो जानता है कि वह किससे बात कर रहा है और फिर भी पाथ पर मौजूद हर किसी के लिए सामग्री छाप देता है।
PPP परिवार में एक एन्क्रिप्शन ऑप्शन है, MPPE10, वह मॉड्यूल जो ppp_mppe.ko में बैठा है। उसकी तरफ़ हाथ मत बढ़ाइए: यह MS-CHAPv2 एक्सचेंज से key किया गया RC4 है, दस साल से ज़्यादा समय से सबके सामने टूटा हुआ, और PPTP के मरने की वजह यही है। 2026 में इस पर नया टनल बनाना एक ऐसे चलते हुए cipher को छोड़कर, जिसकी कोई कीमत नहीं, एक जाने-माने टूटे cipher को चुनना है।
तो अब तक का ईमानदार सार: एक रूट किया हुआ लिंक जिसमें न गोपनीयता है, न एक्सेस कंट्रोल। लैब के लिए ठीक, किसी ऐसे लिंक के अंदर ठीक जो पहले से एन्क्रिप्टेड है, और कहीं के लिए ठीक नहीं। इलाज है कैरियर को एन्क्रिप्ट करना: अगले दो सेक्शन, और यही वजह है कि आपके डिस्ट्रीब्यूशन ने जो भी netcat दिया हो, उसकी जगह ncat इस्तेमाल किया जाए।
चरण तीन: कैरियर को TLS में लपेटना
साफ़ जवाब pppd को बिल्कुल वैसा ही छोड़ता है और कैरियर को एक ऐसे से बदल देता है जो TLS करता है। pppd को कभी पता नहीं चलता कि कुछ बदला।
पहले सर्टिफ़िकेट। एक self-signed काफ़ी है, बशर्ते क्लाइंट उसे वेरिफ़ाई करे। बिना वेरिफ़ाई किया 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, तो कैरियर टनल के दूर वाले सिरे की जगह किसी relay पर खत्म हो सकता है। egress वाला सेक्शन इसी बात पर टिका है। listen करने वाला सिरा:
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 आपको passive सुनने वाले के खिलाफ़ एन्क्रिप्शन देता है और जो भी पहले पोर्ट का जवाब दे उसके खिलाफ़ कुछ नहीं; इसके साथ, Ncat trust file के खिलाफ़ भरोसा और domain name वेरिफ़ाई करता है12। हालाँकि Ncat में सर्वर साइड पर client-cert की कोई जाँच नहीं है, तो सर्वर क्लाइंट की पहचान नहीं कर सकता। इसे CHAP के साथ जोड़िए, या अगले दो में से कोई इस्तेमाल कीजिए।
Stunnel
पारंपरिक रैपर, और वह जो mutual authentication ठीक से करता है:
[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 एक ऐसा client सर्टिफ़िकेट माँगता है जो CAfile के किसी CA से साइन हो: वह एक्सेस कंट्रोल जो netcat बिल्ड में कभी था ही नहीं। क्लाइंट stunnel को client mode में चलाता है, और pppd की pty कमांड लोकल plaintext साइड से कनेक्ट करती है।
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 वेरिफ़िकेशन फ़ेल होने पर चेतावनी देकर आगे बढ़ने की बजाय कनेक्शन बंद करवाता है। ये डीबगिंग टूल हैं और वैसा ही बर्ताव करते हैं, पर जिस बॉक्स पर आप कुछ इंस्टॉल नहीं कर सकते, वहाँ ये एक लिंक चालू कर देते हैं।
चरण चार: DTLS, क्योंकि कैरियर अब भी UDP होना चाहिए
यहाँ अटपटा हिस्सा है, और यही वजह है कि यह सेक्शन अलग है। ऊपर का हर TLS ऑप्शन TCP पर चलता है, तो कैरियर को TLS में लपेटना UDP वाले तर्क को पलट देता है और meltdown आपको वापस थमा देता है। एन्क्रिप्शन और सही ट्रांसपोर्ट के बीच सौदा नहीं होना चाहिए। DTLS datagram पर TLS है, और आपको यही चाहिए: यह record-layer सुरक्षा रखता है, क्रम और retransmission की गारंटी छोड़ देता है, और खोए पैकेट को खोया ही रहने देता है, ठीक वही जिसे सोखने के लिए PPP का frame check sequence बना है।
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 record उस तरह fragment नहीं हो सकता जैसे एक TLS record TCP स्ट्रीम में फैल जाता है, तो सब कुछ एक बार में पाथ MTU में फ़िट होना चाहिए।
PPP बिल्ड की ट्यूनिंग: MTU, कम्प्रेशन, और असल में क्या मदद करता है
चार नॉब, सब pppd ऑप्शन। अगले सेक्शन वाले tap बिल्ड में इनमें से कोई नहीं है, क्योंकि उसमें वह मशीनरी ही नहीं जिसे ये कॉन्फ़िगर करते हैं।
novj से बंद कीजिए। वह बस गोलाई की गलती जितना बचाता है, हर पैकेट पर CPU खाता है और लॉस में टूट जाता है। deflate/bsdcomp बंद कीजिए: payload पहले से एन्क्रिप्टेड है, और सिक्योरिटी बाउंड्री के पार कम्प्रेस करना एक अटैक है, फ़ीचर नहीं।इनमें से कुछ भी टनल को तेज़ नहीं बनाता, और इसकी वजह मायने रखती है क्योंकि इसका दोष PPP पर डाला जाता है और नहीं डाला जाना चाहिए। PPP बॉटलनेक नहीं है। PPPoE उसी डेमन पर 2 Gbit ढोता है, क्योंकि उसका डेटा पाथ कभी kernel से बाहर नहीं जाता: ppp_generic और pppoe फ़्रेमिंग और फ़ॉरवर्डिंग करते हैं, और pppd सिर्फ़ control plane संभालता है। यहाँ आपकी कीमत pty है: हर बाइट userspace में जाता है, netcat से होकर, एक सॉकेट में और वापस, एक ऐसा चक्कर जो PPPoE कभी नहीं लगाता। वह pseudo-terminal का है, PPP का नहीं।
इसी मौके पर इसे करने के दूसरे तरीके को देखना ठीक रहेगा, जिसमें pty है ही नहीं।
दूसरा तरीका: एक tap डिवाइस, और PPP बिल्कुल नहीं
अब तक सब कुछ लिंक वाले आधे हिस्से के लिए PPP इस्तेमाल करता रहा है। वर्चुअल इंटरफ़ेस बनाने का एक दूसरा तरीका भी है, और उसे किसी प्रोटोकॉल की ज़रूरत नहीं।
Kernel का TUN/TAP ड्राइवर आपको एक इंटरफ़ेस और एक file descriptor आपस में बँधे हुए देता है: descriptor में एक पैकेट लिखिए और वह इंटरफ़ेस पर ऐसे दिखता है जैसे तार से आया हो; पढ़िए तो आपको वह पैकेट मिलता है जिसे kernel भेजना चाहता था। पूरा इंटरफ़ेस बस इतना है13, और यह 1999 से Linux में है।
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
उस पहली कमांड में दो बारीकियाँ दिखने से ज़्यादा कीमती हैं।
user damien डिवाइस को persistent और unprivileged बनाता है। इस तरह बना डिवाइस उसे इस्तेमाल करने वाले प्रोसेस के बाद भी बचा रहता है, और एक नामित यूज़र उसे root हुए बिना खोल सकता है। Root डिवाइस एक बार बनाता है; जो चीज़ फ़्रेम ढोती है उसे root की ज़रूरत ही नहीं। यह बात egress वाले सेक्शन तक याद रखिए।
mode tun उसी ड्राइवर का दूसरा आधा हिस्सा है, और ज़्यादातर लोगों को असल में यही चाहिए। Tun IP पैकेट ढोता है। Tap Ethernet फ़्रेम ढोता है। यह फ़र्क इतना मायने रखता है कि नीचे इसका अपना सेक्शन है।
PPP के मुकाबले आप वह सब छोड़ते हैं जो PPP नेगोशिएट करता है: LCP नहीं, तो न तय किया हुआ फ़्रेम साइज़ और न लाइवनेस चेक; IPCP/IPV6CP नहीं, तो दोनों सिरे हाथ से कॉन्फ़िगर; कोई ऑथेंटिकेशन नहीं, कोई हेडर कम्प्रेशन नहीं। tap डिवाइस kernel में एक छेद है, और उसमें से जाने वाला प्रोटोकॉल वही है जो आप वहाँ रखें। बदले में आपको मिलता है: फ़्रेमिंग का बिल्कुल कोई ओवरहेड नहीं, कोई एस्केपिंग नहीं, कोई कंट्रोल चैनल नहीं, और एक ऐसा इंटरफ़ेस जिसे ब्रिज किया जा सकता है।
UDP पर tap, जहाँ एक datagram एक फ़्रेम है
यह पूरी पोस्ट की सबसे साफ़ मैपिंग है, और यह डिज़ाइन से ही निकलती है। tap डिवाइस एक datagram डिवाइस है (एक read() ठीक एक फ़्रेम लौटाता है) और UDP सॉकेट एक datagram सॉकेट है, हर datagram के लिए एक sendto()। तो एक फ़्रेम एक datagram में जाता है, फ़्रेम के रूप में पहुँचता है, और न कुछ अलग करना है, न बफ़र करना, न फिर से सिंक करना। एक datagram खोइए तो आपने एक फ़्रेम खोया, और गिरा हुआ पैकेट वैसे भी ऐसा ही दिखता है।
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 इंस्टॉल नहीं है, तो ये दोनों यहाँ चलाने की बजाय उसके डॉक्यूमेंटेशन से हैं; इन पर भरोसा करने से पहले अपने बिल्ड के address नाम जाँच लीजिए। यह रखने लायक है: इस पोस्ट में यही अकेला टूल है जो tun, tap, TLS और DTLS एक प्रोसेस में करता है।
जहाँ आप कुछ इंस्टॉल नहीं कर सकते, वहाँ पूरा काम लगभग पचास लाइनें है, standard library के अलावा कोई dependency नहीं। इसका दिल यह है, जहाँ 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)
पूरी फ़ाइल (आर्ग्युमेंट पार्सिंग, getaddrinfo से IPv6, वह zero-length datagram जो UDP listener को बताता है कि जवाब कहाँ देना है, और वह कम्प्रेशन जो अगला सेक्शन जोड़ता है) बंडल में है:
हर datagram पर peer = src वह हिस्सा है जिसे दो बार पढ़ना चाहिए। जिसने आखिरी फ़्रेम भेजा, वही पीयर बन जाता है। ऐसे NAT के पीछे सुविधाजनक जिसका source पोर्ट बदलता रहता है, और अविश्वसनीय नेटवर्क पर एक खुला दरवाज़ा, जहाँ कोई भी जो पोर्ट पर एक datagram भेज सके, टनल पर कब्ज़ा कर लेता है। DTLS सेशन के अंदर ठीक है, और बात वहीं जा रही है; अपने आप में ठीक नहीं। स्क्रिप्ट का सॉकेट वाला आधा हिस्सा यहाँ IPv6 loopback पर चलाकर देखा गया: शुरुआती datagram पहुँचता है, listener पीयर सीख लेता है, एक फ़्रेम पार जाता है और जवाब वापस आता है; tap वाले आधे हिस्से को root चाहिए, वही एक हिस्सा जो मैं नहीं चला सका।
TCP पर फ़्रेमिंग आपको खुद बनानी पड़ती है
अब कैरियर को TCP से बदलिए और देखिए कि एक पूरी समस्या सामने आती है जिसे PPP ने 1994 में चुपचाप हल कर दिया था।
TCP एक बाइट स्ट्रीम है जिसमें न record की सीमाएँ हैं, न कोई वादा कि पहुँचने पर बाइट्स कैसे समूह में होंगे: लगातार लिखे गए दो फ़्रेम एक read में आ सकते हैं, और एक फ़्रेम तीन में। रिसीवर के पास बाइट्स का ढेर होता है और कोई अंदाज़ा नहीं कि एक फ़्रेम कहाँ खत्म होता है, और tap डिवाइस सिर्फ़ पूरे फ़्रेम स्वीकार करता है।
तो TCP पर आप अपनी फ़्रेमिंग खुद लिखते हैं। हर फ़्रेम के आगे दो बाइट की big-endian length सामान्य जवाब है:
# 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-over-TCP वाली समस्या है; यह हर फ़्रेम पर दो बाइट और एक reassembly लूप जोड़ता है; और एरर से लौटने का इसके पास कोई रास्ता नहीं, क्योंकि जो length-prefixed स्ट्रीम अपनी जगह खो देती है वह आगे की हर length किसी फ़्रेम के बीच से पढ़ती है। HDLC अगले 0x7E पर फिर से सिंक हो जाता है; यह नहीं हो सकता, जब तक HDLC को और खराब तरीके से दोबारा न बनाया जाए। UDP के पक्ष में तीसरा तर्क, और सबसे मज़बूत: datagram कैरियर पर फ़्रेमिंग की कोई समस्या नहीं, क्योंकि कैरियर के पास पहले से वह अकेला फ़ीचर है जिसकी आपको ज़रूरत थी।
Tun या tap: लेयर 3, जब तक सच में लेयर 2 की ज़रूरत न हो
एक ही ड्राइवर आपको दो डिवाइस देता है, और लोग लगातार गलत वाला चुनते हैं क्योंकि किसी ट्यूटोरियल ने tap कहा था।
| tun | tap | |
|---|---|---|
| क्या पार जाता है | IP पैकेट | Ethernet फ़्रेम |
| हर पैकेट का ओवरहेड | कुछ नहीं | 14-बाइट Ethernet हेडर |
| ARP, DHCP, broadcast | नहीं | हाँ, सब कुछ, टनल के पार |
| Non-IP प्रोटोकॉल | नहीं | हाँ |
| ब्रिज में जुड़ सकता है | नहीं | हाँ |
| किसके बराबर | पॉइंट-टू-पॉइंट लिंक, ppp0 जैसा | एक नेटवर्क केबल |
Tun एक रूट किया हुआ लिंक है, पहले हिस्से के PPP इंटरफ़ेस जैसा: दो एड्रेस, एक रूट, पैकेट अंदर और बाहर। Tap एक वर्चुअल Ethernet केबल है, तो सेगमेंट का हर broadcast, ARP query और multicast का हर शोर अब आपके टनल को पार करता है और बैंडविड्थ जलाता है।
बदलने के लिए स्क्रिप्ट में एक लाइन बदलिए:
IFF_TUN = 0x0001 # instead of IFF_TAP
tap तब इस्तेमाल कीजिए जब सच में लेयर 2 की ज़रूरत हो। असली वजहें होती हैं: कोई प्रोटोकॉल जो IP नहीं है, कोई cluster heartbeat जो broadcast देखने की उम्मीद करता है, कोई DHCP सर्वर जिसे टनल के पार क्लाइंट तक पहुँचना है, या दो सेगमेंट को ब्रिज करके एक बनाना।
वह आखिरी वाला आम केस है और उसी के साथ सावधान रहना है:
ip link add br0 type bridge
ip link set tap0 master br0
ip link set eth1 master br0
ip link set br0 up
अब दूर का सेगमेंट आपके लोकल सेगमेंट का हिस्सा है: उसके broadcast, उसका spanning tree, उसका MAC churn और, अगर किसी ने लापरवाही की, तो उसका DHCP सर्वर भी। दो ऐसी साइट को ब्रिज करना जो दोनों 192.168.1.0/24 चलाती हैं, एक खराब दोपहर है; ऐसा ब्रिज जो उसी सेगमेंट पर लूप हो जाए, एक खराब हफ़्ता। डिफ़ॉल्ट tun रखिए, tap तब उठाइए जब आप उस लेयर 2 चीज़ का नाम ले सकें जिसकी आपको ज़रूरत है, और ब्रिज तभी कीजिए जब दोनों तरफ़ देख लें कि कौन broadcast कर रहा है।
वही रैपर, हर सिरे पर एक प्रोसेस
tap बिल्ड में वही छेद है जो PPP वाले में: कैरियर खुला है और listener उसे स्वीकार कर लेता है जो पहले पहुँचे। इलाज भी वही है, और 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
इस पोस्ट का यह सबसे छोटा सही बिल्ड है। एक वर्चुअल इंटरफ़ेस, एक datagram कैरियर, mutual certificate authentication और एन्क्रिप्शन। दो कमांड। न कोई डेमन, न प्रोटोकॉल नेगोशिएशन।
verify=1 वैकल्पिक नहीं है: वही बात जो --ssl-verify के साथ थी, और ऊपर वाले peer = src बर्ताव के साथ, कोई अनजान पार्टी आपके टनल की मालिक बनने से बस एक datagram दूर है। अगर आप Python स्क्रिप्ट के साथ फँसे हैं, तो उसमें TLS मत ठूँसिए: उसे एक loopback पोर्ट की तरफ़ कीजिए और आगे रैपर रखिए, या socat इस्तेमाल कीजिए। हाथ से बने टनल के चारों ओर हाथ से बना TLS रैपर, दिलचस्प हिस्से को गलत करने के दो मौके हैं।
चरण पाँच: zstd से स्ट्रीम को कम्प्रेस करना
बैकएंड में डालने लायक एक और चीज़ है, और pppd के कम्प्रेशन ऑप्शन के उलट इसका सच में फ़ायदा हो सकता है: फ़्रेम को कैरियर में डालने से पहले zstd से कम्प्रेस कीजिए।
वहाँ अहम शब्द है फ़्रेम, बहुवचन। स्ट्रीम को कम्प्रेस कीजिए, हर पैकेट को अलग-अलग नहीं। इस पोस्ट में मापा गया यही सबसे बड़ा असर है।
नेटवर्क ट्रैफ़िक ऐसे दोहराव वाला होता है जो सिर्फ़ पैकेटों के पार दिखता है: वही हेडर, होस्टनेम और JSON keys, बार-बार। जो कम्प्रेसर हर 1,400-बाइट फ़्रेम पर नए सिरे से शुरू करता है उसे इसमें से कुछ नहीं दिखता; जो अपनी window फ़्रेमों के पार रखता है उसे सब दिखता है।
मौजूदा Fedora पर इसके लिए कुछ इंस्टॉल नहीं करना पड़ता: Python 3.14 zstd को standard library में ले आया14; इस बॉक्स पर zstd 1.5.7 के साथ 3.14.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, तो फ़्रेम आते ही बाहर चला जाता है, कुछ बफ़र नहीं होता, और दूर वाला सिरा हर block पर एक फ़्रेम लौटाता है।
window की कीमत, मापकर
इसी मशीन के आँकड़े। वही 1,400-बाइट फ़्रेम, वही level 1, फ़र्क सिर्फ़ इतना कि कम्प्रेसर अपनी हिस्ट्री रखता है या नहीं:
| टनल में ट्रैफ़िक | स्ट्रीम, FLUSH_BLOCK | हर पैकेट, FLUSH_FRAME | हर पैकेट, trained dictionary के साथ |
|---|---|---|---|
| दोहराव वाले API कॉल और टेलीमेट्री | 5.0% | 14.8% | 5.3% |
| लॉग लाइनें | 7.5% | 24.2% | 15.1% |
| सादा टेक्स्ट और कॉन्फ़िग फ़ाइलें | 37.8% | 51.3% | 45.3% |
| रैंडम बाइट्स, TLS की जगह | 100%+ | 100.7% | — |
level 1 पर throughput टेक्स्ट पर 205 MB/s और दोहराव वाले ट्रैफ़िक पर 1 GB/s से ऊपर रहा: जितना ज़्यादा कम्प्रेस होने लायक, उतना तेज़, क्योंकि एनकोड करने को कम है।
लॉग ट्रैफ़िक अपने मूल साइज़ के 7.5% पर आ जाता है, हर पैकेट वाले 24.2% के मुकाबले: तीन गुना, वही डेटा, वही level, एक फ़्लैग से। और level 1 ही सही level है: level 3 से लगभग एक प्रतिशत मिला, level 9 से एक और, जबकि throughput 211 MB/s से 61 पर गिर गया।
पेंच, और यह वही पेंच है जो यहाँ बाकी हर चीज़ में है
साझा window का मतलब है कि हर फ़्रेम अपने से पहले वालों पर निर्भर है: एक खोइए तो decompressor की हिस्ट्री मेल नहीं खाती, और उसके बाद कुछ भी डिकोड नहीं होता। तो स्ट्रीम कम्प्रेशन को ऐसा कैरियर चाहिए जो सब कुछ क्रम से पहुँचाए: TCP, या TCP पर TLS, UDP या DTLS नहीं। इस पूरी पोस्ट में TCP कैरियर के पक्ष में यही एक ईमानदार तर्क है। अगर आपके टनल से जो गुज़रता है वह सच में कम्प्रेस होने लायक है (syslog, खुले में database replication, टेलीमेट्री, बातूनी API), तो स्ट्रीम-कम्प्रेस्ड TLS सेशन datagram कैरियर के मुकाबले एक तिहाई बाइट्स ले जाता है, जो ठीक-ठाक पाथ पर retransmission की सज़ा से भारी पड़ सकता है। अपने ट्रैफ़िक पर मापिए।
UDP पर, जहाँ dictionary window का काम करती है
जहाँ कैरियर UDP या DTLS है, और डिफ़ॉल्ट रूप से होना चाहिए, वहाँ आप window नहीं रख सकते: हर datagram अपने आप में अकेला है, यानी FLUSH_FRAME और ऊपर वाला कमज़ोर कॉलम। एक trained dictionary कम्प्रेसर को पैकेटों के पार वह संदर्भ देती है जो window देती, datagram के बीच कोई निर्भरता बनाए बिना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%।
इसके साथ तीन नियम आते हैं। दोनों सिरों को वही dictionary लोड करनी होगी वरना कुछ डिकोड नहीं होता; यहाँ जाँचा गया, dictionary से कम्प्रेस हुआ फ़्रेम उसके बिना ZstdError देता है। असली ट्रैफ़िक के कैप्चर पर ट्रेन कीजिए, क्योंकि dictionary एक पूर्वधारणा है और गलत वाली आपको महँगी पड़ती है: टेक्स्ट वाली dictionary ने अलग टेक्स्ट को थोड़ा बदतर कर दिया। और उसे एक लंबे चलने वाले कम्प्रेसर में एक बार लोड कीजिए; हर कॉल पर देने से 5 MB/s मापा गया, और यह टाइपो नहीं है।
हेडर बाइट, और एक सेकंड का रैंप
दो छोटी बातें जो इसे नाज़ुक होने से रोकती हैं।
हर datagram एक बाइट का हेडर ढोता है, और वह सिर्फ़ “कम्प्रेस्ड” कहने की बजाय मोड का नाम बताता है: 0x00 फ़्रेम जैसा है वैसा, 0x01 एक अपने आप में पूरा zstd फ़्रेम, 0x02 चलती स्ट्रीम का एक block। तब रिसीवर दूर वाले सिरे ने जो भी चुना उसे डिकोड कर सकता है, उससे मेल खाने के लिए कॉन्फ़िगर किए बिना, और अकेले इसी के लिए वह बाइट वाजिब है।
फ़्रेम मोड में भेजने वाला कम्प्रेस्ड रूप तभी भेजता है जब वह सच में छोटा हो, क्योंकि कम्प्रेशन हमेशा फ़ायदा नहीं है: रैंडम बाइट्स 100.7% पर निकले, और 64-बाइट का TCP ACK 73 पर कम्प्रेस होता है, यानी ऐसे पैकेट पर दस बाइट का zstd हेडर जिसमें निचोड़ने को कुछ नहीं। असली लिंक पर पैकेटों की गिनती में छोटे पैकेट हावी होते हैं, तो इस जाँच के बिना आप अपने ज़्यादातर ट्रैफ़िक को फुलाते ताकि थोड़े से को सिकोड़ सकें। स्ट्रीम मोड में यह हमेशा कम्प्रेस्ड रूप भेजता है, क्योंकि एक भी छोड़ना दोनों window को ताल से बाहर कर देगा।
और लिंक raw शुरू होता है: पहले एक सेकंड तक हर फ़्रेम बिना कम्प्रेस हुए जाता है, सेटिंग्स कुछ भी कहें, और हर दिशा अपने आप रैंप करती है:
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
यह पोस्ट की शुरुआत वाला चरणों का विचार है, एक अकेले लिंक पर लागू। टनल अपने सबसे सरल रास्ते पर चालू होता है, साबित करता है कि वह एक फ़्रेम ढो सकता है, और उसके बाद ही कोई होशियारी शुरू करता है। जब यह टूटता है, तो आपको पता होता है कि किस सेकंड में टूटा।
चरण छह: कम्प्रेस्ड और एन्क्रिप्टेड, और क्रम की कीमत
क्रम मायने रखता है, और सिर्फ़ एक काम करता है: पहले कम्प्रेस, फिर एन्क्रिप्ट। Ciphertext कम्प्रेस नहीं होता, जैसा 100.7% वाली पंक्ति दिखाती है, और इसीलिए TLS 1.3 ने अपना कम्प्रेशन हटा दिया, जिससे आपकी लेयर ही इसे करने की अकेली जगह बची। इस क्रम की एक जानी-मानी समस्या है, वही जो मैंने deflate के खिलाफ़ उठाई थी: एन्क्रिप्ट करने से पहले कम्प्रेस करना ciphertext की लंबाई के ज़रिए plaintext लीक करता है, और जहाँ अटैकर किसी secret के साथ अपना चुना हुआ डेटा डाल सके और साइज़ देख सके, वहाँ यह लीक एक से ज़्यादा बार चलता हुआ अटैक बना है: TLS के खिलाफ़ CRIME और BREACH16, और ठीक इसी आकार के खिलाफ़ VORACLE17।
यह कभी कम्प्रेस न करने की वजह नहीं है। यह जानने की वजह है कि आप किस केस में हैं:
- ऐसा लिंक जो आपके अपने दो बॉक्स के बीच आपका अपना ट्रैफ़िक ढोता है (replication, backup, लॉग, टेलीमेट्री) उसमें secret के साथ अटैकर का चुना हुआ plaintext सफ़र नहीं करता। इसे कम्प्रेस कीजिए, और स्ट्रीम को कम्प्रेस कीजिए।
- ऐसा लिंक जो यूज़र की मनमानी ब्राउज़िंग ढोता है, जहाँ किसी और का वेब कंटेंट और आपके क्रेडेंशियल साथ जाते हैं, वही केस है जिसके बारे में VORACLE लिखा गया था। इसे बंद रखिए।
मैं इसे tap बिल्ड में रखने में सहज हूँ और PPP वाले में नहीं, तो इसकी वजह कोई सिद्धांत नहीं है: यहाँ आप जानबूझकर एक आधुनिक एल्गोरिदम चुनते हैं, उस ट्रैफ़िक के लिए जिसे आपने देखा है, जबकि pppd का deflate डिफ़ॉल्ट रूप से सब कुछ 1996 वाले एल्गोरिदम से कम्प्रेस करता है, केस उसके लायक हो या न हो।
tap बिल्ड क्या पाता है, और क्या छोड़ता है
दोनों हिस्सों को आमने-सामने रखिए, क्योंकि वे प्रतियोगी नहीं हैं। वे अलग-अलग सौदे हैं।
| सॉकेट पर pppd | सॉकेट पर tap या tun | |
|---|---|---|
| फ़्रेमिंग | अंदर ही (HDLC, नुकसान के बाद फिर से सिंक) | UDP पर कोई नहीं क्योंकि ज़रूरत नहीं; TCP पर खुद बनाइए |
| एड्रेस सेटअप | IPCP और IPV6CP से नेगोशिएट | दोनों सिरों पर हाथ से कॉन्फ़िगर |
| लाइवनेस | LCP echo, अंदर ही | कोई नहीं; आप जोड़िए वरना लिंक चुपचाप मरता है |
| ऑथेंटिकेशन | PAP या CHAP उपलब्ध, दोनों कमज़ोर | बिल्कुल नहीं |
| लेयर | सिर्फ़ 3 | tun के साथ 3, tap के साथ 2 |
| ब्रिजिंग | नहीं | हाँ, tap के साथ |
| ओवरहेड | हर फ़्रेम पर flag, हेडर और FCS, साथ में एस्केपिंग | कुछ नहीं, या tap के साथ 14 बाइट |
| कम्प्रेशन | deflate और BSD, डिफ़ॉल्ट रूप से चालू, 1996 के | कोई नहीं, या हर फ़्रेम पर zstd जिसे आप जोड़ते और नियंत्रित करते हैं |
| Root चाहिए | हाँ, पूरे समय | डिवाइस बनाने के लिए; इस्तेमाल के लिए नहीं |
| चलते पुर्ज़े | एक डेमन, तीस साल पुराना | एक file descriptor |
PPP आपको नेगोशिएट किया हुआ, खुद की निगरानी करने वाला लिंक देता है और उसके बदले एक प्रोटोकॉल वसूलता है। tap डिवाइस आपको मुफ़्त में एक कच्चा छेद देता है, और गायब पुर्ज़े आप खुद लगाते हैं या उनके बिना काम चलाते हैं। चलते छोड़े गए टनल के लिए गायब लाइवनेस चेक ही काटता है: pppd तीस सेकंड में मरे कैरियर को पकड़ लेता है और उसे दोबारा बनाता है, tap बिल्ड कुछ नहीं पकड़ता क्योंकि उसमें कुछ भी नज़र नहीं रख रहा। एक keepalive जोड़िए, इसे किसी ऐसी चीज़ के तहत चलाइए जो इसे रीस्टार्ट करे, या वह बिल्ड इस्तेमाल कीजिए जिसमें पहले से है।
कब यह सही टूल है, और कब नहीं
यह कभी सच में सही टूल नहीं है, और मैं इसका उल्टा दिखावा नहीं करने वाला। ऊपर का सब कुछ काम करता है, और इसमें से कुछ भी वह नहीं है जो आपको प्रोडक्शन में चलाना चाहिए। किसी how-to के ईमानदार वर्ज़न में वह हिस्सा भी होता है जहाँ आप टूल नीचे रख देते हैं, और यह वही हिस्सा है।
यह जिस चीज़ के लिए सच में अच्छा है वह है आपको दिखाना कि कोई चीज़ कैसे काम करती है। एक VPN जिसे खोलकर उसके पुर्ज़े अलग कर दिए गए, और, अगले सेक्शन में, जब कोई root के साथ आपके नेटवर्क के अंदर हो तो egress असल में कैसे बर्ताव करता है। इसे पढ़ने की वजहें यही हैं। नीचे के संकरे केस असली हैं, पर पोस्ट उनकी वजह से नहीं है।
PPP बिल्ड तब उठाइए जब:
- कैरियर IP है ही नहीं: एक सीरियल कंसोल, एक USB gadget, एक रेडियो लिंक, एक named pipe, एक SSH चैनल।
pppdको फ़र्क नहीं पड़ता कि बाइट्स किस पर सफ़र करते हैं, और tap डिवाइस यहाँ आपकी मदद नहीं कर सकता। - आप कुछ बचा रहे हैं: एक मशीन जिसमें सीरियल कंसोल है, नेटवर्क नहीं, और एक काम जो आज रात खत्म करना है। उस कंसोल पर PPP एक रूट किया हुआ लिंक है, दोनों सिरों पर पहले से इंस्टॉल, कुछ भी कॉपी करने की ज़रूरत नहीं।
- आप चाहते हैं कि लिंक अपना ख्याल खुद रखे। LCP echo, एड्रेस नेगोशिएशन और रीस्टार्ट मुफ़्त हैं; इन्हें खुद लिखना ही वह तरीका है जिससे tap बिल्ड एक छोटा, अविश्वसनीय प्रोडक्ट बन जाता है।
tap बिल्ड तब उठाइए जब:
- आपको लेयर 2 चाहिए: कोई non-IP प्रोटोकॉल, कोई cluster heartbeat जो broadcast चाहता है, टनल के पार DHCP, या दो सेगमेंट जिन्हें एक होना ही है।
- आप सबसे कम चलते पुर्ज़े चाहते हैं: UDP पर DTLS के साथ यह दो कमांड है, न डेमन, न नेगोशिएशन, एस्केप करने को कुछ नहीं।
- Root मुश्किल से मिलता है।
userके साथ डिवाइस एक बार बनाइए, और फ़्रेम ढोने वाले प्रोसेस को फिर कभी privilege की ज़रूरत नहीं।
सीखते समय दोनों सही टूल हैं। हर लेयर दिखती है और अलग से बदली जा सकती है, और कोई VPN प्रोडक्ट क्या करता है यह समझने का इससे बेहतर तरीका नहीं कि उसे पुर्ज़ों से बनाइए और हर एक को चालू होते देखिए।
जब आपको VPN चाहिए तब इनमें से कोई सही टूल नहीं। उसके लिए WireGuard इस्तेमाल कीजिए। यह kernel में है, कोड का एक छोटा सा हिस्सा, यह crypto ठीक से करता है, नेगोशिएट करने को कुछ नहीं और गलत करने को कुछ नहीं, और डिज़ाइन से ही datagram प्रोटोकॉल है। ssh -w एक कमांड में मौजूदा SSH सेशन पर आपको tun डिवाइस देता है, और OpenVPN ऊपर वाले DTLS-over-tap आकार का परिपक्व, ऑडिट किया हुआ वर्ज़न है। तीनों इस काम में यहाँ बनाई गई किसी भी चीज़ से बेहतर हैं।
इन्हें इसलिए बनाइए क्योंकि आप जानना चाहते हैं कि आप जो चीज़ खरीदते हैं उसके अंदर क्या है। इसलिए नहीं कि यह होशियारी थी।
यह असल में क्या दिखाता है: अटैकर की तरफ़ से egress
यही वजह है एक ऐसी बिल्ड पोस्ट पढ़ने की जिसे इस्तेमाल न करने को अभी आपसे कहा गया। इसे पलटिए और अपने ही नेटवर्क के अंदर से देखिए, उस इंसान की तरह जो अभी-अभी root के साथ वहाँ उतरा है। हर असली breach आखिर में वहीं पहुँचता है: चुराई गई की से, कंटेनर escape से, बिना पैच की सर्विस से, किसी अंदर वाले से। उसके बाद जो सवाल तय करता है कि दिन कितना बुरा जाएगा वह “वे क्या चला सकते हैं” नहीं है, क्योंकि वे कुछ भी चला सकते हैं। सवाल है “क्या बाहर जा सकता है, और क्या आपने यह उनके आने से पहले तय किया था।”
अगर आउटबाउंड डिफ़ॉल्ट रूप से खुला है, तो जवाब है सब कुछ, और अब आप ज़्यादा कुछ नहीं कर सकते। यहाँ कुछ भी अनोखा नहीं था। pppd, ncat, socat और ip साइन किए हुए डिस्ट्रीब्यूशन पैकेज हैं जो पहले से बॉक्स पर हैं; tap shim standard library की पचास लाइनें है। एक इजाज़त वाला आउटबाउंड पोर्ट (और वह 443 है, जिसे हर नेटवर्क डिफ़ॉल्ट रूप से खोलता है) और आपके नेटवर्क से किसी और के नेटवर्क तक एक रूट किया हुआ लिंक बन जाता है: एन्क्रिप्टेड, ऑथेंटिकेटेड, रीस्टार्ट झेलने वाला, IPv4 और IPv6 ढोने वाला, और आपके बॉर्डर पर उस किसी भी HTTPS सेशन से अलग न पहचाना जा सकने वाला जो आपके यूज़र दिन में दस हज़ार बार बनाते हैं। इसे tap बनाइए और ब्रिज कर दीजिए, तो जो इमारत से बाहर गया वह एक रूट नहीं है। वह पूरा सेगमेंट है।
किसी स्कैनर के पकड़ने को कुछ नहीं है: कोई malware signature नहीं क्योंकि कोई malware नहीं, कोई अजीब प्रोटोकॉल नहीं क्योंकि यह 443 पर एक सामान्य TLS handshake है, कोई असामान्य बाइनरी नहीं क्योंकि हर एक आपके अपने package manager ने इंस्टॉल की। प्रॉक्सी एक कनेक्शन और एक बाइट काउंट लॉग करता है, और दोनों काम जैसे दिखते हैं।
और गंतव्य तय भी नहीं है। सॉकेट को वहाँ खत्म होना ज़रूरी नहीं जहाँ पैकेट आखिर में पहुँचते हैं, क्योंकि कैरियर को एक प्रॉक्सी के ज़रिए भेजा जा सकता है: एक relay जो दो कनेक्शन और एक पाइप से ज़्यादा कुछ नहीं, जिसे अगला सेक्शन shell की एक लाइन में बनाता है। ncat --proxy के साथ --proxy-type http, socks4 या socks5 लेता है, तो आपके बॉर्डर को दिखने वाला TLS सेशन वहाँ खत्म होता है जिसके ज़रिए कनेक्ट करने को अटैकर ने कहा: कोई अंदरूनी jump host, कोई इजाज़त वाला SaaS एंडपॉइंट जो संयोग से CONNECT फ़ॉरवर्ड करता है, कोई क्लाउड relay। और टनल वहाँ से आगे किसी ऐसी जगह तक जाता है जिसे आप कभी नहीं देखते। HTTP CONNECT और SOCKS दोनों डिज़ाइन से यही करते हैं, क्योंकि प्रॉक्सी होता ही इसके लिए है। तो जिस गंतव्य पर आप भरोसा करते हैं उसकी allow-list एंट्री हमेशा उस गंतव्य पर और हर उस चीज़ पर भरोसा है जिस तक वह फ़ॉरवर्ड करेगा, जिसे न आप नियंत्रित करते हैं, न गिन सकते हैं। आपके फ़ायरवॉल लॉग में एंडपॉइंट प्रॉक्सी है। वह कभी दूर वाला सिरा नहीं था।
तो असहज सच यह है: जब कोई root के साथ अंदर हो और आउटबाउंड ढीला हो, तो टनल वह चीज़ नहीं है जिसे आप रोक पाएँ। पुर्ज़े इंस्टॉल हैं, बाहर का रास्ता खुला है, और वह वहाँ तक भी नहीं जाता जहाँ जाता दिखता है। इसे मुश्किल बनाने का आपका एक मौका अटैकर के आने से पहले था, बॉर्डर पर, यह तय करके कि क्या बाहर जा सकता है।
वही default-deny egress है, और पूरा सबक यही है। आउटबाउंड डिफ़ॉल्ट रूप से ब्लॉक; एक छोटी, नामों वाली allow-list जिसमें हर गंतव्य और पोर्ट को किसी इंसान ने जायज़ ठहराया हो; बाकी सब मना, लॉग, और अलर्ट। इसलिए नहीं कि यह किसी पक्के इरादे वाले अटैकर को वहीं रोक देता है (इजाज़त वाला गंतव्य इजाज़त वाला टनल है), बल्कि इसलिए कि इसका विकल्प है लागू करने को कोई फ़ैसला ही न होना। इजाज़त वाले पोर्टों की सूची के रूप में लिखी गई egress पॉलिसी पोर्ट नंबरों की पॉलिसी है। वह कभी इस बारे में पॉलिसी नहीं थी कि क्या बाहर जाता है, और जब किसी के पास root हो, तो वह सिर्फ़ पोर्ट नंबरों की रक्षा करती है।
यह वही नतीजा है जो ping वाली पोस्ट में है, जो ICMP echo से टनल बनाती है, और protocol helpers वाली पोस्ट में, जहाँ आपका फ़ायरवॉल खुद छेद खोलता है। अंदर आने के तीन रास्ते, एक निष्कर्ष: जो कंट्रोल आपको लगा कि आपके पास है वह प्रोटोकॉल पर था, और इनमें से एक भी प्रोटोकॉल वह नहीं है जो वह कहता है। पहले से तय किया गया, default-deny वाला बॉर्डर ही वह अकेला कंट्रोल है जो कभी असली था।
प्रॉक्सी दो कनेक्शन और एक पाइप है
यह देखना फ़ायदेमंद है कि relay कितनी छोटी चीज़ है, क्योंकि इससे समझ आता है कि आप पास वाले सिरे से दूर वाले सिरे के बारे में क्यों नहीं सोच सकते। प्रॉक्सी कोई खास सॉफ़्टवेयर नहीं है। यह एक कनेक्शन है जो एक पाइप से दूसरे से जुड़ा है। सबसे पुराना रूप वापसी की दिशा ढोने के लिए एक named pipe, यानी FIFO, इस्तेमाल करता है: एक ncat listen करता है, दूसरा आगे कनेक्ट करता है, और FIFO उनके बीच जवाब का रास्ता जोड़ता है।
mkfifo backpipe
ncat -l 7000 0<backpipe | ncat farend.example.net 7100 1>backpipe
इसे पाइपलाइन की तरह पढ़िए: listener का आउटपुट दूसरे ncat में जाता है और आगे दूर वाले सिरे तक, और जवाब FIFO से होकर क्लाइंट के पास लौटते हैं। दो सॉकेट, एक पाइप, दोनों दिशाएँ, और क्लाइंट का कनेक्शन यहीं, relay पर खत्म होता है, जबकि पैकेट farend तक और वापस जाते रहते हैं। मैंने loopback पर ठीक यही चलाया, दूर वाले सिरे पर एक तीसरा ncat echo कर रहा था, और भेजी गई एक लाइन पूरा चक्कर लगाकर वापस आई।
Ncat यही काम एक प्रोसेस में करेगा, हर आने वाले क्लाइंट के लिए आगे का कनेक्शन exec करके:
ncat -l 7000 --keep-open --sh-exec 'ncat farend.example.net 7100'
वही आकार, कम पुर्ज़े: listener का सॉकेट exec किए गए ncat के सॉकेट से उस पाइप से जुड़ता है जो shell उनके बीच लगाता है। तीन जोड़ दीजिए और टनल तीन नेटवर्क पार करता है, हर एक पर खत्म होकर फिर से शुरू होता है, और हर hop का फ़ायरवॉल अगले तक एक साफ़-सुथरा लोकल कनेक्शन लॉग करता है और उसके आगे कुछ नहीं।
पूरी तरकीब यही है, और इसीलिए बॉर्डर लॉग किसी गंतव्य का सबूत नहीं है। हर relay उससे पहले वाले बॉक्स के लिए, जहाँ तक वह बता सकता है, दूर वाला सिरा है, और असली दूसरा सिरा उतने पाइप दूर है जितनों पर कोई नज़र नहीं रख रहा था।
अब उन relay को ऐसी मशीनों पर रखिए जो अटैकर की नहीं हैं।
उस चेन पर हर मालिक बस पिछले hop से अगले hop तक एक कनेक्शन देखता है: न शुरुआत, न मंज़िल, बस बीच। यह कोई नया विचार नहीं जो मैं किसी को थमा रहा हूँ। pivot chain और C2 नेटवर्क बीस साल से ऐसे ही काम करते आए हैं, और इसीलिए compromised होस्ट का आउटबाउंड ट्रैफ़िक अक्सर अटैकर तक नहीं, किसी और शिकार तक ले जाता है। आपके लॉग दिखाते हैं कि आपने किसी डेटा सेंटर में कहीं एक बॉक्स से बात की। किसका, और वह आगे किसे फ़ॉरवर्ड करता है, यह उनमें कभी था ही नहीं।
बचाव की तरफ़ से इसका वज़न एक लाइन है: जिस गंतव्य को आपने पहले से सीमित नहीं किया, उसका न आप पता लगा सकते हैं, न उस पर भरोसा कर सकते हैं। जब तक ट्रैफ़िक बाहर जा रहा होता है, जिस एड्रेस पर वह जाता है वह आपको लगभग कुछ नहीं बताता, क्योंकि वह किसी और की मशीन पर एक relay है और असली एंडपॉइंट उसके पीछे धुलकर छिपा है।
लिंक कभी प्रोडक्ट था ही नहीं
इसे खोलकर अलग करने के बाद जो बात मुझे खटकती है वह यह कि इसमें कितना कम नया है और कितना ज़्यादा बेचा जाता है।
RFC 1661 1994 का है। pppd तीस साल से हर Linux डिस्ट्रीब्यूशन में है, kernel मॉड्यूल एक डायरेक्टरी में आठ फ़ाइलें हैं, और VPN को VPN बनाने वाली पूरी चीज़ (एक वर्चुअल इंटरफ़ेस, एक नेगोशिएट किया लिंक, एक एन्क्रिप्टेड कैरियर, एक रूट) चार प्रोग्राम और एक सर्टिफ़िकेट है। इसमें से कुछ भी मुश्किल या गुप्त नहीं। उन्होंने हर बाइट डॉक्यूमेंट किया और मुफ़्त दे दिया, और आपके और उसके बीच एक पूरी इंडस्ट्री खड़ी हो गई जो वही चार पुर्ज़े एक डिब्बे में बेचती है, हर सीट के लाइसेंस और एक्सपायर होने वाले सपोर्ट कॉन्ट्रैक्ट के साथ। पुर्ज़े बेहतर नहीं हुए। बस लपेट दिए गए।
यह इसे प्रोडक्शन में चलाने का तर्क नहीं है। मैंने अभी आपसे कहा कि मत चलाइए। यह इस बात का तर्क है कि आप जो डिब्बा खरीदते हैं उसमें क्या है यह जानिए, क्योंकि जिस दिन वेंडर लाइसेंसिंग बदलता है, खरीद लिया जाता है, या आपका मॉडल बंद कर देता है, उस दिन एक खराब तिमाही और एक खराब साल के बीच का फ़र्क यही होता है कि आपके यहाँ किसी को पता है या नहीं कि वह चीज़ किससे बनी थी।
एक शाम निकालिए और पुर्ज़ों से टनल बनाइए। LCP को नेगोशिएट करते देखिए, लिंक तोड़िए और उसे वापस आते देखिए, सर्टिफ़िकेट हटाइए और देखिए क्या रुकता है। फिर अपने VPN वेंडर की datasheet दोबारा पढ़िए, और देखिए कि उसमें से कितना आप पहचानते हैं।
वही शाम दूसरा आधा हिस्सा भी खरीद देती है। अगर आपके नेटवर्क से बाहर एक रूट किया हुआ लिंक चार इंस्टॉल किए प्रोग्राम और एक सर्टिफ़िकेट है, तो जिस इंसान को अभी आपके किसी बॉक्स पर root मिला है उसे इस बात से नहीं रोका जा सकता कि टनल बनाना कितना मुश्किल है। यह मुश्किल नहीं है। उसे सिर्फ़ इससे रोका जा सकता है कि उसके आने से पहले आपने क्या बाहर जाने की इजाज़त तय की थी। इसे एक बार बनाइए और आप egress को ऐसी चीज़ समझना बंद कर देंगे जिसे कोई प्रोडक्ट लागू करता है, और उसे एक ऐसे फ़ैसले की तरह सोचने लगेंगे जो आपने या तो लिया या नहीं लिया।
इसमें जादू ज़्यादा नहीं है। ज़्यादातर यह 1994 है, ऊपर से रंग-रोगन, और 1994 में कोई बुराई नहीं। वह चलता था, डॉक्यूमेंटेड था, और आज भी चलता है।
RFC 1661 — The Point-to-Point Protocol (PPP), 1994। लिंक, LCP, और उसके ऊपर बैठने वाले नेटवर्क कंट्रोल प्रोटोकॉल के परिवार को परिभाषित करता है। ↩︎
RFC 2637 — Point-to-Point Tunneling Protocol (PPTP), जो PPP को GRE के अंदर ढोता है। ↩︎
RFC 3931 — Layer Two Tunneling Protocol version 3, उस प्रोटोकॉल का standards-track वंशज जो PPP को UDP के अंदर ढोता है। ↩︎
pppd(8) — PPP डेमन का manual page।
pty,notty,local,passive,noipdefault,proxyarp,record,receive-all, LCP echo ऑप्शन, और asyncmap डिफ़ॉल्ट का स्रोत: “If no asyncmap option is given, the default is zero, so pppd will ask the peer not to escape any control characters.” यहाँ के उद्धरण ppp 2.5.1 परman pppdसे पढ़े गए। ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎RFC 1662 — PPP in HDLC-like Framing। flag sequence, octet-stuffing का नियम और 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 — retransmission के एक के ऊपर एक चढ़ने की मानक व्याख्या, जो ठीक इसी बिल्ड से शुरू होती है। मूल URL अब यह लेख नहीं देता; यह Internet Archive का कैप्चर है। ↩︎
RFC 5072 — IP Version 6 over PPP। IPV6CP और 64-bit इंटरफ़ेस आइडेंटिफ़ायर, IPCP से स्वतंत्र। ↩︎
RFC 1332 — The PPP Internet Protocol Control Protocol (IPCP), जो लिंक के हर सिरे पर IPv4 एड्रेस नेगोशिएट करता है। ↩︎
RFC 1994 — PPP Challenge Handshake Authentication Protocol (CHAP)। पीयर की पहचान साबित करता है; कुछ भी एन्क्रिप्ट नहीं करता। ↩︎
RFC 3079 — Deriving Keys for use with Microsoft Point-to-Point Encryption (MPPE)। MS-CHAP एक्सचेंज से key किया गया RC4 ढाँचा, और वजह कि PPTP अब कोई जीवित विकल्प नहीं। ↩︎
Ncat Users’ Guide — connecting through a proxy — HTTP CONNECT और SOCKS 4/5 के लिए
--proxyऔर--proxy-type, ताकि TLS कैरियर प्रॉक्सी पर खत्म हो, टनल के दूर वाले सिरे पर नहीं। ↩︎Ncat Users’ Guide —
--ssl,--ssl-verifyऔर--ssl-trustfileऑप्शन, और listen व UDP मोड। यहाँ टेस्ट किया गया वर्ज़न: Ncat 7.92। ↩︎Universal TUN/TAP device driver —
/dev/net/tun,TUNSETIFF, और tun व tap के फ़र्क पर kernel का अपना डॉक्यूमेंटेशन। ↩︎PEP 784 — Adding Zstandard to the standard library, इसीलिए Python 3.14 पर
compression.zstdके लिए कोई पैकेज नहीं चाहिए। यहाँ Python 3.14.7 और zstd 1.5.7 पर मापा गया। ↩︎zstd(1) —
--trainमोड और--maxdict, वह dictionary बनाने के लिए जो दोनों सिरों को लोड करनी होती है। ↩︎RFC 7457 — Summarizing Known Attacks on TLS and DTLS, जो CRIME और compression-before-encryption वाले length leak के सामान्य आकार को कवर करता है। ↩︎
OpenVPN — the VORACLE attack — वही लीक, उस VPN के खिलाफ़ जो एन्क्रिप्ट करने से पहले कम्प्रेस करता है, और वजह कि OpenVPN अब कम्प्रेशन के खिलाफ़ सलाह देता है। ↩︎