Secure aggregation
यह क्यों मायने रखता है एक fitness ऐप एक शहर में चले कुल क़दम चाहता है; एक keyboard बनाने वाला जानना चाहता है कि सारे फ़ोनों पर एक शब्द कितनी बार type होता है। हर मामले में कंपनी को कई devices से एक संख्या चाहिए। Secure aggregation उसे किसी एक व्यक्ति का मान देखे बिना वह कुल जानने देता है, और यह हैरानी की हद तक सादा है।
सीखने का crypto, सुरक्षित नहीं: इस module के labs की संख्याएँ पढ़ने लायक छोटी हैं और बेतरतीबी seeded है ताकि grading दोहराने लायक हो। असली सिस्टम जाँची libraries और कहीं बड़ी संख्याएँ इस्तेमाल करते हैं। सीखने का code कभी एक product में copy न करें।
वेतन वाली तरकीब
तीन दोस्त अपना औसत वेतन चाहते हैं बिना किसी के अपना बताए। पहली अपने वेतन में एक बड़ी बेतरतीब संख्या जोड़कर नतीजा दूसरे के कान में कहती है। वह अपना वेतन जोड़कर आगे कहता है। तीसरी अपना जोड़कर उसे वापस देती है। पहली अपनी बेतरतीब संख्या घटाती है, और कुल निकल आता है। हर फुसफुसाहट सुनने वाले को एक बेतरतीब संख्या जैसी लगी।
Secure aggregation: कई लोगों के मानों का एक कुल (या औसत) निकालना ताकि कोई भी अकेला मान किसी को न दिखे, उन्हें इकट्ठा करने वाले server समेत।
Additive secret sharing: एक गुप्त संख्या को कई shares में काटना जो अकेले बेतरतीब दिखते हैं पर जुड़कर रहस्य बनते हैं। कोई एक share, या कम से कम एक share से वंचित कोई भी समूह, रहस्य के बारे में कुछ नहीं बताता।
Shares कैसे काम करते हैं
संख्या 7,350 को तीन shares में बाँटने के लिए, दो बेतरतीब संख्याएँ चुनें और तीसरी ऐसी चुनें कि तीनों जुड़कर 7,350 हों। घूमने वाले गणित (modulus M, यहाँ 2 की घात 32, 4 अरब से थोड़ा ज़्यादा) के साथ, हर share अकेले एक समान रूप से बेतरतीब संख्या है:
M = 2 ** 32
s1, s2 = 3919211450, 120775123 # random
s3 = (7350 - s1 - s2) % M # whatever makes it add up
print((s1 + s2 + s3) % M) # 7350
घुमाएँ क्यों? इसके बिना, एक share कभी-कभी ऋणात्मक या रहस्य के संदिग्ध रूप से क़रीब होता। इसके साथ, रहस्य चाहे जो हो हर share मान बराबर संभावित है, इसलिए एक अकेला share कोई जानकारी नहीं ले जाता।
कई devices, कई servers
अब हर फ़ोन अपनी क़दम गिनती को हर server के लिए एक share में बाँटता है और share 1 server 1 को, share 2 server 2 को, और ऐसे ही भेजता है। हर server अपने मिले shares जोड़ता है। हर server का कुल फिर भी बेतरतीब दिखता है। सिर्फ़ जब servers के कुल साथ जोड़े जाएँ तभी असली शहर का कुल दिखता है। जब तक servers एक फ़ोन के अपने कच्चे shares इकट्ठा न करें, किसी फ़ोन का मान कभी नहीं दिखता।
असली दुनिया का वर्ज़न
कई फ़ोनों के पार models train करने के लिए इस्तेमाल सिस्टम (जिन्हें federated learning कहते हैं) एक server के साथ एक ज़्यादा चतुर रूप इस्तेमाल करते हैं: devices के जोड़े बेतरतीब masks पर सहमत होते हैं जो सब कुछ जुड़ने पर कट जाते हैं, साथ में बीच में offline हुए फ़ोनों से निपटने के अतिरिक्त क़दम। मुख्य विचार वही है जो आप बनाएँगे: बेतरतीब दिखते टुकड़े जो सिर्फ़ साथ में समझ आते हैं।
Secure aggregation क्या नहीं करता
कुल ठीक-ठीक उजागर होता है। अगर सिर्फ़ दो लोगों ने योगदान दिया और एक अपना मान जानता है, तो वह उसे घटाकर दूसरे का जान सकता है। अगर कुल ख़ुद संवेदनशील है, तो उसमें differential privacy शोर भी जोड़ें। दोनों औज़ार साथ अच्छा काम करते हैं: aggregation inputs छिपाता है, DP output पर हर व्यक्ति का असर छिपाता है।
दूसरी भाषाओं में
JavaScript में बाँटना, >>> 0 के साथ 32-bit घुमाव और ब्राउज़र का सुरक्षित बेतरतीब स्रोत इस्तेमाल करते हुए:
function split(value, n) {
const shares = Array.from(crypto.getRandomValues(new Uint32Array(n - 1)));
const sum = shares.reduce((a, b) => (a + b) >>> 0, 0);
shares.push((value - sum) >>> 0);
return shares;
}और Rust में, जहाँ एक u32 पर wrapping_sub आपके लिए घुमाव करता है:
let last = value.wrapping_sub(shares.iter().fold(0u32, |a, &b| a.wrapping_add(b)));सार
- Secure aggregation एक कुल बताता है पर कोई अकेला योगदान नहीं।
- Additive secret sharing घूमने वाले गणित से एक मान को बेतरतीब दिखते shares में बाँटता है जो जुड़कर वह बनते हैं।
- हर server सिर्फ़ बेतरतीब दिखते shares देखता है; सिर्फ़ सारे server कुल साथ में जवाब देते हैं।
- कुल ख़ुद ठीक-ठीक उजागर होता है, इसलिए जब कुल किसी को उजागर कर सके तो उसे DP शोर के साथ जोड़ें।
अभ्यास दुनिया के M (2 की घात 32) का इस्तेमाल करते हुए तीन functions लिखें। split(value, n, rng) n shares की एक सूची लौटाता है: पहले n - 1 rng.randrange(M) से, आख़िरी (value - sum(shares)) % M के बराबर। combine(shares) sum(shares) % M लौटाता है। aggregate(values, n_servers, rng) हर मान को split से बाँटता है, share j को server_totals[j] में जोड़ता है (mod M), और एक tuple (total, server_totals) लौटाता है जहाँ total = combine(server_totals)।
इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें
यह अभ्यास जल्द खुलेगा
इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।
यह ब्राउज़र learn.floati.life के लिए कुकी रोक रहा है, इसलिए यहाँ पूरे किए गए पाठ क्रम से नहीं खुल सकते। इस साइट के लिए कुकी की अनुमति दें और फिर से लोड करें।