💖 👨‍👨‍👧 👩🏾‍🌾 1024 बाइट्स में AVR असेंबलर पर AES-128 और EAX के साथ बूटलोडर 👨🏽‍🎤 🖌️ 👨‍✈️

या मैं कैसे डरना बंद कर दिया और कोडांतरक के साथ प्यार में गिर गया

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

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

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

मंच और भाषा

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

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

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

बूटलोडर क्या है

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

AVR आर्किटेक्चर में, बूटलोडर को दो तरीकों से बुलाया जा सकता है - उस पर एक रीसेट वेक्टर सेट करके या BOOTRST फ्यूज को स्थापित करके, जो माइक्रोकंट्रोलर को 0 पते से काम शुरू करने के लिए बाध्य नहीं करेगा, लेकिन बूटलोडर के प्रारंभ पते से, जिसका आकार सेट है, फिर से, फ़्यूज़ में।

इस स्तर पर क्या समस्याएं पैदा हो सकती हैं? संलयन संपादित किया जा सकता है। एक उच्च बुद्धिमान "उपयोगकर्ता", उदाहरण के लिए, रिपॉजिट BOOTRST और काम एक रीसेट वेक्टर के साथ शुरू होगा, हमारे बूट से नहीं। यह बूटलोडर के आकार को बदल सकता है, माइक्रोकंट्रोलर बूट के बीच से किसी प्रकार के विधर्म को निष्पादित करना शुरू कर देगा और यह सिस्टम से समझौता कर सकता है।

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

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

क्रिप्टोग्राफी

काम शुरू करने से पहले, मैंने कोर्टेरा पर डैन बोनट से क्रिप्टोग्राफी पाठ्यक्रम का भाग 1 पूरा किया। प्रोफेसर डैन ने लगातार कहा कि किसी भी मामले में आपको क्रिप्टोग्राफिक सिस्टम खुद नहीं लिखना चाहिए, यह पेशेवरों द्वारा किया जाना चाहिए, न कि प्रथम वर्ष के छात्रों को अपनी छुट्टियों के दौरान। बेशक। औचित्य में, मैं कह सकता हूं कि यह बूटलोडर सभी हमलों के लिए अयोग्य के रूप में तैनात नहीं है। इसका अस्तित्व एक बुनियादी नहीं है, लेकिन बौद्धिक संपदा की रक्षा का एक अतिरिक्त उपाय है। संक्षेप में, एक व्यक्ति को अद्यतन फ़ाइल में गहरी खुदाई करनी चाहिए, ऑसिलोस्कोप में टकरा जाना चाहिए, एक सप्ताह के लिए खुद को पीड़ा देनी चाहिए, "अच्छी तरह से सोचो, इसके साथ नरक करने के लिए, मैं चीनी को $ 2000 का भुगतान करूंगा, वे इसे काट देंगे" और बस यही करते हैं। सॉफ्टवेयर हैकिंग की लागत भौतिक हैकिंग की लागत से अधिक होनी चाहिए, और अधिक नहीं।

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

यदि आप किसी भी तरह से फर्मवेयर को बदलने की संभावना को अनुमति नहीं दे सकते हैं, तो आपको संदेश प्रामाणिकता कोड का उपयोग करना होगा। ऐसे कोड के उदाहरण CCM, GCM, EAX हैं। ईमानदारी से, मुझे याद नहीं है कि मैंने EAX को क्यों चुना। सबसे अधिक संभावना है, कोडांतरक में इसका भविष्य का कार्यान्वयन मुझे सबसे सरल लग रहा था।

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

EAX

एन्क्रिप्शन लिखने के लिए एक इंजीनियर को कितने प्रलेखन की आवश्यकता होती है? वैज्ञानिक कार्यों से लिए गए दो चित्र।

हेल्पर एल्गोरिदम

हम फर्मवेयर एन्क्रिप्शन के चरण में डेटा वॉल्यूम की बहुलता को ब्लॉक आकार की गारंटी देते हैं, जो पैड फ़ंक्शन को M ^ B (31) तक कम कर देता है और चर P (32) का उपयोग कभी नहीं किया जाएगा।

मुख्य पीढ़ी के चरण में, हम निरंतर एल (40) की गणना कर सकते हैं और, परिणामस्वरूप, बी।

"छोड़कर या एक तीर के साथ" (31) का अर्थ है कि बी केवल एक्स के अंत में होगा एम।

एन्क्रिप्शन प्रक्रिया

जहाँ M अनएन्क्रिप्टेड टेक्स्ट है, CT ciphertext है, K कुंजी है, N इनिशियलाइज़ेशन वेक्टर है, H हेडर है।

कोडांतरक में, आपको केवल डिक्रिप्शन फ़ंक्शन लिखना होगा।

संदेश शीर्षलेख H को सेट, अपरिवर्तित और केवल हमारे लिए जाना जाता है। यह क्रिप्टोग्राफिक ताकत को प्रभावित नहीं करता है, क्योंकि यह समझा जाता है कि शीर्षक सार्वजनिक जानकारी है। अब आप प्रमुख पीढ़ी के चरण में एच '(23) की गणना कर सकते हैं।

यदि आप 50 और 10 के साथ 22, 24 को देखते हैं, तो आप महसूस कर सकते हैं कि OMAC के साथ सुपरस्क्रिप्ट में अंक ब्लॉक की लंबाई के बराबर लंबाई के साथ लाइन के अंतिम वर्ण पर जाएगा और CBC में पहले ब्लॉक के रूप में उपयोग किया जाएगा, अर्थात यह एन्क्रिप्ट किया गया है। इन लाइनों का एन्क्रिप्शन मुख्य पीढ़ी के चरण में किया जा सकता है। इसके अलावा, केवल संख्याएँ 0 (L0) और 2 (L2) के साथ एन्क्रिप्टेड लाइनों को क्रमशः 'N और C' की गणना करने के लिए महत्वपूर्ण फ़ाइल में शामिल किया जाएगा।

एल 0, बी, और एन के साथ हाथ पर, एन 'की गणना ई (एल 0 ^ बी ^ एन) तक कम हो जाती है।

तो, प्रमुख पीढ़ी के चरण में, बी, एल 0, एल 2, एच 'की गणना की जाएगी।

