पाठ्यक्रम 156 में से पाठ 50 · एक blocker बनाएँ
एक blocker बनाएँ

Fingerprinting को हराएँ

यह क्यों मायने रखता है एक fingerprinting script रोकना सिर्फ़ तब काम करता है जब आपकी सूची उसे जानती हो। गहरा बचाव गुणों को ही बेकार बनाना है, ताकि एक चलने वाली script भी कुछ ऐसा न सीखे जो आपको अलग करे। यह lab bits में मापता है कि वह असल में कितना मदद करता है।

सब एक ही बरसाती में

एक भीड़ की तस्वीर बनाएँ जहाँ हर कोई एक ही धूसर बरसाती और टोपी पहनता है। एक व्यक्ति को पहचानना कठिन है, इसलिए नहीं कि आप उन्हें देख नहीं सकते, बल्कि क्योंकि वे सब एक जैसे दिखते हैं। यह uniformity है: ब्राउज़र बचाव इस्तेमाल करने वाले बाक़ी सबके जैसे ही मान बताता है।

Fingerprint: गुणों का वह set जो एक पन्ना आपके ब्राउज़र के बारे में पढ़ सकता है (screen आकार, time zone, fonts, graphics card वग़ैरह)। साथ में वे बिना किसी cookie के एक ब्राउज़र पहचान सकते हैं।

Uniformity: एक बचाव जहाँ ब्राउज़र उसी बचाव के हर दूसरे उपयोगकर्ता जैसे ही तय मान बताता है। Tor Browser सबसे जाना-माना उदाहरण है; Safari भी जो बताता है उसे घटाता है (अक्टूबर 2026 में जाँचा)।

दूसरा मुख्य बचाव randomisation है (Brave और Floati इसे farbling कहते हैं): छोटा, बदलता शोर जोड़ें ताकि गुण हर साइट पर अलग हो। यह lab uniformity आज़माता है।

bits में मापना

चरण 1 में आप पहचान के bits से मिले: हर bit भीड़ को आधा करता है। एक भीड़ में एक व्यक्ति के लिए उन्हें मापने का यह एक निष्पक्ष तरीका है:

bits = log2( (crowd size + 1) / (people who look exactly like you + 1) )

+ 1 आपको भीड़ के एक सदस्य के रूप में गिनता है। अगर 5,000 की भीड़ में कोई आपके जैसा नहीं दिखता, तो यह log2(5001 / 1) है, लगभग 12.3 bits: अनोखा। अगर 4,999 लोग आपके जैसे दिखते हैं, तो यह log2(5001 / 5000) है, लगभग 0 bits।

योजना

  1. fingerprint_bits(crowd, fp): TRAIT_NAMES के हर गुण पर fp के बराबर rows गिनें, फिर सूत्र इस्तेमाल करें।
  2. make_uniform(traits): UNIFORM के हर गुण को बदलकर एक प्रति लौटाएँ। dict(traits) एक प्रति बनाता है; copy.update(UNIFORM) उन keys को overwrite करता है।
  3. uniform_filter(traits, page): इसे Browser(world, trait_filter=uniform_filter) में लगाएँ और हर script uniform मान पढ़ती है।
  4. Sam (recorded_fingerprints()[0]) को 5,000 synthetic ब्राउज़रों में मापें, पहले और बाद।

क़दम 4 में एक ईमानदार विवरण: "बाद" वाली संख्या के लिए पूरी भीड़ पर भी make_uniform लागू करें। Uniformity आपको सिर्फ़ उसी बचाव का इस्तेमाल करने वाले दूसरे लोगों के बीच छिपाती है। अगर सिर्फ़ आप धूसर बरसाती पहनें, तो आप कम नहीं, ज़्यादा अलग दिखते हैं।

संख्याएँ आपको क्या बताएँगी

आप कई bits हटाएँगे, पर सब नहीं। Sam फिर भी एक Linux सिस्टम और एक कम आम ब्राउज़र बताता है, और वे दो गुण अकेले एक छोटे समूह को अलग करते हैं। यह uniformity का असली सबक़ है: यह सबसे अच्छा तब काम करती है जब सब कुछ एक जैसा हो, ब्राउज़र ख़ुद भी। इसीलिए Tor Browser हर उपयोगकर्ता को एक ही तरह के सिस्टम पर एक ही ब्राउज़र जैसा दिखाता है, और इसीलिए यह window का आकार कुछ मानक क़दमों तक गोल करता है (letterboxing)।

एक आम ग़लतफ़हमी

"एक दुर्लभ मान नक़ली बनाना मुझे छिपाता है।" एक बनावटी मान जो कोई असली ब्राउज़र नहीं बताता, या एक मेल जो साथ नहीं बैठता (Windows पर एक Mac graphics card), आपको ज़्यादा अनोखा बना सकता है। अच्छे बचाव ऐसे मान चुनते हैं जो कई असली उपयोगकर्ता साझा करते हैं, और उन्हें साथ बदलते हैं।

आज़माएँ पास होने के बाद, UNIFORM से "timezone" हटाएँ और अपना code फिर चलाएँ। after_bits को बढ़ते देखें: एक साधारण दिखता गुण असली bits के बराबर है।

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

JavaScript:

const UNIFORM = { screen: "1920x1080", timezone: "Etc/UTC", language: "en-US" };

// Copy, then overwrite: the original object is untouched.
const makeUniform = traits => ({ ...traits, ...UNIFORM });

function fingerprintBits(crowd, fp, names) {
  const same = crowd.filter(r => names.every(t => r[t] === fp[t])).length;
  return Math.log2((crowd.length + 1) / (same + 1));
}

Rust:

fn fingerprint_bits(crowd: &[Vec<String>], fp: &[String]) -> f64 {
    let same = crowd.iter().filter(|r| r.as_slice() == fp).count();
    ((crowd.len() + 1) as f64 / (same + 1) as f64).log2()
}

सार

  • Uniformity कई उपयोगकर्ताओं से एक जैसे मान बतवाकर आपको छिपाती है।
  • bits को log2((crowd + 1) / (look-alikes + 1)) के रूप में मापें, ख़ुद को भीड़ में गिनते हुए।
  • यह सिर्फ़ उसी बचाव का इस्तेमाल करने वाले लोगों के बीच काम करती है, और बचे गुण (ब्राउज़र, सिस्टम) फिर भी bits रिसाते हैं।
  • दुर्लभ या असंगत नक़ली मान आपको ज़्यादा अलग दिखा सकते हैं।
आपकी बारी

UNIFORM रखें। fingerprint_bits(crowd, fp) (TRAIT_NAMES के हर गुण पर fp के बराबर rows को same के रूप में गिनें, log2((len(crowd) + 1) / (same + 1)) लौटाएँ), make_uniform(traits) (हर UNIFORM key बदलकर एक नया dict; input बिना बदले) और uniform_filter(traits, page) (make_uniform(traits) लौटाता है) लिखें। फिर before_bits (crowd में Sam), after_bits (एक ऐसी भीड़ में uniform Sam जहाँ हर row make_uniform से गुज़री) और bits_removed सेट करें।

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

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

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