बड़े एन्क्रिप्टेड डेटा पर होमोमोर्फिक संचालन लागू करें
वर्तमान में PALISADE लाइब्रेरी का उपयोग करके होमोमोर्फिक एन्क्रिप्शन पर प्रयोग कर रहे हैं ।
मैं सरल और बड़े एन्क्रिप्टेड इनपुट पर परिवर्धन और गुणा जैसे संचालन लागू करना चाहता हूं। उदाहरण के लिए इनपुट A[3200]
और इनपुट B[4096]
दोनों वैक्टर / सरणियों के अंतर मान एन्क्रिप्टेड हो जाते हैं। उन दो इनपुट के साथ Enc(A)
और Enc(B)
मैं एक गुणा लागू करना चाहता हूं:
EvalMult(Enc(A[0]), Enc(B[42]))
*0 and 42 denoting the indexes of the corresponding inputs
** no SIMD needed
जहां तक मेरा सवाल है, वह उपरोक्त वर्णित कार्यान्वयनों को दो अलग-अलग तरीकों से हल कर सकता है:
एकल सिफर (SIMD जैसे) में इनपुट पैक करें और उसके लिए मैं
EvalIndexAt()
एन्क्रिप्टेड इनपुट से सही मूल्य प्राप्त करने के लिए उपयोग कर सकता हूं ।प्रत्येक मान को A और B से अलग से एन्क्रिप्ट करें।
मुझे पूरा यकीन नहीं है कि वर्णित समाधान दक्षता के मामले में सबसे अच्छा क्या होगा । पहले दृष्टिकोण का यह प्रमुख लाभ है कि पूरे इनपुट के लिए केवल एक एन्क्रिप्शन प्रक्रिया की आवश्यकता होती है, लेकिन यह इस नुकसान के साथ आता है कि मुझे हमेशा EvalAtIndex()
विधि का उपयोग करके सही तत्व तक पहुंचना पड़ता है और बड़े इनपुट धीमे की गणना प्राप्त करते हैं EvalAtIndexKeyGen()
। (कम से कम मेरी मशीन पर)
दूसरे दृष्टिकोण को फिट बेहतर लगता है क्योंकि EvalAtIndex()
इसकी आवश्यकता नहीं है लेकिन यह प्रत्येक मूल्य को अलग-अलग एन्क्रिप्ट करने की लागत के साथ आता है जिसमें काफी समय लगता है।
किसी भी विचार सिफारिशें?
जवाब
सवाल के लिए आपका धन्यवाद।
दृष्टिकोण # 1 (SIMD) का मुख्य लाभ यह है कि आप एकल होमोमोर्फिक जोड़ या गुणा (बहुत कुशल) का उपयोग करके वैक्टर के जोड़ और गुणा (4096 या उससे अधिक पूर्णांक / वास्तविक संख्या) कर सकते हैं। रोटेशन ( EvalAtIndex
PALISADE में कहा जाता है) एक अतिरिक्त ऑपरेशन है जो एक व्यक्ति के इंडेक्स तक पहुंचने की अनुमति देता है या कुशल योग करता है (जैसा कि आंतरिक उत्पाद में है), मैट्रिक्स गुणन, आदि। इस दृष्टिकोण में एक बहुत छोटा सिफरटेक्स्ट एक्सपेंशन फैक्टर (4096 या उससे अधिक) है। दृष्टिकोण # 2। आमतौर पर विकल्प # 1 अभ्यास में पसंद किया जाता है (और मैं किसी भी वास्तविक उपयोग के मामले के बारे में नहीं सोच सकता हूं जहां मैं विकल्प # 2 के साथ जाना चाहता हूं)।
गुणन की लागत को कम करने के लिए, शायद आप वेक्टर को सन्निहित ब्लॉकों में पैक कर सकते हैं ताकि आपको एक ब्लॉक के लिए एक रोटेशन की आवश्यकता हो। उदाहरण के लिए,
EvalMult(Enc(A[0:5]),Enc(B[42:47))
एक अन्य तकनीक EvalFastRotation
जिसका आप उपयोग कर सकते हैं (केवल PALKADE v1.10.x में CKKS और BGVrns के लिए उपलब्ध है)। यदि आपको एक ही सिफरटेक्स्ट के कई घुमावों की आवश्यकता है, तो आप सिफरटेक्स्ट के लिए कुछ पूर्व-स्थापित कर सकते हैं, और फिर सस्ते घुमावों का उपयोग कर सकते हैं (बीवी कुंजी स्विचिंग के लिए सबसे अधिक लाभ प्राप्त होता है) - देखेंhttps://gitlab.com/palisade/palisade-development/-/blob/master/src/pke/examples/advanced-real-numbers.cpp एक उदाहरण के लिए।
यदि आपको कई घुमावों की आवश्यकता होती है, तो उत्पन्न की जाने वाली कुंजियों की संख्या को कम करने के भी तरीके हैं (केवल आवश्यक घुमावों की संख्या का एक वर्गमूल गणना), उदाहरण के लिए, इसमें वर्णित बेबी-स्टेप-विशाल-चरण तकनीक का उपयोग करके https://eprint.iacr.org/2018/244 (इन तकनीकों को आपके PALISADE- आधारित एप्लिकेशन में लागू किया जा सकता है)।
आप वेक्टर को पैक करने के एक विशेष क्रम का उपयोग कर सकते हैं यदि गुणन करने के लिए पैटर्न जाना जाता है (इस तरह आपका रोटेशन एक एकल रोटेशन ऑपरेशन का उपयोग करके वेक्टर के कई ब्लॉक तैयार करेगा)। रोटेशन CKKS और BGVrns दोनों में चक्रीय (चारों ओर लपेटें) होते हैं जब # प्लेनटेक्स्ट स्लॉट (बैच आकार) ring dimension
/ 2 के बराबर होता है । यदि आपके पास इससे छोटा वेक्टर है, तो आप जरूरत के अनुसार कई बार छोटे वेक्टर का क्लोन / प्रतिकृति कर सकते हैं। भरने के लिए ring dimension
/ 2।
सारांश में, सबसे बड़ी दक्षता सुधार प्राप्त किया जा सकता है यदि आप SIMD जैसी वैक्टर के संदर्भ में अपनी समस्या के बारे में सोचते हैं। तब आप टूलसेट HE प्रदान करने का पूरा लाभ उठाने के लिए अपनी समस्या / मॉडल का सुधार कर सकते हैं। एक तरह से, यह वेक्टर किए गए निर्देशों, उदाहरण के लिए, AVX या मैट्रिक्स-उन्मुख प्रोग्रामिंग (MATLAB की तरह) का उपयोग करके प्रोग्रामिंग के समान है।