एक साथ वे 64 बाइट पर कब्जा कर लेंगे।

एईएस 128

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

एईएस विशेषता यह है कि डिक्रिप्शन एन्क्रिप्शन की तुलना में एल्गोरिदम अधिक जटिल है। डिक्रिप्शन प्रक्रिया में, आपको अंतिम फ़ील्ड में 14 से गुणा करना होगा। चूँकि हमारे पास इस हॉरर में कई गुणा तार नहीं हैं, इसलिए हम एईएस गैर-मानक रूप से उपयोग करेंगे - शक्तिशाली कंप्यूटर पर अपडेट को एन्क्रिप्ट करने के लिए, हम इसे "डिक्रिप्ट" करेंगे, और जब एक कमजोर माइक्रोकंट्रोलर, "एन्क्रिप्ट" पर डिक्रिप्ट होगा। क्रिप्टोग्राफिक ताकत में कोई अंतर नहीं है।

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

विस्तारित कुंजी 176 बाइट्स पर कब्जा करेगी। गणना की गई स्थिरांक के साथ, यह एक प्रमुख फ़ाइल बनाता है जो हमेशा के लिए 240 बाइट्स फ्लैश ले जाएगा। 784 बचे हैं, अर्थात् 392 कोडांतरक निर्देश।

एईएस का एक महत्वपूर्ण और विशाल हिस्सा लुकअप टेबल है - बाइट्स जो टेक्स्ट के बाइट्स को बदल देता है। एक बाइट में 256 संभावित संयोजन होते हैं और तालिका में फ्लैश मेमोरी की समान मात्रा होगी। अस्वीकार्य! तो, हम इसकी गणना करेंगे।

लुकअप तालिका की गणना निम्न प्रकार से की जाती है: सबसे पहले, वह संख्या ज्ञात करें जो तालिका तत्व की संख्या के विपरीत है, फिर, यह विपरीत है, निम्न चक्कर परिवर्तन से गुजरता है:

x0 ... x7 एक वेक्टर के रूप में व्युत्क्रम संख्या है। आपको कोडांतरक में यह लिखना होगा और लाभ प्राप्त करने के लिए 256 बाइट्स से कम में फिट होना चाहिए। हम 88 बाइट्स में फिट होंगे। चलिए शुरू करते हैं।

नमस्ते दुनिया!

एक असेंबलर प्रोग्रामर हमेशा अपने स्वयं के जीवन को सरल बनाकर एक कार्यक्रम शुरू करता है। इसमें रजिस्टरों का नाम बदलना शामिल है ताकि, उदाहरण के लिए, r16 के बजाय temp_0 लिखा जा सके। परंपरा से, मैं 0 और 1 रजिस्टर OP0 और OP1, 2 और 3 - NULL और OxFF (संबंधित मानों के साथ उन्हें भरता हूं), और बाकी - आवश्यकतानुसार कॉल करता हूं।

रजिस्टरों

.def OP0 = r0 .def OP1 = r1 .def NULL = r2 .def OxFF = r3 .def b0 = r4 .def b1 = r5 .def b2 = r6 .def b3 = r7 .def b4 = r8 .def b5 = r9 .def b6 = r10 .def b7 = r11 .def b8 = r12 .def b9 = r13 .def bA = r14 .def bB = r15 .def bC = r16 .def bD = r17 .def bE = r18 .def bF = r19 .def temp_0 = r20 .def temp_1 = r21 .def temp_2 = r22 .def temp_3 = r23 .def temp_4 = r24 .def temp_5 = r25

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

25 के माध्यम से 20 रजिस्टरों का उपयोग गणना किए गए डेटा के अस्थायी भंडारण के लिए किया जाता है और तदनुसार नाम दिए जाते हैं।

26 से 32 तक विशेष 16-बिट रजिस्टर हैं - एक्स, वाई, जेड, मेमोरी एड्रेसिंग के लिए उपयोग किया जाता है। इसके अलावा, फ्लैश को संबोधित करने के लिए केवल Z का उपयोग किया जा सकता है। जैसा कि मैंने सुना है, उनके पास शारीरिक रूप से वेतन वृद्धि, विस्थापन और विस्थापन की गणना के लिए तकनीकी उपकरण हैं, इसलिए, अन्य उद्देश्यों के लिए उनका उपयोग करते हुए, हालांकि संभव है, बुरा अभ्यास माना जाता है और महत्वपूर्ण अनुप्रयोगों में अस्वीकार्य glitches हो सकता है।

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

स्थिरांक

 .equ PAGE_BYTES = PAGESIZE*2 .equ BOOT_SIZE = 1024 .equ BLOCK_SIZE = 16 .equ PAGES = (FLASHEND+1)/PAGESIZE - BOOT_SIZE/PAGE_BYTES .equ BLOCKS_PER_PAGE = PAGE_BYTES / BLOCK_SIZE .equ KEY_ADDR = (FLASHEND + 1) — (BLOCK_SIZE*(11+4))/2

आइए लचीलेपन के भविष्य के चमत्कार को जोड़ दें - चलो UART की संचार गति, पोर्ट, आउटपुट और उस स्तर को चुनें, जिसके द्वारा हम तय करेंगे कि बूटलोडर में रहना है या लोड करना जारी रखना है। इस तरह की उपयोगितावादी सेटिंग्स के अलावा, आप उस लेबल के पते को निर्दिष्ट कर सकते हैं, जिस पर फ़र्मवेयर की आवश्यकता नहीं होने पर जंप किया जाएगा, और यह भी तय करें कि क्या बूटलोडर को मेमोरी के शून्य पृष्ठ को बदलना चाहिए - वहाँ एक रुकावट वेक्टर है और एक हमलावर द्वारा इसे ओवरराइट करने से सिस्टम समझौता कर सकता है।

सेटिंग्स

 ;Reset address (Where to jump to if not asked to load boot) .equ RESET_VECT = 0 ;Is 0th flash page used? .equ USE_0th_PAGE = 1 ;////////////////////////PORT SETUP #define check_port \ port_settings \ /* use port letter... */\ /* A / B / C / D / E */\ C, \ /* check status of pin number...*/\ 5, \ /* load boot only if port is... */\ /* (S)ET (1) / (C)LEAR (0) */\ S ;////////////////////////BAUD RATE SETUP .equ Fosc = 16000000 ;clock frequency .equ baud = 19200 ;baud rate .equ UBRR = Fosc / ( BLOCK_SIZE * baud ) - 1 .if high( UBRR ) != 0 .error "Unsupported baud rate setting - high byte of UBRR is not 0!" .endif

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

