Seguretat amb Arduino: Atecc608a: 7 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:12

Tema

Hola a tothom !

Aquest és el meu primer article instructable, així que espero que sigui interessant per a tots vosaltres.

En aquest article, us explicaré com utilitzar un micro xip anomenat "ATECC608A" que proporciona diverses eines de seguretat.

Aquest xip ha estat dissenyat per MicroChip i és l'última versió del "xip CryptoAuthentication". Abans d'aquesta versió, hi havia "ATSHA204A" i "ATECC508A".

Per què he decidit utilitzar la darrera versió i no la versió anterior?

Aquesta versió és el xip més avançat i té funcionalitats que la versió anterior no té (per exemple: mòdul AES, mòdul de protecció IO …).

Per què aquest projecte?

Treballo en el domini de la CiberSeguretat i, com a tothom, m’encantava la programació i l’electrònica. Durant els meus estudis, tinc una conferència amb un especialista en seguretat IoT que ens va demostrar que Industrial no utilitza la seguretat en el seu objecte IoT. Ens vam mostrar un cadenat que es pot obrir amb el vostre telèfon intel·ligent mitjançant Bluetooth. Al cadenat, una frase deia "Aquest cadenat és més segur que un cadenat de clau!". Aquesta frase el va fer somriure i va modificar la frase "Aquest cadenat és el pitjor cadenat que s'ha creat mai".

Ens va demostrar amb el seu propi PC i un sniffer Bluetooth que cada ordre enviada pel telèfon intel·ligent és la mateixa cada vegada i és molt senzill copiar-lo i enviar-lo amb el telèfon intel·ligent. Ens va explicar que la "seguretat" per a "Industrial" no és el principal problema. Ens va mostrar xips (menys de 0,60 $) que podrien afegir una capa de seguretat a aquests objectes.

Després d’aquesta demostració, vaig intentar trobar algun projecte de codi obert que afegís capa de seguretat a l’objecte IoT, però mai no el vaig trobar.

Així que vaig decidir treballar en un projecte que utilitzés la capa de seguretat per a la comunicació entre dos objectes IoT.

Quina és la meva idea?

Durant una comunicació entre dos objectes IoT, es poden existir diversos atacs: Home dels dolços, còpia d'informació i molt més. Per tant, la meva idea és molt senzilla:

1. Utilització de dades xifrades entre dos o més objectes IoT.
2. Subministraments de baix cost
3. Pot treballar amb un Arduino UNO

Ara us explicaré com he implementat aquesta imatge abstracta amb un Arduino i un xip Atecc608a. En aquest article, us explicaré com utilitzar l’Arduino UNO amb l’ATECC608A.

La propera vegada escriuré un article sobre la comunicació de dos objectes.

Subministraments

Necessiteu algunes coses per a aquest projecte:

1. Arduino UNO o MEGA (el xip ha de ser Atmega 328 o ATMEGA 2560)
2. Xip Atecc608A (costa menys de 0,80 $ cadascun, fàcil de trobar al lloc web del vostre proveïdor)
3. Adaptador SOIC de 8 pins
4. Alguns cables i resistències

El full de dades de la versió anterior d’aquest xip (Atecc508a) està disponible aquí -> Fitxa tècnica Atecc508a

Pas 1: pas a pas

En aquest article, us mostraré com modificar la configuració d’aquest xip i després com xifrar les dades mitjançant l’algoritme AES CBC.

Seguirem aquests passos:

1. Disseny del circuit
2. Configuració d’aquest xip
3. Utilització del mòdul AES CBC
4. Per què necessiteu utilitzar aquest xip

Per a cada pas, us detallaré tot. A més, he afegit el meu codi al meu Github amb comentaris per a cada funció. Si teniu alguna pregunta sobre el meu codi o aquest projecte, estaré encantat de respondre-ho.

My Github: El meu Github

Pas 2: advertència sobre l'Atecc608a

El xip Atecc608a no és un xip "fàcil".

