Securitate cu Arduino: Atecc608a: 7 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:42

Subiect

Bună ziua tuturor !

Acesta este primul meu articol Instructables, așa că sper că va fi interesant pentru voi toți.

În acest articol, vă voi explica cum să utilizați un microcip numit „ATECC608A” care oferă mai multe instrumente de securitate.

Acest cip a fost proiectat de MicroChip și este ultima versiune a „cipului CryptoAuthentication”. Înainte de această versiune, existau „ATSHA204A” și „ATECC508A”.

De ce am decis să folosesc ultima versiune și nu versiunea anterioară?

Această versiune este cel mai avansat cip și are funcționalități pe care versiunea veche nu le are (De exemplu: modulul AES, modulul de protecție IO …).

De ce acest proiect?

Lucrez în domeniul CyberSecurity și, ca toată lumea, am iubit programarea și electronica. În timpul studiilor mele, primesc o conferință cu un specialist în securitatea IoT, care ne-a arătat că Industrial nu folosește securitatea în obiectul lor IoT. Ne-am arătat un lacăt care poate fi deschis cu smartphone-ul dvs. prin Bluetooth. Pe lacăt, o frază spunea „Acest lacăt este cel mai sigur decât un lacăt cu cheie!”. Această frază îl face să zâmbească și a modificat propoziția „Acest lacăt este cel mai prost lacăt construit vreodată!”.

El ne-a arătat cu propriul computer și un sniffer Bluetooth că fiecare comandă trimisă de smartphone este aceeași de fiecare dată și este foarte simplu să copiezi această comandă și să o trimiți cu smartphone-ul tău. El ne-a explicat că „Securitatea” pentru „Industrial” nu este principala problemă. El ne-a arătat cipuri (mai puțin de 0,60 $) care ar putea adăuga un strat de securitate acestor obiecte.

După această demonstrație, am încercat să găsesc un proiect open source care să adauge un strat de securitate obiectului IoT, dar nu l-am găsit niciodată.

Așa că am decis să lucrez la un proiect care utilizează stratul de securitate pentru comunicarea dintre două obiecte IoT.

Care este ideea mea?

În timpul unei comunicări între două obiecte IoT, pot exista atacuri multiple: Omul celor blânzi, Copie de informații și multe altele.. Deci ideea mea este foarte simplă:

1. Utilizarea datelor criptate între două sau mai multe obiecte IoT.
2. Aprovizionare cu cost redus
3. Poate funcționa cu un Arduino UNO

Acum vă voi explica cum am implementat această imagine abstractă cu un cip Arduino și Atecc608a. În acest articol, vă voi explica cum să utilizați Arduino UNO cu ATECC608A.

Voi scrie data viitoare un articol despre comunicarea a două obiecte.

Provizii

Aveți nevoie de câteva lucruri pentru acest proiect:

1. Arduino UNO sau MEGA (cipul trebuie să fie Atmega 328 sau ATMEGA 2560)
2. Cip Atecc608A (costă mai puțin de 0,80 USD fiecare, ușor de găsit pe site-ul furnizorului dvs.)
3. Adaptor SOIC cu 8 pini
4. Unele fire și rezistențe

Fișa tehnică a versiunii anterioare a acestui cip (Atecc508a) este disponibilă aici -> Fișă tehnică Atecc508a

Pasul 1: Pas cu pas

În acest articol, vă voi arăta cum să modificați configurația acestui cip și după cum să criptați datele folosind algoritmul AES CBC.

Vom urma acești pași:

1. Proiectarea circuitului
2. Configurarea acestui cip
3. Utilizarea modulului AES CBC
4. De ce trebuie să utilizați acest cip

Pentru fiecare etapă, voi detalia totul pentru dvs. De asemenea, mi-am adăugat codul în Github cu comentarii pentru fiecare funcție. Dacă aveți câteva întrebări despre codul meu sau despre acest proiect, vă voi răspunde cu plăcere.

My Github: My Github

Pasul 2: Avertisment despre Atecc608a

Cipul Atecc608a nu este un cip „ușor”.

În primul rând, documentația acestui cip se află sub NDA, deci nu o veți găsi complet pe Internet. Dar nu este nicio problemă, foaia tehnică a versiunii anterioare este disponibilă pe foaia de date Internet ATECC508A completă.