स्मृति में एक जगह जकड़ें

 .dseg .org 0x60 SBOX: .byte 256 ;rijndael substitution box ;these three SHOULD be consecutive SAVED_IV: .byte BLOCK_SIZE ;E(L0^N^B) RCVD_PAGE: .byte PAGE_BYTES ;page to be written TAG: .byte BLOCK_SIZE ;initially - precomputed header value ENC_IV: .byte PAGE_BYTES ;IV's to xor with page to decrypt .cseg

ATmega16 पर, 64 बाइट्स के एक पृष्ठ आकार के साथ, RAM की मात्रा का उपयोग 1024 में से 544 बाइट्स है। ATmega8 पर यह 416 है। बहुत अधिक। थोड़ी मात्रा में रैम के साथ फ्लैश-मेमोरी के बड़े पन्नों के साथ माइक्रोकंट्रोलर होते हैं। शायद आप कुछ के साथ आ सकते हैं, लेकिन कुछ लोगों को पूरे परिवार के साथ संगतता की आवश्यकता होगी।

हम प्रीप्रोसेसर निर्देशों से परिचित हो गए, चलो असेंबलर पर चलते हैं। पारंपरिक रूप से स्टैक पॉइंटर को इनिशियलाइज़ करके, इंटरप्ट को बंद करके, NULL और OxFF रजिस्टर सेट करके और UART सेटिंग सेट करके प्रोग्राम शुरू होता है।

प्रारंभ

 BOOT_START: ldi temp_0, low( RAMEND) out SPL, temp_0 ldi temp_0, high(RAMEND) out SPH, temp_0 cli clr NULL mov OxFF, NULL com OxFF ldi temp_0, low( UBRR ) out UBRRH, NULL out UBRRL, temp_0 ldi temp_0, ( 1 << RXEN ) | ( 1 << TXEN ) out UCSRB, temp_0 ldi temp_0, ( 1 << URSEL ) | ( 1 << UCSZ1 ) | ( 1 << UCSZ0 ) out UCSRC, temp_0

इस सब के लिए, हमारे पास पहले से ही 6 अलग-अलग कोडांतरक कमांड हैं, जो संक्षिप्त या संक्षिप्त हैं। ldi - लोड, मूव - मूव, आउट - आउटपुट से I \ O रजिस्टर, कॉम - सप्लीमेंट, क्ली - क्लियर इंटरप्ट फ्लैग। जैसा कि मैंने कहा, असेंबलर असंभव के लिए सरल है। सभी प्रकार के अस्पष्ट UBRRH (UART बॉड रेट रजिस्टर हाई-बाइट) के साथ "मुश्किल" भागों को डेटशीट में विस्तार से वर्णित किया गया है और यह उपकरण सेटिंग्स हैं।

तय करें कि बूट में रहना है या नहीं। उपयोगकर्ता सेटिंग्स के अनुसार पोर्ट रजिस्टर का चयन, विधानसभा स्तर पर किया जाता है:

एक सुरुचिपूर्ण मैक्रो करता है।

 .macro port_settings /*PORT LETTER, PIN NUMBER, LOGIC LEVEL*/ cbi DDR@0 , @1 sbi PORT@0, @1 nop sbi@2 PINB, @1 .endmacro

सीरियल पोर्ट को पढ़ने / लिखने की प्रक्रिया थोड़ी मूल होगी। चूंकि हमारे पास बहुत कम जगह और कम गति है, इसलिए मैंने डेटा प्राप्त करने के साथ काम के लिए तत्परता की पुष्टि को संयोजित करने का निर्णय लिया और प्रक्रिया को कई क्षमताओं में विभाजित किया। असेंबलर में, अलग-अलग लेबल वाले सबरूटीन को कॉल करके ऐसा करना बहुत आसान है:

8 टीमों में तत्परता और प्राप्ति

 ;UART <- 0xC0 ;temp_0 <- UART confirm_and_read: ldi temp_0, 0xC0 ;UART <- temp_0 ;temp_0 <- UART UART_send: sbis UCSRA, UDRE ;skip next command if readiness bit is set rjmp UART_send out UDR, temp_0 ;temp_0 <- UART UART_read: sbis UCSRA, RXC rjmp UART_read in temp_0, UDR ret

सुस्त हिस्सा पूरा हो गया है, दुनिया भविष्य के काम के लिए बनाई गई है। चलिए शुरू करते हैं।

88 बाइट लुकअप टेबल

सबसे पहले, आपको अंतिम फ़ील्ड में दिए गए नंबर के पारस्परिक को खोजने की आवश्यकता है। ऐसा है कि जब इस संख्या को इस से गुणा करते हैं, तो यह 1 निकलता है। विकी पर लेख में गुणा एल्गोरिथ्म का वर्णन किया गया है, मैं इसे नहीं दूंगा।

अंतिम क्षेत्र में विपरीत को ढूंढना एक मुश्किल काम है। यहां आपको उन्नत यूक्लिडियन एल्गोरिथ्म लागू करने की आवश्यकता है ... लेकिन हम इंजीनियर हैं। स्क्रीन से कंप्यूटर विज्ञान स्नातकों को दूर ले जाएं। हम एक्सक्लूसिव सर्च द्वारा व्युत्क्रम तत्व की तलाश कर रहे हैं, गुणा का उपयोग कर।

