Arduino के साथ सुरक्षा: Atec608a: 7 चरण

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:19

विषय

सभी को नमस्कार !

यह मेरा पहला इंस्ट्रक्शनल आर्टिकल है इसलिए मुझे उम्मीद है कि यह आप सभी के लिए दिलचस्प होगा।

इस लेख में, मैं आपको समझाऊंगा कि "ATECC608A" नामक एक माइक्रो चिप का उपयोग कैसे किया जाता है जो कई सुरक्षा उपकरण प्रदान करता है।

इस चिप को माइक्रोचिप द्वारा डिजाइन किया गया है और यह "CryptoAuthentication chip" का अंतिम संस्करण है। इस संस्करण से पहले, "ATSHA204A" और "ATECC508A" थे।

मैंने पिछले संस्करण का उपयोग करने का निर्णय क्यों लिया और पिछले संस्करण का नहीं?

यह संस्करण सबसे उन्नत चिप है और इसमें ऐसे कार्य हैं जो पुराने संस्करण में नहीं हैं (उदाहरण के लिए: एईएस मॉड्यूल, आईओ सुरक्षा मॉड्यूल …)।

यह परियोजना क्यों?

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

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

इस प्रदर्शन के बाद, मैंने कुछ ओपन सोर्स प्रोजेक्ट खोजने की कोशिश की जो IoT ऑब्जेक्ट में सुरक्षा परत जोड़ते हैं लेकिन मुझे यह कभी नहीं मिला।

इसलिए मैंने एक ऐसे प्रोजेक्ट पर काम करने का फैसला किया जो दो IoT ऑब्जेक्ट के बीच संचार के लिए सुरक्षा परत का उपयोग करता है।

मेरा विचार क्या है?

दो IoT ऑब्जेक्ट के बीच संचार के दौरान, कई हमले हो सकते हैं: मैन ऑफ़ द माइल्ड, कॉपी ऑफ़ इंफॉर्मेशन और बहुत कुछ.. तो मेरा विचार बहुत सरल है:

1. दो या दो से अधिक IoT ऑब्जेक्ट के बीच एन्क्रिप्टेड डेटा का उपयोग।
2. कम लागत की आपूर्ति
3. एक Arduino UNO के साथ काम कर सकते हैं

अब मैं आपको समझाऊंगा कि कैसे मैंने इस अमूर्त चित्र को एक Arduino और एक Atecc608a चिप के साथ कार्यान्वित किया। इस लेख में, मैं आपको बताऊंगा कि ATECC608A के साथ Arduino UNO का उपयोग कैसे करें।

मैं अगली बार दो वस्तुओं के संचार के बारे में एक लेख लिखूंगा।

आपूर्ति

इस परियोजना के लिए आपको कुछ चीजों की आवश्यकता है:

1. Arduino UNO या MEGA (चिप Atmega 328 या ATMEGA 2560 होनी चाहिए)
2. Atecc608A चिप (प्रत्येक की कीमत 0.80 डॉलर से कम, आपकी आपूर्तिकर्ता वेबसाइट पर आसानी से मिल जाती है)
3. 8-पिन SOIC एडाप्टर
4. कुछ तार और प्रतिरोधक

इस चिप के पिछले संस्करण की डेटाशीट (Atecc508a) यहाँ उपलब्ध है -> डेटाशीट Atecc508a

चरण 1: चरण दर चरण

इस लेख में, मैं आपको दिखाऊंगा कि इस चिप के कॉन्फ़िगरेशन को कैसे संशोधित किया जाए और एईएस सीबीसी एल्गोरिथम का उपयोग करके डेटा को कैसे एन्क्रिप्ट किया जाए।

हम उन चरणों का पालन करेंगे:

1. सर्किट का डिजाइन
2. इस चिप का विन्यास
3. एईएस सीबीसी मॉड्यूल का उपयोग
4. आपको इस चिप का उपयोग करने की आवश्यकता क्यों है

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

माई गीथूब: माई जीथूब

चरण 2: Atec608a के बारे में चेतावनी

Atec608a चिप "आसान" चिप नहीं है।

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

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

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

चार, पुस्तकालय ने इस चिप के लिए लिखा है कि यह Arduino UNO के लिए काम नहीं करता है, लेकिन इसने कार्यक्षमता को जोड़ा है कि इसे Arduino UNO के साथ काम करने की आवश्यकता है।

