🎡 👏🏻 🧑🏿 डमीज के लिए विभेदक क्रिप्टोनालिसिस 👩‍👧‍👧 🐸 👨🏽‍🌾

FEAL कोड में DES के समान ताकत है। इसके अलावा, बढ़ी हुई प्रमुख लंबाई (डेस में 56 बिट्स की तुलना में 64 बिट्स) की गणना करना कठिन हो जाता है। FEAL सिफर में सिफरटेक्स का अच्छा वितरण है, जो यादृच्छिक के करीब है। और यह DES की तुलना में FEAL के पक्ष में भी बोलता है।

यह 1987 FEAL एन्क्रिप्शन एल्गोरिथ्म विनिर्देश का एक सारांश है।

कुछ भी नहीं हमेशा के लिए रहता है। इस विषय में, मैं आपको बताऊंगा कि कुछ ही मिनटों में पूर्ण FEAL4 कुंजी कैसे प्राप्त करें यदि खुले-बंद ग्रंथों के केवल 40 जोड़े हैं।

विभेदक क्रिप्टैनालिसिस

शुरू करने के लिए, रूसी कान को दुलारते हुए "डिफरेंशियल क्रिप्टोनालिसिस" नाम के तहत जो छिपा हुआ है, उसे बताएं।
डिफरेंशियल क्रिप्टैनालिसिस चयनित स्पष्ट पाठ के साथ एक हमला है। इसका मतलब है कि डीसी का उपयोग करने के लिए, आपको बिल्कुल किसी भी मात्रा में किसी भी ग्रंथ को एन्क्रिप्ट करने में सक्षम होना चाहिए।

डीसी का उपयोग कर हमलावर का लक्ष्य कुंजी के बारे में कुछ जानकारी प्राप्त करना है, जो दोनों कुंजी (जो बहुत दुर्लभ है) से पूरी तरह से समझौता कर सकते हैं और कुंजी का चयन करते समय बस कुछ लाभ देते हैं।

यह सभी इस प्रकार काम करता है। दो पूर्व चयनित सिफरटेक्स्ट पी ₁ और पी _{2 के लिए,} हमलावर "अंतर" ΔP = P ₁ P P _{2 की} गणना करता है। और ΔP की मदद से, वह यह निर्धारित करने की कोशिश करता है कि सिफरटेक्स्ट का "अंतर" क्या है = C ₁ .C ₂ होना चाहिए। 100% सटीकता के साथ भविष्यवाणी करना अक्सर असंभव होता है जिसका मूल्य will होगा। केवल एक हमलावर जो कर सकता है वह यह निर्धारित करता है कि एक पूर्वनिर्धारित ΔP के लिए सिफर विभिन्न आवृत्ति को किस आवृत्ति पर लौटाता है। यह ज्ञान हमलावर को कुंजी या संपूर्ण कुंजी का हिस्सा खोलने की अनुमति देता है।

उदाहरण के लिए, आइए नीचे दिए गए चित्र में दिखाए गए तीन-राउंड ब्लॉक सिफर पर एक नज़र डालें।

इस सिफर में 64 बिट ब्लॉक आकार और 128 बिट कुंजी है।
प्रत्येक दौर पर, इनपुट ब्लॉक को 8 बाइट्स में विभाजित किया जाता है, जिनमें से प्रत्येक Sbox प्रतिस्थापन फ़ंक्शन से गुजरता है । उसके बाद, डेटा 64 बिट सबकी उपकुंजी के साथ मिलाया जाता है। फेरबदल फ़ंक्शन एक नियमित XOR है।

