SIMD ब्लॉक के कारण बैकल-टी 1 प्रोसेसर पर GOST 28147-89 के अनुसार एन्क्रिप्शन को कैसे तेज करें

फिस्टल नेटवर्क पर निर्मित GOST 28147-89 के अनुसार एन्क्रिप्शन एल्गोरिथ्म के कार्यान्वयन के विवरण का एक उदाहरण का उपयोग करते हुए, लेख दोहरे कोर प्रोसेसर BE-T1000 (उर्फ बाइकाल-टी 1) की क्षमताओं को दर्शाता है और बिना सिमड कोप्रोसेसर के और बिना वेक्टर गणना के एल्गोरिथ्म के कार्यान्वयन के तुलनात्मक परीक्षण करता है। यहां हम GOST 28147-89, ECB मोड के अनुसार एन्क्रिप्शन कार्य के लिए SIMD ब्लॉक का उपयोग प्रदर्शित करेंगे।

यह लेख पिछले साल बैकल इलेक्ट्रॉनिक्स के एक प्रमुख प्रोग्रामर अलेक्सी कोलोनिकोव द्वारा इलेक्ट्रॉनिक अवयव जर्नल के लिए लिखा गया था। और चूंकि इस पत्रिका में बहुत सारे पाठक नहीं हैं, और लेख उन लोगों के लिए उपयोगी है जो पेशेवर रूप से क्रिप्टोग्राफी में शामिल हैं, मैं, लेखक और उसकी छोटी-छोटी जोड़ियों की अनुमति से, इसे यहां प्रकाशित करता हूं।

बाइकाल-टी 1 प्रोसेसर और इसके अंदर सिमड ब्लॉक

बाइकाल-टी 1 प्रोसेसर में एमआइपीएस 32 पी 5600 परिवार का मल्टीप्रोसेसर ड्यूल-कोर सिस्टम शामिल है, साथ ही परिधीय उपकरणों को नियंत्रित करने के लिए डेटा और कम गति का आदान-प्रदान करने के लिए उच्च गति वाले इंटरफेस का एक सेट है। यहाँ इस प्रोसेसर का संरचनात्मक आरेख है:

प्रत्येक दो कोर में एक SIMD ब्लॉक शामिल है जो आपको 128-बिट वैक्टर के साथ काम करने की अनुमति देता है। SIMD विधि का उपयोग करते समय, एक से अधिक नमूने संसाधित किए जाते हैं,
और पूरे वेक्टर, जिसमें कई नमूने हो सकते हैं, अर्थात, डेटा के पूरे वेक्टर (सरणी) पर एक कमांड तुरंत लागू होता है। इस प्रकार, एक कमांड चक्र में, कई नमूनों को संसाधित किया जाता है। प्रोसेसर MIPS32 SIMD ब्लॉक का उपयोग करता है, जो आपको 128-बिट रजिस्टरों के 32 टुकड़ों के साथ काम करने की अनुमति देता है।

प्रत्येक रजिस्टर में निम्न आयामों के वैक्टर हो सकते हैं: 8 × 16; 16 × 8; 4 × 32 या
2 × 64 बिट्स। डेटा संसाधित करने के लिए 150 से अधिक निर्देशों का उपयोग करना संभव है: पूर्णांक, फ्लोटिंग-पॉइंट और फिक्स्ड-पॉइंट, जिसमें बिटवाइज़ ऑपरेशंस, तुलना संचालन और रूपांतरण संचालन शामिल हैं।

"MIPS SIMD प्रौद्योगिकी और बाइकाल-टी 1 प्रक्रिया" लेख में SparF द्वारा बहुत विस्तृत MIPS SIMD तकनीक का वर्णन किया गया था।

वेक्टर कंप्यूटिंग की प्रभावशीलता का मूल्यांकन

