Draadloos versleutelde kommunikasie Arduino: 5 stappe

2025 Outeur: John Day | [email protected]. Laas verander: 2025-01-13 06:56

Hallo almal, In hierdie tweede artikel sal ek u verduidelik hoe u die chip Atecc608a kan gebruik om u draadlose kommunikasie te beveilig. Hiervoor gebruik ek die NRF24L01+ vir die draadlose deel en die Arduino UNO.

Die mikroskyfie ATECC608A is ontwerp deur MicroChip en het verskeie beveiligingsinstrumente. Hierdie chip kan byvoorbeeld ECC -sleutels, AES -sleutels (vir AES 128) en SHA2 Hash stoor.

Die artikel: NRF24L01 + Arduino UNO + ATECC608A

Tydens 'n kommunikasie tussen twee IoT -voorwerpe kan daar verskeie aanvalle wees: Man Of the mild, afskrif van inligting en meer.. My idee is dus baie eenvoudig:

1. Gebruik van geïnkripteer data tussen twee of meer IoT -voorwerpe.
2. Goedkoop voorrade
3. Kan werk met 'n Arduino UNO

In my geval gebruik ek

• die Atecc608a om my AES -sleutel te stoor en om my data te versleut/ontsyfer.
• die Arduino Uno as mikrobeheerder
• Die NRF24L01 om my data te stuur

U moet hierdie stappe vir hierdie projek volg:

1. Stel die chip ATECC608A op
2. Doen die kring (Master Node en Slave Node)
3. Kode deel
4. Gaan verder !

Vir die eerste stappe "Stel die chip ATECC608A op", het ek 'n ander artikel geskryf wat elke stap in volgorde verduidelik. Die skakel is hier:

Begin nou!

Voorrade

Vir hierdie projek benodig u:

• 2 Arduino UNO of Arduino NANO of Arduino Mega
• 'N Paar draad
• 2 Atecc608a (elk kos minder as 0,60 $)
• 2 NRF24L01+
• 2 kondensator (10 μF)
• Broodplanke

Skakel na my artikel wat verduidelik hoe die chip ATECC608A opgestel word -> Hoe om Atecc608a op te stel

Stap 1: 1. Stel die Atecc608a op

Ek sal nie besonderhede gee oor elke stap om 'n ATECC608A op te stel nie, want ek het 'n volledige artikel geskryf wat elke stappe verduidelik om dit te doen. Om dit op te stel, moet u die 'Stap 4' van hierdie artikel volg, genaamd '2. Configuration of the Chip (Atecc608a)'.

Die skakel is: Hoe om 'n ATECC608A op te stel

U moet ook dieselfde konfigurasie vir die Atecc608a, master side en slave kant plaas, anders kan u nie u data ontsyfer nie

Waarskuwing:

Om hierdie chip op te stel, moet u elke stap van die artikel hierbo volg. As een stap ontbreek of die chip nie sluit nie, kan u hierdie projek nie uitvoer nie

Restant:

Stap hiervoor om te volg:

• Skep 'n konfigurasie sjabloon
• Skryf hierdie sjabloon op die skyfie
• Sluit die konfig sone
• Skryf u AES -sleutel (128 bits) in 'n gleuf
• Sluit die datasone

Stap 2: 2. Ontwerp van die stroombaan (meester en slaaf)

In hierdie projek sal u 'n meester -knoop en 'n slaweknoop hê.

Die hoofknoop druk die data wat deur die slaweknoop gestuur is, duidelik uit. Dit sal elke X keer data van die slaweknoop aanvra.

Die slaafknooppunt luister na die 'netwerk', en as dit 'Request data' ontvang, genereer dit dit, versleut dit en stuur dit na die hoofknoop.

Vir beide kante, meester en slaaf, is die stroombaan dieselfde:

• Een arduino Nano
• Een ATECC608A
• Een NRF24L01

Ek het die stroombaan by hierdie stap aangeheg (sien prent hierbo).

Vir die ATECC608A na die Arduino UNO, is dit 'n 8 -pen soic. Ek het die 'bo -aansig' hierbo bygevoeg:

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

Vir die NRF24L01 na die 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) -> slegs vir slaafknooppunt, nie gebruik in hoofmodus nie

Waarom die IRQ -pen van die NRF24L01 gebruik?

Die IRQ -pen is baie handig; met hierdie pen kan u (LOW) sê wanneer 'n pakkie deur die NRF24L01 ontvang word, sodat ons 'n onderbreking aan hierdie pen kan heg om die slaafknoop wakker te maak.

