💂 ☣️ 🈁 एईएस कैसे काम करता है 🤝 🐮 🙏🏻

यह लेख किस बारे में है

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

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

एईएस कैसे लागू करें

यह एल्गोरिथ्म उस गुप्त कुंजी का उपयोग करके एक 128-बिट ब्लॉक को दूसरे में परिवर्तित करता है जो इस तरह के रूपांतरण के लिए आवश्यक है। प्राप्त 128-बिट ब्लॉक को डिक्रिप्ट करने के लिए, उसी गुप्त कुंजी के साथ एक दूसरे रूपांतरण का उपयोग किया जाता है। यह इस तरह दिखता है:

cipher = encrypt(block, key) //  block   key block = decrypt(cipher, key) //  cipher   key

ब्लॉक का आकार हमेशा 128 बिट्स होता है। मुख्य आकार का भी एक निश्चित आकार होता है। किसी भी पासवर्ड के साथ मनमाने पाठ को एन्क्रिप्ट करने के लिए, आप यह कर सकते हैं:

पासवर्ड हैश प्राप्त करें
एईएस मानक में वर्णित नियमों के अनुसार एक हैश को एक कुंजी में बदलें
पाठ को 128 बिट के ब्लॉक में विभाजित करें
सिफर फ़ंक्शन के साथ प्रत्येक ब्लॉक को एन्क्रिप्ट करें

इसे इस तरह लिखा जा सकता है:

 hash = md5(password) // MD5    128  key = keyexpansion(hash) //     blocks = split(text, 16) //      16  for (i = 0; i < blocks.length; i++) cipher[i] = encrypt(blocks[i], key)

सिफर ब्लॉक की एक सरणी को डिक्रिप्ट करने के लिए, आपको प्रत्येक ब्लॉक में डिक्रिप्ट लागू करना होगा:

 hash = md5(password) key = keyexpansion(hash) for (i = 0; i < cipher.length; i++) blocks[i] = decrypt(cipher[i], key) text = merge(blocks) //

बेशक, पाठ की लंबाई 128 बिट्स से अधिक नहीं हो सकती है। ऐसे मामलों में, आप टेक्स्ट को ज़ीरो के साथ वांछित लंबाई तक पैड कर सकते हैं, और एन्क्रिप्टेड डेटा के मूल पाठ के एन्क्रिप्टेड आकार के साथ कई बाइट्स जोड़ सकते हैं। उदाहरण में aes.js फ़ाइल में aes.encrypt और anes.decrypt फ़ंक्शन इस दृष्टिकोण का उपयोग करते हैं।

GF फील्ड (2 ⁸ )

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

फ़ील्ड GF (2 ⁸ ) 0..255 संख्या है जिसके लिए एक विशेष गुणन और एक विशेष जोड़ निर्धारित किया गया है। हम इस क्षेत्र से कुछ संख्या लेते हैं और इसे आठ बिट्स के रूप में दर्शाते हैं: a = a ₇ a ₆ a a a a a a a a a a ₀ a। इसी तरह, संख्या बी की कल्पना करें। ए और बी के अलावा प्रसिद्ध बिटवाइज़ ऑपरेशन एक्सोर है:

a + b = a xor b

जोड़ में सरल गुण हैं:

a + a = 0 -a = 0 - a = a a - b = a + (-b) = a + b

गुणन निर्धारित करना अधिक कठिन है। हम इन संख्याओं के बिट्स से गुणांक वाले बहुपद लिखते हैं:

p = a ₇ x ⁷ + a ₆ x ⁶ + a ₅ x ⁵ + a ₄ x ⁴ + a ₃ x ³ + a ₂ x ² + a ₁ x + a ₀ q = b ₇ x ⁷ + b ₆ x ⁶ + b ₅ x ⁵ + b ₄ x ⁴ + b ₃ x ³ + b ₂ x ² + b ₁ x + b ₀

अब हम इन दो बहुपदों को गुणा करते हैं और विभाजन के शेष भाग को m द्वारा पाते हैं:

m = x ⁸ + x ⁴ + x ³ + x + 1 r = pq mod (m)

