Sicurezza con Arduino: Atecc608a: 7 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Argomento

Ciao a tutti !

Questo è il mio primo articolo su Instructables, quindi spero che sarà interessante per tutti voi.

In questo articolo ti spiegherò come utilizzare un microchip chiamato "ATECC608A" che fornisce molteplici strumenti di sicurezza.

Questo chip è stato progettato da MicroChip ed è l'ultima versione del "CryptoAuthentication chip". Prima di questa versione, c'era "ATSHA204A" e "ATECC508A".

Perché ho deciso di utilizzare l'ultima versione e non la versione precedente?

Questa versione è il chip più avanzato e ha funzionalità che la vecchia versione non ha (ad esempio: modulo AES, modulo di protezione IO …).

Perché questo progetto?

Lavoro nel campo della CyberSecurity e come tutti amavo la programmazione e l'elettronica. Durante i miei studi, ho avuto una conferenza con uno specialista sulla sicurezza IoT che ci ha mostrato che Industrial non usa la sicurezza nel loro oggetto IoT. Ci ho mostrato un lucchetto che può essere aperto con il tuo smartphone tramite Bluetooth. Sul lucchetto c'era una frase che diceva "Questo lucchetto è più sicuro di un lucchetto a chiave!". Questa frase lo fece sorridere e modificò la frase "Questo lucchetto è il peggior lucchetto mai costruito!".

Ci ha mostrato con il suo PC e uno sniffer Bluetooth che ogni comando inviato dallo smartphone è lo stesso ogni volta ed è molto semplice copiare questo comando e inviarlo con il tuo smartphone. Ci ha spiegato che "Sicurezza" per "Industriale" non è il problema principale. Ci ha mostrato dei chip (meno di 0,60$) che potevano aggiungere un livello di sicurezza a questi oggetti.

Dopo questa dimostrazione, ho provato a trovare un progetto Open Source che aggiungesse un livello di sicurezza all'oggetto IoT ma non l'ho mai trovato.

Quindi ho deciso di lavorare su un progetto che utilizza il livello di sicurezza per la comunicazione tra due oggetti IoT.

Qual è la mia idea?

Durante una comunicazione tra due oggetti IoT, possono esistere più attacchi: Man Of the mild, Copy of information e altro.. Quindi la mia idea è molto semplice:

1. Utilizzo di dati crittografati tra due o più oggetti IoT.
2. Forniture a basso costo
3. Può funzionare con un Arduino UNO

Ora ti spiego come ho implementato questa immagine astratta con un Arduino e un chip Atecc608a. In questo articolo ti spiego come utilizzare Arduino UNO con ATECC608A.

Scriverò un articolo sulla comunicazione di due oggetti la prossima volta.

Forniture

Hai bisogno di alcune cose per questo progetto:

1. Arduino UNO o MEGA (il chip deve essere Atmega 328 o ATMEGA 2560)
2. Chip Atecc608A (costo inferiore a 0,80 $ ciascuno, facile da trovare sul sito del tuo fornitore)
3. Adattatore SOIC a 8 pin
4. Alcuni fili e resistori

Il datasheet della versione precedente di questo chip (Atecc508a) è disponibile qui -> Datasheet Atecc508a

Passaggio 1: passo dopo passo

In questo articolo, ti mostrerò come modificare la configurazione di questo chip e poi come crittografare i dati utilizzando l'algoritmo AES CBC.

Seguiremo questi passaggi:

1. Progettazione del circuito
2. Configurazione di questo chip
3. Utilizzo del modulo AES CBC
4. Perché hai bisogno di usare questo chip?

Per ogni passaggio, dettaglierò tutto per te. Inoltre, ho aggiunto il mio codice nel mio Github con commenti per ciascuna funzione. Se hai qualche domanda sul mio codice o su questo progetto, sarò felice di risponderti.

Il mio Github: Il mio Github

Passaggio 2: avvertenza sull'Atecc608a

Il chip Atecc608a non è un chip "facile".