În al doilea rând, atunci când utilizați acest cip, trebuie să blocați configurația acestuia și este imposibil să modificați configurația cipului dacă acesta este blocat. Deci, aveți grijă când veți bloca zona de configurare și zona de date.

În al treilea rând, biblioteca scrisă în C este foarte mare și completă, așa că trebuie să citiți documentația funcțiilor pe care le veți folosi înainte.

Patru, biblioteca a scris că acest cip nu funcționează pentru Arduino UNO, dar a adăugat că funcționalitățile au nevoie pentru a funcționa cu Arduino UNO.

Cipul ATECC608A

Puteți comunica cu acest cip prin I2C. Adresa acestui cip poate fi modificată în configurație.

Acest cip conține 16 sloturi diferite care pot conține diferite tipuri de date:

1. Cheie ECC (privată sau publică)
2. Cheia AES
3. Alte date (cum ar fi Sha hash sau doar cuvinte)

În cazul nostru, vom stoca cheia AES într-un singur slot.

Pasul 3: 1. Proiectarea circuitului

1. Proiectarea circuitului

Schema acestui circuit este foarte simplă!

Trebuie să utilizați puterea de 3,3V, deoarece recomandarea este între 2,0V și 5,5V, dar am preferat să folosesc 3,3V.

Pentru acest cip, în mod normal aveți un punct pe un colț al cipului, acest punct este Pinul 1 al acestei plăci. Am adăugat vizualizarea de sus a Atecc608a cu număr PIN, deoarece este un SOIC cu 8 plumburi, astfel încât cipul este foarte mic.

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

Trebuie să utilizați puterea de 3,3V, deoarece recomandarea este între 2,0V și 5,5V, dar am preferat să folosesc 3,3V.

Am adăugat vizualizarea de sus a Atecc608a, deoarece este un SOIC cu 8 plumburi, așa că cipul este foarte mic. Dacă preferați, astfel încât furnizorii să construiască niște plăci cu lipirea cipurilor, ar putea fi mai ușor pentru dvs.

Atenție: În cazul meu, trebuie să adaug un rezistor între SDA-ul Arduino și Chip (de asemenea, pentru SDL). Am adăugat câte un rezistor de 4,7 Kohm pentru fiecare.

Pasul 4: 2. Configurarea cipului (Atecc608a)

Înainte de a utiliza funcția de criptare sau decriptare, trebuie să configurați cipul. În acest pas, voi detalia fiecare etapă pe care trebuie să o faceți pentru configurarea acestui cip.

Atenție: acest pas este foarte important și dacă blocați zonele înainte de final nu le puteți modifica.

După cum s-a explicat anterior, acest cip a primit două zone:

1. Zona de configurare
2. Zona de date

Zona de configurare a avut o dimensiune de 128 octeți, dar primii 16 octeți nu pot fi modificați.

Pentru a configura acest cip, trebuie să urmați doi pași. Este foarte important să urmați fiecare pas în ordine sau configurarea dvs. nu va funcționa, iar cipul dvs. va fi blocat și inutilizabil. Acești pași sunt:

1. Creați un șablon de configurare
2. Scrieți acest șablon pe cip
3. Blocați zona de configurare
4. Scrieți cheia AES (128 biți) într-un slot
5. Blocați zona de date

informație

Mai jos am detaliat fiecare pas al conifurării cu codul meu, dar fără griji, am adăugat un exemplu complet de configurație în Github. Am pus comentarii la fiecare funcție și un fișier *.ino este disponibil la fiecare pas pentru dvs.

• My Github: My Github
• Calea configurării de exemplu: configuration_example.ino

Primul pas: creați un șablon de configurare

După cum sa explicat anterior, zona de configurare are o dimensiune de 128 biți, dar primii 16 biți nu pot fi modificați. Această zonă este compusă din mai multe părți, dar trebuie să cunoașteți doar 3 părți din această zonă de configurare pentru acest proiect:

1. Bytes 16 -> Aceasta este adresa I2C a cipului
2. Octetii 20 până la 51 -> Puteți modifica aici tipul de slot pentru cele 16 sloturi ale acestui cip
3. Octetii 96 - 127 -> Puteți seta aici tipul de cheie sau date utilizate în fiecare slot.