इस m को क्यों चुना गया है? इस बहुपद में केवल दो भाजक-बहुपद हैं जिनमें यह बिना शेष के विभाज्य है: इकाई और वह स्वयं। Primes के साथ समानता से, बहुपद m "अभाज्य" है। विभाजन के शेष भाग को सामान्य संख्याओं की तरह भी किया जा सकता है: इसके लिए बहुपद को जोड़ने, घटाने और घटाने में सक्षम होने के लिए पर्याप्त है, इसके अलावा, जोड़ और घटाव GF (2 ⁸ ) के नियमों के अनुसार किए जाते हैं, अर्थात बहुपत्नी के जोड़ और घटाव गुणांक के प्रत्येक जोड़े के बीच xor है। यहाँ दो उदाहरण हैं:

x ³ + x ² + 1 mod (x ³ + 1) = x ² // x ³ +1 x ³ + x ² + 1 mod (x ² + 1) = (x ³ + x ² + 1) - (x + 1)(x ² + 1) = -x

हम फार्म में बहुपद आर का प्रतिनिधित्व करते हैं

r = r ₇ x ⁷ + r ₆ x ⁶ + r ₅ x ⁵ + r ₄ x ⁴ + r ₃ x ³ + r ₂ x ² + r ₁ x + r ₀

इसके 8 गुणांक GF फ़ील्ड ( ^{8 8} ) से 8-बिट संख्या का प्रतिनिधित्व करते हैं और इस संख्या को उत्पाद a • b कहा जाता है। इसके अलावा, गुणन सरल बिटवाइज़ ऑपरेशंस की एक जोड़ी के साथ नहीं मिल सकता है। हालांकि, जीएफ (2 ⁸ ) क्षेत्र में एक अनियंत्रित बहुपद द्वारा गुणा को बहुपद x से घटाया जा सकता है, और x से गुणा करके कई बिटवाइज़ ऑपरेशन किए जा सकते हैं, जिसके बारे में नीचे चर्चा की जाएगी।

GF (2 ⁸ ) बहुपद का निरूपण करने के लिए हेक्साडेसिमल अंकों का उपयोग करता है। उदाहरण के लिए

m = x ⁸ + x ⁴ + x ³ + x + 1 = 100011011 = 0x011b = {01}{1b}

क्षेत्र GF (2 ⁸ ) में बहुपद x = {02} से गुणा करना बहुत सरल है। उत्पाद पर विचार करें:

xp = x(a ₇ x ⁷ + a ₆ x ⁶ + a ₅ x ⁵ + a ₄ x ⁴ + a ₃ x ³ + a ₂ x ² + a ₁ x + a ₀ ) = a ₇ x ⁸ + a ₆ x ⁷ + a ₅ x ⁶ + a ₄ x ⁵ + a ₃ x ⁴ + a ₂ x ³ + a ₁ x ^<2 + a ₀ x p = a ₇ a ₆ a ₅ a ₄ a ₃ a ₂ a ₁ a ₀ xp = a ₇ a ₆ a ₅ a ₄ a ₃ a ₂ a ₁ a ₀ 0 //

अब आपको m द्वारा शेष भाग को खोजने की आवश्यकता है। यदि बिट ₇ = 1 है, तो मी को एक बार घटाएं। यदि एक ₇ = 0 तो कुछ भी घटाया नहीं जाना चाहिए। तो:

r = xp mod (m) = xp - m a ₇ = 1 r = xp mod (m) = xp a ₇ = 0

एक्स द्वारा गुणा इस फ़ंक्शन के साथ लिखा जा सकता है:

 gf.xtime = function(b) { var highbit = b & 0x80 var shl = (b << 1) & 0xff return highbit == 0 ? shl : shl ^ 0x1b }

यह जानना कि एक्स द्वारा गुणा कैसे किया जा सकता है, किसी अन्य बहुपद से गुणा किया जा सकता है। एक उदाहरण के रूप में, हम एक a • b जहां a = {3c}, b = {a1}} पाते हैं

b = {a1} = 10100001 = {80} + {20} + {01} a•b = a•{80} + a•{20} + a•{01} = a•x ⁷ + a•x ⁵ + a = a•{02}•{02}•{02}•{02}•{02}•{02}•{02} + a•{02}•{02}•{02}•{02}•{02} + a = {29} + {c1} + {3c} = {d4}

