पाठ्यक्रम 156 में से पाठ 142 · गुमनामी networks और traffic analysis
गुमनामी networks और traffic analysis

Traffic analysis

यह क्यों मायने रखता है Encryption छिपाता है कि आप क्या कहते हैं, पर यह नहीं कि आप कब कहते हैं या कितना। सिर्फ़ traffic के समय पर नज़र रखना बता सकता है कि कौन किससे बात करता है, एक गुमनामी network से भी। इसे simulated flows पर काम करते देखना साफ़ करता है कि Tor क्या वादा कर सकता है और क्या नहीं, और सबसे मज़बूत बचाव इतना महँगा क्यों है।

कल्पना करें कि आप किसी की डाक नहीं खोल सकते, पर दो डाकघरों पर खड़े हो सकते हैं। हर बार जब Ana के घर से चिट्ठियों की एक बौछार निकलती है, एक मिलती-जुलती बौछार एक पल बाद एक clinic पहुँचती है। आपने एक शब्द नहीं पढ़ा, फिर भी आप अंदाज़ा लगा सकते हैं कि Ana clinic को लिखती है।

Metadata: एक संदेश की सामग्री के बजाय उसके बारे में डेटा: वह कब भेजा गया, कितना बड़ा था, कहाँ से आया और कहाँ गया।

Traffic analysis: सामग्री पढ़े बिना संचार के pattern (समय, आकार, मात्राएँ) से बातें जानना।

स्थिति

एक देखने वाला दो जगहों पर नज़र रखता है: उपयोगकर्ताओं और उनके guard के बीच की कड़ी, और exits और वेबसाइटों के बीच की कड़ी। watched.leg7b_onion में function tor_flows(seed) आपको दोनों की simulated रिकॉर्डिंग देता है। हर packet एक cell है, Tor की traffic की तय आकार वाली इकाई (514 bytes), इसलिए आकार आपको कुछ नहीं बताता। आपके पास बस समय है। दोनों ओर के flow नाम फेंटे गए हैं, और exit वाली ओर थोड़ी देर से है।

from watched.leg7b_onion import tor_flows
flows = tor_flows(seed=1)
print(flows["entry"][0]["flow"])          # e01
print(flows["entry"][0]["packets"][:3])   # [(time_in_seconds, size), ...]
print(flows["exit"][0]["flow"])           # x01, but which user is it?
# flows["answers"] holds the truth, so you can score your guesses.

क़दम 1: packets को एक आकार में बदलें

गिनें कि हर सेकंड में कितने packets आते हैं: सेकंड 0 में 0 से 1 तक (1 शामिल नहीं) के समय हैं, और ऐसे ही आगे। int(t) वह सेकंड देता है जिसका एक समय है। एक flow [0, 7, 9, 1, 0, 0, 6, ...] जैसी एक सूची बन जाता है: समय के साथ उसका आकार।

क़दम 2: दो आकारों की तुलना करें

Correlation: -1 से 1 तक की एक संख्या जो बताती है कि दो सूचियाँ कितना साथ उठती-गिरती हैं। 1 का मतलब पूरी तरह क़दम मिलाकर, 0 का मतलब कोई संबंध नहीं। Python में यह पहले से बना है: statistics.correlation(a, b)।

अगर एक सूची कभी नहीं बदलती (हर मान बराबर), तो correlation अपरिभाषित है और Python statistics.StatisticsError उठाता है। उसे पकड़ें और 0.0 इस्तेमाल करें, जिसका मतलब है "किसी भी ओर कोई सबूत नहीं"।

import statistics
print(statistics.correlation([1, 5, 2, 8], [2, 9, 3, 15]))   # close to 1: in step
try:
    statistics.correlation([3, 3, 3], [1, 2, 3])
except statistics.StatisticsError:
    print("a flat list has no correlation")

क़दम 3: हर entry flow को उसके सबसे मिलते-जुलते exit flow से मिलाएँ

हर entry flow के लिए हर exit flow आज़माएँ और सबसे ऊँचे correlation वाला रखें। इस simulation में अकेले यही लगभग सबको सही जोड़ देता है। शोधकर्ताओं के अध्ययन किए इस तरह के असली हमले इसी भावना से काम करते हैं।