En primer lloc, la documentació d’aquest xip es troba sota NDA, de manera que no la trobareu completa a Internet. Però no hi ha cap problema per a això, el full de dades de la versió anterior està disponible a Full de dades d'Internet ATECC508A complet.

En segon lloc, quan utilitzeu aquest xip, heu de bloquejar-ne la configuració i és impossible modificar-ne la configuració si està bloquejat. Així que tingueu cura quan bloquejarà la zona de configuració i la zona de dades.

En tercer lloc, la biblioteca que va escriure en C és molt gran i completa, de manera que heu de llegir la documentació de les funcions que utilitzarà abans.

Quatre, la biblioteca va escriure que aquest xip no funcionava per a Arduino UNO, però va afegir que les funcionalitats el necessiten per funcionar amb Arduino UNO.

El xip ATECC608A

Podeu comunicar-vos amb aquest xip mitjançant I2C. L'adreça d'aquest xip es pot modificar a la configuració.

Aquest xip conté 16 ranures diferents que poden contenir diferents tipus de dades:

1. Clau ECC (privada o pública)
2. Clau AES
3. Altres dades (com ara hash Sha o només paraules)

En el nostre cas, emmagatzemarem la clau AES en una sola ranura.

Pas 3: 1. Disseny del circuit

1. Disseny del circuit

L’esquema d’aquest circuit és molt senzill.

Heu d’utilitzar una alimentació de 3,3 V perquè la recomanació oscil·la entre 2,0 V i 5,5 V, però he preferit utilitzar el 3,3 V.

Per a aquest xip, normalment teniu un punt en una cantonada del xip, aquest punt és el pin 1 d’aquest tauler. He afegit la vista superior de l'Atecc608a amb número PIN perquè és un SOIC de 8 derivacions, de manera que el xip és molt petit.

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)

Heu d’utilitzar una alimentació de 3,3 V perquè la recomanació oscil·la entre 2,0 V i 5,5 V, però he preferit utilitzar el 3,3 V.

He afegit la vista superior de l'Atecc608a perquè és un SOIC de 8 derivacions, de manera que el xip és molt petit. Si ho preferiu, de manera que els proveïdors construeixen una placa amb la soldadura de xips, us podria resultar més fàcil.

Advertència: en el meu cas, he d'afegir una resistència entre l'SDA de l'Arduino i el xip (també per a l'SDL). He afegit una resistència de 4,7 Kohm per a cadascuna.

Pas 4: 2. Configuració del xip (Atecc608a)

Abans d’utilitzar la funció de xifratge o desxifratge, heu de configurar el xip. En aquest pas, detallaré tots els passos que heu de fer per a la configuració d’aquest xip.

Advertiment: aquest pas és molt important i si bloquegeu les zones abans del final no les podreu modificar.

Com s’ha explicat abans, aquest xip tenia dues zones:

1. Zona de configuració
2. Zona de dades

La zona de configuració té una mida de 128 bytes però els primers 16 bytes no es poden modificar.

Per configurar aquest xip, cal que seguiu aquests dos passos. És molt important seguir cada pas en ordre o la vostra configuració no funcionarà i el vostre xip quedarà bloquejat i inutilitzable. Aquests passos són:

1. Creeu una plantilla de configuració
2. Escriviu aquesta plantilla al xip
3. Bloqueja la zona de configuració
4. Escriviu la vostra clau AES (128 bits) en una ranura
5. Bloqueja la zona de dades

Informació

A continuació, detallo cada pas de la configuració amb el meu codi, però sense preocupacions, he afegit un exemple complet de configuració al meu Github. Poso comentaris sobre cadascuna de les funcions i hi ha disponible un fitxer *.ino amb cada pas.

• My Github: El meu Github
• Camí de configuració d'exemple: configuration_example.ino

Primer pas: creeu una plantilla de configuració

Com s’ha explicat anteriorment, la zona de configuració té una mida de 128 bits, però els primers 16 bits no es poden canviar. Aquesta zona es compon de diverses parts, però només heu de conèixer 3 parts d'aquesta zona de configuració per a aquest projecte:

1. Els bytes 16 -> Aquesta és l'adreça I2C del xip
2. Els bytes 20 a 51 -> Podeu modificar aquí el tipus de ranura per a les 16 ranures d’aquest xip
3. Els bytes del 96 al 127 -> Podeu definir aquí el tipus de clau o dades utilitzades a cada ranura.

(Si necessiteu més explicació de tota aquesta zona, llegiu la documentació (pàgina 13, secció 2.2))

Aquí, he posat en detall cada Byte / Part dels 112 bytes de la configuració d’un xip. Aquest és un exemple, cada xip comprat pot tenir una configuració diferent:

0xC0, // adreça 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, // Ranura de configuració de clau 1 0x33, 0x00, // Ranura de configuració de clau 2 0x33, 0x00, // Ranura de configuració de clau 3 0x1C, 0x00, // Ranura de configuració de clau 4 0x1C, 0x00, // Ranura de configuració de la clau 5 0x 1C, 0x00, // Ranura de configuració de clau 6 0x1C, 0x00, // Ranura de configuració de clau 7 0x3C, 0x00, // Ranura de configuració de clau 8 0x1A, 0x00, // Ranura de configuració de clau 9 0x3A, 0x00, // Ranura de configuració de clau 10 0x1A, 0x00, // Ranura de configuració de clau 11 0x3A, 0x00, // Ranura de configuració de clau 12 0x3A, 0x00, // Ranura de configuració de clau 13 0x3C, 0x00, // Ranura de configuració de clau 14 0x3C, 0x00, // Ranura de configuració de clau 15 0x1C, 0x00 // Ranura 16 de configuració de claus

Com veieu, he posat alguns comentaris en aquest codi per entendre més aquesta configuració.

En el vostre cas, haureu d’entendre només tres coses:

1. Els bytes 16 -> Aquesta és l'adreça I2C del xip
2. Els bytes 20 a 51 -> Podeu modificar aquí el tipus de ranura per a les 16 ranures d’aquest xip
3. El byte 96 a 127 -> Podeu definir aquí el tipus de clau o dades que s'utilitzen a cada ranura.

No explicaré el tipus de configuració i per què he fet servir aquesta i no una altra perquè és complicat explicar-ho tot. Si necessiteu més informació, aneu a la documentació, pàgina 16 secció 2.2.1 per a "SlotConfig" i pàgina 19 secció 2.2.5 per a "KeyConfig"

Per a aquest exemple, utilitzeu la ranura 9 per emmagatzemar una clau AES.

Per a això, hem de posar (si ho necessiteu, podeu copiar l'exemple anterior, la modificació s'hi ha fet):

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

Per què he configurat aquesta configuració: per a cada ranura d’aquest xip, podeu establir paràmetres per dir al xip quin tipus de dades s’emmagatzemaran. Teniu diversos paràmetres:

• La ranura es pot escriure o llegir (acció neta o xifrada)
• Tipus de dades emmagatzemades (clau ECC, clau pública, hash SHA, clau AES …)
• La ranura es pot bloquejar
• Es permet la generació de claus
• …

Amb el byte 36 i 37 definit a "0x0F8F":

• Les dades es poden escriure a Clear
• El contingut d'aquesta ranura és secret i no es pot llegir
• La ranura no es pot utilitzar per a l'ordre Copia CheckMac

Amb els bytes 112 i 113 definits a "0x001A":

La ranura pot emmagatzemar fins a quatre tecles simètriques AES de 128 bits (KeyType = 0x6)

Segon pas: escriviu aquesta configuració

Aquest pas és molt important perquè establirem el xip amb la nostra configuració i, si aquesta configuració no és bona, utilitzarà aquest xip.

Però no us preocupeu, mentre la configuració no estigui bloquejada, podeu modificar la configuració.

Aquí, aquest és el codi utilitzat per escriure la configuració al xip:

/ ** / brief Escriviu una nova configuració al xip.

