चिपविस्परर: मैग्मा पर ऊर्जा हमला

Rakf द्वारा पोस्ट किया गया

डिजिटल सुरक्षा में हैक 2019 की गर्मियों के हिस्से के रूप में, मैंने एक बिजली के हमले से निपटा और चिप वॉशर के साथ काम किया।

यह क्या है

ऊर्जा विश्लेषण तीसरे पक्ष के चैनलों के माध्यम से एक प्रकार का हमला है। यही है, सिस्टम के भौतिक कार्यान्वयन के परिणामस्वरूप दिखाई देने वाली जानकारी का उपयोग करने वाले हमले।

हमलावर के लिए क्या जानकारी उपयोगी हो सकती है:

• क्रिप्टोग्राफिक रूपांतरण समय;
• बिजली की खपत;
• विद्युत चुम्बकीय क्षेत्र;
• शोर आदि।

एक ऊर्जा हमले को सबसे सार्वभौमिक माना जाता है।

यह काम क्यों करता है?

माइक्रोप्रोसेसर, माइक्रोकंट्रोलर, रैम और कई अन्य लॉजिक सर्किट सीएमओएस तकनीक पर आधारित हैं। CMOS सर्किट की बिजली की खपत में दो घटक होते हैं: स्थिर और गतिशील। स्थैतिक बिजली की खपत बहुत कम है, जो प्रौद्योगिकी के विमुद्रीकरण के कारणों में से एक है। गतिशील शक्ति ट्रांजिस्टर के स्विचिंग के कारण होती है और संसाधित डेटा और प्रदर्शन किए गए कार्यों पर निर्भर करती है। चूंकि स्थिर घटक मुख्य रूप से स्थिर है, कुल शक्ति में परिवर्तन केवल गतिशील शक्ति के कारण होता है और इसलिए, कुल ऊर्जा खपत का उपयोग विश्लेषण के लिए किया जा सकता है।

उपकरण

ChipWhisperer , मैंने 2-भाग संस्करण का उपयोग किया:

चिपव्हीपर एम्बेडेड उपकरणों की सुरक्षा पर शोध करने के लिए एक खुला स्रोत टूलकिट है। यह ऊर्जा विश्लेषण और त्रुटि आधारित हमलों की अनुमति देता है।

शुल्क $ 250 का खर्च आएगा। डेवलपर्स इसे एक क्रांतिकारी समाधान के रूप में स्थान देते हैं, क्योंकि ऐसे परिसर, रचनाकारों के अनुसार, $ 30k से लागत। डिवाइस में 2 बोर्ड होते हैं: लक्ष्य और कैप्चर बोर्ड।

अन्य संस्करण हैं, उनके फायदे (लेकिन यह भी एक बड़ी कीमत पर) के साथ, आप अलग-अलग लक्ष्य बोर्ड, विस्तार कार्ड, अपने उपकरणों के पूर्ण विश्लेषण के लिए जांच भी कर सकते हैं और केवल हटाने के लिए ChipWhisperer का उपयोग कर सकते हैं।

ChipWhisperer में एक उत्कृष्ट विकी , छोटे विकास प्रयोगशालाएं हैं , और 5 वें संस्करण तक उन्होंने अच्छा एपीआई प्रलेखन भी बनाया है। कनेक्ट किए गए डिवाइस से ट्रैक्स को उनके सॉफ़्टवेयर का उपयोग करके हटा दिया जाता है और इसे NumPy सरणी के रूप में रिकॉर्ड किया जाता है।

सबसे पहले आपको लक्ष्य डिवाइस के लिए फर्मवेयर लिखने की आवश्यकता है। लैब के हिस्से के रूप में, सिफर्स AES, DES, TEA को माना जाता है। उनके लिए, निशान हटाने के लिए पहले से तैयार फर्मवेयर और सेटिंग्स हैं (लिए जाने वाले नमूनों की संख्या, ऑफसेट, एडीसी आवृत्ति, आदि)। स्वतंत्र अनुसंधान के लिए सेटिंग्स को प्रयोगात्मक रूप से चुनना होगा।

जैसा कि ऊपर उल्लेख किया गया है, आप लक्ष्य बोर्ड की विफलता को भड़का सकते हैं: घड़ी के सिग्नल में खराबी, निर्देशों को छोड़ना और गुप्त जानकारी निकालना।

बड़े परिसरों में, पटरियों का पता लगाने के लिए एक आस्टसीलस्कप का उपयोग किया जाता है।

के विश्लेषण

कई बुनियादी विश्लेषण विधियाँ हैं:

• सरल शक्ति विश्लेषण (एसपीए);
• अंतर शक्ति विश्लेषण (डीपीए);
• शक्ति सहसंबंध विश्लेषण (सीपीए)।

एक साधारण बिजली विश्लेषण में पावर ग्राफ का एक दृश्य विश्लेषण शामिल है। उदाहरण के लिए, सही वर्ण में प्रवेश करने और गलत के साथ तुलना करने पर पासवर्ड को एक बार में एक प्रोफ़ाइल प्राप्त की जा सकती है।

या आप पटरियों पर एन्क्रिप्शन राउंड देख सकते हैं। यह एक कुंजी प्राप्त करने के लिए पर्याप्त डेटा नहीं है, लेकिन यह माना जा सकता है कि कौन सा एल्गोरिथ्म निष्पादित किया गया है। आंकड़ा स्पष्ट रूप से एईएस के 10 चक्कर दिखाता है।

विभेदक विश्लेषण (डीपीए) सरल विश्लेषण की तुलना में बहुत अधिक कुशल है। डीपीए बिजली के निशान में अंतर का पता लगाने के लिए सांख्यिकीय विश्लेषण विधियों पर आधारित है। एक बहुत ही प्रभावी उपकरण, हालांकि, कुंजी को "खोलने" के लिए बड़ी संख्या में मार्गों की आवश्यकता होगी। मैंने विश्लेषण के लिए इस पद्धति का उपयोग नहीं किया, लेकिन अंत में मैं उन स्रोतों के लिए कुछ लिंक दूंगा जहां यह अच्छी तरह से वर्णित है।

सहसंबंध विश्लेषण का आधार गुप्त एन्क्रिप्शन कुंजी का निर्धारण करने के लिए एक सांख्यिकीय उपकरण है। कभी-कभी इसे एक अलग प्रकार में पृथक किया जाता है, कभी-कभी इसे डीपीए के रूप में संदर्भित किया जाता है। इस विधि को डीपीए की तुलना में कम निशान की आवश्यकता होती है, मैंने इसे शक्ति विश्लेषण के लिए उपयोग किया। मैं आपको इसके बारे में और अधिक बताऊंगा।

मुख्य कार्य अध्ययन के तहत डिवाइस की ऊर्जा खपत का एक सटीक मॉडल बनाना है। यदि एक सटीक मॉडल बनाया गया है, तो अनुमानित और वास्तविक मूल्य के बीच ध्यान देने योग्य संबंध है।

जिन पावर मॉडल का इस्तेमाल किया जा सकता है उनमें से एक हैमिंग वेट मॉडल है। बाइनरी प्रतिनिधित्व में हैमिंग का वजन गैर-शून्य मानों की संख्या है। इस मॉडल की धारणा यह है कि रजिस्टर में सेट बिट्स की संख्या डिवाइस द्वारा खपत ऊर्जा के साथ सहसंबंधित होगी। हैमिंग के वजन का उपयोग ऊर्जा की पारंपरिक इकाई के रूप में किया जाता है। हैमिंग डिस्टेंस मॉडल का उपयोग भी किया जाता है - 2 मानों में विभिन्न बिट्स की संख्या।

हेमिंग वजन मॉडल और वास्तविक बिजली की खपत की तुलना करने के लिए, एक रैखिक पियर्सन गुणांक का उपयोग किया जाता है। यह एक मात्रा की रैखिक निर्भरता को दूसरे पर दिखाता है। एक सही ढंग से निर्मित मॉडल के साथ, यह गुणांक 1 तक हो जाएगा।

सामान्यीकृत CPA एल्गोरिथ्म में निम्नलिखित मुख्य चरण होते हैं:

• अज्ञात कुंजी पर संदेशों को परिवर्तित करते समय बिजली की खपत को हटा दें;
• जब हम कुंजी उप-ब्लॉक के सभी संभावित वेरिएंट (प्रत्येक बाइट के लिए 256 विकल्प) पर समान संदेश परिवर्तित करते हैं, तो हम चिप की ऊर्जा खपत का एक मॉडल बनाते हैं;
• हम सिम्युलेटेड बिजली की खपत और वास्तविक के लिए रैखिक सहसंबंध गुणांक पाते हैं। एक सच्ची कुंजी के मामले में, गुणांक 1 हो जाएगा;
• शेष कुंजी उप-ब्लॉक के लिए एल्गोरिथ्म दोहराया जाता है।