चिप ATECC608A

आप इस चिप के साथ I2C द्वारा संचार कर सकते हैं। इस चिप के पते को कॉन्फ़िगरेशन में संशोधित किया जा सकता है।

इस चिप में 16 अलग-अलग स्लॉट हैं जिनमें विभिन्न प्रकार के डेटा हो सकते हैं:

1. ईसीसी कुंजी (निजी या सार्वजनिक)
2. एईएस कुंजी
3. अन्य डेटा (जैसे शा हैश या सिर्फ शब्द)

हमारे मामले में, हम AES Key को एक स्लॉट में स्टोर करेंगे।

चरण 3: 1. सर्किट का विवरण

1. सर्किट का डिजाइन

इस सर्किट की स्कीमा बहुत सरल है!

आपको 3.3V शक्ति का उपयोग करने की आवश्यकता है क्योंकि सिफारिश 2.0V और 5.5V के बीच है लेकिन मैंने 3.3V का उपयोग करना पसंद किया।

इस चिप के लिए आमतौर पर आपके पास चिप के एक कोने पर एक बिंदु होता है, यह बिंदु इस बोर्ड का पिन 1 होता है। मैंने पिन नंबर के साथ Atecc608a का शीर्ष दृश्य जोड़ा क्योंकि यह 8-लीड SOIC है इसलिए चिप बहुत छोटी है।

1. ARDUINO 3.3V -> पिन 8 (Atecc608a)
2. ARDUINO GND -> पिन 4 (Atecc608a)
3. ARDUINO A4 (SDL) -> पिन 5 (Atecc608a)
4. ARDUINO A5 (SCL) -> पिन 6 (Atecc608a)

आपको 3.3V शक्ति का उपयोग करने की आवश्यकता है क्योंकि सिफारिश 2.0V और 5.5V के बीच है लेकिन मैंने 3.3V का उपयोग करना पसंद किया।

मैंने Atec608a का शीर्ष दृश्य जोड़ा क्योंकि यह 8-लीड SOIC है इसलिए चिप बहुत छोटी है। यदि आप पसंद करते हैं, तो आपूर्तिकर्ता चिप सोल्डर के साथ कुछ बोर्ड बनाते हैं, यह आपके लिए आसान हो सकता है।

चेतावनी: मेरे मामले में, मुझे Arduino के एसडीए और चिप (एसडीएल के लिए भी) के बीच एक अवरोधक जोड़ना होगा। मैंने प्रत्येक के लिए 4.7Kohm रोकनेवाला जोड़ा।

चरण 4: 2. चिप का विन्यास (Atecc608a)

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

चेतावनी: यह चरण बहुत ही महत्वपूर्ण है और यदि आप अंत से पहले ज़ोन को लॉक कर देते हैं तो आप उन्हें संशोधित नहीं कर सकते।

जैसा कि पहले बताया गया है, इस चिप को दो जोन मिले:

1. कॉन्फिग जोन
2. डेटा क्षेत्र

कॉन्फ़िगरेशन ज़ोन को 128 बाइट्स का आकार मिला लेकिन पहले 16 बाइट्स को संशोधित नहीं किया जा सकता है।

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

1. एक कॉन्फ़िगरेशन टेम्प्लेट बनाएं
2. इस टेम्पलेट को चिप में लिखें
3. कॉन्फिग जोन को लॉक करें
4. एक स्लॉट में अपनी एईएस कुंजी (128 बिट) लिखें
5. डेटा ज़ोन लॉक करें

जानकारी

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

• माई जीथब: माई जीथूब
• उदाहरण विन्यास का पथ:configuration_example.ino

पहला चरण: एक कॉन्फ़िगरेशन टेम्प्लेट बनाएं

जैसा कि पहले बताया गया है, कॉन्फ़िगरेशन ज़ोन को 128 बिट्स का आकार मिलता है, लेकिन पहले 16 बिट्स को बदला नहीं जा सकता है। यह ज़ोन कई भागों से बना है, लेकिन आपको इस प्रोजेक्ट के लिए इस कॉन्फ़िगरेशन ज़ोन के केवल 3 भागों को जानने की आवश्यकता है:

1. बाइट्स 16 -> यह चिप का I2C पता है
2. बाइट २० से ५१ -> आप यहाँ इस चिप के १६ स्लॉट के लिए स्लॉट के प्रकार को संशोधित कर सकते हैं
3. बाइट्स 96 से 127 -> आप यहां प्रत्येक स्लॉट में उपयोग की जाने वाली कुंजी या डेटा का प्रकार सेट कर सकते हैं।

(यदि आपको इस सभी क्षेत्र के बारे में अधिक जानकारी की आवश्यकता है, तो कृपया दस्तावेज़ीकरण पढ़ें (पृष्ठ १३, खंड २.२))

यहां, मैं एक चिप के विन्यास के 112 बाइट्स के प्रत्येक बाइट्स/पार्ट्स का विवरण देता हूं। यह एक उदाहरण है, खरीदी गई प्रत्येक चिप का एक अलग विन्यास हो सकता है:

0xC0, // I2C पता

0x00, 0x00, 0x00, 0x83, 0x20, // स्लॉट कॉन्फ़िग स्लॉट 1 0x85, 0x20, // स्लॉट कॉन्फ़िग स्लॉट 2 0x8F, 0x20, // स्लॉट कॉन्फ़िग स्लॉट 3 0xC4, 0x8F, // स्लॉट कॉन्फ़िग स्लॉट 4 0x8F, 0x8F, // स्लॉट कॉन्फिगर स्लॉट 5 0x8F, 0x8F, // स्लॉट कॉन्फिग स्लॉट 6 0x9F, 0x8F, // स्लॉट कॉन्फिग स्लॉट 7 0x0F, 0x0F, // स्लॉट कॉन्फिग स्लॉट 8 0x8F, 0x0F, // स्लॉट कॉन्फिग स्लॉट 9 0x8F, 0x0F, // स्लॉट कॉन्फिगर स्लॉट 10 0x8F, 0x0F, // स्लॉट कॉन्फिग स्लॉट 11 0x8F, 0x0F, // स्लॉट कॉन्फिग स्लॉट 12 0x8F, 0x0F, // स्लॉट कॉन्फिग स्लॉट 13 0x00, 0x00, // स्लॉट कॉन्फिग स्लॉट 14 0x00, 0x00, // स्लॉट कॉन्फ़िग स्लॉट 15 0xAF, 0x8F, // स्लॉट कॉन्फ़िग स्लॉट 16 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x00, // की कॉन्फिग स्लॉट 1 0x33, 0x00, // की कॉन्फिग स्लॉट 2 0x33, 0x00, // की कॉन्फिग स्लॉट 3 0x1C, 0x00, // की कॉन्फिग स्लॉट 4 0x1C, 0x00, // कुंजी कॉन्फ़िग स्लॉट 5 0x 1C, 0x00, // की कॉन्फिग स्लॉट 6 0x1C, 0x00, // की कॉन्फिग स्लॉट 7 0x3C, 0x00, // की कॉन्फिग स्लॉट 8 0x1A, 0x00, // की कॉन्फिग स्लॉट 9 0x3A, 0x00, // की कॉन्फिग स्लॉट 10 0x1A, 0x00, // की कॉन्फिग स्लॉट 11 0x3A, 0x00, // की कॉन्फिग स्लॉट 12 0x3A, 0x00, // की कॉन्फिग स्लॉट 13 0x3C, 0x00, // की कॉन्फिग स्लॉट 14 0x3C, 0x00, // की कॉन्फिग स्लॉट 15 0x1C, 0x00 // की कॉन्फिग स्लॉट 16

जैसा कि देखें, मैंने इस कॉन्फ़िगरेशन को और अधिक समझने के लिए इस कोड में कुछ टिप्पणियां डाली हैं।

आपके मामले में केवल तीन चीजों को समझने की जरूरत है:

1. बाइट्स 16 -> यह चिप का I2C पता है
2. बाइट २० से ५१ -> आप यहाँ इस चिप के १६ स्लॉट के लिए स्लॉट के प्रकार को संशोधित कर सकते हैं
3. बाइट 96 से 127 -> आप यहां प्रत्येक स्लॉट में उपयोग की जाने वाली कुंजी या डेटा का प्रकार सेट कर सकते हैं।