जीएफ (2 ⁸ ) क्षेत्र में एक सरल ऑपरेशन रहता है। शून्य को छोड़कर किसी भी बाइट b में, एक बाइट a = b ^-1 है, जिसमें गुण a • b = {01} है। क्षेत्र के साथ काम करने के लिए तीनों कार्य - एक्स द्वारा गुणा, दो मनमाने बाइट्स को गुणा करना और इसके विपरीत का पता लगाना - मैंने इसे जावास्क्रिप्ट में एक छोटी सी gf लाइब्रेरी में रखा।

SBox तालिका

यह तालिका 256-बाइट सरणी है और इसका उपयोग एक बाइट को दूसरे के साथ बदलने के लिए किया जाता है। यह समझना आवश्यक नहीं है कि यह कैसे बदल जाता है, क्योंकि आप इस सरणी को कोड में कॉपी कर सकते हैं। यह पता लगाने के लिए कि SBox [b] तत्व किसके बराबर है, तीन क्रियाओं की आवश्यकता है:

GF फ़ील्ड (2 ⁸ ) में b पर वापसी बाइट ढूंढें (शून्य अपरिवर्तित छोड़ें)
8 बिट्स के परिणाम को 64 बिट्स के 8 × 8 मैट्रिक्स द्वारा गुणा करें
{63} जोड़ें

कुल मिलाकर, ये तीन क्रियाएं एक परिवर्तन देती हैं:

यह समझना आसान है कि बिट्स का यह मैट्रिक्स कैसे बनाया गया है। बिट के गुणन के लिए "और" लागू करना आवश्यक है, इसके अलावा - "xor"। उदाहरण के लिए:

r ₀ = b ₀ + b ₄ + b ₅ + b ₆ + b ₇ + 1

मैंने sbox फंक्शन को इस तरह लिखा है:

 aes.sbox = function(b) { var m = 0xf8 var r = 0 var q = gf.inv(b) || 0 for (var i = 0; i < 8; i++) { r = (r << 1) | bits.xorbits(q & m) m = (m >> 1) | ((m & 1) << 7) } return r ^ 0x63 }

निर्मित तालिका इस तरह दिखती है:

63 7c 77 7b f2 6b 6f c5 30 01 67 2b fe d7 ab 76 ca 82 c9 7d fa 59 47 f0 ad d4 a2 af 9c a4 72 c0 b7 fd 93 26 36 3f f7 cc 34 a5 e5 f1 71 d8 31 15 04 c7 23 c3 18 96 05 9a 07 12 80 e2 eb 27 b2 75 09 83 2c 1a 1b 6e 5a a0 52 3b d6 b3 29 e3 2f 84 53 d1 00 ed 20 fc b1 5b 6a cb be 39 4a 4c 58 cf d0 ef aa fb 43 4d 33 85 45 f9 02 7f 50 3c 9f a8 51 a3 40 8f 92 9d 38 f5 bc b6 da 21 10 ff f3 d2 cd 0c 13 ec 5f 97 44 17 c4 a7 7e 3d 64 5d 19 73 60 81 4f dc 22 2a 90 88 46 ee b8 14 de 5e 0b db e0 32 3a 0a 49 06 24 5c c2 d3 ac 62 91 95 e4 79 e7 c8 37 6d 8d d5 4e a9 6c 56 f4 ea 65 7a ae 08 ba 78 25 2e 1c a6 b4 c6 e8 dd 74 1f 4b bd 8b 8a 70 3e b5 66 48 03 f6 0e 61 35 57 b9 86 c1 1d 9e e1 f8 98 11 69 d9 8e 94 9b 1e 87 e9 ce 55 28 df 8c a1 89 0d bf e6 42 68 41 99 2d 0f b0 54 bb 16

इसे केवल कोड पर कॉपी किया जा सकता है, जैसा कि अक्सर किया जाता है, या आवश्यकतानुसार सॉकेट फ़ंक्शन द्वारा गणना की जा सकती है।

InvSBox तालिका