Innanzitutto, la documentazione di questo chip è sotto NDA, quindi non la troverai completa su Internet. Ma nessun problema per questo, il datasheet della versione precedente è disponibile su Internet Datasheet Complete ATECC508A.

In secondo luogo, quando si utilizza questo chip è necessario bloccarne la configurazione ed è impossibile modificare la configurazione del chip se è bloccato. Quindi fai attenzione quando bloccherai la zona di configurazione e la zona dati.

Terzo, la libreria scritta in C è molto grande e completa, quindi devi leggere la documentazione delle funzioni che utilizzerai prima.

Quattro, la libreria scritta per questo chip non funziona per Arduino UNO, ma ha aggiunto le funzionalità necessarie per funzionare con Arduino UNO.

Il chip ATECC608A

Puoi comunicare con questo chip tramite I2C. L'indirizzo di questo chip può essere modificato nella configurazione.

Questo chip contiene 16 slot diversi che possono contenere diversi tipi di dati:

1. Chiave ECC (privata o pubblica)
2. Chiave AES
3. Altri dati (come Sha hash o solo parole)

Nel nostro caso, memorizzeremo la chiave AES in uno slot.

Passaggio 3: 1. Progettazione del circuito

1. Progettazione del circuito

Lo schema di questo circuito è molto semplice!

È necessario utilizzare l'alimentazione a 3,3 V perché la raccomandazione è compresa tra 2,0 V e 5,5 V, ma ho preferito utilizzare 3,3 V.

Per questo chip, normalmente hai un punto su un angolo del chip, questo punto è il Pin 1 di questa scheda. Ho aggiunto la vista dall'alto dell'Atecc608a con il numero PIN perché è un SOIC a 8 derivazioni, quindi il chip è molto piccolo.

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)

È necessario utilizzare l'alimentazione a 3,3 V perché la raccomandazione è compresa tra 2,0 V e 5,5 V, ma ho preferito utilizzare 3,3 V.

Ho aggiunto la vista dall'alto dell'Atecc608a perché è un SOIC a 8 derivazioni, quindi il chip è molto piccolo. Se preferisci, quindi i fornitori costruiscono una scheda con la saldatura del chip, potrebbe essere più facile per te.

Attenzione: Nel mio caso, devo aggiungere un resistore tra la SDA dell'Arduino e il Chip (anche per l'SDL). Ho aggiunto un resistore da 4,7Kohm per ciascuno.

Fase 4: 2. Configurazione del Chip (Atecc608a)

Prima di utilizzare la funzione di crittografia o decrittografia è necessario configurare il chip. In questo passaggio, descriverò in dettaglio tutti i passaggi necessari per la configurazione di questo chip.

Attenzione: questo passaggio è molto importante e se si bloccano le zone prima della fine non è possibile modificarle.

Come spiegato prima, questo chip ha due zone:

1. Zona di configurazione
2. Zona dati

La zona di configurazione ha una dimensione di 128 byte ma i primi 16 byte non possono essere modificati.

Per configurare questo chip, sono necessari due segui questi passaggi. È molto importante seguire ogni passaggio in ordine o la tua configurazione non funzionerà e il tuo chip sarà bloccato e inutilizzabile. Questi passaggi sono:

1. Crea un modello di configurazione
2. Scrivi questo modello sul chip
3. Blocca la zona di configurazione
4. Scrivi la tua chiave AES (128 bit) in uno slot
5. Blocca l'area dati

Informazione

Di seguito ho dettagliato ogni passaggio della configurazione con il mio codice, ma non preoccuparti, ho aggiunto un esempio completo di configurazione nel mio Github. Ho inserito commenti su ciascuna funzione e un file *.ino è disponibile con ogni passaggio in ordine per te.

• Il mio Github: Il mio Github
• Percorso della configurazione di esempio: configuration_example.ino

Primo passo: creare un modello di configurazione