(Dacă aveți nevoie de mai multe explicații despre toată această zonă, vă rugăm să citiți documentația (pagina 13, secțiunea 2.2))

Aici, am pus în detalii fiecare octeți / părți din cei 112 octeți ai configurației unui cip. Acesta este un exemplu, fiecare cip cumpărat poate avea o configurație diferită:

0xC0, // Adresă I2C

0x00, 0x00, 0x00, 0x83, 0x20, // Slot Config Slot 1 0x85, 0x20, // Slot Config Slot 2 0x8F, 0x20, // Slot Config Slot 3 0xC4, 0x8F, // Slot Config Slot 4 0x8F, 0x8F, // Slot Config Slot 5 0x8F, 0x8F, // Slot Config Slot 6 0x9F, 0x8F, // Slot Config Slot 7 0x0F, 0x0F, // Slot Config Slot 8 0x8F, 0x0F, // Slot Config Slot 9 0x8F, 0x0F, // Slot Config Slot 10 0x8F, 0x0F, // Slot Config Slot 11 0x8F, 0x0F, // Slot Config Slot 12 0x8F, 0x0F, // Slot Config Slot 13 0x00, 0x00, // Slot Config Slot 14 0x00, 0x00, // Slot Config Slot 15 0xAF, 0x8F, // Slot Config Slot 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, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00 0x00, 0x00, 0x33, 0x00, // Slot de configurare cheie 1 0x33, 0x00, // Slot de configurare cheie 2 0x33, 0x00, // Slot de configurare cheie 3 0x1C, 0x00, // Slot de configurare cheie 4 0x1C, 0x00, // Slot de configurare cheie 5 0x 1C, 0x00, // Slot de configurare cheie 6 0x1C, 0x00, // Slot de configurare cheie 7 0x3C, 0x00, // Slot de configurare cheie 8 0x1A, 0x00, // Slot de configurare cheie 9 0x3A, 0x00, // Slot de configurare cheie 10 0x1A, 0x00, // Slot de configurare cheie 11 0x3A, 0x00, // Slot de configurare cheie 12 0x3A, 0x00, // Slot de configurare cheie 13 0x3C, 0x00, // Slot de configurare cheie 14 0x3C, 0x00, // Slot de configurare cheie 15 0x1C, 0x00 // Slot de configurare cheie 16

După cum se vede, am pus câteva comentarii în acest cod pentru a înțelege mai mult această configurație.

În cazul dvs., trebuie să înțelegeți doar trei lucruri:

1. Bytes 16 -> Aceasta este adresa I2C a cipului
2. Octetii 20 până la 51 -> Puteți modifica aici tipul de slot pentru cele 16 sloturi ale acestui cip
3. Byte 96 - 127 -> Puteți seta aici tipul de cheie sau date utilizate în fiecare slot.

Nu voi explica tipul de configurație și de ce am folosit aceasta și nu alta, pentru că este complicat să explic totul. Dacă aveți nevoie de mai multe informații, accesați documentația, pagina 16 secțiunea 2.2.1 pentru „SlotConfig” și pagina 19 secțiunea 2.2.5 pentru „KeyConfig”

Pentru acest exemplu, veți utiliza slotul 9 pentru a stoca o cheie AES.

Pentru aceasta, trebuie să punem (dacă aveți nevoie, puteți copia exemplul de mai sus, modificarea a fost făcută în el):

1. Octet 36 = 0x8F
2. Octet 37 = 0x0F
3. Octet 112 = 0x1A
4. Octet 113 = 0x00

De ce am setat această configurație: pentru fiecare slot al acestui cip, puteți seta parametri pentru a spune cipului ce tip de date vor fi stocate. Aveți mai mulți parametri:

• Slotul poate fi scris sau citit (acțiune clară sau criptată)
• Tipul de date stocate (cheie ECC, cheie publică, SHA Hash, cheie AES …)
• Slotul poate fi blocabil
• Generarea cheii este permisă
• …

Cu octetul 36 și 37 setat la „0x0F8F”:

• Datele pot fi scrise în Clear
• Conținutul acestui slot este secret și nu poate fi citit
• Slotul nu poate fi utilizat pentru comanda CheckMac Copy