नतीजतन, कुंजी को छोटे भागों में क्रमिक रूप से बहाल किया जाता है। यदि हम एक बार में कुंजी के एक बाइट पर हमला करते हैं, तो हम प्रत्येक कुंजी के लिए 2 ⁸ प्रयासों का उपयोग करते हैं। उदाहरण के लिए, यदि आप एईएस - 128 चुनते हैं, तो कुंजी के 16 बाइट्स के लिए प्रयासों की कुल संख्या 2 ¹² होगी, जो कि 2 ^{128 को} मारने की तुलना में बहुत बेहतर है।

मैग्मा सिफर विश्लेषण

मैग्मा एक कोड है जिसे GOST R 34.12-2015 में परिभाषित किया गया है, वास्तव में GOST 28147-89, केवल प्रोफ़ाइल में। एन्क्रिप्ट किया गया ब्लॉक 32 राउंड से गुजरता है जिसमें कुछ परिवर्तन होते हैं। कुंजी में 256 बिट होते हैं, प्रत्येक गोल कुंजी मूल का एक हिस्सा है।

हम सीपीए पद्धति का उपयोग करके प्राप्त आंकड़ों का विश्लेषण करेंगे।

सबसे पहले, आपको एल्गोरिथ्म का एक मध्यवर्ती मूल्य चुनने की आवश्यकता है, जो ज्ञात डेटा और कुंजी के एक छोटे हिस्से पर निर्भर करता है और सरल परिवर्तनों द्वारा गणना की जा सकती है। आमतौर पर यह मान एस-बॉक्स आउटपुट है (मैग्मा में अब 1 प्रतिस्थापन तालिका है, इसलिए पहले के ऐसे हमलों को करना आसान है) (खुले ग्रंथों को जाना जाता है) या अंतिम दौर (सिफरटेक्स ज्ञात हैं)।

मैंने प्रसिद्ध खुले ग्रंथों के साथ एक कुंजी पर शोध किया, इसलिए इस विकल्प पर आगे विचार किया जाएगा। मैग्मा एल्गोरिथ्म में डेस, एईएस के विपरीत, एक गोल कुंजी के साथ 32-बिट ब्लॉक का जोड़ मोडुलो 2 ³² होता है, इसलिए, एस-बॉक्स के अंतिम आउटपुट से विश्लेषण शुरू करना बेहतर होता है, क्योंकि उच्चतम मान जोड़ने से युवा प्रभावित नहीं होते हैं। हम प्रत्येक एस-बॉक्स के आउटपुट पर विचार करते हैं: पहले 8, फिर 8, 7 और इसी तरह पहले दिए गए। ट्रैक हटाने को 8-बिट माइक्रोकंट्रोलर पर किया गया था, और हम यह मान सकते हैं कि यह दोहरी एस-बॉक्स के साथ काम करता है। इसलिए, मैं तुरंत 1 बाइट पर हमला करूंगा।

अंतिम कुंजी बाइट के लिए ऊर्जा मॉडल की गणना:

for kguess in range(0, 256): #Initialize arrays & variables to zero sumnum = np.zeros(numpoint) sumden1 = np.zeros(numpoint) sumden2 = np.zeros(numpoint) hyp = np.zeros(numtraces) for tnum in range(numtraces): hyp[tnum] = HW[leak("Gost28147_tc26_ParamZ", kguess, block2ns(text[tnum])[0], 0)] 

जहां लीक फ़ंक्शन केवल अंतिम बाइट का एस-बॉक्स आउटपुट देता है।

हम सूत्र के अनुसार सिम्युलेटेड और वास्तविक मूल्यों के लिए रैखिक पियरसन गुणांक की गणना करते हैं:

  cpaoutput = [0]*256 maxcpa = [0]*256 #Mean of hypothesis meanh = np.mean(hyp, dtype=np.float64) #Mean of all points in trace meant = np.mean(traces, axis=0, dtype=np.float64) #For each trace, do the following for tnum in range(0, numtraces): hdiff = (hyp[tnum] - meanh) tdiff = traces[tnum,:] - meant sumnum = sumnum + (hdiff*tdiff) sumden1 = sumden1 + hdiff*hdiff sumden2 = sumden2 + tdiff*tdiff cpaoutput[kguess] = sumnum / np.sqrt( sumden1 * sumden2 ) maxcpa[kguess] = max(abs(cpaoutput[kguess])) 

जब एक सच्चे उपकुंजी चुनते हैं, तो सहसंबंध गुणांक में एक महत्वपूर्ण वृद्धि होगी:

इस प्रकार, गोल कुंजी के प्रत्येक बाइट का विश्लेषण किया जाता है।

  for bnum in range(0, 4): cpaoutput = [0]*256 maxcpa = [0]*256 for kguess in range(0, 256): best_round_key = kguess << (bnum * 8) | best_round ... 