* / param [in] cfg Configuració de la interfície lògica. Algunes configuracions * predefinides es poden trobar a atca_cfgs.h * / param [in] config Array uint8_t de configuració (longitud 112) * / param [in] len Mida de la matriu de configuració * / return ATCA_SUCCESS en cas d’èxit, en cas contrari, un codi d’error. * / ATCA_STATUS write_configuration (ATCAIfaceCfg * cfg, uint8_t * config, size_t len) {if (len! = 112) retorna ATCA_BAD_PARAM; Estat ATCA_STATUS; estat = atcab_init (cfg); if (status == ATCA_SUCCESS) {// Escriviu la matriu de configuració al xip // Completament de 16 bytes (no es poden escriure 16 primers bytes) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); estat de retorn; } estat de retorn; }

Aquesta funció escriurà la vostra configuració al xip.

Tercer pas: bloquejar la zona de configuració

Advertència: aneu amb compte amb aquest pas, si bloquegeu aquesta zona i la vostra configuració no és bona, el xip no es podrà utilitzar i no podreu modificar aquesta zona

Per a aquesta acció, utilitzarem aquesta funció:

/ ** / breu Comproveu si la DATA_ZONE o la CONFIG_ZONE estan bloquejades

* / param [in] cfg Configuració de la interfície lògica. Algunes configuracions * predefinides es poden trobar a atca_cfgs.h * / param [in] zone LOCK_ZONE_DATA o LOCK_ZONE_CONFIG * / return ATCA_SUCCESS si és correcte, en cas contrari, un codi d'error. * / ATCA_STATUS check_lock_zone (ATCAIfaceCfg * cfg, zona uint8_t) {estat ATCA_STATUS; bloqueig bool = fals; if (zona! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) retorna ATCA_BAD_PARAM; estat = atcab_init (cfg); if (estat == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (estat = atcab_is_locked (zona i bloqueig))) {return ATCA_FUNC_FAIL; } if (! lock) {return ATCA_NOT_LOCKED; } torna ATCA_SUCCESS; } torna ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Quart pas: escriure la clau AES en una ranura

En aquesta part, establireu la clau AES personal a la ranura que heu definit a la configuració del xip.

Per a aquest exemple, utilitzaré la ranura número 9 del xip.

Heu de saber: una característica especial d’aquest xip és que podeu escriure dades a la ranura només 4 bytes o 32 bytes. Per a AES necessitem una clau de 128 bits, de manera que 16 bytes de dades. Així que vaig decidir escriure a la clau de 16 bytes cadascun en aquesta ranura per tenir dades de 32 bytes.

Ara us mostraré el codi utilitzat:

/ ** / brief Escriu la clau AES en una ranura determinada. * / param [in] cfg Configuració de la interfície lògica. Algunes configuracions * predefinides es poden trobar a atca_cfgs.h * / param [in] número de ranura de clau clau * / param [in] matriu de claus datakey uint8_t * / param [in] len Mida de la matriu de claus * / return ATCA_SUCCESS si és correcte, en cas contrari, un codi d’error. * / 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) retorna 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) estat de retorn; } estat de retorn; }

Per a aquest exemple, utilitzaré dues claus AES de 16 bytes cadascuna:

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

Si aquesta acció és bona, ara heu de passar l'últim pas "bloquejar la zona de dades"

Últim pas: bloquejar la zona de dades

Advertiment: aneu amb compte amb aquest pas, si bloquegeu aquesta zona i les vostres dades no estan configurades, el xip no es podrà utilitzar i no podreu modificar aquesta zona

Per a aquesta acció, utilitzarem aquesta funció:

/ ** / breu Comproveu si hi ha bloquejades DATA_ZONE o CONFIG_ZONE