Stap 3: 3. die kode (slaaf en meester)

Slawe Node

Ek gebruik kragbesparing vir die slaafknoop, want dit hoef nie altyd te luister nie.

Hoe dit werk: die slaweknoop luister en wag om 'n "Wake UP -pakkie" te ontvang. Hierdie pakkie word deur die hoofknooppunt gestuur om data van die slaaf te vra.

In my geval gebruik ek 'n skikking van twee int:

// Ontwaak pakkie

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

As my knoop 'n pakkie ontvang,

1. dit word wakker, lees hierdie pakkie, as die pakkie 'n "wakker word" is,
2. dit genereer die data,
3. enkripteer die data,
4. stuur die data na die meester, wag 'n ACK -pakkie,
5. slaap.

Vir die AES -kodering gebruik ek 'n sleutel in die gleuf nommer 9.

Dit is my kode vir die Slave -knoop

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

#sluit "SPI.h" in

#include "nRF24L01.h" #include "RF24.h"

#sluit "Wire.h" in

// ATECC608A biblioteek

#sluit "ATECCX08A_Arduino/cryptoauthlib.h" in "insluit" AES BASIC/aes_basic.h"

#definieer ID_NODE 255

#definieer AES_KEY (uint8_t) 9

ATCAIfaceCfg cfg;

ATCA_STATUS status;

RF24 radio (9, 10);

const uint64_t masteraddresse = 0x1111111111;

const uint64_t slaveaddresse = 0x1111111100;