पहले राउंड की को देखते हुए, हम उसी तरह से 2 और बाद की राउंड कीज की गणना कर सकते हैं। एक पूर्ण मैग्मा कुंजी 8 गोल कुंजी निकालकर प्राप्त की जा सकती है।

इस समस्या को हल करने की प्रक्रिया में, कई बारीकियाँ उत्पन्न होती हैं। एईएस, डेस, ग्रासहॉपर सिफर्स के विपरीत, एक प्लेनटेक्स्ट राउंड की के अलावा मॉडुलो 2 ³² होता है। कम बिट्स का जोड़ XORa के विपरीत उच्च को प्रभावित करता है। प्रत्येक बाद के उपकुंजी की गणना करते समय, आपको अतीत के परिणामों पर विचार करना होगा। इसी तरह गोल चाबियों के साथ। डेटा बहुत संवेदनशील है। यदि किसी एक मान की गलत गणना की जाती है, तो आगे की पूरी गणना गलत होगी।

यह भी विचार करने योग्य है कि अब एक चिप ढूंढना काफी मुश्किल है जिसमें चार-बिट वास्तुकला है: अधिकांश चिप्स में आठ-बिट होते हैं। बेशक, विशेष क्रिप्टोग्राफ़िक चिप्स हैं जो एक विशिष्ट सुरक्षा रूपांतरण एल्गोरिथ्म (या कई एल्गोरिदम) के लिए डिज़ाइन किए गए हैं और इनमें सबसे कुशल वास्तुकला है।

डीईएस सिफर को निष्पादित करने के लिए, इस तरह के क्रिप्टोप्रोसेसर में मैग्मा के लिए छह-बिट आर्किटेक्चर हो सकता है - एक चार-बिट एक, जो प्रत्येक एस-बॉक्स को अलग से संसाधित करने की अनुमति देता है। मेरा लक्ष्य डिवाइस 8-बिट है, और "मैग्मा" के मामले में, एक दृष्टिकोण में आठ बिट्स पर रूपांतरण किया जाएगा, अर्थात प्रतिस्थापन 2 एस-बॉक्स पर होगा, 2 एस-बॉक्स के लिए बिजली की खपत पर विचार किया जाएगा। यदि S- बॉक्स में से कोई एक, सीनियर या जूनियर, सच्ची कुंजी से मेल खाता है, और दूसरा मेल नहीं खाता है, तो उच्च सहसंबंध फट सकता है।