उल्टा तत्व खोज

  ldi XH, high(SBOX) ;point X to SBOX memory location ldi XL, low( SBOX) ser bF ;first inc will overflow to 0 next_box: inc bF mov temp_1, bF ;save input in temp_1 cp temp_1, NULL ;if it's null - return breq sbox_byte_done ;return here mov OP0, OxFF ;so it overflows look_more: inc OP0 ;try next candidate ;temp_0 <- OP0 * temp_1 (in a Galois field) ;branching is fine, function used in precomputation only finite_multiplication: mov b0, OP0 ;operand 0 (candidate) mov b1, temp_1 ;operand 1 (current byte) ldi temp_2, 0x1B ;0x1B holder clr temp_0 ;multiplication result next_bit: lsr b0 ;operand 0 >> 1 brcc PC+2 ;if lsb of operand 0 was 1 eor temp_0, b1 ;xor operand 1 into result lsl b1 ;operand 1 << 1 brcc PC+2 ;if msb of operand 1 was 1 eor b1, temp_2 ;xor 0x1B into operand 1 cp b0, NULL ;while there are bits in operand0 brne next_bit ;work on it cpi temp_0, 1 ;if multiplication result was not 1 brne look_more ;inverse is in OP0

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

असेम्बलर एफाइन ट्रांसफॉर्म

  clr temp_1 ;affine transform result ldi temp_5, 0b11110001 ;matrix producer ldi temp_3, 0b00000001 ;current bit mask process_bit: mov temp_4, OP0 ;multiplicative inverse and temp_4, temp_5 ;and with matrix producer pop_next_bit: lsl temp_4 ;inv&matrix << 1 brcc PC+2 ;if it had msb eor temp_1, temp_3 ;sum bit into result cp temp_4, NULL ;while operand has bits brne pop_next_bit ;work on it lsl temp_3 ;move to next bit lsl temp_5 ;cyclically shift matrix producer brcc PC+2 ;if it had msb ori temp_5, 1 ;move msb to lsb cp temp_3, NULL ;while there are bits left brne process_bit ;process next bit sbox_byte_done: ldi temp_2, 0b01100011 ;0x63 eor temp_1, temp_2 ;xor it into result st X+, temp_1 ;save to memory cpse bF, OxFF ;if we're at last byte rjmp next_box ;we're done

मिशन पूरा हुआ।

यह सब कितनी तेजी से काम करता है? सिम्युलेटर में - 2203268 उपाय। 8 मेगाहर्ट्ज की आवृत्ति पर 0.27 सेकंड। मुझे लगता है कि यह एक अद्भुत गति है।

हमने शुरुआत में 256 बाइट्स रैम और 0.27 सेकंड खो दिए, जिससे 168 बाइट्स की फ्लैश मेमोरी बच गई और एक अद्भुत पहेली सुलझ गई।

स्पूफिंग टेबल तैयार है, चाबियों का विस्तार कंप्यूटर पर किया जाता है - एईएस को लागू करने के लिए आपको आवश्यक सभी कुछ है।

इकट्ठे एन्क्रिप्शन मानक

आइए प्राथमिक ऑपरेशन से शुरू करते हैं। डिक्रिप्शन के प्रत्येक चरण में, कुंजी डेटा के साथ अभिव्यक्त होती है। डेटा 4 वीं से रजिस्टर फ़ाइल में है, उनमें से 16 हैं, और रजिस्टर Z को हमेशा वर्तमान कुंजी को इंगित करने दें। सूचक रजिस्टर न केवल SRAM या फ़्लैश क्षेत्रों को इंगित कर सकते हैं, बल्कि रजिस्टर फ़ाइल को भी इंगित कर सकते हैं, जो हमें बहुत सरल बनाते हैं। जीवन और प्रणाली को गति।

गोल कुंजी जोड़ें

 add_round_key: clr YH ;point to register file ldi YL, 4 xor_Z_to_Y: lpm temp_0, Z+ ;load key byte ld temp_1, Y ;load data byte eor temp_1, temp_0 ;xor them st Y+, temp_1 ;store back to data cpi YL, low( 4 + 16 ) ;check if it was the last byte brne xor_Z_to_Y ;if not - process next data byte ret

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

पंक्तियों को शिफ्ट करें

 ;cyclical shift: 0_row << 0; 1_row << 1; 2_row << 2; 3_row << 3 shift_rows: ;1st row eor b1, bD eor bD, b1 eor b1, bD eor b1, b5 eor b5, b1 eor b1, b5 eor b5, b9 eor b9, b5 eor b5, b9 ;2nd row eor b2, bA eor bA, b2 eor b2, bA eor b6, bE eor bE, b6 eor b6, bE ;3rd row eor b3, bF eor bF, b3 eor b3, bF eor b7, bF eor bF, b7 eor b7, bF eor bB, bF eor bF, bB eor bB, bF ;done ret

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

प्रतिस्थापन हमेशा लाइन ऑफ़सेट द्वारा पीछा किया जाता है, इसलिए, हम इन प्रक्रियाओं को अलग नहीं करेंगे।

उप बाइट्स

 substitute_shift_rows: ldi XH, high(SBOX) ldi XL, low( SBOX) movw OP0, X ;one column at a time clr YH ldi YL, 4 sub_next: movw X, OP0 ldd temp_0, Y+0x08 add XL, temp_0 adc XH, NULL ld temp_0, X std Y+0x08, temp_0 movw X, OP0 ldd temp_0, Y+0x0C add XL, temp_0 adc XH, NULL ld temp_0, X std Y+0x0C, temp_0 movw X, OP0 ldd temp_0, Y+0x04 add XL, temp_0 adc XH, NULL ld temp_0, X std Y+0x04, temp_0 movw X, OP0 ldd temp_0, Y+0x00 add XL, temp_0 adc XH, NULL ld temp_0, X st Y+, temp_0 sbrs YL, 3 ;XL == 8 rjmp sub_next

हम नरक के लिए पोर्टल से संपर्क कर रहे हैं। वहां प्रवेश करने से पहले, हमें 2 से गुणा करने की आवश्यकता है। इंजीनियरिंग के दृष्टिकोण से, अंतिम क्षेत्र में 2 से गुणा करना सरल से अलग है कि बाईं ओर जाने के बाद, आपको परिणाम में 0x1B जोड़ना होगा यदि गुणक का सबसे महत्वपूर्ण बिट एक था। यदि बिट एक था, तो ... आप क्रिप्टोग्राफिक सिस्टम के महत्वपूर्ण क्षेत्रों में संक्रमण और शर्तों का उपयोग नहीं कर सकते। कोई बात नहीं! बाईं ओर शिफ्ट करने से पहले, हम सबसे महत्वपूर्ण बिट को बचाएंगे और फिर हम इसे खाली रजिस्टर में वांछित स्थानों पर लिखेंगे जब तक कि हम 0x1B जमा नहीं करते हैं यदि बिट एक था, या 0 अगर यह शून्य था।

