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

Website fingerprinting

यह क्यों मायने रखता है जब एक देखने वाला यह नहीं देख सकता कि आप कौन-सी साइट पर जाते हैं, तब भी एक पन्ने के load का आकार उसे बता सकता है: आप कितना भेजते हैं, कितना वापस आता है। यह lab दिखाता है कि वह अनुमान कैसे लगाया जाता है, padding उससे कैसे लड़ता है, और lab के नतीजे हमले को असल ज़िंदगी से ज़्यादा मज़बूत क्यों दिखाते हैं।

सादे भूरे कागज़ में लिपटे पार्सलों की सोचें। आप label नहीं पढ़ सकते, पर एक लंबा पतला पार्सल शायद एक poster है और एक भारी चौकोर शायद किताबें। पन्ने के loads ऐसे ही हैं: एक video साइट बहुत डेटा खींचती है, एक टेक्स्ट forum बहुत कम। आवरण सामग्री छिपाता है, आकार और रूप नहीं।

Website fingerprinting: सिर्फ़ किसी के encrypted traffic के pattern से अंदाज़ा लगाना कि उसने कौन-सी वेबसाइट load की, उसकी तुलना पहले दर्ज patterns से करके।

Cell: traffic की एक तय आकार वाली इकाई। इस lab में एक पन्ने का load cells की एक सूची है: आपके भेजे cell के लिए 1, आपके पाए cell के लिए -1।

एक सरल classifier: nearest centroid

पहले हर load को दो संख्याओं में घटाएँ, उसके features: बाहर जाने वाले cells और अंदर आने वाले cells। cells.count(1) और cells.count(-1) यह करते हैं। फिर हर साइट के लिए उसके training loads के features का औसत लें। वह औसत बिंदु साइट का centroid है, उसका आम आकार। एक नए load को classify करने के लिए, उसके सबसे पास का centroid ढूँढें।

Centroid: बिंदुओं के एक समूह का औसत: औसत x, औसत y। यहाँ, हर साइट के लिए एक।

import math
from watched.leg7b_onion import page_loads

data = page_loads(seed=3)          # {"train": [...], "test": [...]}
load = data["train"][0]
print(load["site"], len(load["cells"]))
print(math.dist((30, 400), (33, 420)))   # straight-line distance between two points
# min(sorted(model), key=lambda s: ...) picks the site with the smallest value,
# and on a tie the one that comes first alphabetically.

बचाव: padding

Padding dummy cells जोड़ता है ताकि loads अपनी साइट जैसे कम दिखें। FRONT नाम का शोध डिज़ाइन dummies की एक रैंडम संख्या जोड़ता है, ज़्यादातर एक load की शुरुआत के पास जहाँ एक पन्ना सबसे ज़्यादा बताता है। pad_traces(traces, budget, seed) हर load में हर दिशा में budget तक dummy cells जोड़ता है।

इसे निष्पक्ष रूप से मापने के लिए, मान लें कि देखने वाला जानता है कि आप pad करते हैं और padded loads पर भी train करता है। Padding हमले को हराने के बजाय accuracy घटाता है, और dummies की क़ीमत bandwidth है। आप दोनों मापेंगे: accuracy की गिरावट और overhead, मूल के हिस्से के रूप में अतिरिक्त cells:

overhead = total_cells_after_padding / total_cells_before - 1   # 0.5 means 50% more traffic

Tor के पास circuits को pad करने का एक ढाँचा है, पर website fingerprinting के ख़िलाफ़ भारी padding साधारण browsing के लिए चालू नहीं है (अक्टूबर 2026 में जाँचा), मुख्यतः इसी bandwidth क़ीमत के कारण।

lab हमले को बढ़ा-चढ़ाकर क्यों दिखाता है

यहाँ देखने वाला जानता है कि आप आठ साइटों में से एक पर जाते हैं। यह एक closed world है। असली लोग लाखों साइटों पर जाते हैं: एक open world। तब base rates असर दिखाते हैं। मान लें एक classifier एक संवेदनशील साइट को 95% बार सही चिह्नित करता है और 5% दूसरे loads को ग़लत चिह्नित करता है। अगर 1,000 में सिर्फ़ 1 load सचमुच उस साइट का है, तो 100,000 loads में से लगभग 95 असली visits चिह्नित होती हैं, साथ में लगभग 4,995 झूठे अलार्म। 98% से ज़्यादा अलार्म ग़लत हैं।

एक आम ग़लतफ़हमी: "Website fingerprinting का मतलब है Tor टूटा हुआ है।" इसका मतलब है एक ख़ास देखने वाला, जो आपके और आपके guard के बीच है, समझदारी भरे अनुमान लगा सकता है जो उलझी open world की तुलना में lab में कहीं बेहतर काम करते हैं। यह बचाव के लायक एक असली जोखिम है, हार मानने का कारण नहीं।

यहाँ के सारे loads simulated हैं। कोई असली traffic दर्ज या विश्लेषित नहीं होता।

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

nearest-centroid क़दम, कहीं और:

// JavaScript
function classify(model, cells) {
  const f = [cells.filter(c => c === 1).length, cells.filter(c => c === -1).length];
  let best = null, bestD = Infinity;
  for (const site of Object.keys(model).sort()) {
    const d = Math.hypot(f[0] - model[site][0], f[1] - model[site][1]);
    if (d < bestD) { best = site; bestD = d; }
  }
  return best;
}
// Rust
fn dist(c: &(f64, f64), out: f64, inc: f64) -> f64 {
    ((c.0 - out).powi(2) + (c.1 - inc).powi(2)).sqrt()
}

fn classify(model: &BTreeMap<String, (f64, f64)>, cells: &[i8]) -> String {
    let out = cells.iter().filter(|&&c| c == 1).count() as f64;
    let inc = cells.iter().filter(|&&c| c == -1).count() as f64;
    model.iter()
        .min_by(|a, b| dist(a.1, out, inc).partial_cmp(&dist(b.1, out, inc)).unwrap())
        .map(|(s, _)| s.clone()).unwrap()
}

सार

  • encrypted पन्ने के loads का फिर भी एक आकार होता है; आकारों की तुलना साइट का अंदाज़ा लगा सकती है।
  • Nearest centroid: हर साइट के features का औसत लें, फिर सबसे पास का औसत चुनें।
  • Padding हमले को हराने के बजाय accuracy घटाता है, और bandwidth की क़ीमत लेता है: दोनों मापें।
  • closed-world lab संख्याएँ असली हमलों को बढ़ा-चढ़ाकर दिखाती हैं, क्योंकि base rates बहुत झूठे अलार्म पैदा करते हैं।
आपकी बारी

चार functions लिखें:

  1. features(cells): tuple (outgoing, incoming), 1 और -1 की गिनतियाँ।
  2. train(traces): एक dict जो हर trace["site"] को उसके traces की औसत outgoing और औसत incoming गिनती से जोड़े।
  3. classify(model, cells): वह साइट जिसका centroid math.dist से सबसे पास है; min(sorted(model), key=...) इस्तेमाल करें ताकि बराबरी वर्णक्रम में पहली साइट को जाए।
  4. accuracy(model, traces): वह हिस्सा जो अपनी ही साइट के रूप में classify हुआ।
फिर acc_plain (data["train"] पर train, data["test"] पर test), acc_padded (padded_train पर एक नया model train करें, padded_test पर test) और overhead (padded_test के कुल cells भाग data["test"] के कुल cells, घटा 1) सेट करें। Tests दूसरे loads भी इस्तेमाल करते हैं।

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

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

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