* / param [in] cfg Configuració de la interfície lògica. Algunes configuracions * predefinides es poden trobar a atca_cfgs.h * / param [in] zone LOCK_ZONE_DATA o LOCK_ZONE_CONFIG * / return ATCA_SUCCESS si és correcte, en cas contrari, un codi d'error. * / ATCA_STATUS check_lock_zone (ATCAIfaceCfg * cfg, zona uint8_t) {estat ATCA_STATUS; bloqueig bool = fals; if (zona! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) retorna ATCA_BAD_PARAM; estat = atcab_init (cfg); if (estat == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (estat = atcab_is_locked (zona i bloqueig))) {return ATCA_FUNC_FAIL; } if (! lock) {return ATCA_NOT_LOCKED; } torna ATCA_SUCCESS; } torna ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Si aquesta acció és bona, el vostre xip ja es pot utilitzar

Pas 5: 3. Utilització del mòdul AES CBC

Explicaré com xifrar i desxifrar dades amb l'algorisme AES CBC i el xip Atecc608a.

Recordeu: abans d’utilitzar aquesta funció, heu de configurar el xip. Per a això, seguiu el pas 2 d'aquest article

Aquest xip té diversos tipus de mòdul AES (AES 128 bits), només és possible AES 128 bits:

1. AES normal
2. AES CBC
3. AES GCM (amb hash GFM) (consulteu la wikipedia per obtenir més explicacions)

Per facilitar-ne l’ús, he creat dues funcions:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Aquestes dues funcions estan disponibles al meu Github.

Explicació

Decideixo utilitzar l'algorisme AES CBC perquè és més segur que els AES bàsics de 128 bits. Aquest algorisme utilitza un vector inicial per xifrar les vostres dades.

Informació

A continuació, detallo cada pas del mètode de xifratge i desxifratge. Però vaig escriure un codi per a l'Arduino que utilitzava ambdues funcions. Podeu veure aquest codi al meu Github:

• Github: El meu Github
• Exemple de codi "Xifra / Desxifra": AES_crypto_example.ino

Primer pas: xifreu les vostres dades

En aquesta part, us mostraré com xifrar les vostres dades.

Primer necessitareu aquesta funció:

/ ** / brief Xifra les dades mitjançant l'algoritme AES CBC * / param [en] cfg Configuració de la interfície lògica. Algunes configuracions * predefinides es poden trobar a atca_cfgs.h * / param [in] data Words to encypt (s’ha de dividir per 16, longitud màxima 240) * / param [in] len length de Words to encypt (s’ha de dividir per 16), longitud màxima 240) * / param [out] iv Vector inicial utilitzat a l'AES CBC (retorna el vector d'aquesta var) * / param [out] text xifrat torna aquí el text Cypher * / param [in] key Número de ranura de la key * / return ATCA_SUCCESS si l'èxit és el cas, en cas contrari, es produirà un codi d'error. * / ATCA_STATUS aes_cbc_encrypt (ATCAIfaceCfg * cfg, uint8_t * data, int len, uint8_t * iv, uint8_t * text xifrat, clau uint8_t) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC && len% 16! = 0) {Serial.print (F ("ERROR: ATCA_BAD_PARAM")); torna ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS status = atcab_init (cfg); if (estat == ATCA_SUCCESS) {estat = atcab_aes_cbc_init (& ctx, clau, 0, tmp_iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (estat, HEX); tornar; } 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 (estat, HEX); } estat de retorn; } estat de retorn; }

Aquesta funció és senzilla d’utilitzar, heu d’establir dues coses:

1. Un IV buit (vector inicial) de 16 bytes
2. Dades per xifrar (mida màxima 240 bytes)

Aquí teniu un exemple de "com utilitzar aquesta funció".

Vull xifrar la paraula "AAAAAAAAAAAAAAA", amb la meva clau escrita al número de ranura "9":

ATCA_STATUS status = atcab_init (& cfg); if (estat! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () ha fallat: Codi -> 0x")); Serial.println (estat, HEX); } uint8_t text clar [16] = "AAAAAAAAAAAAAAA"; // Text original uint8_t iv [IV_LENGTH_CBC]; // Vector inicial uint8_t cypherdata [sizeof (text clar)]; // Estat xifrat de dades = aes_cbc_encrypt (& cfg, text clar, sizeof (text pla), iv, cypherdata, 9);

Si l'acció és bona, tindreu les dades encriptades a la variable "cypherdata" i el Vector inicial a la variable "IV".

Conserveu aquestes dues variables per desxifrar el text.

Segon pas: desxifra les dades

Per desxifrar les vostres dades necessitareu dues coses:

1. El vector inicial
2. Les dades de Cypher (dades xifrades)

Per desxifrar les vostres dades, necessitareu aquesta funció:

/ ** / brief Desxifra les dades mitjançant l'algoritme AES CBC * / param [en] cfg Configuració de la interfície lògica. Algunes configuracions * predefinides es poden trobar a atca_cfgs.h * / param [in] text xifrat Paraules a decipt (s’ha de dividir per 16, longitud màxima 240) * / param [in] longitud de paraules a decipt (s’ha de dividir per 16), longitud màxima 240) * / param [in] iv Vector inicial per utilitzar a AES CBC * / param [out] text en forma de text torna aquí el text desxifrat * / param [in] key Número de ranura de la clau * / return ATCA_SUCCESS si l'èxit, en cas contrari, un codi d'error. * / ATCA_STATUS aes_cbc_decrypt (ATCAIfaceCfg * cfg, uint8_t * text xifrat, int len, uint8_t * iv, uint8_t * text clar, clau uint8_t) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC || len% 16! = 0) {Serial.print (F ("ERROR Desxifra: ATCA_BAD_PARAM")); torna ATCA_BAD_PARAM; } ATCA_STATUS status = atcab_init (cfg); if (estat == ATCA_SUCCESS) {estat = atcab_aes_cbc_init (& ctx, clau, 0, iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Desxifra: atcab_aes_cbc_init, Error de codi 0x")); Serial.println (estat, HEX); tornar; } 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 (estat, HEX); } estat de retorn; } estat de retorn; }

Vull desxifrar les meves dades anteriors (vegeu a continuació, primer pas). Per això faré això:

uint8_t text complet [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (text clar)]; uint8_t decryptdata [sizeof (text pla)]; status = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (estat == ATCA_SUCCESS) {Serial.print ("El text desxifrat és:"); per a (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } else {// Vegeu el fitxer atca_status.h per al codi Error Serial.print (F ("Impossible fer el desxifratge | Error de codi 0x")); Serial.println (estat, HEX); tornar; }

Si l'acció és bona, tindreu les dades desxifrades a la variable "decryptdata".

Ara ja sabeu com utilitzar el xifratge i desxifratge amb el xip Atecc608a

Pas 6: 5. Per què necessiteu utilitzar aquest xip

Les dades xifrades són molt útils perquè podeu amagar la vostra informació i enviar-la per Wireless o simplement emmagatzemar-la.

Aquí teniu un exemple d’utilització:

1. Dades emmagatzemades a una EEPROM externa: podeu protegir les dades d'una EEPROM externa i, si algú continua amb aquesta EEPROM, necessitarà la clau i l'IV per al desxifratge
2. Enviar dades sense fils: podeu enviar aquestes dades xifrades mitjançant Wireless (nrf24L01, RFM95W …) i si algú intercepta les vostres dades, aquestes dades seran segures
3. Contrasenya emmagatzemada
4. …

Podeu fer diverses coses amb aquest xip. Es pot utilitzar en múltiples projectes. Si tens temps, digues-me en quin projecte faràs servir aquest xip?

Un darrer consell: si creeu algun projecte sense fils o emmagatzemeu dades en brut, aneu amb compte, la seguretat és molt important i si sabeu com és senzill que un "noob" intercepti o us robi les dades. Ara, amb Internet, tothom pot tenir scripts per llançar al seu ordinador només per "piratejar-vos".

Pas 7: Conclusió

Espero que aquest article us sigui útil. Disculpeu si he equivocat el meu text, però l'anglès no és el meu idioma principal i parlo millor del que escric.

Gràcies per llegir-ho tot.

Gaudeix-ho.