बचाव, और उनकी क़ीमत

  • रैंडम cover traffic: रैंडम समयों पर नक़ली cells जोड़ें। यह आकार को थोड़ा धुंधला करता है, पर बौछारें फिर भी उभरती हैं। आप देखेंगे कि यह मुश्किल से मदद करता है।
  • स्थिर दर: हर सेकंड ठीक उतने ही cells भेजें, ख़ाली जगहें dummies से भरते हुए और असली cells को अपनी बारी का इंतज़ार कराते हुए। हर सेकंड एक जैसा दिखता है, इसलिए आकार ग़ायब हो जाता है। क़ीमत bandwidth (वे सारे dummies) और देरी है (बौछारों के दौरान cells कतार में लगते हैं)।

Tor मोटे connection records को धुंधला करने के लिए थोड़ा padding जोड़ता है, पर यह आपके traffic का आकार दोनों छोरों पर नज़र रख सकने वाले से नहीं छिपाता (अक्टूबर 2026 में जाँचा)। यह कम देरी चुनता है ताकि वेब इस्तेमाल लायक रहे। इस मॉड्यूल का आख़िरी पाठ उन networks को देखता है जो दूसरा रास्ता चुनते हैं।

एक आम ग़लतफ़हमी: "अगर सब कुछ encrypted है, तो कोई नहीं बता सकता कि मैं किससे बात करता हूँ।" Encryption सामग्री छिपाता है। समय और मात्रा फिर भी दिखते हैं, और वे अक्सर काफ़ी होते हैं।

यह lab सिर्फ़ simulated flows इस्तेमाल करता है। यह जोखिम समझने के बारे में है ताकि आप बचावों को परख सकें; यह असली लोगों पर नज़र रखने का तरीका नहीं है, और असली networks कहीं ज़्यादा शोर वाले हैं।

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

हर सेकंड packets गिनना और एक correlation निकालना, कहीं और:

// JavaScript
function countsPerSecond(packets, seconds) {
  const counts = new Array(seconds).fill(0);
  for (const [t] of packets) if (t >= 0 && t < seconds) counts[Math.floor(t)]++;
  return counts;
}
function correlation(a, b) {
  const n = a.length, ma = a.reduce((x, y) => x + y) / n, mb = b.reduce((x, y) => x + y) / n;
  let num = 0, da = 0, db = 0;
  for (let i = 0; i < n; i++) { num += (a[i]-ma)*(b[i]-mb); da += (a[i]-ma)**2; db += (b[i]-mb)**2; }
  return da && db ? num / Math.sqrt(da * db) : 0;
}
// Go
func countsPerSecond(times []float64, seconds int) []int {
    counts := make([]int, seconds)
    for _, t := range times {
        if t >= 0 && t < float64(seconds) { counts[int(t)]++ }
    }
    return counts
}

सार

  • Encryption सामग्री छिपाता है, समय या मात्रा (metadata) नहीं।
  • हर सेकंड packets गिनना हर flow को एक आकार देता है; correlation दोनों छोरों पर मेल खाते आकार ढूँढता है।
  • रैंडम cover traffic मुश्किल से मदद करता है; स्थिर-दर भेजना आकार छिपाता है पर bandwidth और देरी की क़ीमत लेता है।
  • Tor कम देरी को तरजीह देता है, इसलिए वह दोनों छोरों पर नज़र रखने वाले को नहीं रोक सकता।
आपकी बारी

चार functions लिखें, फिर उन्हें tor_flows(seed=1) पर इस्तेमाल करें:

  1. counts_per_second(packets, seconds): seconds संख्याओं की एक सूची, उन packets की गिनती जिनका समय t 0 <= t < seconds को पूरा करता है, index int(t) पर रखी।
  2. similarity(a, b): statistics.correlation(a, b), या 0.0 अगर वह statistics.StatisticsError उठाए।
  3. match(entry, exits, seconds): एक dict जो हर entry flow की "flow" id को सबसे ऊँची similarity वाले exit flow की id से जोड़े।
  4. accuracy(guesses, answers): answers की ids का वह हिस्सा जो आपके अनुमानों ने सही पाया।
फिर acc_plain (कोई बचाव नहीं), acc_cover (add_cover_traffic(flows["entry"], rate=20, seed=1, seconds=S) के बाद entry वाली ओर) और acc_constant (constant_rate(flows["entry"], per_second=10, seconds=S) के बाद entry वाली ओर) सेट करें। Tests नई रिकॉर्डिंग भी इस्तेमाल करते हैं।

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

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

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