Come spiegato in precedenza, la zona di configurazione ottiene una dimensione di 128 bit, ma i primi 16 bit non possono essere modificati. Questa zona è composta da più parti, ma è necessario conoscere solo 3 parti di questa zona di configurazione per questo progetto:

1. The Bytes 16 -> Questo è l'indirizzo I2C del chip
2. I Byte da 20 a 51 -> Puoi modificare qui il tipo di Slot per i 16 slot di questo chip
3. I byte da 96 a 127 -> È possibile impostare qui il tipo di chiave o dati utilizzati in ogni slot.

(Se hai bisogno di maggiori spiegazioni su tutta questa zona, leggi la documentazione (pagina 13, sezione 2.2))

Qui, ho messo in dettaglio ogni Byte/Parte dei 112 byte della configurazione di un Chip. Questo è un esempio, ogni chip acquistato può avere una configurazione diversa:

0xC0, // indirizzo I2C

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

Come vedi, ho inserito alcuni commenti in questo codice per capire di più questa configurazione.

Nel tuo caso bisogna capire solo tre cose:

1. The Bytes 16 -> Questo è l'indirizzo I2C del chip
2. I Byte da 20 a 51 -> Puoi modificare qui il tipo di Slot per i 16 slot di questo chip
3. I Byte da 96 a 127 -> Qui puoi impostare il Tipo di chiave o dati utilizzati in ogni slot.

Non spiego il tipo di configurazione e perché ho usato questa e non un'altra perché è complicato spiegare tutto. Se hai bisogno di maggiori informazioni vai alla documentazione, pagina 16 sezione 2.2.1 per "SlotConfig" e pagina 19 sezione 2.2.5 per "KeyConfig"

Per questo esempio, utilizzerai lo slot 9 per memorizzare una chiave AES.