मान लीजिए कि हमलावर ने अंतर 0x80 की जांच करने का फैसला किया। ऐसा करने के लिए, यह एक मनमाना बाइट एक्स ₁ उत्पन्न करता है, और एक्स ₂ = एक्स ₁ .80 की गणना करता है।
अगला, हमलावर Sbox फ़ंक्शन के माध्यम से X ₁ और X ₂ चलाता है और Y ₁ और Y ₂ के मान प्राप्त करता है। ऐसी प्रत्येक जोड़ी X ₁ और X _{2 के लिए} , जिसका अंतर 80 है, हमलावर अंतर .Y प्राप्त करने में सक्षम है। प्राप्त मूल्यों का विश्लेषण करते हुए, हमलावर एक isY मान चुनता है जो होने की अधिक संभावना है।

हमारे उदाहरण पर लौटते हुए, मान लीजिए कि सभी 256 जोड़े X ₁ और X ₂ में से 192 मामलों में Y ₁ = Y ₂ = 02 हैं। इस प्रकार, संभावना है कि, दिए गए 80X = 80 के लिए, मान 02Y = 02, 192/256 = 3/4 है। यह, बदले में, इसका अर्थ है कि दिए गए 80X = 80 के लिए, प्रायिकता P ₁ = 3/4, दो मान U ₁ और U ₂ , जैसे कि =U = 02, दूसरे दौर के इनपुट को मिलेगा।
कृपया ध्यान दें कि किसी भी तरह से कुंजी विभेदकों के मूल्य को प्रभावित नहीं करती है। चूंकि विभिन्न ग्रंथों को एन्क्रिप्ट करने और कुंजी अनुक्रम के साथ मिश्रण करने पर कुंजी नहीं बदलती है, XOR का उपयोग करके प्रदर्शन किया जाता है, जब byU की गणना करते हैं, तो कुंजी के बाइट को पारस्परिक रूप से बाहर रखा जाता है।

दूसरे राउंड के गुणों को प्रकट करने के लिए, हमलावर इनपुट बाइट्स X ₁ और X _{2 के} नए 256 जोड़े उत्पन्न करता है, जैसे कि X ₁ X X ₂ = 02। X ₁ और X ₂ की प्रत्येक जोड़ी के लिए Sbox फ़ंक्शन की गणना करने के बाद, हमलावर ने नोटिस दिया कि 64 मामलों में 256 256Y = 88 में से। यानी संभावना है कि abilityY = 88, दिए गए 02X = 02 के लिए, P ₂ = 64/256 = 1/4 है।

इस प्रकार, संभावनाओं की एक सरल गणना करने के बाद, हमलावर समझता है कि बाइट्स X ₁ और X ₂ की प्रत्येक जोड़ी के लिए निर्दिष्ट सिफर के लिए ऐसा है कि ΔX = 80, प्रायिकता P = P ₁ * P ₂ = 3/4/4/4 = 3 के साथ / 16, अंतिम दौर से पहले सिफर की आंतरिक स्थिति का अंतर 88Y = 88 है।

इस ज्ञान को ध्यान में रखते हुए, हमलावर कई जोड़े ग्रंथों को उत्पन्न करता है जैसे कि 80P = 808080808080 और तीसरे राउंड उपकुंजी के बाइट-वार चयन के लिए आगे बढ़ता है।
हम दिखाते हैं कि उपकुंजी के पहले बाइट को कैसे खोला जाए।
पहले सबकी बाइट [0] के 256 संभावित वेरिएंट में से प्रत्येक के लिए और प्रत्येक सिफरटेक्स्ट जोड़ी {C ₁ , C ₂ } के लिए, हमलावर U ₁ = Sbox (C ₁ ub उपकुंजी [0]) और U ₂ = Sbox (C ₂ ⊕ उपकुंजी) की गणना करता है। [0])।
यदि उपकुंजी [0] का सही अनुमान लगाया जाता है, तो keyU की गणना करते समय हर 16 में से लगभग 3 जोड़े U ₁ और U ₂ 88 होंगे।
इस प्रकार, सबकी उपकुंजी के सबसे संभावित पहले बाइट को चुने जाने के बाद, हमलावर दूसरे बाइट में जा सकता है और इसी तरह तीसरे राउंड की पूरी कुंजी खोलेगा।