बैकल-टी 1 प्रोसेसर कोर के अंकगणित सहसंसाधक एक पारंपरिक फ्लोटिंग-पॉइंट प्रोसेसर और एक समानांतर SIMD प्रोसेसर को जोड़ती है, जो वैक्टर और डिजीटल सिग्नल के कुशल प्रसंस्करण पर केंद्रित है। 2017 में SparF द्वारा "MIPS SIMD टेक्नॉलॉजी और बाइकाल-टी 1 प्रोसेसर" लेख लिखते हुए वेक्टर SIMD कॉपरप्रोसेसर का एक स्वतंत्र प्रदर्शन मूल्यांकन किया गया था। यदि वांछित है, तो इस तरह के माप को दोहराया जा सकता है, एक प्रोसेसर के साथ रिमोट स्टैंड से कनेक्ट करके स्वतंत्र रूप से प्रदर्शन किया जाता है।

तब परीक्षण कार्य नियमित अंतराल पर लिए गए स्क्रीनशॉट के साथ मुक्त x264 पुस्तकालयों (H.264 डेमो क्लिप) और x265 (HEVC वीडियो फ़ाइल) का उपयोग करके एन्कोड किए गए वीडियो को डीकोड करना था। उम्मीद के मुताबिक, SIMD हार्डवेयर क्षमताओं के उपयोग के साथ FFmpeg कार्यों पर प्रोसेसर कोर प्रदर्शन में एक उल्लेखनीय वृद्धि नोट की गई थी:

एल्गोरिथ्म GOST 28147-89 का संक्षिप्त विवरण

यहां हम केवल कोड और अनुकूलन को समझने के लिए मुख्य विशेषताओं पर ध्यान देंगे:

• एल्गोरिथ्म Feistel नेटवर्क पर बनाया गया है।
  
• एल्गोरिथ्म में 32 राउंड होते हैं।
• एक राउंड में एक कुंजी मिलाना और 11 बिट्स के बदलाव के साथ एक टेबल में 4 बिट्स के 8 भागों को बदलना शामिल है।

GOST 28147-89 के अनुसार सूचना रूपांतरण एल्गोरिथ्म का विस्तृत विवरण यूएसएसआर के राज्य मानक में दिया गया है ।

एक SIMD ब्लॉक का उपयोग किए बिना GOST 28147-89 एल्गोरिथ्म का कार्यान्वयन

तुलनात्मक उद्देश्यों के लिए, एल्गोरिदम को शुरू में मानक, "गैर-वेक्टरकृत" आदेशों का उपयोग करके लागू किया गया था।

यहां प्रस्तावित MIPS कोडांतरक कोड आपको 450 मेगाहर्ट्ज (या ~ 150 एमबी / एस) में 64 बिट्स के एक ब्लॉक को 1200 मेगाहर्ट्ज के नाममात्र प्रोसेसर आवृत्ति पर एन्क्रिप्ट करने की अनुमति देता है। गणना में केवल एक कोर शामिल है।

एक प्रतिस्थापन तालिका तैयार करने का मतलब है कि गोल के काम को गति देने के लिए इसे 32-बिट प्रतिनिधित्व में विस्तारित करना: अग्रिम में चार बिट्स को बदलने और बदलने के बजाय।
तैयार तालिका में आठ बिट्स की जगह है।