Per questo, dobbiamo mettere (se necessario, puoi copiare l'esempio sopra, la modifica è stata fatta in esso):

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

Perché ho impostato questa configurazione: per ogni slot di questo chip, puoi impostare i parametri per dire al chip che tipo di dati verranno archiviati. Hai più parametri:

• Lo slot può essere scritto o letto (azione di cancellazione o crittografia)
• Tipologia di dati archiviati (chiave ECC, Public Key, SHA Hash, AES Key…)
• Lo slot può essere bloccabile
• La generazione della chiave è consentita
• …

Con i byte 36 e 37 impostati a "0x0F8F":

• I dati possono essere scritti in Clear
• I contenuti di questo slot sono segreti e non possono essere letti
• Slot non può essere utilizzato per il comando Copia CheckMac

Con i byte 112 e 113 impostati a "0x001A":

Lo slot può memorizzare fino a quattro chiavi simmetriche AES a 128 bit (KeyType = 0x6)

Secondo passo: scrivere questa configurazione

Questo passaggio è molto importante perché imposteremo il chip con la nostra configurazione e se questa configurazione non è buona, utilizzerai questo chip.

Ma non preoccuparti, finché la Configurazione non è bloccata, puoi modificare la tua configurazione.

Ecco, questo il codice utilizzato per scrivere la configurazione sul chip:

/** \brief Scrive una nuova configurazione nel chip.

* \param[in] cfg Configurazione dell'interfaccia logica. Alcune * configurazioni predefinite possono essere trovate in atca_cfgs.h * \param[in] config Array uint8_t di configurazione (lunghezza 112) * \param[in] len Dimensione dell'array di configurazione * \return ATCA_SUCCESS in caso di successo, altrimenti un codice di errore. */ ATCA_STATUS write_configuration(ATCAIfaceCfg *cfg, uint8_t *config, size_t len) { if (len != 112) return ATCA_BAD_PARAM; stato ATCA_STATUS; stato = atcab_init(cfg); if (status == ATCA_SUCCESS) { // Scrivi la configurazione Array sul chip // Padding di 16 byte (16 i primi byte non possono essere scritti) status = atcab_write_bytes_zone(ATCA_ZONE_CONFIG, 0, 16, (uint8_t *)config, len); Stato reso; } Stato reso; }

Questa funzione scriverà la tua configurazione nel chip.

Terzo passo: bloccare la zona di configurazione

Attenzione: fai attenzione con questo passaggio, se blocchi questa zona e la tua configurazione non è buona, il chip è inutilizzabile e non puoi modificare questa zona

Per questa azione utilizzeremo questa funzione:

/** \brief Controlla se DATA_ZONE o CONFIG_ZONE è bloccato

* \param[in] cfg Configurazione dell'interfaccia logica. Alcune * configurazioni predefinite possono essere trovate in atca_cfgs.h * \param[in] zone LOCK_ZONE_DATA o LOCK_ZONE_CONFIG * \return ATCA_SUCCESS in caso di successo, altrimenti un codice di errore. */ ATCA_STATUS check_lock_zone(ATCAIfaceCfg *cfg, uint8_t zone) { ATCA_STATUS status; blocco bool = falso; if (zone != (uint8_t)LOCK_ZONE_CONFIG && zone != (uint8_t)LOCK_ZONE_DATA) return ATCA_BAD_PARAM; stato = 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; } restituisce ATCA_SUCCESS; } restituisce ATCA_BAD_PARAM; } check_lock_zone(&cfg, LOCK_ZONE_CONFIG);

Quarto passo: scrivi la tua chiave AES in uno slot

In questa parte imposterai la tua chiave AES personale nello slot che hai definito nella configurazione del chip.

Per questo esempio, userò lo slot numero 9 del chip.

Devi sapere: una caratteristica speciale di questo chip è che puoi scrivere dati nello slot solo da 4 byte o 32 byte. Per AES abbiamo bisogno di una chiave a 128 bit quindi 16 byte di dati. Quindi ho deciso di scrivere su una chiave di 16 byte ciascuna in questo slot per avere 32 byte di dati.

Ora, ti mostrerò il codice utilizzato:

/** \brief Scrive la chiave AES in un dato slot. * \param[in] cfg Configurazione dell'interfaccia logica. Alcune * configurazioni predefinite possono essere trovate in atca_cfgs.h * \param[in] key slot number * \param[in] datakey key array uint8_t * \param[in] len Dimensione dell'array di chiavi * \return ATCA_SUCCESS in caso di successo, altrimenti un codice di errore. */ 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) return ATCA_BAD_PARAM; ATCA_STATUS stato = 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) restituisce lo stato; } Stato reso; }

Per questo esempio, userò due chiavi AES di 16 byte ciascuna:

// Esempio di AES KEY (len 32)uint8_t example_of_key[32] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; write_key_slot(&cfg, 9, example_of_key, sizeof(example_of_key));

Se questa azione è buona, ora devi superare l'ultimo passaggio "bloccare la zona dati"

Ultimo passaggio: bloccare l'area dati

Attenzione: fai attenzione con questo passaggio, se blocchi questa zona e i tuoi dati non sono impostati, il chip è inutilizzabile e non puoi modificare questa zona

Per questa azione utilizzeremo questa funzione:

/** \brief Controlla se DATA_ZONE o CONFIG_ZONE è bloccato

* \param[in] cfg Configurazione dell'interfaccia logica. Alcune * configurazioni predefinite possono essere trovate in atca_cfgs.h * \param[in] zone LOCK_ZONE_DATA o LOCK_ZONE_CONFIG * \return ATCA_SUCCESS in caso di successo, altrimenti un codice di errore. */ ATCA_STATUS check_lock_zone(ATCAIfaceCfg *cfg, uint8_t zone) { ATCA_STATUS status; blocco bool = falso; if (zone != (uint8_t)LOCK_ZONE_CONFIG && zone != (uint8_t)LOCK_ZONE_DATA) return ATCA_BAD_PARAM; stato = 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; } restituisce ATCA_SUCCESS; } restituisce ATCA_BAD_PARAM; } check_lock_zone(&cfg, LOCK_ZONE_DATA);

Se questa azione è buona, il tuo chip è pronto per essere utilizzato

