वायरलेस एन्क्रिप्टेड संचार Arduino: 5 कदम

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

सभी को नमस्कार, इस दूसरे लेख में, मैं आपको बताऊंगा कि अपने वायरलेस संचार को सुरक्षित करने के लिए चिप एटेक६०८ए का उपयोग कैसे करें। इसके लिए, मैं वायरलेस भाग और Arduino UNO के लिए NRF24L01+ का उपयोग करूंगा।

माइक्रो चिप ATECC608A को माइक्रोचिप द्वारा डिजाइन किया गया है और इसमें कई सुरक्षा उपकरण हैं। उदाहरण के लिए, यह चिप ECC Keys, AES Keys (AES 128 के लिए) और SHA2 हैश को स्टोर कर सकती है।

लेख: NRF24L01 + Arduino UNO + ATECC608A

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

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

मेरे मामले में, मैं उपयोग करता हूँ

• Atecc608a मेरी एईएस कुंजी को स्टोर करने और मेरे डेटा को एन्क्रिप्ट/डिक्रिप्ट करने के लिए।
• माइक्रोकंट्रोलर के रूप में Arduino Uno
• मेरा डेटा भेजने के लिए NRF24L01

इस परियोजना के लिए आपको उन चरणों का पालन करना होगा:

1. चिप सेट करें ATECC608A
2. सर्किट करें (मास्टर नोड और स्लेव नोड)
3. कोड भाग
4. आगे जाओ !

पहले चरणों के लिए "चिप सेट करें ATECC608A", मैंने एक अन्य लेख लिखा जो प्रत्येक चरण को क्रम से समझाता है। लिंक यहाँ है:

अब शुरू करो!

आपूर्ति

इस परियोजना के लिए आपको चाहिए:

• 2 Arduino UNO या Arduino NANO या Arduino Mega
• कुछ तार
• 2 Atecc608a (प्रत्येक की कीमत 0.60$ से कम है)
• 2 एनआरएफ24एल01+
• 2 संधारित्र (10 μF)
• ब्रेडबोर्ड

मेरे लेख का लिंक जो बताता है कि चिप ATECC608A कैसे सेट करें -> Atecc608a कैसे सेट करें

चरण 1: 1. Atec608a सेट करें

मैं ATECC608A को स्थापित करने के लिए अनुसरण किए जाने वाले प्रत्येक चरण का विवरण नहीं दूंगा क्योंकि मैंने एक पूरा लेख लिखा है जो इसे करने के लिए प्रत्येक चरण की व्याख्या करता है। इसे स्थापित करने के लिए, आपको इस लेख के "चरण 4" का पालन करना होगा जिसे "2. चिप का विन्यास (Atecc608a)" कहा जाता है।

लिंक है: ATECC608A कैसे सेट करें?

साथ ही, आपको Atecc608a, मास्टर साइड और स्लेव साइड के लिए समान कॉन्फ़िगरेशन डालने की आवश्यकता है, अन्यथा आप अपने डेटा को डिक्रिप्ट करने में सक्षम नहीं होंगे।

चेतावनी:

इस चिप को सेट करने के लिए, आपको ऊपर दिए गए लेख के हर चरण का क्रम से पालन करना होगा। यदि एक चरण गुम है या चिप लॉक नहीं है, तो आप इस परियोजना को करने में सक्षम नहीं होंगे।

शेष:

इसके लिए अनुसरण करने के लिए कदम:

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

चरण 2: 2. सर्किट का डिज़ाइन (मास्टर और स्लेव)

इस परियोजना में, आपके पास एक मास्टर नोड और एक स्लेव नोड होगा।

मास्टर नोड स्लेव नोड द्वारा भेजे गए डेटा को स्पष्ट रूप से प्रिंट करेगा। यह हर X बार स्लेव नोड से डेटा का अनुरोध करेगा।

दास नोड "नेटवर्क" सुनेगा और जब इसे "अनुरोध डेटा" प्राप्त होगा, तो यह इसे उत्पन्न करेगा, इसे एन्क्रिप्ट करेगा और इसे मास्टर नोड को भेज देगा।

दोनों पक्षों के लिए, मास्टर और दास सर्किट समान हैं:

• एक आर्डिनो नैनो
• एक ATECC608A
• एक NRF24L01

मैंने सर्किट को इस चरण से जोड़ा (ऊपर cf चित्र)।

