पाठ्यक्रम 156 में से पाठ 102 · Packets, DNS और IP addresses
Packets, DNS और IP addresses

Relays और VPNs, ईमानदारी से

यह क्यों मायने रखता है VPNs, Tor और two-hop relays सब "निजता" के रूप में बेचे जाते हैं, और वे बहुत अलग चीज़ों की रक्षा करते हैं। इनमें से किसी से भी पूछने लायक ईमानदार सवाल है: क्या कोई अकेला पक्ष यह दोनों जानता है कि मैं कौन हूँ और मैं कहाँ जाता हूँ? आप एक छोटा मॉडल बनाएँगे जो किसी भी route के लिए इसका जवाब दे।

पाठ 86 ने VPN के साथ और बिना जीवन की तुलना की। यहाँ आप आगे जाते हैं और कई औज़ारों को साथ-साथ मॉडल करते हैं।

कक्षा में एक पर्ची आगे बढ़ाने की कल्पना करें। अगर आप उसे एक दोस्त को देते हैं जो उसे पाने वाले तक ले जाता है, तो वह दोस्त जानता है कि किसने भेजी और किसे मिली। अगर वह दो दोस्तों से गुज़रती है, और पर्ची ऐसे मुड़ी है कि पहला बस "Bea को दो" देखे और दूसरा बस "Sol को दो" देखे, तो कोई भी दोस्त दोनों छोर नहीं जानता।

Relay: एक server जो आपका traffic पाता है और आगे भेजता है। हर relay देखता है कि एक packet कहाँ से आया (पिछला hop) और आगे कहाँ जाता है (अगला hop)।

VPN: एक relay, एक कंपनी का चलाया: यह आपका IP address और आपकी पहुँची साइटें देखता है।

Two-hop relay: अलग कंपनियों के चलाए दो relays। पहला (ingress) आपका IP देखता है पर सिर्फ़ अगला relay जानता है; दूसरा (egress) साइट देखता है पर सिर्फ़ पहला relay जानता है। iCloud Private Relay एक जाना-माना उदाहरण है।

Tor: volunteer relays का एक मुफ़्त network। आपका traffic तीन से गुज़रता है: एक guard, एक middle और एक exit, encryption की परतों (onion routing) में लिपटा, ताकि कोई अकेला relay दोनों छोर न देखे। चरण 7 एक circuit क़दम दर क़दम बनाता है।

तथ्य, तारीख़ के साथ

iCloud Private Relay (Apple के paid iCloud+ plan का हिस्सा) Safari में browsing, DNS lookups, और ऐप्स से कुछ unencrypted traffic ढकता है (अक्टूबर 2026 में जाँचा)। इसका दूसरा hop साझेदार content delivery networks (कंपनियाँ जो वेबसाइटें जल्दी पहुँचाने के लिए दुनिया भर में servers चलाती हैं) चलाते हैं, Apple नहीं। यह एक पूरा VPN नहीं है: दूसरे ब्राउज़र और ज़्यादातर ऐप traffic इससे नहीं गुज़रते।

एक VPN आमतौर पर आपके device का भेजा सब कुछ ढकता है, पर VPN कंपनी वह देखती है जो पहले आपका प्रदाता देखता था। Tor Browser अपना traffic Tor से भेजता है और अपने उपयोगकर्ताओं को एक जैसा भी दिखाता है, जो fingerprints के लिए मायने रखता है (अगला मॉड्यूल, Network fingerprints)।

मॉडल के नियम