Cu octetul 112 și 113 setat la „0x001A”:

Slotul poate stoca până la patru taste simetrice AES pe 128 de biți (KeyType = 0x6)

Al doilea pas: scrieți această configurație

Acest pas este foarte important deoarece vom seta cipul cu configurația noastră și dacă această configurație nu este bună, veți utiliza acest cip.

Dar nu vă faceți griji, atâta timp cât configurația nu este blocată, puteți modifica configurația.

Aici, acesta este codul folosit pentru a scrie configurația pe cip:

/ ** / brief Scrieți o nouă configurație pe cip.

* / param [în] cfg Configurare interfață logică. Unele configurații * predefinite pot fi găsite în atca_cfgs.h * / param [in] config Array uint8_t de configurație (lungime 112) * / param [in] len Dimensiunea setului de configurare * / return ATCA_SUCCESS la succes, altfel un cod de eroare. * / ATCA_STATUS write_configuration (ATCAIfaceCfg * cfg, uint8_t * config, size_t len) {if (len! = 112) return ATCA_BAD_PARAM; Statutul ATCA_STATUS; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {// Scrieți configurația Array pe cip // Padding de 16 octeți (nu se pot scrie 16 primii octeți) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); statutul de returnare; } starea de returnare; }

Această funcție vă va scrie configurația în cip.

Al treilea pas: blocați zona de configurare

Atenție: aveți grijă la acest pas, dacă blocați această zonă și configurația dvs. nu este bună, cipul este inutilizabil și nu ați putut modifica această zonă

Pentru această acțiune, vom folosi această funcție:

/ ** / scurt Verificați dacă un DATA_ZONE sau CONFIG_ZONE este blocat

* / param [în] cfg Configurare interfață logică. Unele configurații * predefinite pot fi găsite în atca_cfgs.h * / param [în] zona LOCK_ZONE_DATA sau LOCK_ZONE_CONFIG * / returnează ATCA_SUCCESS cu succes, altfel un cod de eroare. * / ATCA_STATUS check_lock_zone (ATCAIfaceCfg * cfg, uint8_t zone) {ATCA_STATUS status; bool lock = fals; if (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) returnează ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zone, & lock))) {return ATCA_FUNC_FAIL; } if (! lock) {return ATCA_NOT_LOCKED; } returnează ATCA_SUCCESS; } returnează ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Al patrulea pas: Scrieți-vă cheia AES într-un slot

În această parte vă veți seta cheia personală AES în slotul pe care l-ați definit în configurația cipului.

Pentru acest exemplu, voi folosi slotul numărul 9 al cipului.

Trebuie să știți: o caracteristică specială a acestui cip este că puteți scrie date în slot doar cu 4 octeți sau 32 de octeți. Pentru AES avem nevoie de 128 biți cheie deci 16 octeți de date. Așa că am decis să scriu pe cheia de 16 octeți fiecare în acest slot pentru a avea date de 32 de octeți.

Acum, vă voi arăta codul utilizat:

/ ** / scurt Scrieți cheia AES într-un anumit slot. * / param [în] cfg Configurare interfață logică. Unele configurații * predefinite pot fi găsite în atca_cfgs.h * / param [in] key key number number * / param [in] datakey key array uint8_t * / param [in] len Size of the key array * / return ATCA_SUCCESS on success, altfel un cod de eroare. * / ATCA_STATUS write_key_slot (ATCAIfaceCfg * cfg, uint8_t key, uint8_t * datakey, size_t len) {if (key 16) return ATCA_BAD_PARAM; if (len! = 32) returnează ATCA_BAD_PARAM; ATCA_STATUS status = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) key, 0, 0, datakey, 32); if (status! = ATCA_SUCCESS) returnează starea; } starea de returnare; }

Pentru acest exemplu, voi folosi două chei AES de câte 16 octeți:

// Exemplu de AES KEY (len 32) uint8_t example_of_key [32] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; write_key_slot (& cfg, 9, example_of_key, sizeof (example_of_key));

Dacă această acțiune este bună, acum trebuie să treceți ultimul pas „blocați zona de date”

Ultimul pas: blocați zona de date

Atenție: aveți grijă cu acest pas, dacă blocați această zonă și datele dvs. nu sunt setate, cipul este inutilizabil și nu ați putut modifica această zonă