ATECC608A से Arduino UNO के लिए, यह एक सोइक 8 पिन है। मैंने ऊपर "शीर्ष दृश्य" जोड़ा:

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

NRF24L01 के लिए Arduino के लिए:

• ARDUINO 3.3V -> VCC (nrf24l01)
• ARDUINO GND -> GND (nrf24l01)
• ARDUINO 9 -> सीई (nrf24l01)
• ARDUINO 10 -> CSN (nrf24l01)
• ARDUINO 11 -> MOSI (nrf24L01)
• ARDUINO 12 -> MISO (nrf24l01)
• ARDUINO 13 -> SCK (nrf24l01)
• ARDUINO 3 -> IRQ (nrf24l01) -> केवल स्लेव नोड के लिए, मास्टर मोड में उपयोग नहीं किया जाता है

NRF24L01 के IRQ पिन का उपयोग क्यों करें

IRQ पिन बहुत उपयोगी है, यह पिन NRF24L01 द्वारा एक पैकेट प्राप्त होने पर (LOW) कहने की अनुमति देता है, इसलिए हम गुलाम नोड को जगाने के लिए इस पिन में एक इंटरप्ट संलग्न कर सकते हैं।

चरण 3: 3. कोड (दास और गुरु)

गुलाम नोड

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

यह कैसे काम करता है: दास नोड "वेक यूपी पैकेट" प्राप्त करने के लिए सुनते हैं और प्रतीक्षा करते हैं। यह पैकेट मास्टर नोड द्वारा दास से डेटा पूछने के लिए भेजा जाता है।

मेरे मामले में मैं दो int की एक सरणी का उपयोग करता हूं:

// वेक यूपी पैकेट

कॉन्स्ट इंट वेक_पैकेट [2] = {20, 02};

अगर मेरे नोड को एक पैकेट प्राप्त होता है,

1. यह जागो, इस पैकेट को पढ़ो, अगर पैकेट "वेक यूपी" है,
2. यह डेटा उत्पन्न करता है,
3. डेटा एन्क्रिप्ट करें,
4. मास्टर को डेटा भेजें, एसीके पैकेट की प्रतीक्षा करें,
5. नींद।

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

स्लेव नोड के लिए यह मेरा कोड है

#include "Arduino.h"#include "avr/sleep.h" #include "avr/wdt.h"

#शामिल "एसपीआई.एच"

#शामिल "nRF24L01.h" #शामिल "RF24.h"

#शामिल "वायर.एच"

// ATECC608A लाइब्रेरी

#include "ATECCX08A_Arduino/cryptoauthlib.h" #include "AES BASIC/aes_basic.h"

#परिभाषित करें ID_NODE 255

# परिभाषित करें AES_KEY (uint8_t)9

एटीसीएआईफेससीएफजी सीएफजी;

ATCA_STATUS स्थिति;

RF24 रेडियो (9, 10);

कॉन्स्ट uint64_t मास्टरएड्रेस = 0x11111111111;

कॉन्स्ट uint64_t स्लेवएड्रेस = 0x1111111100;

/**

* इंटरप्ट सेट होने पर संक्षिप्त फ़ंक्शन निष्पादित (IRQ LOW) * * */ void WakeUpIRQ() { जबकि (रेडियो.उपलब्ध ()) {इंट डेटा [32]; रेडियो.रीड (और डेटा, 32); अगर (डेटा [0] == 20 && डेटा [1] == 02) {फ्लोट अस्थायी = 17.6; फ्लोट हम = १६.४;

uint8_t डेटा [16];

uint8_t साइफरडेटा [16];

// मेरा पूरा मान सेट करने के लिए एक स्ट्रिंग बनाएँ

// प्रत्येक मान को "|" से अलग किया जाता है और "$" का अर्थ है डेटा का अंत // चेतावनी: 11 लंबाई से कम होना चाहिए स्ट्रिंग tmp_str_data = स्ट्रिंग (ID_NODE) + "|" + स्ट्रिंग (अस्थायी, 1) + "|" + स्ट्रिंग (हम, १) + "$"; // 11 सीरियल का आकार। प्रिंट्लन ("tmp_str_data:" + tmp_str_data);

tmp_str_data.getBytes (डेटा, आकार (डेटा));

// डेटा एन्क्रिप्ट करें

ATCA_STATUS स्थिति = aes_basic_encrypt(&cfg, डेटा, आकार (डेटा), साइफरडेटा, AES_KEY); अगर (स्थिति == ATCA_SUCCESS) { लंबी रैंड = यादृच्छिक ((लंबी) १००००, (लंबी) ९९९९९);

// तीन पहले नंबर = आईडी नोड के आधार पर एक यूयूआईडी उत्पन्न करें

स्ट्रिंग uuid = स्ट्रिंग (ID_NODE) + स्ट्रिंग (रैंड); // 8. का आकार

uint8_t tmp_uuid[8];

uint8_t data_to_send[32];

uuid.getBytes(tmp_uuid, sizeof(tmp_uuid) + 1);

memcpy (data_to_send, tmp_uuid, sizeof (tmp_uuid));

memcpy(data_to_send + sizeof(tmp_uuid), cypherdata, sizeof(cypherdata)); // रेडियो सुनना बंद करो। स्टॉपलिस्टिंग ();

बूल आरएसएलटी;

// डेटा भेजें rslt = Radio.write(&data_to_send, sizeof(data_to_send)); // रेडियो सुनना शुरू करें।स्टार्टलिस्टिंग (); if (rslt) {// एंड एंड स्लीप मोड Serial.println(F("Done")); } } } } }

व्यर्थ व्यवस्था()

{ सीरियल.बेगिन (९६००);

// लाइब्रेरी के लिए कंस्ट्रक्टर को इनिट करें

cfg.iface_type = ATCA_I2C_IFACE; // संचार का प्रकार -> I2C मोड cfg.devtype = ATECC608A; // चिप का प्रकार cfg.atcai2c.slave_address = 0XC0; // I2C पता (डिफ़ॉल्ट मान) cfg.atcai2c.bus = 1; cfg.atcai2c.baud = १०००००; cfg.wake_delay = १५००; // जागने में देरी (1500 एमएस) cfg.rx_retries = 20;

रेडियो। शुरू ();

Radio.setDataRate(RF24_250KBPS); Radio.maskIRQ(1, 1, 0); Radio.enableAckPayload (); Radio.setRetries(5, 5);

Radio.openWritingPipe (मास्टर एड्रेस);

Radio.openReadingPipe(1,slavaddresse); // पिन को इंटरप्ट संलग्न करें ३ // यदि आप पिन में रुकावट चाहते हैं तो ओ द्वारा १ को संशोधित करें २ // फॉलिंग मोड = कम अटैचमेंट पर पिन करें (१, वेकअपआईआरक्यू, फॉलिंग); }

शून्य लूप ()

{ // कोई ज़रुरत नहीं है }

मास्टर नोड

दास नोड से डेटा पूछने के लिए मास्टर नोड हर 8 सेकंड में जागता है

यह कैसे काम करता है: मास्टर नोड दास को "वेकअप" पैकेट भेजता है और डेटा के साथ दास के उत्तर की प्रतीक्षा करने के बाद।

मेरे मामले में मैं दो int की एक सरणी का उपयोग करता हूं:

// वेक यूपी पैकेट

कॉन्स्ट इंट वेक_पैकेट [2] = {20, 02};

यदि मास्टर द्वारा वेकअप पैकेट भेजे जाने के बाद दास नोड एक ACK पैकेट भेजता है:

1. मास्टर को सुनो मोड में सेट किया गया है और संचार की प्रतीक्षा करें
2. अगर संचार
3. 8 पहले बाइट निकालें, 8 बाइट्स के पहले तीन बाइट लूटें, अगर यह आईडी नोड है
4. साइफर के 16 बाइट निकालें
5. डेटा को डिक्रिप्ट करें
6. सीरियल में डेटा प्रिंट करें
7. स्लीप मोड

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

यह मास्टर नोड के लिए मेरा कोड है

#शामिल "Arduino.h"

#include "avr/sleep.h" #include "avr/wdt.h" #include "SPI.h" #include "nRF24L01.h" #include "RF24.h" #include "Wire.h" // ATECC608A लाइब्रेरी #include "ATECCX08A_Arduino/cryptoauthlib.h" #include "AES BASIC/aes_basic.h" #define ID_NODE 255 #define AES_KEY (uint8_t)9 ATCAIfaceCfg cfg; ATCA_STATUS स्थिति; RF24 रेडियो (9, 10); कॉन्स्ट uint64_t मास्टरएड्रेस = 0x11111111111; कॉन्स्ट uint64_t स्लेवएड्रेस = 0x1111111100; // वेक यूपी पैकेट कॉन्स इंट वेक_पैकेट [2] = {20, 02}; // वॉचडॉग इंटरप्ट ISR (WDT_vect) {wdt_disable (); // वॉचडॉग को अक्षम करें} शून्य स्लीपमोड () {// एडीसी ADCSRA = 0 को अक्षम करें; // विभिन्न "रीसेट" झंडे MCUSR = 0 साफ़ करें; // परिवर्तन की अनुमति दें, रीसेट अक्षम करें WDTCSR = बिट (WDCE) | बिट (डब्ल्यूडीई); // इंटरप्ट मोड और एक अंतराल सेट करें WDTCSR = बिट (WDIE) | बिट (WDP3) | बिट (WDP0); // WDIE सेट करें, और 8 सेकंड देरी wdt_reset (); // वॉचडॉग सेट_स्लीप_मोड (SLEEP_MODE_PWR_DOWN) को रीसेट करें; नो इंटरप्ट्स (); // समयबद्ध अनुक्रम इस प्रकार है sleep_enable(); // सॉफ्टवेयर MCUCR = बिट (BODS) में ब्राउन-आउट सक्षम करें बंद करें | बिट (बोडसे); एमसीयूसीआर = बिट (बीओडीएस); इंटरप्ट (); // गारंटी देता है कि अगला निर्देश निष्पादित स्लीप_सीपीयू (); // नींद को एहतियात के तौर पर रद्द करें स्लीप_डिसेबल (); } शून्य सेटअप () {Serial.begin (९६००); // लाइब्रेरी cfg.iface_type = ATCA_I2C_IFACE के लिए इनिट कंस्ट्रक्टर; // संचार का प्रकार -> I2C मोड cfg.devtype = ATECC608A; // चिप का प्रकार cfg.atcai2c.slave_address = 0XC0; // I2C पता (डिफ़ॉल्ट मान) cfg.atcai2c.bus = 1; cfg.atcai2c.baud = १०००००; cfg.wake_delay = १५००; // जागने में देरी (1500 एमएस) cfg.rx_retries = 20; रेडियो। शुरू (); Radio.setDataRate(RF24_250KBPS); Radio.maskIRQ(1, 1, 0); Radio.enableAckPayload (); Radio.setRetries(5, 5); Radio.openWritingPipe(slaveaddresse); Radio.openReadingPipe(1, Masteraddresse); } शून्य लूप () {बूल rslt; // डेटा भेजें rslt = Radio.write(&wake_packet, sizeof(wake_packet)); अगर (rslt) {// रेडियो सुनना शुरू करें। जबकि (रेडियो.उपलब्ध ()) { uint8_t उत्तर [32]; Radio.read(&answer, sizeof(answer)); uint8_t नोड_आईडी [3]; uint8_t साइफर [16]; memcpy (नोड_आईडी, उत्तर, 3); memcpy (साइफर, उत्तर + 3, 16); अगर ((int) node_id == ID_NODE) {uint8_t आउटपुट [16]; ATCA_STATUS स्थिति = aes_basic_decrypt(&cfg, cypher, 16, output, AES_KEY); अगर (स्थिति == ATCA_SUCCESS) { Serial.println ("डिक्रिप्टेड डेटा:"); for (size_t i = 0; i <16; i++) {Serial.print((char)output); } } } } और { Serial.println ("वाकअप पैकेट के लिए प्राप्त नहीं हुआ"); } // स्लीप मोड 8 सेकेंड स्लीपमोड (); }

यदि आपके कोई प्रश्न हैं, तो मैं इसका उत्तर देने के लिए यहां हूं

चरण 4: 4. आगे बढ़ें

यह उदाहरण सरल है ताकि आप इस परियोजना में सुधार कर सकें

सुधार:

• एईएस 128 बुनियादी है और आप सुरक्षित होने के लिए एईएस सीबीसी के रूप में एईएस के अन्य एल्गोरिदम का उपयोग कर सकते हैं।
• वायरलेस मॉड्यूल बदलें (NRF24L01 23 बाइट्स के पेलोड द्वारा सीमित है)
• …

यदि आप सुधार करने के लिए देखते हैं, तो इसे चर्चा क्षेत्र में समझाएं

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

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

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

का आनंद लें।