/**

* / brief Funksie uitgevoer wanneer die onderbreking ingestel is (IRQ LOW) * * */ void wakeUpIRQ () {while (radio.available ()) {int data [32]; radio.lees (& data, 32); as (data [0] == 20 && data [1] == 02) {float temp = 17,6; float hum = 16.4;

uint8_t data [16];

uint8_t cypherdata [16];

// Bou 'n string om al my waarde in te stel

// Elke waarde word geskei deur 'n "|" en die "$" beteken die einde van die data // WAARSKUWING: Moet minder as 11 lengte wees String tmp_str_data = String (ID_NODE) + "|" + String (temp, 1) + "|" + String (neurie, 1) + "$"; // grootte van 11 Serial.println ("tmp_str_data:" + tmp_str_data);

tmp_str_data.getBytes (data, sizeof (data));

// Enkripteer die data

ATCA_STATUS status = aes_basic_encrypt (& cfg, data, sizeof (data), cypherdata, AES_KEY); as (status == ATCA_SUCCESS) {lang rand = ewekansige ((lang) 10000, (lang) 99999);

// genereer 'n UUID gebaseer op die drie eerste nommer = ID -knoop

String uuid = String (ID_NODE) + String (rand); // Grootte van 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)); // Hou op luister na radio.stopListening ();

bool rslt;

// Stuur data rslt = radio.write (& data_to_send, sizeof (data_to_send)); // Begin luister radio.startListening (); if (rslt) {// Einde en slaapmodus Serial.println (F ("Klaar")); }}}}}

leemte opstelling ()

{Serial.begin (9600);

// Begin die bouer vir die biblioteek

cfg.iface_type = ATCA_I2C_IFACE; // Soort kommunikasie -> I2C -modus cfg.devtype = ATECC608A; // Soort chip cfg.atcai2c.slave_address = 0XC0; // I2C -adres (verstekwaarde) cfg.atcai2c.bus = 1; cfg.atcai2c.baud = 100000; cfg.wake_delay = 1500; // Vertraagde wakker word (1500 ms) cfg.rx_retries = 20;

radio.begin ();

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

radio.openWritingPipe (hoofadres);

radio.openReadingPipe (1, slaveaddresse); // Heg onderbreking aan pen 3 // Verander 1 deur O as u die onderbreking aan pen 2 wil/ // VALMODUS = Speld by LAGE hegInterrupt (1, wakeUpIRQ, FALLING); }

leemte lus ()

{ // Nie nodig nie }

Meester Node

Die hoofknoop word elke 8 sekondes wakker om data van die slaafknoop te vra

Hoe dit werk: Die hoofknoop stuur 'n "WakeUP" -pakket na die slaaf en na afwagting 'n antwoord van die slaaf met data.

In my geval gebruik ek 'n skikking van twee int:

// Ontwaak pakkie

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

As die slaafknoop 'n ACK -pakkie stuur nadat die meester 'n WakeUp -pakkie gestuur het:

1. Bemeester die opstel in die luistermodus en wag vir 'n kommunikasie
2. As kommunikasie
3. Onttrek die 8 eerste byte, buit die drie eerste byte van die 8 grepe, as dit die ID -knoop is
4. Onttrek die 16 byte cypher
5. Dekripteer die data
6. Druk die data in serie
7. Slaap stelling

Vir die AES -kodering gebruik ek 'n sleutel in die gleuf nommer 9.

Dit is my kode vir die Master -knoop

#sluit "Arduino.h" in

#include "avr/sleep.h" #include "avr/wdt.h" #include "SPI.h" #include "nRF24L01.h" #include "RF24.h" #include "Wire.h" // ATECC608A library #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 status; RF24 radio (9, 10); const uint64_t masteraddresse = 0x1111111111; const uint64_t slaveaddresse = 0x1111111100; // Wake UP -pakkie const int wake_packet [2] = {20, 02}; // waghond onderbreek ISR (WDT_vect) {wdt_disable (); // deaktiveer waghond} void slaapmodus () {// deaktiveer ADC ADCSRA = 0; // verwyder verskillende "reset" -vlae MCUSR = 0; // laat veranderinge toe, deaktiveer reset WDTCSR = bit (WDCE) | bietjie (WDE); // stel onderbrekingsmodus in en 'n interval WDTCSR = bit (WDIE) | bietjie (WDP3) | bietjie (WDP0); // stel WDIE in, en vertraag 8 sekondes wdt_reset (); // stel die waghond se stel_slaapmodus (SLEEP_MODE_PWR_DOWN) terug; noInterrupts (); // tydsreeks volg op sleep_enable (); // skakel brown -out aktiveer in sagteware MCUCR = bit (BODS) | bietjie (BODSE); MCUCR = bietjie (BODS); onderbreek (); // waarborg volgende instruksie uitgevoer sleep_cpu (); // kanselleer slaap as 'n voorsorgmaatreël sleep_disable (); } ongeldige opstelling () {Serial.begin (9600); // Begin die bouer vir die biblioteek cfg.iface_type = ATCA_I2C_IFACE; // Soort kommunikasie -> I2C -modus cfg.devtype = ATECC608A; // Soort chip cfg.atcai2c.slave_address = 0XC0; // I2C -adres (verstekwaarde) cfg.atcai2c.bus = 1; cfg.atcai2c.baud = 100000; cfg.wake_delay = 1500; // Vertraagde wakker word (1500 ms) cfg.rx_retries = 20; radio.begin (); radio.setDataRate (RF24_250KBPS); radio.maskIRQ (1, 1, 0); radio.enableAckPayload (); radio.setRetries (5, 5); radio.openWritingPipe (slawejurk); radio.openReadingPipe (1, hoofadres); } leemte lus () {bool rslt; // Stuur data rslt = radio.write (& wake_packet, sizeof (wake_packet)); if (rslt) {// Begin luister radio.startListening (); terwyl (radio.available ()) {uint8_t antwoord [32]; radio.lees (& antwoord, grootte van (antwoord)); uint8_t node_id [3]; uint8_t cypher [16]; memcpy (node_id, antwoord, 3); memcpy (cypher, antwoord + 3, 16); as ((int) node_id == ID_NODE) {uint8_t uitset [16]; ATCA_STATUS status = aes_basic_decrypt (& cfg, cypher, 16, output, AES_KEY); if (status == ATCA_SUCCESS) {Serial.println ("Gedecodeerde data:"); vir (size_t i = 0; i <16; i ++) {Serial.print ((char) uitset ); }}}}} else {Serial.println ("Ontvang nie vir Wakup -pakkie nie"); } // Slaapmodus 8 sekondes slaapmodus (); }

As u vrae het, is ek hier om dit te beantwoord

Stap 4: 4. Gaan verder

Hierdie voorbeeld is eenvoudig, sodat u hierdie projek kan verbeter

Verbeterings:

• Die AES 128 is basies en u kan 'n ander algoritme van AES as AES CBC gebruik om veiliger te wees.
• Verander die draadlose module (die NRF24L01 word beperk deur 'n laai van 23 Bytes)
• …

As u verbetering sien, moet u dit op die besprekingsgebied verduidelik

Stap 5: Gevolgtrekking

Ek hoop dat hierdie artikel vir u nuttig sal wees. Jammer as ek 'n fout met my teks gemaak het, maar Engels is nie my hooftaal nie en ek praat beter as wat ek skryf.

Dankie dat u alles gelees het.

Geniet dit.