पाठ को डिक्रिप्ट करने के लिए, एईएस एसबॉक्स के विपरीत एक टेबल का उपयोग करता है। InvSBox तालिका में एक गुण है: InvSBox [SBox [i]] = i। InvSBox इस तरह दिखता है:

52 09 6a d5 30 36 a5 38 bf 40 a3 9e 81 f3 d7 fb 7c e3 39 82 9b 2f ff 87 34 8e 43 44 c4 de e9 cb 54 7b 94 32 a6 c2 23 3d ee 4c 95 0b 42 fa c3 4e 08 2e a1 66 28 d9 24 b2 76 5b a2 49 6d 8b d1 25 72 f8 f6 64 86 68 98 16 d4 a4 5c cc 5d 65 b6 92 6c 70 48 50 fd ed b9 da 5e 15 46 57 a7 8d 9d 84 90 d8 ab 00 8c bc d3 0a f7 e4 58 05 b8 b3 45 06 d0 2c 1e 8f ca 3f 0f 02 c1 af bd 03 01 13 8a 6b 3a 91 11 41 4f 67 dc ea 97 f2 cf ce f0 b4 e6 73 96 ac 74 22 e7 ad 35 85 e2 f9 37 e8 1c 75 df 6e 47 f1 1a 71 1d 29 c5 89 6f b7 62 0e aa 18 be 1b fc 56 3e 4b c6 d2 79 20 9a db c0 fe 78 cd 5a f4 1f dd a8 33 88 07 c7 31 b1 12 10 59 27 80 ec 5f 60 51 7f a9 19 b5 4a 0d 2d e5 7a 9f 93 c9 9c ef a0 e0 3b 4d ae 2a f5 b0 c8 eb bb 3c 83 53 99 61 17 2b 04 7e ba 77 d6 26 e1 69 14 63 55 21 0c 7d

एईएस के प्रकार

एईएस एल्गोरिथ्म 128 बिट्स के ब्लॉक को उसी लंबाई के दूसरे ब्लॉक में परिवर्तित करता है। रूपांतरण के लिए, कुंजी से प्राप्त की गई प्रमुख अनुसूची w का उपयोग किया जाता है। एईएस में 128-बिट ब्लॉक को 4 × एन _बी मैट्रिक्स के रूप में दर्शाया गया है। मानक एन _बी = 4 के केवल एक मूल्य की अनुमति देता है, इसलिए ब्लॉक की लंबाई हमेशा 128 बिट्स होती है, हालांकि एल्गोरिथ्म किसी भी एन _{बी के} साथ काम कर सकता है। मुख्य लंबाई 4N _k बाइट्स है। ब्लॉक एन्क्रिप्शन एल्गोरिथ्म में एन _आर राउंड होते हैं - एक ही परिवर्तन समूह को 128-बिट डेटा ब्लॉक में लागू करना। मानक इन तीन मापदंडों के निम्नलिखित संयोजनों की अनुमति देता है:

	एन _के	एन _बी	एन _आर
एईएस 128	4	4	10
एईएस 192	6	4	12
एईएस 256	8	4	14

KeyExpansion रूपांतरण

AES पाठ को एन्क्रिप्ट करने के लिए पासवर्ड या पासवर्ड हैश का उपयोग नहीं करता है, लेकिन कुंजी से प्राप्त तथाकथित "कुंजी शेड्यूल"। इस अनुसूची को 4 × N _b आकार के N _r + 1 मैट्रिक्स के रूप में दर्शाया जा सकता है। एन्क्रिप्शन एल्गोरिथ्म एन _r + 1 कदम और प्रत्येक कदम पर, अन्य बातों के अलावा, यह "शेड्यूल" से एक 4 × N _बी मैट्रिक्स लेता है और इसे डेटा ब्लॉक में एलिमेंट वाइज जोड़ता है।

डेटा ब्लॉक एन्क्रिप्शन

एन्क्रिप्शन एल्गोरिथ्म 128-बिट डेटा ब्लॉक इनपुट और कुंजी शेड्यूल w प्राप्त करता है, जो KeyExpansion के बाद प्राप्त होता है। यह 4 × N _b मैट्रिक्स s के रूप में 16-बाइट इनपुट लिखता है, जिसे AES राज्य कहा जाता है, और फिर इस मैट्रिक्स N _r समय में 4 परिवर्तन लागू करता है। अंत में, वह एक सरणी के रूप में मैट्रिक्स लिखता है और इसे आउटपुट को खिलाता है - यह एक एन्क्रिप्टेड ब्लॉक है। चार परिवर्तनों में से प्रत्येक बहुत सरल है।