uint8_t sbox_test[8][16] = { {0x9, 0x6, 0x3, 0x2, 0x8, 0xb, 0x1, 0x7, 0xa, 0x4, 0xe, 0xf, 0xc, 0x0, 0xd, 0x5}, {0x3, 0x7, 0xe, 0x9, 0x8, 0xa, 0xf, 0x0, 0x5, 0x2, 0x6, 0xc, 0xb, 0x4, 0xd, 0x1}, {0xe, 0x4, 0x6, 0x2, 0xb, 0x3, 0xd, 0x8, 0xc, 0xf, 0x5, 0xa, 0x0, 0x7, 0x1, 0x9}, {0xe, 0x7, 0xa, 0xc, 0xd, 0x1, 0x3, 0x9, 0x0, 0x2, 0xb, 0x4, 0xf, 0x8, 0x5, 0x6}, {0xb, 0x5, 0x1, 0x9, 0x8, 0xd, 0xf, 0x0, 0xe, 0x4, 0x2, 0x3, 0xc, 0x7, 0xa, 0x6}, {0x3, 0xa, 0xd, 0xc, 0x1, 0x2, 0x0, 0xb, 0x7, 0x5, 0x9, 0x4, 0x8, 0xf, 0xe, 0x6}, {0x1, 0xd, 0x2, 0x9, 0x7, 0xa, 0x6, 0x0, 0x8, 0xc, 0x4, 0x5, 0xf, 0x3, 0xb, 0xe}, {0xb, 0xa, 0xf, 0x5, 0x0, 0xc, 0xe, 0x8, 0x6, 0x2, 0x3, 0x9, 0x1, 0x7, 0xd, 0x4} }; uint32_t sbox_cvt[4*256]; for (i = 0; i < 256; ++i) { uint32_t p; p = sbox[7][i >> 4] << 4 | sbox[6][i & 15]; p = p << 24; p = p << 11 | p >> 21; sbox_cvt[i] = p; // S87 p = sbox[5][i >> 4] << 4 | sbox[4][i & 15]; p = p << 16; p = p << 11 | p >> 21; sbox_cvt[256 + i] = p; // S65 p = sbox[3][i >> 4] << 4 | sbox[2][i & 15]; p = p << 8; p = p << 11 | p >> 21; sbox_cvt[256 * 2 + i] = p; // S43 p = sbox[1][i >> 4] << 4 | sbox[0][i & 15]; p = p << 11 | p >> 21; sbox_cvt[256 * 3 + i] = p; // S21 } 

ब्लॉक एन्क्रिप्शन कुंजी का उपयोग करके गोल का 32 गुना दोहराना है।

 // input: a0 - &in, a1 - &out, a2 - &key, a3 - &sbox_cvt LEAF(gost_encrypt_block_asm) .set reorder lw n1, (a0) // n1, IN lw n2, 4(a0) // n2, IN + 4 lw t0, (a2) // key[0] -> t0 gostround n1, n2, 1 gostround n2, n1, 2 gostround n1, n2, 3 gostround n2, n1, 4 gostround n1, n2, 5 gostround n2, n1, 6 gostround n1, n2, 7 gostround n2, n1, 0 gostround n1, n2, 1 gostround n2, n1, 2 gostround n1, n2, 3 gostround n2, n1, 4 gostround n1, n2, 5 gostround n2, n1, 6 gostround n1, n2, 7 gostround n2, n1, 0 gostround n1, n2, 1 gostround n2, n1, 2 gostround n1, n2, 3 gostround n2, n1, 4 gostround n1, n2, 5 gostround n2, n1, 6 gostround n1, n2, 7 gostround n2, n1, 7 gostround n1, n2, 6 gostround n2, n1, 5 gostround n1, n2, 4 gostround n2, n1, 3 gostround n1, n2, 2 gostround n2, n1, 1 gostround n1, n2, 0 gostround n2, n1, 0 1: sw n2, (a1) sw n1, 4(a1) jr ra nop END(gost_encrypt_block_asm) 

एक फैल टेबल राउंड सिर्फ एक टेबल स्वैप है।

  .macro gostround x_in, x_out, rkey addu t8, t0, \x_in /* key[0] + n1 = x */ lw t0, \rkey * 4 (a2) /* next key to t0 */ ext t2, t8, 24, 8 /* get bits [24,31] */ ext t3, t8, 16, 8 /* get bits [16,23] */ ext t4, t8, 8, 8 /* get bits [8,15] */ ext t5, t8, 0, 8 /* get bits [0, 7] */ sll t2, t2, 2 /* convert to dw offset */ sll t3, t3, 2 /* convert to dw offset */ sll t4, t4, 2 /* convert to dw offset */ sll t5, t5, 2 /* convert to dw offset */ addu t2, t2, a3 /* add sbox_cvt */ addu t3, t3, a3 /* add sbox_cvt */ addu t4, t4, a3 /* add sbox_cvt */ addu t5, t5, a3 /* add sbox_cvt */ lw t6, (t2) /* sbox[x[3]] -> t2 */ lw t7, 256*4(t3) /* sbox[256 + x[2]] -> t3 */ lw t9, 256*2*4(t4) /* sbox[256 *2 + x[1]] -> t4 */ lw t1, 256*3*4(t5) /* sbox[256 *3 + x[0]] -> t5 */ or t2, t7, t6 /* | */ or t3, t1, t9 /* | */ or t2, t2, t3 /* | */ xor \x_out, \x_out, t2 /* n2 ^= f(...) */ .endm 

एक SIMD ब्लॉक का उपयोग कर GOST 28147-89 एल्गोरिथ्म का कार्यान्वयन

नीचे प्रस्तावित कोड आपको समान परिस्थितियों में एक साथ 64 बिट्स के 720 (या ~ 350 Mbit / s) प्रति 64 बिट्स के चार ब्लॉकों को एन्क्रिप्ट करने की अनुमति देता है: प्रोसेसर आवृत्ति 1200 मेगाहर्ट्ज, एक कोर।

प्रतिस्थापन दो चौगुनी में और तुरंत 4 ब्लॉकों में shuffle निर्देश और महत्वपूर्ण चौकों की मास्किंग के साथ किया जाता है।

एक प्रतिस्थापन तालिका का विस्तार

 for(i = 0; i < 16; ++i) { sbox_cvt_simd[i] = (sbox[7][i] << 4) | sbox[0][i]; // $w8 [7 0] sbox_cvt_simd[16 + i] = (sbox[1][i] << 4) | sbox[6][i]; // $w9 [6 1] sbox_cvt_simd[32 + i] = (sbox[5][i] << 4) | sbox[2][i]; // $w10[5 2] sbox_cvt_simd[48 + i] = (sbox[3][i] << 4) | sbox[4][i]; // $w11[3 4] } 

प्रारंभिक मास्क।

 l0123: .int 0x0f0f0f0f .int 0xf000000f /* substitute from $w8 [7 0] mask in w12*/ .int 0x0f0000f0 /* substitute from $w9 [6 1] mask in w13*/ .int 0x00f00f00 /* substitute from $w10 [5 2] mask in w14*/ .int 0x000ff000 /* substitute from $w11 [4 3] mask in w15*/ .int 0x000f000f /* mask $w16 x N x N */ .int 0x0f000f00 /* mask $w17 N x N x */ LEAF(gost_prepare_asm) .set reorder .set msa la t1, l0123 /* masks */ lw t2, (t1) lw t3, 4(t1) lw t4, 8(t1) lw t5, 12(t1) lw t6, 16(t1) lw t7, 20(t1) lw t8, 24(t1) fill.w $w2, t2 /* 0f0f0f0f -> w2 */ fill.w $w12, t3 /* f000000f -> w12*/ fill.w $w13, t4 /* 0f0000f0 -> w13*/ fill.w $w14, t5 /* 00f00f00 -> w14*/ fill.w $w15, t6 /* 000ff000 -> w15*/ fill.w $w16, t7 /* 000f000f -> w16*/ fill.w $w17, t8 /* 0f000f00 -> w17*/ ld.b $w8, (a0) /* load sbox */ ld.b $w9, 16(a0) ld.b $w10, 32(a0) ld.b $w11, 48(a0) jr ra nop END(gost_prepare_asm) 

4 ब्लॉक एन्क्रिप्शन

 LEAF(gost_encrypt_4block_asm) .set reorder .set msa lw t1, (a0) // n1, IN lw t2, 4(a0) // n2, IN + 4 lw t3, 8(a0) // n1, IN + 8 lw t4, 12(a0) // n2, IN + 12 lw t5, 16(a0) // n1, IN + 16 lw t6, 20(a0) // n2, IN + 20 lw t7, 24(a0) // n1, IN + 24 lw t8, 28(a0) // n2, IN + 28 lw t0, (a2) // key[0] -> t0 insert.w ns1[0],t1 insert.w ns2[0],t2 insert.w ns1[1],t3 insert.w ns2[1],t4 insert.w ns1[2],t5 insert.w ns2[2],t6 insert.w ns1[3],t7 insert.w ns2[3],t8 gostround4 ns1, ns2, 1 gostround4 ns2, ns1, 2 gostround4 ns1, ns2, 3 gostround4 ns2, ns1, 4 gostround4 ns1, ns2, 5 gostround4 ns2, ns1, 6 gostround4 ns1, ns2, 7 gostround4 ns2, ns1, 0 gostround4 ns1, ns2, 1 gostround4 ns2, ns1, 2 gostround4 ns1, ns2, 3 gostround4 ns2, ns1, 4 gostround4 ns1, ns2, 5 gostround4 ns2, ns1, 6 gostround4 ns1, ns2, 7 gostround4 ns2, ns1, 0 gostround4 ns1, ns2, 1 gostround4 ns2, ns1, 2 gostround4 ns1, ns2, 3 gostround4 ns2, ns1, 4 gostround4 ns1, ns2, 5 gostround4 ns2, ns1, 6 gostround4 ns1, ns2, 7 gostround4 ns2, ns1, 7 gostround4 ns1, ns2, 6 gostround4 ns2, ns1, 5 gostround4 ns1, ns2, 4 gostround4 ns2, ns1, 3 gostround4 ns1, ns2, 2 gostround4 ns2, ns1, 1 gostround4 ns1, ns2, 0 gostround4 ns2, ns1, 0 1: copy_s.w t1,ns2[0] copy_s.w t2,ns1[0] copy_s.w t3,ns2[1] copy_s.w t4,ns1[1] copy_s.w t5,ns2[2] copy_s.w t6,ns1[2] copy_s.w t7,ns2[3] copy_s.w t8,ns1[3] sw t1, (a1) // n2, OUT sw t2, 4(a1) // n1, OUT + 4 sw t3, 8(a1) // n2, OUT + 8 sw t4, 12(a1) // n1, OUT + 12 sw t5, 16(a1) // n2, OUT + 16 sw t6, 20(a1) // n1, OUT + 20 sw t7, 24(a1) // n2, OUT + 24 sw t8, 28(a1) // n1, OUT + 28 jr ra nop END(gost_encrypt_4block_asm) 

एक साथ 4 ब्लॉक की गणना के साथ SIMD ब्लॉक कमांड का उपयोग करके राउंड

 .macro gostround4 x_in, x_out, rkey fill.w $w0, t0 /* key -> Vi */ addv.w $w1, $w0, \x_in /* key[0] + n1 = x */ srli.b $w3, $w1, 4 /* $w1 >> 4 */ and.v $w4, $w1, $w16 /* x 4 x 0*/ and.v $w5, $w1, $w17 /* 6 x 2 x*/ and.v $w6, $w3, $w17 /* 7 x 3 x */ and.v $w7, $w3, $w16 /* x 5 x 1 */ lw t0, \rkey * 4(a2) /* next key -> t0 */ or.v $w4, $w6, $w4 /* 7 4 3 0 */ or.v $w5, $w5, $w7 /* 6 5 2 1 */ move.v $w6, $w5 /* 6 5 2 1 */ move.v $w7, $w4 /* 7 4 3 0 */ /* 7 xx 0 */ /* 6 xx 1 */ /* x 5 2 x */ /* x 4 3 x */ vshf.b $w4, $w8, $w8 /* substitute $w8 [7 0] */ and.v $w4, $w4, $w12 vshf.b $w5, $w9, $w9 /* substitute $w9 [6 1] */ and.v $w5, $w5, $w13 vshf.b $w6, $w10, $w10 /* substitute $w10 [5 2] */ and.v $w6, $w6, $w14 vshf.b $w7, $w11, $w11 /* substitute $w11 [4 3] */ and.v $w7, $w7, $w15 or.v $w4, $w4, $w5 or.v $w6, $w6, $w7 or.v $w4, $w4, $w6 srli.w $w1, $w4, 21 /* $w4 >> 21 */ slli.w $w3, $w4, 11 /* $w4 << 11 */ or.v $w1, $w1, $w3 xor.v \x_out, \x_out, $w1 .endm 

संक्षिप्त निष्कर्ष

बाइकाल-टी 1 प्रोसेसर के सिमड-ब्लॉक का उपयोग करने से GOST 28147-89 एल्गोरिदम के अनुसार लगभग 350 Mbit / s की डेटा रूपांतरण दर प्राप्त करने की अनुमति मिलती है, जो कि मानक आदेशों पर कार्यान्वयन की तुलना में ढाई () है। चूंकि इस प्रोसेसर में दो कोर हैं, इसलिए ~ 700 एमबीपीएस की गति से स्ट्रीम को एन्क्रिप्ट करना सैद्धांतिक रूप से संभव है। GOST 28147-89 के अनुसार एन्क्रिप्शन के साथ कम से कम IPsec के परीक्षण कार्यान्वयन ने चैनल को एक द्वैध पर ~ 400 एमबीपीएस के थ्रूपुट दिखाया।