उपरोक्त सभी को देखते हुए, आउटपुट पर हमारे पास मैग्मा सिफर के लिए ऊर्जा खपत पथ के विश्लेषण के लिए निम्नलिखित स्क्रिप्ट है:

  import numpy as np path = r'C:\Users\user\chipwhisperer\projects\gost_10000_2_data\traces\2019.08.11-19.53.25_' traces = np.load(path + 'traces.npy') text = np.load(path + 'textin.npy') keys = np.load(path + 'keylist.npy') HW = [bin(n).count("1") for n in range(0,256)] SBOXES = {"Gost28147_tc26_ParamZ": ( (12, 4, 6, 2, 10, 5, 11, 9, 14, 8, 13, 7, 0, 3, 15, 1), (6, 8, 2, 3, 9, 10, 5, 12, 1, 14, 4, 7, 11, 13, 0, 15), (11, 3, 5, 8, 2, 15, 10, 13, 14, 1, 7, 4, 12, 9, 6, 0), (12, 8, 2, 1, 13, 4, 15, 6, 7, 0, 10, 5, 3, 14, 9, 11), (7, 15, 5, 10, 8, 1, 6, 13, 0, 9, 3, 14, 11, 4, 2, 12), (5, 13, 15, 6, 9, 2, 12, 10, 11, 7, 8, 1, 4, 3, 14, 0), (8, 14, 2, 5, 6, 9, 1, 12, 15, 4, 11, 0, 13, 10, 3, 7), (1, 7, 14, 13, 0, 5, 8, 3, 4, 15, 10, 6, 9, 12, 11, 2), )} def _K(s, _in): """ S-box substitution :param s: S-box :param _in: 32-bit word :returns: substituted 32-bit word """ return ( (s[0][(_in >> 0) & 0x0F] << 0) + (s[1][(_in >> 4) & 0x0F] << 4) + (s[2][(_in >> 8) & 0x0F] << 8) + (s[3][(_in >> 12) & 0x0F] << 12) + (s[4][(_in >> 16) & 0x0F] << 16) + (s[5][(_in >> 20) & 0x0F] << 20) + (s[6][(_in >> 24) & 0x0F] << 24) + (s[7][(_in >> 28) & 0x0F] << 28) ) def block2ns(data): """ Convert block to N1 and N2 integers """ data = bytearray(data) return ( data[7] | data[6] << 8 | data[5] << 16 | data[4] << 24, data[3] | data[2] << 8 | data[1] << 16 | data[0] << 24, ) def addmod(x, y, mod=2 ** 32): """ Modulo adding of two integers """ r = x + int(y) return r if r < mod else r - mod def _shift11(x): """ 11-bit cyclic shift """ return ((x << 11) & (2 ** 32 - 1)) | ((x >> (32 - 11)) & (2 ** 32 - 1)) def round(sbox, key, data, byte): s = SBOXES[sbox] _in = addmod(data, key) sbox_leak = _K(s, _in); return (sbox_leak >> (8 * byte)) & 0xFF def Feistel(sbox, key, data, nround): s = SBOXES[sbox] w = bytearray(key) x = [ w[3 + i * 4] | w[2 + i * 4] << 8 | w[1 + i * 4] << 16 | w[0 + i * 4] << 24 for i in range(8) ] n1, n2 = block2ns(data) for i in range(nround): n1, n2 = _shift11(_K(s, addmod(n1, x[i]))) ^ n2, n1 return n1 numtraces = len(traces) numpoint = np.shape(traces)[1] bestguess = [0]*32 round_data = [0] * numtraces for i in range(numtraces): round_data[i] = [0] * 8 for rnum in range(0, 8): best_round = 0 for tnum_r in range(numtraces): round_data[tnum_r][rnum] = Feistel("Gost28147_tc26_ParamZ", bestguess, text[tnum_r], rnum) for bnum in range(0, 4): cpaoutput = [0]*256 maxcpa = [0]*256 for kguess in range(0, 256): #Initialize arrays & variables to zero best_round_key = kguess << (bnum * 8) | best_round sumnum = np.zeros(numpoint) sumden1 = np.zeros(numpoint) sumden2 = np.zeros(numpoint) hyp = np.zeros(numtraces) for tnum in range(numtraces): hyp[tnum] = HW[round("Gost28147_tc26_ParamZ", best_round_key, round_data[tnum][rnum], bnum)] #Mean of hypothesis meanh = np.mean(hyp, dtype=np.float64) #Mean of all points in trace meant = np.mean(traces, axis=0, dtype=np.float64) #For each trace, do the following for tnum in range(0, numtraces): hdiff = (hyp[tnum] - meanh) tdiff = traces[tnum,:] - meant sumnum = sumnum + (hdiff*tdiff) sumden1 = sumden1 + hdiff*hdiff sumden2 = sumden2 + tdiff*tdiff cpaoutput[kguess] = sumnum / np.sqrt( sumden1 * sumden2 ) maxcpa[kguess] = max(abs(cpaoutput[kguess])) best_round = best_round | (np.argmax(maxcpa) << (bnum * 8)) bestguess[((rnum + 1) * 4)-bnum - 1] = np.argmax(maxcpa) print "Best Key Guess: " for b in bestguess: print "%02x "%b, 

गिटहब परिणाम रिपोजिटरी

निष्कर्ष

अध्ययन के हिस्से के रूप में, मैंने चीपवियर्स के साथ काम किया। इस तथ्य के बावजूद कि मैंने सभी उपकरणों की कोशिश नहीं की (उदाहरण के लिए, ग्लिचिंग), मुझे निश्चित रूप से चिपवर्पर उपयोगी लगता है, खासकर यदि आप महंगे विशेष हार्डवेयर खरीदना नहीं चाहते हैं।

ऊर्जा की खपत के लिए हमारे सिफर के विश्लेषण के लिए, यह ऊपर वर्णित सिफर की तुलना में इस हमले के लिए अधिक प्रतिरोधी है, लेकिन पर्याप्त डेटा के साथ, कुंजी समस्याओं के बिना प्राप्त की जा सकती है।

दिलचस्प सामग्री:

• पी। कोचर डिफरेंशियल पावर एनालिसिस
• "पावर एनालिसिस अटैक: स्मार्ट कार्ड्स के राज का खुलासा"
• बंदूक की नोक पर क्रिप्टोग्राफी I: क्रिप्टोग्राफ़िक एल्गोरिदम आर। कोर्किकन की कुंजी की तलाश में।
• गनपॉइंट II पर क्रिप्टोग्राफी: अंतर पोषण विश्लेषण आर। कोर्किकन।
• जीरोनाइट्स 2014 आर। कोर्किकन के साथ रिपोर्ट ।
• सॉफ्टवेयर कार्यान्वयन के बारे में जीरोनाइट्स 2014 के साथ क्रिप्टोकरंसी v2 ।