AddRoundKey मुख्य शेड्यूल से एक 4 × N _b मैट्रिक्स लेता है और इसे स्टेट मैट्रिक्स में एलिमेंट वाइज जोड़ता है। यदि आप AddRoundKey को दो बार लागू करते हैं, तो कुछ भी नहीं बदलेगा, इसलिए AddRoundKey का व्युत्क्रम परिवर्तन स्वयं है।
सबबाइट्स एसबीएक्स टेबल के संबंधित तत्व के साथ राज्य मैट्रिक्स के प्रत्येक तत्व को प्रतिस्थापित करता है: एसजे = एसबॉक्स [एस _{आईओएक्स} ]। SubBytes रूपांतरण प्रतिवर्ती है। इसका उलटा InvSBox तालिका का उपयोग करके पाया जाता है।
ShiftRows मैट्रिक्स की ith पंक्ति को i स्थिति से बाईं ओर स्थानांतरित करता है, जिसे मैं शून्य से गिनता हूं। उलटा InvShiftRows ट्रांसफ़ॉर्म को पंक्तियों को दाईं ओर बदलता है।
MixColumns मैट्रिक्स के प्रत्येक कॉलम को एक विशेष 4 × 4 मैट्रिक्स द्वारा बाईं ओर गुणा करता है:

एन्क्रिप्शन उपयोग के लिए [abcd] = [{०२} {०३} {०१} {०१}]। आप यह सत्यापित कर सकते हैं कि रूपांतरण MixColumns [{02} {03} {01} {01}] के विपरीत है, यह MixColumns [{0e} {0b} {0d} {09}] है।

योजनाबद्ध एन्क्रिप्शन को निम्नानुसार दर्शाया जा सकता है:

 AddRoundKey(0) for (var i = 1; i <= Nr - 1; i++) { SubBytes() ShiftRows() MixColumns([0x02, 003, 0x01, 0x01]) AddRoundKey(i) } SubBytes() ShiftRows() AddRoundKey(Nr)

प्रतिलिपि

जैसा कि आप देख सकते हैं, डेटा ब्लॉक को एन्क्रिप्ट करने के लिए, एईएस लगातार इसमें कई प्रतिवर्ती परिवर्तन लागू करता है। डिक्रिप्ट करने के लिए, आपको रिवर्स ऑर्डर में उलटा रूपांतर लागू करना होगा।

थोड़ा सा अनुकूलन

Sbox फ़ंक्शन में कुल 256 संभावित इनपुट मान और 256 संभावित आउटपुट मान हैं। कई बार एक तर्क के लिए sbox की गणना नहीं करने के लिए, आपको परिणामों को कैश करना होगा। जावास्क्रिप्ट में, आपके द्वारा पहले लिखे गए कोड को बदलने के बिना भी करना आसान है। ऐसा करने के लिए, आपको बस इसके नीचे जोड़ना होगा:

 Function.prototype.cached = function() { var old = this var cache = {} return function(x) { if (cache[x] !== undefined) return cache[x] cache[x] = old(x) return cache[x] } } aes.sbox = aes.sbox.cached()

यह कोड sbox को एक फ़ंक्शन के साथ बदलता है जो sbox परिणाम को कैश करता है। किसी भी फ़ंक्शन के लिए एक ही काम किया जा सकता है, उदाहरण के लिए इनबॉक्स और आरओएन। उसी तकनीक को gf.mul फ़ंक्शन पर लागू किया जा सकता है जो GF फ़ील्ड (2 ⁸ ) में दो बाइट्स को गुणा करता है, लेकिन इस मामले में कैश का आकार 256 × 256 तत्व होगा, जो कि काफी अधिक है।

संदर्भ

अंग्रेजी में AES प्रलेखन को 197 FIPS कहा जाता है।

एईएस कैसे काम करता है