अंतिम राउंड की कुंजी सामने आने के बाद, हमलावर पेनल्टी राउंड पर हमला करना शुरू कर सकता है और इस तरह से अभिनय करने से अंततः सभी राउंड सिफर कुंजी के बारे में जानकारी प्राप्त होगी।

FEAL सिफर विवरण

अब क्रिप्टोग्राफ़िक एल्गोरिथम पर विचार करें जिसके साथ हम ऊपर वर्णित क्रियाओं को करने का प्रयास करेंगे।
तो, FEAL4 एक ब्लॉक सिफर है, जिसमें 64 बिट्स की ब्लॉक साइज और की लंबाई है।
FEAL4 एल्गोरिथ्म के कई समकक्ष विवरण हैं, हम अंतर क्रिप्टोनालिसिस के प्रदर्शन के लिए सबसे सुविधाजनक उपयोग करेंगे।

सिफर में 4 राउंड होते हैं और मुख्य कुंजी से उत्पन्न छह 32-बिट उपकुंजियों का उपयोग करता है (भविष्य में, हम मानते हैं कि प्रत्येक उपकुंजी स्वतंत्र रूप से उत्पन्न होती है, इस प्रकार 2 ⁶⁴ से 2 ¹⁹² तक प्रतिरोध सीमा "बढ़ती" है)।

प्रारंभिक चरण में, प्लेटेक्स्ट को दो ब्लॉकों, 32 बिट्स में विभाजित किया गया है। बाएं और दाएं ब्लॉकों को क्रमशः 32-बिट उपकुंज K [4] और K [5] के साथ modulo दो जोड़ा गया है। फिर बायां भाग अपरिवर्तित रहता है, और दाएं बाएं खंड के साथ मोडुलो दो जोड़कर बनता है।

उसके बाद, एन्क्रिप्शन के 4 राउंड किए जाते हैं, जिनमें से प्रत्येक में राउंड K [i] के कनेक्शन के साथ राइट ब्लॉक को मोडुलो दो कहा जाता है, और फिर परिणाम को क्रमपरिवर्तन फ़ंक्शन F के माध्यम से चलाया जाता है। क्रमपरिवर्तन का परिणाम पाठ के बाएं भाग में जोड़ा जाता है। इन ऑपरेशनों के बाद, बाएं और दाएं ब्लॉकों को परस्पर बदल दिया जाता है और परिणाम अगले दौर के इनपुट को खिलाया जाता है।

अंतिम दौर बाकी सभी से थोड़ा अलग है। बाएँ और दाएँ ब्लॉक स्थानों को बदलते नहीं हैं, जैसा कि पिछले दौर में था।
इसके बजाय, दाएं खंड को बाएं खंड के साथ modulo दो जोड़ा जाता है और परिणाम सिफरटेक्स्ट के दाईं ओर के रूप में वापस किया जाता है। 4 राउंड के बाद बचा हुआ हिस्सा अपरिवर्तित रहता है और प्राप्त सिफरटेक्स के पहले 32 बिट्स बनाता है।

रचनाकारों द्वारा वर्णित मूल सिफर योजना उपरोक्त से थोड़ी अलग थी। छह 32-बिट उपकुंजियों के बजाय, मूल विवरण बारह 16-बिट उपकुंजियों का उपयोग करता है। हालाँकि, दोनों विकल्प समान हैं और यदि वांछित हैं, तो 32-बिट कुंजियों को मूल विवरण से 16-बिट कुंजी के रूप में आसानी से दर्शाया जा सकता है।

सिफर के विवरण में एकमात्र सफेद स्थान फ़ंक्शन एफ है। आंकड़े में, इसे निम्नानुसार दर्शाया जा सकता है:

इनपुट पर, फ़ंक्शन एफ को 4 बाइट्स एक्स ₁ , एक्स ₂ , एक्स ₃ , एक्स _{4 प्राप्त होता है} । अगला, इनपुट बाइट्स मिश्रित होते हैं और फ़ंक्शन जी ₀ या जी ₁ से गुजरते हैं। फ़ंक्शन _{एक्स की} गणना के बाद प्राप्त 4 बाइट्स फ़ंक्शन एफ का 32-बिट आउटपुट अनुक्रम बनाते हैं।