आश्चर्य। मेरे कार्यान्वयन में, बूटलोडर के एक आकार पर 2 से गुणा करने की प्रक्रिया स्थित है। इस आकार के गिरने के बिंदु पर, हम बूट की शुरुआत में बिना शर्त कूदते हैं और इसलिए कि यह 2 से प्रत्येक गुणा के साथ हस्तक्षेप नहीं करता है, हम इस पर कूदते हैं।

उप बाइट्स

 ;temp_0 <- temp_0 * 2 (in a finite field) ;temp_0 = (temp_0 << 1) ^ (0x1B & MSB(temp_0)) ;NO BRANCHING HERE ;uses NULL in a dirty way mul_by_2: bst temp_0, 7 ;store 7th bit in T bld NULL, 0 ;we form 0x1B in NULL if T is set rjmp cont_mul rjmp BOOT_START ;0x1F80. BOOTSZ can be here cont_mul: bld NULL, 4 lsl temp_0 bld NULL, 3 bld NULL, 1 eor temp_0, NULL clr NULL ret

अंतिम चरण रहता है - स्तंभों को मिलाते हुए। प्रत्येक स्तंभ के तत्व निम्न परिवर्तन से गुजरते हैं:

2 से गुणा हमने ऊपर लिखा है। अंतिम क्षेत्र में जोड़ विशेष या है। 3 से गुणा करने के लिए, आपको बस संख्या को 2 से गुणा करने के परिणाम में जोड़ना होगा। एक बार फिर, कठिनाई यह है कि हम अचानक असेंबलर में लिखते हैं, कोड की मात्रा में सीमित हैं और बहुत कुछ गिनना होगा। मन और टिप्पणियों में अनुकूलन करना होगा। गणना के दौरान सावधानीपूर्वक सोचना और रजिस्टरों का बुद्धिमानी से उपयोग करना आवश्यक है।

कॉलम मिलाएं

 mix_columns: ;point to register file clr YH ldi YL, 4 next_column: ldd temp_2, Y+0x00 ;result0 ldd temp_3, Y+0x01 ;r1 ldd temp_4, Y+0x02 ;r2 ldd temp_5, Y+0x03 ;r3 mov temp_0, temp_3 ;r1 to operand rcall mul_by_2 ;r1 * 2 mov temp_1, temp_0 ;save r1 * 2 eor temp_0, temp_2 ;r0 + r1 * 2 eor temp_0, temp_5 ;r0 + r1 * 2 + r3 (lacks r2 * 3) std Y+0x01, temp_0 ;to r1 mov temp_0, temp_2 ;r0 to operand rcall mul_by_2 ;r0 * 2 mov OP0, temp_0 ;OP0 <- r0 * 2 eor temp_0, temp_1 ;r0 * 2 + r1 * 2 eor temp_0, temp_3 ;r0 * 2 + r1 * 3 eor temp_0, temp_4 ;r0 * 2 + r1 * 3 + r2 eor temp_0, temp_5 ;r0 * 2 + r1 * 3 + r2 + r3 (done) std Y+0x00, temp_0 ;to r0 mov temp_1, OP0 ;OP0 -> r0 * 2 mov temp_0, temp_5 ;r3 to operand rcall mul_by_2 ;r3 * 2 mov OP0, temp_0 ;OP0 <- r3 * 2 eor temp_0, temp_1 ;r3 * 2 + r0 * 2 eor temp_0, temp_2 ;r0 * 3 + r3 * 2 eor temp_0, temp_3 ;r0 * 3 + r1 + r3 * 2 eor temp_0, temp_4 ;r0 * 3 + r1 + r2 + r3 * 2 (done) std Y+0x03, temp_0 ;to r3 mov temp_1, OP0 ;OP0 -> r3 * 2 mov temp_0, temp_4 ;r2 to operand rcall mul_by_2 ;r2 * 2 mov OP0, temp_0 ;OP0 <- r2 * 2 eor temp_0, temp_1 ;r2 * 2 + r3 * 2 eor temp_0, temp_5 ;r2 * 2 + r3 * 3 eor temp_0, temp_2 ;r0 + r2 * 2 + r3 * 3 eor temp_0, temp_3 ;r0 + r1 + r2 * 2 + r3 * 3 (done) std Y+0x02, temp_0 ;to r2 mov temp_1, OP0 ;OP0 -> r2 * 2 ldd temp_0, Y+0x01 ;r0 + r1 * 2 + r3 eor temp_0, temp_1 ;r0 + r1 * 2 + r2 * 2 + r3 eor temp_0, temp_4 ;r0 + r1 * 2 + r2 * 3 + r3 (done) std Y+0x01, temp_0 ;to r1 adiw Y, 4 ;pointer to next column cpi YL, 20 ;if not done brne next_column ;process next ret

बस बहुत से अंकगणित। गणना की प्रक्रिया में, अपेक्षित 4 के बजाय 6 मेमोरी एक्सेस होते हैं, लेकिन यह मुझे लगता है कि अधिकतम संभव स्थानिक अनुकूलन प्राप्त किया गया है।

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

एन्क्रिप्शन ही

 ;performs a round of encryption ;using given expanded keys and s-box Rijndael_encrypt: push ZH push ZL push YH push YL push XH push XL ldi ZH, high(KEYS*2) ldi ZL, low( KEYS*2) rcall add_round_key ldi temp_0, 9 encryption_cycle: push temp_0 ;store cycle counter rcall substitute_shift_rows rcall mix_columns rcall add_round_key rjmp continue_enc rjmp BOOT_START ;0x1F00. BOOTSZ can be here continue_enc: pop temp_0 ;restore cycle counter dec temp_0 brne encryption_cycle rcall substitute_shift_rows rcall add_round_key pop XL pop XH pop YL pop YH pop ZL pop ZH ret