मैं कॉन्फ़िगरेशन के प्रकार की व्याख्या नहीं करूंगा और मैंने इसका उपयोग क्यों किया और दूसरे का नहीं क्योंकि यह सब कुछ समझाने के लिए जटिल है। यदि आपको अधिक जानकारी की आवश्यकता है, तो दस्तावेज़ीकरण पर जाएं, "SlotConfig" के लिए पृष्ठ 16 अनुभाग 2.2.1 और "KeyConfig" के लिए पृष्ठ 19 अनुभाग 2.2.5 पर जाएं।

इस उदाहरण के लिए, आप एईएस कुंजी को स्टोर करने के लिए स्लॉट 9 का उपयोग करेंगे।

इसके लिए हमें डालने की आवश्यकता है (यदि आपको आवश्यकता है, तो आप ऊपर दिए गए उदाहरण को कॉपी कर सकते हैं, इसमें संशोधन किया गया है):

1. बाइट 36 = 0x8F
2. बाइट 37 = 0x0F
3. बाइट 112 = 0x1A
4. बाइट 113 = 0x00

मैंने यह कॉन्फ़िगरेशन क्यों सेट किया: इस चिप के प्रत्येक स्लॉट के लिए, आप चिप को यह कहने के लिए पैरामीटर सेट कर सकते हैं कि किस प्रकार का डेटा स्टोर किया जाएगा। आपके पास कई पैरामीटर हैं:

• स्लॉट लिखा या पढ़ा जा सकता है (स्पष्ट या एन्क्रिप्ट कार्रवाई)
• संग्रहीत डेटा का प्रकार (ईसीसी कुंजी, सार्वजनिक कुंजी, एसएचए हैश, एईएस कुंजी …)
• स्लॉट लॉक करने योग्य हो सकता है
• कुंजी बनाने की अनुमति है
• …

बाइट 36 और 37 के साथ "0x0F8F" पर सेट:

• डेटा Clear. में लिखा जा सकता है
• इस स्लॉट की सामग्री गुप्त है और इसे पढ़ा नहीं जा सकता
• चेकमैक कॉपी कमांड के लिए स्लॉट का उपयोग नहीं किया जा सकता है

बाइट 112 और 113 के साथ "0x001A" पर सेट:

स्लॉट चार एईएस 128-बिट सममित कुंजी तक स्टोर कर सकता है (कीटाइप = 0x6)

दूसरा चरण: इस कॉन्फ़िगरेशन को लिखें

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

लेकिन कोई चिंता नहीं, जब तक कॉन्फ़िगरेशन लॉक नहीं है, आप अपने कॉन्फ़िगरेशन को संशोधित कर सकते हैं।

यहाँ, यह कोड चिप को कॉन्फ़िगरेशन लिखने के लिए उपयोग किया जाता है:

/** \संक्षिप्त चिप में एक नया विन्यास लिखें।

* / परम [इन] cfg लॉजिकल इंटरफेस कॉन्फ़िगरेशन। कुछ पूर्वनिर्धारित * कॉन्फ़िगरेशन atca_cfgs.h * \param[in] config Array uint8_t कॉन्फ़िगरेशन (लंबाई 112) * \param[in] len कॉन्फ़िगरेशन सरणी का आकार * / वापसी ATCA_SUCCESS सफलता पर पाया जा सकता है, अन्यथा एक त्रुटि कोड। */ ATCA_STATUS write_configuration(ATCAIfaceCfg *cfg, uint8_t *config, size_t len) { अगर (लेन! = 112) ATCA_BAD_PARAM लौटाएं; ATCA_STATUS स्थिति; स्थिति = atcab_init (cfg); if (status == ATCA_SUCCESS) {//कॉन्फ़िगरेशन एरे को चिप में लिखें // 16 बाइट की पैडिंग (16 फर्स्ट बाइट्स को नहीं लिखा जा सकता) स्टेटस = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *)config, len); वापसी की स्थिति; } वापसी की स्थिति; }

यह फ़ंक्शन आपके कॉन्फ़िगरेशन को चिप में लिखेगा।

तीसरा चरण: कॉन्फ़िगरेशन ज़ोन को लॉक करें

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

इस क्रिया के लिए, हम इस फ़ंक्शन का उपयोग करेंगे:

/** \संक्षिप्त जांचें कि क्या कोई DATA_ZONE या CONFIG_ZONE लॉक है

* / परम [इन] cfg लॉजिकल इंटरफेस कॉन्फ़िगरेशन। कुछ पूर्वनिर्धारित * कॉन्फ़िगरेशन atca_cfgs.h * \param[in] ज़ोन LOCK_ZONE_DATA या LOCK_ZONE_CONFIG * / वापसी ATCA_SUCCESS में सफलता पर पाए जा सकते हैं, अन्यथा एक त्रुटि कोड। */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t ज़ोन) {ATCA_STATUS स्थिति; बूल लॉक = झूठा; अगर (ज़ोन!= (uint8_t)LOCK_ZONE_CONFIG && ज़ोन!= (uint8_t)LOCK_ZONE_DATA) वापसी ATCA_BAD_PARAM; स्थिति = atcab_init (cfg); if (status == ATCA_SUCCESS) { if (ATCA_SUCCESS != (status = atcab_is_locked(zone, &lock))) { return ATCA_FUNC_FAIL; } अगर (!लॉक) { वापसी ATCA_NOT_LOCKED; } वापसी ATCA_SUCCESS; } ATCA_BAD_PARAM लौटाएं; } check_lock_zone(&cfg, LOCK_ZONE_CONFIG);

चौथा चरण: आपको AES Key को एक स्लॉट में लिखें

इस भाग में आप व्यक्तिगत एईएस कुंजी को उस स्लॉट में सेट करेंगे जिसे आपने चिप के विन्यास में परिभाषित किया है।

इस उदाहरण के लिए, मैं चिप के स्लॉट नंबर 9 का उपयोग करूंगा।

आपको पता होना चाहिए: इस चिप की एक खास बात यह है कि आप स्लॉट में केवल 4 बाइट्स या 32 बाइट्स द्वारा डेटा लिख सकते हैं। एईएस के लिए हमें 128 बिट्स की की जरूरत है इसलिए 16 बाइट्स डेटा। इसलिए मैंने 32 बाइट्स डेटा रखने के लिए इस स्लॉट में प्रत्येक में 16 बाइट्स की कुंजी लिखने का फैसला किया।

अब, मैं आपको इस्तेमाल किया गया कोड दिखाऊंगा:

/** / संक्षेप में दिए गए स्लॉट में AES कुंजी लिखें। * / परम [इन] cfg लॉजिकल इंटरफेस कॉन्फ़िगरेशन। कुछ पूर्वनिर्धारित * विन्यास atca_cfgs.h * \param[in] कुंजी कुंजी स्लॉट संख्या * \param[in] डेटाकी कुंजी सरणी uint8_t * \param[in] len कुंजी सरणी का आकार * / वापसी ATCA_SUCCESS सफलता पर पाया जा सकता है, अन्यथा एक त्रुटि कोड। */ ATCA_STATUS write_key_slot(ATCAIfaceCfg *cfg, uint8_t key, uint8_t *datakey, size_t len) { अगर (कुंजी 16) रिटर्न ATCA_BAD_PARAM; अगर (लेन! = 32) ATCA_BAD_PARAM लौटाएं; ATCA_STATUS स्थिति = atcab_init (cfg); अगर (स्थिति == ATCA_SUCCESS) {स्थिति = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) कुंजी, 0, 0, डेटाकी, 32); अगर (स्थिति! = ATCA_SUCCESS) वापसी की स्थिति; } वापसी की स्थिति; }

इस उदाहरण के लिए, मैं प्रत्येक 16 बाइट्स की दो एईएस कुंजी का उपयोग करूंगा:

// एईएस कुंजी का उदाहरण (लेन 32)uint8_t example_of_key [32] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; write_key_slot(&cfg, 9, example_of_key, sizeof(example_of_key));

यदि यह क्रिया अच्छी है, तो अब, आपको अंतिम चरण "डेटा क्षेत्र को लॉक करें" पास करना होगा

अंतिम चरण: डेटा ज़ोन को लॉक करें

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

इस क्रिया के लिए, हम इस फ़ंक्शन का उपयोग करेंगे:

/** \संक्षिप्त जांचें कि क्या कोई DATA_ZONE या CONFIG_ZONE लॉक है

* / परम [इन] cfg लॉजिकल इंटरफेस कॉन्फ़िगरेशन। कुछ पूर्वनिर्धारित * कॉन्फ़िगरेशन atca_cfgs.h * \param[in] ज़ोन LOCK_ZONE_DATA या LOCK_ZONE_CONFIG * / वापसी ATCA_SUCCESS में सफलता पर पाए जा सकते हैं, अन्यथा एक त्रुटि कोड। */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t ज़ोन) {ATCA_STATUS स्थिति; बूल लॉक = झूठा; अगर (ज़ोन!= (uint8_t)LOCK_ZONE_CONFIG && ज़ोन!= (uint8_t)LOCK_ZONE_DATA) वापसी ATCA_BAD_PARAM; स्थिति = atcab_init (cfg); if (status == ATCA_SUCCESS) { if (ATCA_SUCCESS != (status = atcab_is_locked(zone, &lock))) { return ATCA_FUNC_FAIL; } अगर (!लॉक) { वापसी ATCA_NOT_LOCKED; } वापसी ATCA_SUCCESS; } ATCA_BAD_PARAM लौटाएं; } check_lock_zone(&cfg, LOCK_ZONE_DATA);

यदि यह क्रिया अच्छी है, तो आपकी चिप उपयोग के लिए तैयार है

चरण 5: 3. एईएस सीबीसी मॉड्यूल का उपयोग

मैं समझाऊंगा कि एल्गोरिथम AES CBC और चिप Atecc608a के साथ डेटा को कैसे एन्क्रिप्ट और डिक्रिप्ट किया जाए।

याद रखें: इस फ़ंक्शन का उपयोग करने से पहले, आपको चिप सेट करने की आवश्यकता है। इसके लिए इस लेख के चरण 2 का पालन करें

इस चिप को कई प्रकार के एईएस मॉड्यूल (एईएस 128 बिट्स) मिले हैं, केवल एईएस 128 बिट संभव है:

1. एईएस सामान्य
2. एईएस सीबीसी
3. एईएस जीसीएम (जीएफएम हैश के साथ) (अधिक खोज के लिए विकिपीडिया देखें)

इसका उपयोग करना आसान बनाने के लिए, मैंने दो कार्य बनाए:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

वे दो कार्य मेरे जीथब पर उपलब्ध हैं।

व्याख्या

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

जानकारी

नीचे मैं एन्क्रिप्शन और डिक्रिप्शन विधि के प्रत्येक चरण का विवरण देता हूं। लेकिन मैंने Arduino के लिए एक कोड लिखा था जो उन दोनों कार्यों का उपयोग करता है। आप इस कोड को मेरे जीथब में देख सकते हैं:

• गीथूब: माई जीथूब
• कोड "एन्क्रिप्ट/डिक्रिप्ट" का उदाहरण: AES_crypto_example.ino

पहला कदम: अपना डेटा एन्क्रिप्ट करें

इस भाग में, मैं आपको दिखाऊंगा कि अपने डेटा को कैसे एन्क्रिप्ट किया जाए।

सबसे पहले आपको इस फ़ंक्शन की आवश्यकता होगी:

/** \AES CBC एल्गोरिथम का उपयोग करके डेटा एन्क्रिप्ट करें * \param[in] cfg तार्किक इंटरफ़ेस कॉन्फ़िगरेशन। कुछ पूर्वनिर्धारित * विन्यास atca_cfgs.h * \param[in] डेटा में पाए जा सकते हैं शब्दों को कूटबद्ध करने के लिए (16 से विभाजित किया जाना चाहिए, अधिकतम लंबाई 240) * \param[in] शब्दों की लंबाई को encpt करने के लिए (16 से विभाजित किया जाना चाहिए), अधिकतम लंबाई 240) * \param[out] iv एईएस सीबीसी में प्रयुक्त प्रारंभिक वेक्टर (इस संस्करण में वेक्टर लौटाएं) * \param[out] सिफरटेक्स्ट यहां साइफर टेक्स्ट * \param[in] कुंजी स्लॉट संख्या लौटाएं कुंजी * / वापसी ATCA_SUCCESS सफलता पर, अन्यथा एक त्रुटि कोड। */ ATCA_STATUS aes_cbc_encrypt(ATCA_aes_cbc_ctx_t ctx; अगर (लेन> LIMIT_DATA_SIZE_CBC && लेन% 16! = 0) { Serial.print(F("ERROR: ATCA_BAD_PARAM")); वापसी ATCA_BAD_PARAM; } uint8_t tmp_iv[IV_LENGTH_CBC]; uint8_t tmp_data [लेन]; ATCA_STATUS स्थिति = atcab_init (cfg); अगर (स्थिति == ATCA_SUCCESS) {स्थिति = atcab_aes_cbc_init (& ctx, कुंजी, 0, tmp_iv); अगर (स्थिति! = ATCA_SUCCESS) { सीरियल.प्रिंट (एफ ("त्रुटि एन्क्रिप्ट करें: atcab_aes_cbc_init, कोड त्रुटि 0x")); Serial.println (स्थिति, हेक्स); वापसी; } memcpy(iv, tmp_iv, IV_LENGTH_CBC); memcpy (tmp_data, डेटा, लेन); इंट मैक्स = लेन / 16; के लिए (int j = 0; j <अधिकतम; j++) {स्थिति = atcab_aes_cbc_encrypt_block(&ctx, &tmp_data[j *16], &ciphertext[j * 16]); } अगर (स्थिति! = ATCA_SUCCESS) { Serial.print(F("ERROR Encrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (स्थिति, हेक्स); } वापसी की स्थिति; } वापसी की स्थिति; }

इस फ़ंक्शन का उपयोग करना आसान है, आपको दो चीज़ें सेट करनी होंगी:

1. 16 बाइट्स का एक खाली IV (आरंभिक वेक्टर)
2. एन्क्रिप्ट करने के लिए डेटा (अधिकतम आकार 240 बाइट्स)

यहां एक उदाहरण "इस फ़ंक्शन का उपयोग कैसे करें"।

मैं "एएएएएएएएएएएएएएएएएएएएए" शब्द को एन्क्रिप्ट करना चाहता हूं, मेरी कुंजी स्लॉट संख्या "9" में लिखी गई है:

ATCA_STATUS स्थिति = atcab_init (& cfg); अगर (स्थिति! = ATCA_SUCCESS) { Serial.println (F ("atcab_init () विफल: कोड -> 0x")); Serial.println (स्थिति, हेक्स); } uint8_t प्लेनटेक्स्ट[16] = "AAAAAAAAAAAAAAAAA"; // मूल पाठ uint8_t iv [IV_LENGTH_CBC]; // प्रारंभिक वेक्टर uint8_t साइबरडेटा [आकार (सादा पाठ)]; // डेटा एन्क्रिप्टेड स्थिति = aes_cbc_encrypt (&cfg, प्लेनटेक्स्ट, साइज़ऑफ़ (प्लेनटेक्स्ट), iv, साइफरडेटा, 9);

यदि कार्रवाई अच्छी है, तो आपके पास "साइफरडेटा" चर में एन्क्रिप्टेड डेटा और चर "IV" में प्रारंभिक वेक्टर होगा।

अपने पाठ को डिक्रिप्ट करने के लिए उन दो चरों को रखें!

दूसरा चरण: अपना डेटा डिक्रिप्ट करें

अपने डेटा को डिक्रिप्ट करने के लिए आपको दो चीजों की आवश्यकता होगी:

1. प्रारंभिक वेक्टर
2. साइफर डेटा (एन्क्रिप्टेड डेटा)

अपने डेटा को डिक्रिप्ट करने के लिए, आपको इस फ़ंक्शन की आवश्यकता होगी:

/** \AES CBC एल्गोरिथम का उपयोग करके डेटा को डिक्रिप्ट करें * \param[in] cfg तार्किक इंटरफ़ेस कॉन्फ़िगरेशन। कुछ पूर्वनिर्धारित * विन्यास atca_cfgs.h * \param[in] ciphertext Words to decypt (16 से विभाजित किया जाना चाहिए, अधिकतम लंबाई 240) में पाया जा सकता है, अधिकतम लंबाई 240) * \param[in] iv एईएस सीबीसी में उपयोग करने के लिए प्रारंभिक वेक्टर * \param[out] प्लेनटेक्स्ट यहां डिक्रिप्टेड टेक्स्ट * \param[in] कुंजी की स्लॉट संख्या * / वापसी ATCA_SUCCESS सफलता पर लौटाता है, अन्यथा एक त्रुटि कोड। */ ATCA_STATUS aes_cbc_decrypt(ATCA_aes_cbc_ctx_t ctx; अगर (लेन> LIMIT_DATA_SIZE_CBC || लेन% 16! = 0) { Serial.print(F("ERROR Decrypt: ATCA_BAD_PARAM")); वापसी ATCA_BAD_PARAM; } ATCA_STATUS स्थिति = atcab_init (cfg); अगर (स्थिति == ATCA_SUCCESS) {स्थिति = atcab_aes_cbc_init (& ctx, कुंजी, 0, iv); अगर (स्थिति! = ATCA_SUCCESS) { सीरियल.प्रिंट (एफ ("त्रुटि डिक्रिप्ट: atcab_aes_cbc_init, कोड त्रुटि 0x")); Serial.println (स्थिति, हेक्स); वापसी; } इंट मैक्स = लेन / 16; के लिए (int j = 0; j <अधिकतम; j++) {स्थिति = atcab_aes_cbc_decrypt_block(&ctx, &ciphertext[j *16], &plaintext[j * 16]); } अगर (स्थिति! = ATCA_SUCCESS) { सीरियल.प्रिंट (एफ ("त्रुटि डिक्रिप्ट: atcab_aes_cbc_encrypt_block, कोड त्रुटि 0x")); Serial.println (स्थिति, हेक्स); } वापसी की स्थिति; } वापसी की स्थिति; }

मैं अपने पिछले डेटा को डिक्रिप्ट करना चाहता हूं (नीचे देखें, पहला चरण)। इसके लिए मैं यह करूँगा:

uint8_t सादा पाठ [16] = "AAAAAAAAAAAAAAAAA"; uint8_t iv[IV_LENGTH_CBC]; uint8_t साइफरडेटा [आकार (सादा पाठ)]; uint8_t डिक्रिप्ट डेटा [आकार (सादा पाठ)]; स्थिति = aes_cbc_decrypt(&cfg, cypherdata, sizeof(cypherdata), iv, decryptdata, 9); अगर (स्थिति == ATCA_SUCCESS) { Serial.print ("डिक्रिप्टेड टेक्स्ट है:"); for (size_t i = 0; i < sizeof(decryptdata); i++) { Serial.print((char) decryptdata); } सीरियल.प्रिंट्लन (""); } और {// कोड त्रुटि सीरियल के लिए atca_status.h फ़ाइल देखें। प्रिंट (एफ ("डिक्रिप्शन असंभव है। कोड त्रुटि 0x")); Serial.println (स्थिति, हेक्स); वापसी; }

यदि कार्रवाई अच्छी है, तो आपके पास डिक्रिप्टेड डेटा वेरिएबल "डिक्रिप्टडाटा" में होगा।

अब आप जानते हैं कि Atecc608a चिप के साथ एन्क्रिप्शन और डिक्रिप्शन का उपयोग कैसे करें

चरण 6: 5. आपको इस चिप का उपयोग करने की आवश्यकता क्यों है

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

यहाँ उपयोग के कुछ उदाहरण:

1. बाहरी EEPROM में संग्रहीत डेटा: आप बाहरी EEPROM के डेटा को सुरक्षित कर सकते हैं और यदि कोई अभी भी यह EEPROM है, तो उसे डिक्रिप्शन के लिए कुंजी और IV की आवश्यकता होगी
2. वायरलेस डेटा भेजें: आप इस एन्क्रिप्टेड डेटा को वायरलेस (nrf24L01, RFM95W…) द्वारा भेज सकते हैं और यदि कोई आपके डेटा को इंटरसेप्ट करता है, तो यह डेटा सुरक्षित रहेगा
3. संग्रहीत पासवर्ड
4. …

इस चिप से आप कई काम कर सकते हैं। इसका उपयोग कई प्रोजेक्ट में किया जा सकता है। यदि आपके पास समय हो तो मुझे बताएं कि आप इस चिप का उपयोग किस परियोजना में करेंगे?

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

चरण 7: निष्कर्ष

मुझे उम्मीद है कि यह लेख आपके लिए उपयोगी होगा। क्षमा करें अगर मैंने अपने पाठ में गलती की है लेकिन अंग्रेजी मेरी मुख्य भाषा नहीं है और मैं लिखने से बेहतर बोलता हूं।

सब कुछ पढ़ने के लिए धन्यवाद।

का आनंद लें।