फ़ंक्शन जी ₀ और जी ₁ 16-बिट इनपुट अनुक्रम को 8-बिट परिणाम में परिवर्तित करते हैं।
फ़ंक्शन जी ₀ को निम्नानुसार व्यक्त किया जा सकता है:

जहाँ << बाईं ओर चक्रीय बदलाव है।
जबकि फ़ंक्शन G ₁ की निम्नलिखित परिभाषा है:

।

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

FEAL4 का C # में कार्यान्वयन

class FEAL4 { private byte G0(byte a, byte b) { return (byte)((((a + b) % 256) << 2) | (((a + b) % 256) >> 6)); } private byte G1(byte a, byte b) { return (byte)((((a + b+1) % 256) << 2) | (((a + b+1) % 256) >> 6)); } public byte[] F(byte[] x) { byte[] y = new byte[4]; y[1] = G1((byte)(x[0] ^ x[1]), (byte)(x[2] ^ x[3])); y[0] = G0(x[0], y[1]); y[2] = G0(y[1], (byte)(x[2] ^ x[3])); y[3] = G1(y[2], x[3]); return y; } private void AddKeyPart(byte[] P, byte[] K) { for (int i = 0; i < 4; i++) { P[i] = (byte)(P[i] ^ K[i]); } } private byte[] XOR(byte[] a, byte[] b) { byte[] c=new byte[a.Length]; for (int i = 0; i < c.Length; i++) { c[i] = (byte)(a[i] ^ b[i]); } return c; } public byte[] Encrypt(byte[] P, byte[][] K) { byte[] LeftPart = new byte[4]; byte[] RightPart = new byte[4]; Array.Copy(P, 0, LeftPart, 0, 4); Array.Copy(P, 4, RightPart, 0, 4); AddKeyPart(LeftPart, K[4]); AddKeyPart(RightPart, K[5]); byte[] Round2Left = XOR(LeftPart, RightPart); byte[] Round2Right = XOR(LeftPart, F(XOR(Round2Left, K[0]))); byte[] Round3Left = Round2Right; byte[] Round3Right = XOR(Round2Left,F(XOR(Round2Right,K[1]))); byte[] Round4Left = Round3Right; byte[] Round4Right = XOR(Round3Left, F(XOR(Round3Right, K[2]))); byte[] CipherTextLeft = XOR(Round4Left,F(XOR(Round4Right,K[3]))); byte[] CipherTextRight = XOR(Round4Right, CipherTextLeft); byte[] CipherText = new byte[8]; Array.Copy(CipherTextLeft, 0, CipherText, 0, 4); Array.Copy(CipherTextRight, 0, CipherText, 4, 4); return CipherText; } public byte[] Decrypt(byte[] P, byte[][] K) { byte[] LeftPart = new byte[4]; byte[] RightPart = new byte[4]; Array.Copy(P, 0, LeftPart, 0, 4); Array.Copy(P, 4, RightPart, 0, 4); byte[] Round4Right = XOR(LeftPart, RightPart); byte[] Round4Left = XOR(LeftPart, F(XOR(Round4Right, K[3]))); byte[] Round3Right = Round4Left; byte[] Round3Left = XOR(Round4Right, F(XOR(Round3Right, K[2]))); byte[] Round2Right = Round3Left; byte[] Round2Left = XOR(Round3Right, F(XOR(Round2Right, K[1]))); byte[] Round1Right = Round2Left; byte[] Round1Left = XOR(Round2Right, F(XOR(Round1Right, K[0]))); byte[] TextLeft = Round1Left; byte[] TextRight = XOR(Round1Left,Round1Right); AddKeyPart(TextLeft, K[4]); AddKeyPart(TextRight, K[5]); byte[] Text = new byte[8]; Array.Copy(TextLeft, 0, Text, 0, 4); Array.Copy(TextRight, 0, Text, 4, 4); return Text; } }