आइए गिनें कि हम कितने बाइट्स से मिले। कुंजी जोड़ 18 बाइट्स है। 2 - 22 बाइट्स से गुणा। पंक्ति बदलाव 50 बाइट्स है। प्रतिस्थापन 62 बाइट्स है। कॉलम फेरबदल 94 बाइट्स है। इसे सभी लिंक करें - 56 बाइट्स। कुल - 302 बाइट्स। यह समझने के लिए कि आपने यह किया है अनमोल। विंडोज निष्पादन योग्य हेडर के औसत आकार से थोड़ा बड़ा।

ब्लॉक सिफर - अच्छा है, लेकिन एक विशेष एन्क्रिप्शन मोड के बिना, यह व्यावहारिक रूप से बेकार है। यदि ब्लॉक सिफर का कोई लेना देना नहीं है, तो यह भी बेकार है, इसलिए, हम डेटा के रिसेप्शन से निपटेंगे।

सूचना विनिमय प्रोटोकॉल

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

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

डेटा विनिमय प्रोटोकॉल निम्नानुसार है: स्पूफिंग टेबल की पीढ़ी के तुरंत बाद, बूटलोडर 0xC0 (COnfirm) को पोर्ट पर बाइट्स देता है और 0x60 (GO) बाइट्स का इंतजार करता है। कंप्यूटर से तैयार सिग्नल के बाद, बूट Z पॉइंटर को रिकॉर्ड किए गए मेमोरी क्षेत्र की शुरुआत में सेट करता है, temp_0 को उन पेजों की संख्या लिखता है जिन्हें प्राप्त करने, डिक्रिप्ट करने और लिखने की आवश्यकता होती है, और पेज प्राप्त करने के लिए आगे बढ़ता है। यह इस तरह दिखता है:

शुरुआत हो रही है

 wait_for_start: rcall confirm_and_read cpi temp_0, 0x60 brne wait_for_start ;/////////////////////////////PAGE ADDR INIT .if USE_0th_PAGE == 0 ldi ZH, high(PAGE_BYTES) ldi ZL, low( PAGE_BYTES) ldi temp_0, PAGES - 1 .else clr ZH clr ZL ldi temp_0, PAGES .endif next_page: ;save page counter and address push temp_0 push ZH push ZL ;/////////////////////////////BLOCK RECEPTION ;receive whole block ldi XH, high(SAVED_IV) ldi XL, low( SAVED_IV) ldi temp_1,( BLOCK_SIZE /*nonce*/ + PAGE_BYTES /*page*/ + BLOCK_SIZE /*expected tag*/ ) get_more_block: rcall confirm_and_read st X+, temp_0 dec temp_1 brne get_more_block

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

EAX इकट्ठे हुए

यदि हम EAX को ठीक उसी प्रकार कार्यान्वित करते हैं जैसा दो दस्तावेज़ चित्र में दिखाया गया है, तो हम दायरे में फिट नहीं होंगे। इसलिए, हम घटनाओं के पाठ्यक्रम को सही करेंगे।

हस्ताक्षर - एन्क्रिप्टेड इनिशियलाइज़ेशन वेक्टर (एन, नॉन से) का योग, डेटा हेडर (इसकी प्रोसेसिंग प्रमुख पीढ़ी के चरण में की जाती है) और डेटा के प्रमाणीकरण कोड को स्वयं CMAC \ OMAC एल्गोरिथ्म का उपयोग करके गणना की जाती है। मौके पर गणना किए गए हस्ताक्षर हमें भेजे गए से मेल खाना चाहिए। अनन्य या दो समान संख्याएं 0. हैं। इसलिए, हम सभी गणना किए गए मानों को सीधे प्राप्त हस्ताक्षर में जोड़ देंगे, और फिर जांचें कि क्या इसके सभी मान 0 हो गए हैं।

हम पहले से ही H को जानते हैं - दिए गए और संसाधित हेडर, जो कि मुख्य फ़ाइल में है। तुरंत इसे प्राप्त हस्ताक्षर में जोड़ें:

शुरुआत हो रही है

 ;/////////////////////////////TAG INITIALIZATION ;initialize precomputed header with tag ;tag <- H ^ tag header_to_tag: ldi ZH, high(PRECOMP_HEADER_TAG*2) ldi ZL, low( PRECOMP_HEADER_TAG*2) ldi YH, high(TAG) ldi YL, low( TAG) next_header_byte: lpm temp_0, Z+ ld temp_1, Y eor temp_0, temp_1 st Y+, temp_0 cpi YL, low( TAG + BLOCK_SIZE ) brne next_header_byte

अगला सरल कदम N की गणना करना है। हमारे पास इसके लिए सभी आवश्यक डेटा हैं। मेमोरी ब्लॉक के साथ सभी जोड़तोड़ को अलग-अलग प्रक्रियाओं में अलग करके जीवन को आसान बनाएं। हमें डेटा ब्लॉक को रजिस्टर फ़ाइल में स्थानांतरित करने की आवश्यकता हो सकती है, सूचक द्वारा दो डेटा ब्लॉक जोड़ सकते हैं, आदि। दो प्रक्रियाओं में, कॉल मार्क के आधार पर, यह पहले से ही रखा गया था 9. मैंने नहीं सुना था कि उच्च स्तर की भाषा में ऐसा अनुकूलन संभव था।

हेल्पर कार्य

 ;block <- block ^ Z xor_Z_to_block_RAM: ldi YH, 0 ldi YL, 4 ;Y <- Y ^ Z xor_Z_to_Y_RAM: ldi temp_2, BLOCK_SIZE ;Y <- Y ^ Z ( temp_2 times ) ram_xor_cycle: ld temp_3, Z+ ld temp_1, Y eor temp_1, temp_3 st Y+, temp_1 dec temp_2 brne ram_xor_cycle ret ;block -> SAVED_IV save_IV: ldi YH, high(SAVED_IV) ldi YL, low( SAVED_IV) ;block -> Y from_regs_to_Y: ldi XH, 0 ldi XL, 4 rjmp move_from_X_to_Y ;SAVED_IV -> block rest_IV: ldi XH, high(SAVED_IV) ldi XL, low( SAVED_IV) ;X -> block from_X_to_regs: ldi YH, 0 ldi YL, 4 ;X -> Y move_from_X_to_Y: ldi temp_0, 0x10 ;X -> Y ( temp_0 times ) ram_save_cycle: ld temp_1, X+ st Y+, temp_1 dec temp_0 brne ram_save_cycle ret