Passaggio 5: 3. Utilizzo del modulo AES CBC

Spiegherò come crittografare e decifrare i dati con l'algoritmo AES CBC e il chip Atecc608a.

Ricorda: prima di utilizzare questa funzione, è necessario impostare il chip. Per questo, segui il passaggio 2 di questo articolo

Questo chip ha più tipi di modulo AES (AES 128 bit), è possibile solo AES 128 bit:

1. AES normale
2. AES CBC
3. AES GCM (con hash GFM) (vedi wikipedia per maggiori spiegazioni)

Per facilitarne l'utilizzo ho creato due funzioni:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Queste due funzioni sono disponibili sul mio Github.

Spiegazione

Scelgo di utilizzare l'algoritmo AES CBC perché è più sicuro dell'AES di base a 128 bit. Questo algoritmo utilizza un vettore iniziale per crittografare i tuoi dati.

Informazione

Di seguito ho dettagliato ogni passaggio del metodo di crittografia e decrittografia. Ma ho scritto un codice per Arduino che usa entrambe le funzioni. Puoi vedere questo codice nel mio Github:

• Github: Il mio Github
• Esempio di codice "Encrypt/Decrypt": AES_crypto_example.ino

Primo passo: crittografa i tuoi dati

In questa parte, ti mostrerò come crittografare i tuoi dati.

Per prima cosa avrai bisogno di questa funzione:

/** \brief Cifra i dati usando l'algoritmo AES CBC * \param[in] cfg Configurazione dell'interfaccia logica. Alcune * configurazioni predefinite possono essere trovate in atca_cfgs.h * \param[in] data Parole da cifrare (deve essere diviso per 16, lunghezza massima 240) * \param[in] len lunghezza delle Parole da cifrare (deve essere diviso per 16, lunghezza massima 240) * \param[out] iv Vettore iniziale utilizzato nell'AES CBC (restituisce il vettore in questa var) * \param[out] testo cifrato restituisce qui il testo cifrato * chiave \param[in] Numero di slot del key * \return ATCA_SUCCESS in caso di successo, altrimenti un codice di errore. */ 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("ERRORE: ATCA_BAD_PARAM")); restituire ATCA_BAD_PARAM; } uint8_t tmp_iv[IV_LENGTH_CBC]; uint8_t tmp_data[lunghezza]; ATCA_STATUS stato = 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(stato, HEX); Restituzione; } memcpy(iv, tmp_iv, IV_LENGTH_CBC); memcpy(tmp_data, data, len); int max = lunghezza / 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(stato, HEX); } Stato reso; } Stato reso; }

Questa funzione è semplice da usare, devi impostare due cose:

1. Un IV vuoto (vettore iniziale) di 16 byte
2. Dati da crittografare (dimensione massima 240 Byte)

Ecco un esempio "come usare questa funzione".

Voglio crittografare la parola "AAAAAAAAAAAAAAA", con la mia chiave scritta nello slot numero "9":

ATCA_STATUS status = atcab_init(&cfg); if (status != ATCA_SUCCESS) { Serial.println(F("atcab_init() failed: Code -> 0x")); Serial.println(stato, HEX); } uint8_t plaintext[16] = "AAAAAAAAAAAAAAA"; // Testo originale uint8_t iv[IV_LENGTH_CBC]; // Vettore iniziale uint8_t cypherdata[sizeof(plaintext)]; // Stato dei dati crittografati = aes_cbc_encrypt(&cfg, plaintext, sizeof(plaintext), iv, cypherdata, 9);

Se l'azione è buona, avrai i dati crittografati nella variabile "cypherdata" e il vettore iniziale nella variabile "IV".

Mantieni queste due variabili per decifrare il tuo testo!

Secondo passo: decrittografa i tuoi dati

Per decifrare i tuoi dati avrai bisogno di due cose:

1. Il vettore iniziale
2. I dati Cypher (dati crittografati)

Per decifrare i tuoi dati, avrai bisogno di questa funzione:

/** \brief Decifra i dati utilizzando l'algoritmo AES CBC * \param[in] cfg Configurazione dell'interfaccia logica. Alcune * configurazioni predefinite possono essere trovate in atca_cfgs.h * \param[in] testo cifrato Parole da decifrare (deve essere diviso per 16, lunghezza massima 240) * \param[in] len lunghezza delle Parole da decifrare (deve essere diviso per 16, lunghezza massima 240) * \param[in] iv Vettore iniziale da utilizzare nell'AES CBC * \param[out] testo in chiaro restituisce qui il testo decifrato * \param[in] key Numero di slot della chiave * \return ATCA_SUCCESS in caso di successo, altrimenti un codice di errore. */ ATCA_STATUS aes_cbc_decrypt(ATCAIfaceCfg *cfg, uint8_t *ciphertext, int len, uint8_t *iv, uint8_t *plaintext, uint8_t key) { atca_aes_cbc_ctx_t ctx; if (len > LIMIT_DATA_SIZE_CBC || len % 16 != 0) { Serial.print(F("ERROR Decrypt: ATCA_BAD_PARAM")); restituire ATCA_BAD_PARAM; } ATCA_STATUS stato = 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(stato, HEX); Restituzione; } int max = lunghezza / 16; for (int j = 0; j < max; j++) { status = atcab_aes_cbc_decrypt_block(&ctx, &ciphertext[j * 16], &plaintext[j * 16]); } if (status != ATCA_SUCCESS) { Serial.print(F("ERROR Decrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println(stato, HEX); } Stato reso; } Stato reso; }

Voglio decifrare i miei dati precedenti (vedi sotto, Primo passo). Per questo farò così:

uint8_t plaintext[16] = "AAAAAAAAAAAAAAA"; uint8_t iv[IV_LENGTH_CBC]; uint8_t cypherdata[sizeof(testo semplice)]; uint8_t decryptdata[sizeof(plaintext)]; status = aes_cbc_decrypt(&cfg, cypherdata, sizeof(cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) { Serial.print("Il testo decifrato è: "); for (size_t i = 0; i < sizeof(decryptdata); i++) { Serial.print((char)decryptdata); } Serial.println(""); } else { // Vedere il file atca_status.h per il codice Error Serial.print(F("Impossibile eseguire la decrittazione | Code Error 0x")); Serial.println(stato, HEX); Restituzione; }

Se l'azione è buona, avrai i dati decrittografati nella variabile "decryptdata".

Ora sai come usare la crittografia e la decrittazione con il chip Atecc608a

Passaggio 6: 5. Perché è necessario utilizzare questo chip?

I dati crittografati sono molto utili perché puoi nascondere le tue informazioni e inviarle tramite Wireless o semplicemente archiviarle.

Ecco alcuni esempi di utilizzo:

1. Dati memorizzati su una EEPROM esterna: è possibile proteggere i dati di una EEPROM esterna e se qualcuno ha ancora questa EEPROM, avrà bisogno della chiave e dell'IV per la decrittazione
2. Invia dati wireless: puoi inviare questi dati crittografati tramite wireless (nrf24L01, RFM95W…) e se qualcuno intercetta i tuoi dati, questi dati saranno al sicuro
3. Password memorizzata
4. …

Puoi fare più cose con questo chip. Può essere utilizzato in più progetti. Se hai tempo, dimmi in quale progetto utilizzerai questo chip?

Un ultimo consiglio, se costruisci un progetto wireless o memorizzi dei dati grezzi, fai attenzione, la sicurezza è molto importante e se sai come è semplice per un "niubbo" intercettare o rubare i tuoi dati. Ora con Internet, tutti possono avere script da lanciare sul proprio computer solo per "hackerarti"!

Passaggio 7: conclusione

Spero che questo articolo ti sia utile. Scusa se ho sbagliato nel testo, ma l'inglese non è la mia lingua principale e parlo meglio di quanto scrivo.

Grazie per aver letto tutto.

Divertirsi.