Pentru această acțiune, vom folosi această funcție:

/ ** / scurt Verificați dacă un DATA_ZONE sau CONFIG_ZONE este blocat

* / param [în] cfg Configurare interfață logică. Unele configurații * predefinite pot fi găsite în atca_cfgs.h * / param [în] zona LOCK_ZONE_DATA sau LOCK_ZONE_CONFIG * / returnează ATCA_SUCCESS cu succes, altfel un cod de eroare. * / ATCA_STATUS check_lock_zone (ATCAIfaceCfg * cfg, uint8_t zone) {ATCA_STATUS status; blocare bool = fals; if (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) returnează ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zone, & lock))) {return ATCA_FUNC_FAIL; } if (! lock) {return ATCA_NOT_LOCKED; } returnează ATCA_SUCCESS; } returnează ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Dacă această acțiune este bună, cipul dvs. este gata de utilizare

Pasul 5: 3. Utilizarea modulului AES CBC

Voi explica cum să criptați și să decriptați datele cu algoritmul AES CBC și cipul Atecc608a.

Rețineți: înainte de a utiliza această funcție, trebuie să configurați cipul. Pentru aceasta, urmați pasul 2 al acestui articol

Acest cip a primit mai multe tipuri de module AES (AES 128 biți), doar AES 128 biți este posibil:

1. AES normal
2. AES CBC
3. AES GCM (cu hash GFM) (consultați Wikipedia pentru mai multe explicații)

Pentru a ușura utilizarea, am creat două funcții:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Aceste două funcții sunt disponibile pe Github.

Explicare

Aleg să folosesc algoritmul AES CBC, deoarece este mai sigur decât AES 128 de biți de bază. Acest algoritm folosește un vector inițial pentru a vă cripta datele.

informație

Mai jos detaliază fiecare etapă a metodei de criptare și decriptare. Dar am scris un cod pentru Arduino care utilizează ambele funcții. Puteți vedea acest cod în Github:

• Github: Github al meu
• Exemplu de cod „Criptare / Decriptare”: AES_crypto_example.ino

Primul pas: criptați datele

În această parte, vă voi arăta cum să vă criptați datele.

Mai întâi veți avea nevoie de această funcție:

/ ** / brief Criptați datele utilizând algoritmul AES CBC * / param [în] cfg Configurarea interfeței logice. Unele configurații * predefinite pot fi găsite în atca_cfgs.h * / param [în] date Cuvinte către encypt (trebuie împărțit la 16, lungime maximă 240) * / param [in] lungimea len a Cuvinte către encypt (trebuie împărțit la 16, lungime maximă 240) * / param [out] iv Vector inițial utilizat în AES CBC (returnează vectorul din această var) * / param [out] text cifrat returnează aici textul Cypher * / param [in] cheie Numărul slotului cheie * / return ATCA_SUCCESS la succes, altfel un cod de eroare. * / ATCA_STATUS aes_cbc_encrypt (ATCAIfaceCfg * cfg, uint8_t * data, int len, uint8_t * iv, uint8_t * ciphertext, uint8_t key) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC && len% 16! = 0) {Serial.print (F ("EROARE: ATCA_BAD_PARAM")); returnează ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS status = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, key, 0, tmp_iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (stare, HEX); întoarcere; } memcpy (iv, tmp_iv, IV_LENGTH_CBC); memcpy (tmp_data, data, len); int max = len / 16; for (int j = 0; j <max; j ++) {status = atcab_aes_cbc_encrypt_block (& ctx, & tmp_data [j * 16], & ciphertext [j * 16]); } if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (stare, HEX); } starea de returnare; } starea de returnare; }

Această funcție este ușor de utilizat, trebuie să setați două lucruri:

1. Un IV gol (vector inițial) de 16 octeți
2. Date de criptat (dimensiune maximă 240 octeți)

Iată un exemplu „cum se folosește această funcție”.

Vreau să criptez cuvântul "AAAAAAAAAAAAAAA", cu cheia mea scrisă în numărul slotului "9":