अब, हम दस्तावेज़ीकरण चित्रों के अनुसार एन 'की गणना शुरू करते हैं। यहां, मुख्य पीढ़ी के चरण में तैयार की गई B और L0 का उपयोग किया जाता है। जो कुछ भी होता है, पारंपरिक रूप से टिप्पणियों में वर्णित है। गणना के अंत में, परिणामी N 'को हस्ताक्षर में जोड़ा जाता है।

प्रारंभिक वेक्टर प्रसंस्करण

 ;/////////////////////////////NONCE ;block <- N ldi XH, high(SAVED_IV) ldi XL, low( SAVED_IV) rcall from_X_to_regs ;block <- N ^ B ldi ZH, high(PRECOMP_B*2) ldi ZL, low( PRECOMP_B*2) rcall add_round_key ;block <- N ^ B ^ L0 ldi ZH, high(PRECOMP_L0*2) ldi ZL, low( PRECOMP_L0*2) rcall add_round_key ;block <- E( N^B^L0 ) (nonce) rcall Rijndael_encrypt ;save calculated nonce rcall save_IV ;tag <- H ^ N ^ expected ldi YH, high(TAG) ldi YL, low( TAG) ldi ZH, high(SAVED_IV) ldi ZL, low( SAVED_IV) rcall xor_Z_to_Y_RAM

डेटा को एन्क्रिप्ट करने के लिए, EAX CTR काउंटर मोड में AES का उपयोग करता है। यह मोड ब्लॉक एईएस को एक स्ट्रीम सिफर में बदल देता है, जिसका उपयोग बिना किसी समस्या के मनमानी लंबाई के डेटा को एन्क्रिप्ट करने के लिए किया जा सकता है।इनिशियलाइज़ेशन वेक्टर नव तैयार एन ’है, जो, प्रत्येक ब्लॉक, एक से बढ़ कर एन्क्रिप्टेड है।

एक की वृद्धि एक समस्या है, जब हमारे पास 16 यादृच्छिक बाइट्स की संख्या होती है, तो हमें सभी हस्तांतरण को एक में संसाधित करना होगा, आप कभी नहीं जानते। कुछ भी जटिल नहीं है।

एक साथ 16 रजिस्टर में वृद्धि

 ;block++ ;all carrying is done properly increment_regs: ldi YH, 0 ldi YL, 20 clr temp_0 carry_next: ld temp_0, Y cpi temp_0, 1 ld temp_0, -Y adc temp_0, NULL st Y, temp_0 cpi YL, 5 brsh carry_next ret

डेटा के साथ एन्क्रिप्टेड इनिशियलाइज़ेशन वेक्टर जोड़ें - हमें डिक्रिप्टेड डेटा मिलता है। हम हस्ताक्षर के सत्यापन से पहले उन्हें डिक्रिप्ट नहीं करेंगे, उन्हें मेमोरी में लिखे जाने से तुरंत पहले डिक्रिप्ट किया जाएगा। लेकिन एन 'तैयार है, डिक्रिप्शन कोड के लिए मेमोरी आवंटित की गई है - इसे क्यों नहीं बनाया जाए?

CTR मोड

 ;/////////////////////////////DECRYPTION IVs ldi YH, high(ENC_IV) ldi YL, low( ENC_IV) IV_calc_cycle: ;block <- E(IV) rcall Rijndael_encrypt ;ENC_IV <- E(IV) rcall from_regs_to_Y push YH push YL ;IV++ rcall rest_IV rcall increment_regs rcall save_IV pop YL pop YH cpi YL, low( ENC_IV + PAGE_BYTES ) brne IV_calc_cycle

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

कृपया ध्यान दें कि चित्र के अनुसार, बी केवल अंतिम ब्लॉक के साथ सम्‍मिलित है - एन्क्रिप्टेड स्ट्रिंग के अंत में। आरंभीकरण वेक्टर के साथ, प्राप्त प्रमाणीकरण कोड तुरंत हस्ताक्षर के साथ अभिव्यक्त किया गया है।

CMAC / OMAC हस्ताक्षर की गणना

 ;/////////////////////////////CMAC / OMAC TAG CALCULATION ( block <- C ) ;X contains 20 after last save_IV command clear_registers: st -X, NULL cpi XL, 4 brne clear_registers ;block <- L2 ldi ZH, high(PRECOMP_L2*2) ldi ZL, low( PRECOMP_L2*2) rcall add_round_key ;last block is processed individually ldi temp_0, BLOCKS_PER_PAGE ldi ZH, high(RCVD_PAGE) ldi ZL, low( RCVD_PAGE) CBC_TAG: ;block <- block ^ m(i) ;temp_0 is fine rcall xor_Z_to_block_RAM push temp_0 cpi temp_0, 1 brne dont_add_B ldi ZH, high(PRECOMP_B*2) ldi ZL, low( PRECOMP_B*2) rcall add_round_key dont_add_B: ;Z is saved properly rcall Rijndael_encrypt pop temp_0 dec temp_0 brne CBC_TAG ;block <- H ^ N ^ C ^ expected ldi ZH, high(TAG) ldi ZL, low( TAG) rcall xor_Z_to_block_RAM

हमने केवल पहेली में अंतिम भाग स्थापित किया है और हम जांच सकते हैं कि हस्ताक्षर मेल खाते हैं या नहीं। हस्ताक्षर के सही होने के लिए शर्त यह है कि इसके सभी बाइट्स को ०. 0. तक बदलना होगा। पारंपरिक क्रिप्टोग्राफिक चेक को सभी मानों को एक अलग रजिस्टर में या किसी भी स्थिति में संयोजित करना है। चक्र के बाद, यह तय किया जाता है कि फ्लैश को डेटा लिखना है, या हस्ताक्षर त्रुटि की रिपोर्ट करना और मरना है।

पारंपरिक सुरक्षित हस्ताक्षर सत्यापन

 ;/////////////////////////////TAG CHECK clr temp_0 check_more: ld temp_1, -Y or temp_0, temp_1 cpi YL, 4 brne check_more cp temp_0, NULL breq do_write rjmp die

डाई लेबल हमें किसी भी अनुरोध पर 0xFF भेजने वाले अनंत लूप में भेजता है। चमकता कार्यक्रम गलत पुष्टि बाइट्स को ध्यान में रखना चाहिए और उपयोगकर्ता को सूचित करना चाहिए कि फ़ाइल उपयुक्त नहीं है।

सतत त्रुटि चक्र

 ;/////////////////////////////TAG FAILURE AND EXIT die: ldi temp_0, 0xFF rcall UART_send rjmp die

यदि हस्ताक्षर सही है, तो हम Z प्वाइंटर को वर्तमान फ़्लैश पेज पर पुनर्स्थापित करते हैं और रिकॉर्डिंग प्रक्रिया पर जाते हैं। यदि यह पृष्ठ अंतिम था, तो upload_done लेबल पर जाएं, जो चमकती सफलता बाइट - 0x0C भेजता है और मृत्यु चक्र में चला जाता है।

सब ठीक है - रिकॉर्ड पर जाएं

 ;/////////////////////////////TAG SUCCESS - CTR AND WRITE do_write: ;restore page pointers pop ZL pop ZH ;decrypt and write page rcall store_page ;restore page counter pop temp_0 dec temp_0 ;continue if not done, else - die breq upload_done rjmp next_page

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

स्व-प्रोग्रामिंग प्रक्रिया लोहे पर निर्भर है, जब अन्य माइक्रोकंट्रोलर्स के लिए पोर्टिंग की जाती है, तो स्टोर प्रोग्राम मेमोरी कमांड पर कॉल को सही करना आवश्यक हो सकता है।

फ्लैश के लिए डेटा और लेखन को डिक्रिप्ट करना

 ;D( RCVD_PAGE ) -> flash store_page: ;erase current page ldi temp_1, 0b00000011 rcall spm_it ldi YH, high(RCVD_PAGE) ldi YL, low( RCVD_PAGE) ldi XH, high(ENC_IV) ldi XL, low( ENC_IV) write_next: ld r0, Y+ ld temp_2, X+ eor r0, temp_2 ld r1, Y+ ld temp_2, X+ eor r1, temp_2 ;last countermeasure - if we jumped through tag check eor r0, temp_0 eor r1, temp_0 ;store word to page buffer ldi temp_1, 0b00000001 rcall spm_it adiw Z, 2 cpi YL, low( RCVD_PAGE + PAGE_BYTES ) brne write_next ;write page ;back to page start subi ZL, low( PAGE_BYTES) sbci ZH, high(PAGE_BYTES) ;write page ldi temp_1, 0b00000101 rcall spm_it ;to next page start subi ZL, low( -PAGE_BYTES) sbci ZH, high(-PAGE_BYTES) ;re-enable flash ldi temp_1, 0b00010001 rcall spm_it ret spm_it: in temp_2, SPMCSR sbrc temp_2, SPMEN rjmp spm_it out SPMCSR, temp_1 spm ret

यह सब एक साथ रखना। बिल्कुल 1024 बाइट्स। यह माइक्रोकंट्रोलर को फ्लैश करने, फ्यूज सेट करने और क्लाइंट सॉफ्टवेयर लिखने के लिए रहता है।

परीक्षण

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

फ्लैशर प्राथमिक है - 0xC0 के लिए प्रतीक्षा करें, 0x60 भेजें और, जब तक फ़ाइल समाप्त न हो जाए, प्रत्येक 0xC0 के जवाब में एक बाइट भेजें। 0x0C मिला - सब कुछ तैयार है, 0xFF मिला - एक त्रुटि हुई। चलो इसे लिनक्स के लिए शुद्ध सी में लिखते हैं। मेरे लैपटॉप पर COM पोर्ट नहीं है, इसलिए ... हम Psion 5MX का उपयोग करते हैं, जो मुझसे केवल 5 साल छोटा है।

हम मातृभूमि के डिब्बे से ATmega8A के साथ कुछ मदरबोर्ड लेते हैं, इसे एक बूट के साथ सीवे करते हैं, इसे मदरबोर्ड के एक टुकड़े से जोड़ते हैं, MAX233 के साथ फर्मवेयर को इकट्ठा करते हैं, Psion पर फर्मवेयर को इकट्ठा करते हैं, रैंडम तारों के साथ इसे रिवाइंड करते हैं, फर्मवेयर और फ्लैश चालक को फर्मवेयर इंगित करते हैं, बिजली की आपूर्ति को फिर से शुरू करते हैं ... प्रक्रिया शुरू हो गई है।

याद रखें, कोई Arduino नहीं

कुछ स्पष्ट रूप से हो रहा है।

मैं टेबल और टेस्ट बेंच की स्थिति के लिए माफी मांगता हूं - मेरे से रेडियो इलेक्ट्रॉनिक्स इंजीनियर बहुत अच्छा नहीं है।

परीक्षण कार्यक्रम का पूरा कार्य एलईडी को बाहर रखना और हमेशा के लिए लटका देना है। फर्मवेयर के बाद, वह सफल होती है। सफलता!

मेहनती Psion ने बंदरगाह पर 10KB स्थानांतरित किया और निर्देशों का इंतजार कर रहा है

एलईडी निकल जाती है

ऐसे सरल तरीके से, आप असंभव कर सकते हैं और कस्टम कोड के लिए बहुत सारी जगह छोड़ सकते हैं। अब बिना किसी चिंता के पैचअप को बाहर करने का एक तरीका है कि कुछ चीनी जासूस स्रोत चुरा लेंगे।

मुझे खुशी होगी अगर कोई मेरे कार्यान्वयन में महत्वपूर्ण सुरक्षा त्रुटियां पाता है।

सभी स्रोत कोड और इस लेख को CreativeCommons एट्रिब्यूशन-नॉन-कॉमर्शियल-शेयरएलाइक के तहत लाइसेंस प्राप्त है।

GitHub रिपॉजिटरी: github.com/sirgal/AVR-EAX-AES-bootloader

(पीसी के लिए सभी कोड जल्दी में और, एक साल पहले लिखे गए थे, मुझे खुशी होगी कि अगर कोई इस डरावनी स्थिति को ठीक करना चाहता है, तो मेरे पास अभी तक समय नहीं है)

1024 बाइट्स में AVR असेंबलर पर AES-128 और EAX के साथ बूटलोडर