FEAL4 सिफर के विभेदक क्रिप्टोनालिसिस

जैसा कि ऊपर दिए गए उदाहरण में, हम प्रतिस्थापन समारोह एफ की जांच करके सिफर के क्रिप्टोनालिसिस शुरू करते हैं। यह वह जगह है जहां पूरे FEAL सिफर का सबसे महत्वपूर्ण दोष छिपा हुआ है। तथ्य यह है कि फ़ंक्शन एफ में सुरक्षा के दृष्टिकोण से एक विपत्तिपूर्ण संपत्ति है। X ₁ और X _{2 के} किसी भी दो मान, जैसे कि उनका अंतर X ₁ = X ₂ = 0x80800000, Y ₁ और Y _{2 में} परिवर्तित हो जाता है। इसके अलावा, 100% मामलों में अंतर Y ₁ ₂ Y ₂ = 0x02000000।

ऐसा क्यों होता है यह समझने के लिए, फ़ंक्शन एफ की गणना करते समय होने वाले अंतर परिवर्तन पर एक नज़र डालें।

यह नोटिस करना आसान है कि फ़ंक्शन के लिए इनपुट नॉनजरो मूल्य केवल पहले बाइट की स्थिति में है। तदनुसार, आउटपुट है

।

यह समझना आसान है कि यह संपत्ति सिफर को क्रिप्टोकरेंसी से पूरी तरह से कमजोर बना देती है। एक निश्चित अंतर की 100% संभावना %Y एक हमले के लिए आवश्यक खुले-बंद पाठ जोड़े की संख्या को कम करने की अनुमति देती है।

विचार करें कि अंतिम दौर K [3] की कुंजी को तोड़ने के लिए एक हमलावर को कौन से कदम उठाने चाहिए।
हमलावर कई प्लेनटेक्स्ट जोड़े पी ₁ और पी ₂ बनाता है, जैसे कि 0P = 0x8080000080800000। ऊपर वर्णित फ़ंक्शन एफ की संपत्ति को जानते हुए, हमलावर एन्क्रिप्शन के लगभग हर दौर पर अंतर की गणना करने में सक्षम है।

आप निम्न चित्र में अंतर के व्यवहार को ट्रैक कर सकते हैं:

जैसा कि आप देख सकते हैं, अंतर अंतिम दौर तक गलत हो जाता है। लेकिन इसके बिना भी, हमलावर के पास पहले से ही अंतिम राउंड कुंजी को खोलने के लिए पर्याप्त जानकारी है।
नीचे दिया गया चित्रण FEAL4 सिफर के अंतिम दो दौर को दर्शाता है।

सी ₁ और सी ₂ की एक जोड़ी होने के कारण _, हमलावर thus सी की गणना कर सकता है, इस प्रकार मान एल 'और आर' प्राप्त करता है।
इसके आधार पर, वह Z '= L'202 की गणना कर सकता है।
दूसरी ओर, सिफरटेक्स सी ₁ और सी ₂ की प्रत्येक जोड़ी के लिए, एक हमलावर वाई ₁ और वाई _{2 की} गणना कर सकता है।
Y ₁ और Y _{2 को} जानकर _, हमलावर कुंजी K [3] की गणना शुरू करता है। प्रत्येक संभावित कुंजी केपोस के लिए, Z ₁ = F (Y ₁ andKpos) और Z ₂ = F (Y ₂ calculatedKpos) की गणना की जाती है। जेड ₁ ul जेड _{2 के} मोडुलो दो मानों को जोड़ते हुए _, हमलावर पहले से गणना की गई जेड के साथ परिणामी मूल्य की तुलना करता है। यदि Z '= Z ₁ 2Z ₂ , तो Kpos सबसे अधिक वांछित उपकुंजी K [3] है।
एक त्रुटि की संभावना को कम करने के लिए, प्राप्त कीप कुंजी को कई जोड़े सिफरटेक् ट के साथ जांचना चाहिए (मैंने अपने कार्यान्वयन में 10 जोड़े का उपयोग किया)।

