पाठ्यक्रम 156 में से पाठ 56 · निजता मापें, ईमानदारी से
निजता मापें, ईमानदारी से

बचाव

यह क्यों मायने रखता है पिछले तीन पाठों ने दिखाया कि नाम fingerprints, quasi-identifiers और hashes से वापस आते हैं। ये रहे वे औज़ार जो सचमुच मदद करते हैं जब आप कुछ ऐसा बनाते हैं जो लोगों के बारे में डेटा रखता या साझा करता है। हर एक सरल है, और हर एक की एक क़ीमत है जो आपको पता होनी चाहिए।

चार औज़ार, एक विचार: कम विवरण साझा करें

एक स्कूल के परीक्षा नतीजे प्रकाशित करने की सोचें। हर छात्र के अंक सूचीबद्ध करना, नामों के बिना भी, सहपाठियों को समझने देता है कि कौन कौन है। "कक्षा का औसत 64 था, और 3 छात्रों को सबसे ऊँचे अंक मिले" कहना माता-पिता को उनकी ज़रूरत की बात बहुत कम जोखिम के साथ बताता है। यहाँ का हर औज़ार उसी का एक रूप है।

1. Keyed hashing (एक गुप्त salt)

Salt: hash से पहले input में मिलाया गया अतिरिक्त टेक्स्ट, ताकि एक ही email एक अलग hash दे। जब salt एक संगठन के पास रखा राज़ हो, तो उसे अक्सर key या pepper कहते हैं।

HMAC: एक गुप्त key के साथ hash बनाने का एक मानक तरीका। Python में यह पहले से बना है: hmac.new(key, message, hashlib.sha256).hexdigest()।

पिछले पाठ की lookup table सिर्फ़ इसलिए काम करती है क्योंकि कोई भी sha256(email) निकाल सकता है। एक गुप्त key के साथ, एक बाहरी व्यक्ति candidate emails के hashes नहीं निकाल सकता, इसलिए table बेकार है। क़ीमत: दो कंपनियाँ अब ग्राहक नहीं मिला सकतीं जब तक वे key साझा न करें, जो अक्सर ठीक यही मक़सद है। और यह सिर्फ़ बाहरी लोगों से बचाता है: जिसके पास key है वह फिर भी brute-force कर सकता है।

2. सामान्य करें, फिर दबाएँ: k तक पहुँचना

Generalisation: ठीक मानों को मोटे मानों से बदलना: zip 40113 बनता है 4011*, जन्म तारीख़ 1987-03-03 बनती है 1980s।

मोटे मान बड़े समूह बनाते हैं। पर कुछ समूह छोटे रहते हैं (हमारे डेटा में, लिंग X वाले लोग दुर्लभ हैं)। तो दूसरा क़दम suppression है: उन rows को छोड़ दें जिनका समूह k से छोटा है। दोनों क़दमों के बाद, हर बचा मेल कम से कम k लोग साझा करते हैं। k चुनना (5 और 10 आम हैं) जोखिम के बारे में एक फ़ैसला है।

ईमानदार सीमाएँ: अगर एक समूह के सारे k लोगों का एक ही diagnosis है, तो समूह फिर भी उसे बताता है। और suppression सबसे दुर्लभ लोगों को हटाता है, जिनका डेटा शायद सबसे ज़्यादा मायने रखता है। k-anonymity जोखिम घटाती है; मिटाती नहीं।

3. Aggregation

अक्सर आपको rows की ज़रूरत ही नहीं होती। गिनतियाँ प्रकाशित करें: "asthma वाले 212 लोग"। इसे suppression ("10 से कम कोई गिनती प्रकाशित न करें") के साथ मिलाएँ और कई हमले ग़ायब हो जाते हैं, क्योंकि किसी सार्वजनिक सूची से जोड़ने के लिए कोई row नहीं है।

4. Differential privacy, नरमी से

गिनतियाँ फिर भी रिस सकती हैं। अगर कल की गिनती 212 थी और आज की 213, और आप जानते हैं कि एक व्यक्ति जुड़ा, तो आप उनका diagnosis जान लेते हैं। Differential privacy हर प्रकाशित संख्या में थोड़ा रैंडम शोर जोड़ती है, ताकि कोई अकेला व्यक्ति नतीजे को ऐसे न बदले जिसे कोई देख सके।