एक route आपके और वेबसाइट के बीच के पक्षों की एक सूची है, वेबसाइट पर ख़त्म होती, उदाहरण के लिए ["vpn", "shopb.example"]। हमेशा "network" भी होता है: आपका Wi-Fi और प्रदाता, जो आपके packets को पहले hop तक ले जाते हैं। तीन तथ्य हैं जो कोई भी जान सकता है: "your_ip", "site" (आप कौन-सी वेबसाइट देखते हैं) और "content" (आप क्या पढ़ते और भेजते हैं)।

  • network हमेशा your_ip देखता है। यह site सिर्फ़ तब देखता है जब आप सीधे वेबसाइट से जुड़ते हैं (route में बस एक entry है), और content सिर्फ़ तब जब, साथ ही, HTTPS बंद हो।
  • पहला relay your_ip देखता है, क्योंकि packets सीधे आपसे आते हैं।
  • आख़िरी relay (वेबसाइट से ठीक पहले वाला) site देखता है, क्योंकि उसे उससे जुड़ना होता है। HTTPS के बिना वह content भी देखता है।
  • वेबसाइट हमेशा site और content देखती है, और your_ip सिर्फ़ तब देखती है जब आप सीधे जुड़ते हैं।
  • एक बीच का relay कोई भी छोर नहीं देखता।

एक-relay route (एक VPN) पहले और आख़िरी relay को एक ही बना देता है, इसलिए वह दोनों जानता है। यही इस पाठ का पूरा सार है, इन कुछ नियमों से निकलता।

Python में तथ्यों का एक set {"your_ip", "site"} लिखा जा सकता है, और एक ख़ाली set set() है ({} नहीं, जो एक ख़ाली dict है)। enumerate(route) हर स्थान और नाम देता है: for i, name in enumerate(route):।

दूसरी भाषाओं में

मूल जाँच, "क्या कोई दोनों छोर जानता है?", दूसरी भाषाओं में:

// JavaScript
const linkers = view => Object.keys(view)
  .filter(p => view[p].has("your_ip") && view[p].has("site"))
  .sort();
// Rust
let mut linkers: Vec<&String> = view.iter()
    .filter(|(_, facts)| facts.contains("your_ip") && facts.contains("site"))
    .map(|(party, _)| party)
    .collect();
linkers.sort();
// C#
var linkers = view.Where(kv => kv.Value.Contains("your_ip") && kv.Value.Contains("site"))
                  .Select(kv => kv.Key).OrderBy(k => k).ToList();

एक आम ग़लतफ़हमी: "दो hops का मतलब दोगुना encryption, इसलिए यह दोगुना सुरक्षित है"। फ़ायदा ज़्यादा encryption नहीं है; यह उन पक्षों के बीच जानकारी बाँटना है जो नोट साझा नहीं करते। अगर एक कंपनी दोनों hops चलाती, तो वह फिर से दोनों छोर जान लेती। और कोई relay cookies, logins या fingerprints नहीं रोकता।

सार

  • एक VPN एक relay है: यह आपका IP और आपकी देखी साइटें दोनों जानता है।
  • Two-hop relays और Tor उस जानकारी को बाँटते हैं ताकि किसी अकेले relay के पास दोनों न हों।
  • iCloud Private Relay Safari, DNS और कुछ unencrypted ऐप traffic ढकता है; यह पूरा VPN नहीं है (अक्टूबर 2026 में जाँचा)।
  • इनमें से कोई भी cookies, logins या fingerprinting नहीं रोकता।
आपकी बारी

मॉडल करें कि कौन क्या जानता है। तीन functions लिखें:

  1. who_learns(route, https=True): एक dict लौटाएँ जो "network" और route के हर नाम को उन तथ्यों के एक set से जोड़े जो वह पक्ष जानता है ("your_ip", "site", "content"), पाठ के नियमों के अनुसार। route का आख़िरी नाम हमेशा वेबसाइट है।
  2. linkers(view): view के उन पक्षों की एक sorted सूची लौटाएँ जो "your_ip" और "site" दोनों जानते हैं।
  3. compare(setups, https=True): setups एक नाम को एक route से जोड़ता है; एक dict लौटाएँ जो हर नाम को linkers(who_learns(route, https)) से जोड़े।
table की printing आपके लिए लिखी है। Tests बनावटी नामों के साथ हर लंबाई के routes आज़माते हैं।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।