यह गणना करना आसान है कि ऊपर वर्णित हमले को फ़ंक्शन के 2 ³² संगणनाओं की आवश्यकता है। एफ निश्चित रूप से सिफर के रचनाकारों द्वारा दावा नहीं किया गया 2 ⁶⁴ है, लेकिन आंकड़ा अभी भी बहुत सुखद नहीं है यदि हम सभी 4 गोल कुंजियों की गणना करना चाहते हैं, लेकिन हम निश्चित रूप से यह चाहते हैं।
सौभाग्य से, हमले को सरल बनाया जा सकता है और गणना की संख्या काफी कम हो गई है 2 ¹⁷ ।
ऐसा करने के लिए, हम एक फ़ंक्शन की परिभाषा का परिचय देते हैं

, जहाँ एक बाइट का एक सेट है, और z एक शून्य बाइट है।
प्रत्येक A = (z, a, a, z) के लिए, हमलावर Q ₀ = F (M (Y ₀ ) Y A) और Q ₁ = F (M (Y ₁ )) A) की गणना करता है।
यह सत्यापित करना आसान है कि यदि A = M (K [3]), तो मान Q ₀ ide Q ₁ का दूसरा और तीसरा बाइट मान Z के दूसरे और तीसरे बाइट के साथ मेल खाता है। इस प्रकार, हमें संभावित कुंजी Kpos के दो बाइट्स के बारे में जानकारी मिलती है।
उसके बाद, b ₀ और b ₁ के सभी मानों के लिए, हमलावर अनुक्रम Kpos = (b ₀ , b ₀ 1a ₀ , b ₁ ,a ₁ , b ₁ ) की गणना करता है और परिणामी अनुक्रम की जाँच करता है जैसा कि ऊपर वर्णित है।

उपकुंजी K [3] को खोलने के बाद, हमलावर उन मूल्यों को पुनर्प्राप्त करने में सक्षम होता है जिसमें सिफर तीसरे दौर के बाद था और इससे उसे उपकुंजी K [2] पर इसी तरह से हमला करने का अवसर मिलेगा। हालांकि, यह ध्यान दिया जाना चाहिए कि कुंजी K [2] पर हमला करने के लिए, एक अलग प्रारंभिक अंतर का उपयोग करना आवश्यक होगा, क्योंकि दूसरे राउंड में अंतर 000P = 0x8080000080800000 हमेशा उपयोग की जाने वाली किसी भी कुंजी के लिए Z '= 0x02000000 मान तक ले जाता है। और यह दूसरे दौर की कुंजी का अनुमान लगाने की अनुमति नहीं देगा।
प्रत्येक उपकुंजियों को खोलने के लिए विभेदकों को अंतर के रूप में उपयोग किया जा सकता है:
राउंड 4: 0x8080000080800000
राउंड 3: 0x0000000080800000
राउंड 2: 0x0000000002000000
राउंड 1: 0x0200000080000000
प्रत्येक दौर की सभी चार चाबियों को खोलने के बाद, कुंजी K [5] और K [4] की गणना करना आसान होता है, इसके लिए किसी भी सिफरटेक्स्ट को डिक्रिप्शन के 4 राउंड के माध्यम से ड्राइव करने के लिए पर्याप्त है और परिणामी मूल्य modulte दो को ज्ञात प्लेनटेक्स्ट के साथ जोड़ें।

यदि आप हमले के स्रोत को डाउनलोड करने में रुचि रखते हैं तो आप यहां आ सकते हैं ।

डमीज के लिए विभेदक क्रिप्टोनालिसिस

विभेदक क्रिप्टैनालिसिस

FEAL सिफर विवरण

FEAL4 सिफर के विभेदक क्रिप्टोनालिसिस

उपयोगी लिंक

More articles: