Arduino תקשורת מוצפנת אלחוטית: 5 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:13

שלום לכולם, במאמר השני הזה, אסביר לך כיצד להשתמש בשבב Atecc608a לאבטחת התקשורת האלחוטית שלך. לשם כך אשתמש ב- NRF24L01+ עבור החלק האלחוטי ו- UNO Arduino.

שבב המיקרו ATECC608A תוכנן על ידי MicroChip וקיבל מספר כלי אבטחה. לדוגמה, שבב זה יכול לאחסן מפתחות ECC, מפתחות AES (עבור AES 128) ו- SHA2 Hash.

המאמר: NRF24L01 + Arduino UNO + ATECC608A

במהלך תקשורת בין שני אובייקט IoT, יכולות להיות התקפות מרובות: Man Of the mild, העתק מידע ועוד.. אז הרעיון שלי מאוד פשוט:

1. ניצול נתונים מוצפנים בין שני אובייקט IoT או יותר.
2. אספקה בעלות נמוכה
3. יכול לעבוד עם UNO Arduino

במקרה שלי, אני משתמש

• את Atecc608a לאחסון מפתח ה- AES שלי וכדי להצפין/לפענח את הנתונים שלי.
• ה- Arduino Uno כמיקרו -בקר
• NRF24L01 לשלוח את הנתונים שלי

עליך לבצע את השלבים הבאים לפרויקט זה:

1. הגדר את השבב ATECC608A
2. בצע את המעגל (צומת מאסטר וצומת עבדים)
3. חלק קוד
4. לך הלאה!

עבור השלבים הראשונים "הגדר את השבב ATECC608A", כתבתי מאמר אחר המסביר כל שלב לפי הסדר. הקישור נמצא כאן:

עכשיו התחל!

אספקה

לפרויקט זה אתה צריך:

• 2 Arduino UNO או Arduino NANO או Arduino Mega
• קצת חוט
• 2 Atecc608a (כל אחד עלה פחות מ- 0.60 $)
• 2 NRF24L01+
• 2 קבלים (10 μF)
• לוחות לחם

קישור למאמר שלי המסביר כיצד להגדיר את השבב ATECC608A -> כיצד להגדיר את Atecc608a

שלב 1: 1. הגדר את Atecc608a

לא אפרט על כל שלב שיש לבצע כדי להגדיר ATECC608A מכיוון שכתבתי מאמר מלא המסביר את כל השלבים לביצועו. כדי להגדיר אותו, עליך לבצע את "שלב 4" של מאמר זה בשם "2. תצורת השבב (Atecc608a)"

הקישור הוא: כיצד להגדיר ATECC608A

כמו כן, עליך לשים את אותה תצורה עבור Atecc608a, צד ראשי וצד עבדים, אחרת לא תוכל לפענח את הנתונים שלך

אזהרה:

כדי להגדיר שבב זה, עליך לבצע את כל השלבים של המאמר לעיל לפי הסדר. אם שלב אחד חסר או שהשבב אינו נעול, לא תוכל לבצע את הפרויקט הזה

היתרה:

שלב לעקוב לשם כך:

• צור תבנית תצורה
• כתוב תבנית זו לשבב
• נעל את אזור התצורה
• כתוב את מפתח ה- AES שלך (128 ביט) בחריץ
• נעל את אזור הנתונים

שלב 2: 2. עיצוב המעגל (מאסטר ועבד)

בפרויקט זה יהיה לך צומת מאסטר וצומת עבדים.

הצומת הראשי ידפיס את הנתונים שנשלחו על ידי צומת העבדים באופן ברור. הוא יבקש נתונים מצומת העבדים בכל X פעם אחת.

צומת העבדים יקשיב ל"רשת "וכאשר היא תקבל" נתוני בקשה ", היא תייצר אותם, תצפין אותם ותשלח אותם לצומת הראשי.

עבור שני הצדדים, המאסטר והעבד המעגל זהים:

• ארדואינו ננו אחד
• ATECC608A אחד
• NRF24L01 אחד

צירפתי את המעגל לשלב זה (ראה תמונה למעלה).

עבור ה- ATECC608A ל- UNO Arduino, זהו סיכה של 8 פינים. הוספתי את "הנוף מלמעלה" למעלה:

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

עבור NRF24L01 ל- Arduino:

• ARDUINO 3.3V -> VCC (nrf24l01)
• ARDUINO GND -> GND (nrf24l01)
• ARDUINO 9 -> CE (nrf24l01)
• ARDUINO 10 -> CSN (nrf24l01)
• ARDUINO 11 -> MOSI (nrf24L01)
• ARDUINO 12 -> MISO (nrf24l01)
• ARDUINO 13 -> SCK (nrf24l01)
• ARDUINO 3 -> IRQ (nrf24l01) -> רק לצומת עבדים, לא בשימוש במצב Master

למה להשתמש בסיכה IRQ של NRF24L01

סיכת ה- IRQ שימושית מאוד, סיכה זו מאפשרת לומר (LOW) כאשר מגיעה נתון חבילה על ידי NRF24L01, כך שנוכל לצרף פסיקה לסיכה זו כדי להעיר את צומת העבדים.

שלב 3: 3. הקוד (עבד ומאסטר)

צומת עבדים

אני משתמש בחיסכון בחשמל עבור הצומת העבד מכיוון שהוא לא צריך להקשיב כל הזמן.

איך זה עובד: צומת העבדים מקשיבים ומחכים לקבל "חבילת התעוררות". חבילה זו נשלחת על ידי הצומת הראשי לשאול נתונים מהעבד.

במקרה שלי אני משתמש במערך של שני int:

// חבילת השכמה

const int wake_packet [2] = {20, 02};

אם הצומת שלי מקבל חבילה,

1. תתעורר, קרא את החבילה הזו, אם המנה היא "התעוררות",
2. הוא מייצר את הנתונים,
3. להצפין את הנתונים,
4. שלח את הנתונים למאסטר, המתן חבילת ACK,
5. לִישׁוֹן.

לצורך הצפנת AES, אני משתמש במפתח בחריץ מספר 9.

זהו הקוד שלי לצומת העבדים

#כלול "Arduino.h" #include "avr/sleep.h" #include "avr/wdt.h"

#כלול "SPI.h"

#כלול "nRF24L01.h" #כולל "RF24.h"

#כלול "Wire.h"

// ספריית ATECC608A

#כלול "ATECCX08A_Arduino/cryptoauthlib.h" #כולל "AES BASIC/aes_basic.h"

#הגדר ID_NODE 255

#הגדר AES_KEY (uint8_t) 9

ATCAIfaceCfg cfg;

סטטוס ATCA_STATUS;

רדיו RF24 (9, 10);

const uint64_t masteraddresse = 0x1111111111;

const uint64_t slaveaddresse = 0x1111111100;

/**

* / brief פונקציה המבוצעת כאשר ההפרעה מוגדרת (IRQ LOW) * * */ void wakeUpIRQ () {while (radio.available ()) {נתוני int [32]; radio.read (& data, 32); if (data [0] == 20 && data [1] == 02) {טמפרטורת מצוף = 17.6; לזמזם צף = 16.4;

uint8_t נתונים [16];

uint8_t cypherdata [16];

// בנה מחרוזת כדי להגדיר את כל הערך שלי

// כל ערך מופרד על ידי "|" וה" $ "פירושו סוף הנתונים // אזהרה: חייב להיות באורך של פחות מ -11 אורך מחרוזת tmp_str_data = מחרוזת (ID_NODE) +" | " + מחרוזת (טמפ ', 1) + "|" + מחרוזת (מזמזם, 1) + "$"; // גודל של 11 Serial.println ("tmp_str_data:" + tmp_str_data);

tmp_str_data.getBytes (נתונים, גודל (נתונים));

// להצפין את הנתונים

ATCA_STATUS status = aes_basic_encrypt (& cfg, data, sizeof (data), cypherdata, AES_KEY); אם (status == ATCA_SUCCESS) {rand ארוך = אקראי ((ארוך) 10000, (ארוך) 99999);

// ליצור UUID המבוסס על שלושת המספרים הראשונים = צומת מזהה

מחרוזת 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)); // הפסק להאזין לרדיו.סטופליסט ();

bool rslt;

// שלח נתונים rslt = radio.write (& data_to_send, sizeof (data_to_send)); // התחל להאזין radio.startListening (); if (rslt) {// מצב סיום ושינה Serial.println (F ("בוצע")); }}}}}

הגדרת חלל ()

{Serial.begin (9600);

// תחילה בונה את הספרייה

cfg.iface_type = ATCA_I2C_IFACE; // סוג תקשורת -> מצב I2C cfg.devtype = ATECC608A; // סוג שבב cfg.atcai2c.slave_address = 0XC0; // כתובת I2C (ערך ברירת מחדל) cfg.atcai2c.bus = 1; cfg.atcai2c.baud = 100000; cfg.wake_delay = 1500; // עיכוב השכמה (1500 אלפיות השנייה) cfg.rx_retries = 20;

radio.begin ();

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

radio.openWritingPipe (masteraddresse);

radio.openReadingPipe (1, slaveaddresse); // צרף את הפסק לסיכה 3 // שנה 1 על ידי O אם אתה רוצה את ההפרעה לסיכה 2 // FALLING MODE = Pin at LOW attachInterrupt (1, wakeUpIRQ, FALLING); }

לולאת חלל ()

{ // אין צורך }

צומת מאסטר

הצומת הראשי מתעורר כל 8 שניות לשאול נתונים מהצומת העבד

איך זה עובד: הצומת הראשי שולח חבילת "WakeUP" לעבד ולאחר המתנה תשובה של העבד עם נתונים.

במקרה שלי אני משתמש במערך של שני int:

// חבילת השכמה

const int wake_packet [2] = {20, 02};

אם צומת העבדים שלח חבילת ACK לאחר שהמאסטר שלח חבילת WakeUp:

1. מאסטר מוגדר במצב האזנה והמתן לתקשורת
2. אם תקשורת
3. חלץ את 8 הבייט הראשון, בזז את שלושת הבייט הראשון מתוך 8 הבייטים, אם זהו צומת הזיהוי
4. חלץ את 16 הבייט של הצפנה
5. פענח את הנתונים
6. הדפס את הנתונים בסדרה
7. מצב שינה

לצורך הצפנת AES, אני משתמש במפתח בחריץ מספר 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); const uint64_t masteraddresse = 0x1111111111; const uint64_t slaveaddresse = 0x1111111100; // חבילת Wake UP const int wake_packet [2] = {20, 02}; // כלב שמירה מפריע ISR (WDT_vect) {wdt_disable (); // השבת כלב השמירה} void sleep mode () {// השבת ADC ADCSRA = 0; // נקה דגלי "איפוס" שונים MCUSR = 0; // אפשר שינויים, השבת את איפוס WDTCSR = bit (WDCE) | bit (WDE); // הגדר מצב הפרעה ומרווח WDTCSR = bit (WDIE) | bit (WDP3) | ביט (WDP0); // הגדר WDIE, ועיכוב של 8 שניות wdt_reset (); // אפס את כלב השמירה set_sleep_mode (SLEEP_MODE_PWR_DOWN); noInterrupts (); // רצף מתוזמן עוקב אחר sleep_enable (); // לכבות הפעלה חומה בתוכנה MCUCR = bit (BODS) | bit (BODSE); MCUCR = bit (BODS); מפריע (); // מבטיח את ההוראה הבאה שבוצעה sleep_cpu (); // בטל שינה כאמצעי זהירות sleep_disable (); } הגדרת void () {Serial.begin (9600); // התחל את מבנה הספרייה cfg.iface_type = ATCA_I2C_IFACE; // סוג תקשורת -> מצב I2C cfg.devtype = ATECC608A; // סוג שבב cfg.atcai2c.slave_address = 0XC0; // כתובת I2C (ערך ברירת מחדל) cfg.atcai2c.bus = 1; cfg.atcai2c.baud = 100000; cfg.wake_delay = 1500; // עיכוב השכמה (1500 אלפיות השנייה) cfg.rx_retries = 20; radio.begin (); radio.setDataRate (RF24_250KBPS); radio.maskIRQ (1, 1, 0); radio.enableAckPayload (); radio.setRetries (5, 5); radio.openWritingPipe (slaveaddresse); radio.openReadingPipe (1, masteraddresse); } לולאת חלל () {bool rslt; // שלח נתונים rslt = radio.write (& wake_packet, sizeof (wake_packet)); if (rslt) {// התחל להאזין radio.startListening (); while (radio.available ()) {uint8_t answer [32]; radio.read (& answer, sizeof (answer)); uint8_t node_id [3]; צופן uint8_t [16]; memcpy (node_id, answer, 3); memcpy (cypher, answer + 3, 16); אם ((int) node_id == ID_NODE) {פלט uint8_t [16]; ATCA_STATUS status = aes_basic_decrypt (& cfg, cypher, 16, output, AES_KEY); if (status == ATCA_SUCCESS) {Serial.println ("נתונים מפוענחים:"); עבור (size_t i = 0; i <16; i ++) {פלט Serial.print ((char) ); }}}}} else {Serial.println ("אל תקבל עבור חבילת Wakup"); } // מצב שינה 8 מצבי שינה (); }

אם יש לך שאלה, אני כאן כדי לענות עליה

שלב 4: 4. המשך

דוגמה זו פשוטה, כך שתוכל לשפר את הפרויקט הזה

שיפורים:

• ה- AES 128 בסיסי ותוכל להשתמש באלגוריתם אחר של AES כ- AES CBC כדי להיות בטוח יותר.
• שנה את המודול האלחוטי (NRF24L01 מוגבל במטען של 23 בתים)
• …

אם אתה רואה שיפור לעשות, הסבר אותו באזור הדיון

שלב 5: מסקנה

אני מקווה שמאמר זה יהיה שימושי עבורך. מצטער אם טעיתי בטקסט שלי אבל אנגלית היא לא השפה העיקרית שלי ואני מדבר טוב יותר ממה שאני כותב.

תודה שקראתם הכל.

תהנה.