Differential privacy: एक वादा कि प्रकाशित नतीजे लगभग एक जैसे दिखेंगे चाहे किसी एक व्यक्ति का डेटा शामिल हो या नहीं। यह सावधानी से तय किए आकार का रैंडम शोर जोड़कर हासिल होता है।

Epsilon: निजता सेटिंग। छोटे epsilon का मतलब ज़्यादा शोर और ज़्यादा निजता; बड़े का मतलब ज़्यादा सटीकता और कम निजता।

क्लासिक शोर scale 1 / epsilon वाला Laplace वितरण है। एक साफ़ तरकीब इसे दो साधारण रैंडम draws से बनाती है: rng.expovariate(epsilon) - rng.expovariate(epsilon)। epsilon 1 के साथ प्रकाशित गिनती औसतन लगभग 1 से हटी होती है; epsilon 0.25 के साथ लगभग 4 से। बड़े समूहों पर औसत काम के रहते हैं, क्योंकि शोर उनकी तुलना में छोटा है और कट जाता है।

tests एक seeded random.Random object rng के रूप में देते हैं। सिर्फ़ वही object इस्तेमाल करना आपके शोर को दोहराने लायक बनाता है, ताकि अंक देना निष्पक्ष रहे। चरण 7 और गहरा जाता है: निजता budgets, और जब आप कई सवालों के जवाब दें तो क्या होता है।

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

"शोर डेटा बर्बाद कर देता है।" एक छोटे समूह के लिए करता है, जो मुद्दा है: वहीं व्यक्ति उजागर हो सकते थे। लोगों के असल में इस्तेमाल किए बड़े कुल योगों के लिए, कुछ इकाइयों का शोर मुश्किल से मायने रखता है।

आज़माएँ पास होने पर, epsilon 2, 0.5 और 0.1 हर एक के लिए noisy_count(212, epsilon, rng) दस बार बुलाएँ। जवाबों का फैलाव लिखें। 2,000 लोगों के एक क़स्बे की report के लिए आप कौन-सा epsilon स्वीकार करेंगे?

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

JavaScript (Node):

const { createHmac } = require("crypto");
const keyedHash = (email, key) =>
  createHmac("sha256", key).update(email.trim().toLowerCase()).digest("hex");

// Laplace noise from two exponential draws (use a seeded generator for tests)
const expo = (rate, rand) => -Math.log(1 - rand()) / rate;
const noisyCount = (n, eps, rand) => n + expo(eps, rand) - expo(eps, rand);

Go:

mac := hmac.New(sha256.New, []byte(key))
mac.Write([]byte(strings.ToLower(strings.TrimSpace(email))))
hash := hex.EncodeToString(mac.Sum(nil))

noisy := float64(count) + r.ExpFloat64()/eps - r.ExpFloat64()/eps

सार

  • एक गुप्त key (HMAC) बाहरी लोगों को hashed emails brute-force करने से रोकती है।
  • k-anonymity तक पहुँचने के लिए सामान्य करें, फिर छोटे समूह दबाएँ; यह जोखिम घटाती है, शून्य तक नहीं।
  • rows के बजाय गिनतियाँ प्रकाशित करें, और छोटी गिनतियाँ छिपाएँ।
  • Differential privacy scale 1/epsilon का शोर जोड़ती है: छोटे समूह धुंधले होते हैं, बड़े औसत काम के रहते हैं।
आपकी बारी

keyed_hash(email, key) (normalised email का HMAC-SHA256 hex, key UTF-8 के रूप में), generalise(row) (एक नया dict जिसमें zip = पहले 4 अंक और *, birth_decade जैसे "1980s", और gender और diagnosis बिना बदलाव), suppress_small(rows, columns, k) (क्रम में सिर्फ़ वे rows रखें जिनके बराबर columns मानों वाले समूह में कम से कम k rows हों) और noisy_count(true_count, epsilon, rng) (सिर्फ़ rng से खींचा scale 1/epsilon का Laplace शोर जोड़ें) लिखें।

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

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

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