ATCA_STATUS status = atcab_init (& cfg); if (status! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () a eșuat: Cod -> 0x")); Serial.println (stare, HEX); } uint8_t text clar [16] = "AAAAAAAAAAAAAAA"; // Textul original uint8_t iv [IV_LENGTH_CBC]; // Vector inițial uint8_t cypherdata [sizeof (text clar)]; // Stare criptată de date = aes_cbc_encrypt (& cfg, text clar, sizeof (text clar), iv, cypherdata, 9);

Dacă acțiunea este bună, veți avea datele criptate în variabila „cypherdata” și Vectorul inițial în variabila „IV”.

Păstrați aceste două variabile pentru a vă decripta textul!

Al doilea pas: decriptați datele

Pentru a vă decripta datele, veți avea nevoie de două lucruri:

1. Vectorul inițial
2. Datele Cypher (date criptate)

Pentru a vă decripta datele, veți avea nevoie de această funcție:

/ ** / brief Decriptați datele utilizând algoritmul AES CBC * / param [în] cfg Configurarea interfeței logice. Unele configurații * predefinite pot fi găsite în atca_cfgs.h * / param [în] text cifrat Cuvinte pentru decipt (trebuie împărțit la 16, lungime maximă 240) * / param [in] lungimea len Cuvinte către decipt (trebuie împărțit la 16, lungime maximă 240) * / param [in] iv Vector inițial de utilizat în AES CBC * / param [out] text clar returnează aici textul decriptat * / param [in] cheie Numărul slotului cheii * / return ATCA_SUCCESS la succes, altfel un cod de eroare. * / ATCA_STATUS aes_cbc_decrypt (ATCAIfaceCfg * cfg, uint8_t * text cifrat, int len, uint8_t * iv, uint8_t * text clar, cheie uint8_t) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC || len% 16! = 0) {Serial.print (F ("ERROR Decrypt: ATCA_BAD_PARAM")); returnează ATCA_BAD_PARAM; } ATCA_STATUS status = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, key, 0, iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (stare, HEX); întoarcere; } int max = len / 16; for (int j = 0; j <max; j ++) {status = atcab_aes_cbc_decrypt_block (& ctx, & ciphertext [j * 16], & text clar [j * 16]); } if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (stare, HEX); } starea de returnare; } starea de returnare; }

Vreau să decriptez datele mele anterioare (vezi mai jos, Primul pas). Pentru aceasta voi face acest lucru:

uint8_t text clar [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (text clar)]; uint8_t decryptdata [sizeof (text clar)]; status = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) {Serial.print ("Textul decriptat este:"); for (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } else {// Vedeți fișierul atca_status.h pentru codul Error Serial.print (F ("Imposibil de decriptat | Cod Error 0x")); Serial.println (stare, HEX); întoarcere; }

Dacă acțiunea este bună, veți avea datele decriptate în variabila „decryptdata”.

Acum știi cum să folosești criptarea și decriptarea cu cipul Atecc608a

Pasul 6: 5. De ce trebuie să utilizați acest cip

Datele criptate sunt foarte utile, deoarece vă puteți ascunde informațiile și le puteți trimite prin Wireless sau doar le puteți stoca.

Iată câteva exemple de utilizare:

1. Stocarea datelor către o EEPROM externă: puteți securiza datele unei EEPROM externe și dacă cineva încă mai are această EEPROM, va avea nevoie de cheie și IV pentru decriptare
2. Trimite date wireless: poți trimite aceste date criptate prin Wireless (nrf24L01, RFM95W …) și dacă cineva îți interceptează datele, aceste date vor fi sigure
3. Parolă stocată
4. …

Puteți face mai multe lucruri cu acest cip. Poate fi folosit în mai multe proiecte. Dacă ai timp, spune-mi în ce proiect vei folosi acest cip?

Un ultim sfat, dacă construiți un proiect wireless sau stocați date brute, fiți atenți, securitatea este foarte importantă și dacă știți cum este simplu pentru un „noob” să vă intercepteze sau să vă fure datele. Acum, cu Internetul, toată lumea poate avea scripturi pe care să le lanseze pe computerul lor doar pentru a vă „hack”!

Pasul 7: Concluzie

Sper că acest articol vă va fi de folos. Îmi pare rău dacă am greșit în textul meu, dar engleza nu este limba mea principală și vorbesc mai bine decât scriu.

Mulțumesc că ai citit totul.

Bucură de ea.