Sikkerhed med Arduino: Atecc608a: 7 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:26

Emne

Hej allesammen !

Dette er min første instruktionsartikel, så jeg håber, at det vil være interessant for jer alle.

I denne artikel vil jeg forklare dig, hvordan du bruger en mikrochip kaldet "ATECC608A", der giver flere sikkerhedsværktøjer.

Denne chip er designet af MicroChip, og den er den sidste version af "CryptoAuthentication -chip". Før denne version var der "ATSHA204A" og "ATECC508A".

Hvorfor besluttede jeg at bruge den sidste version og ikke den tidligere version?

Denne version er den mest avancerede chip og har funktioner, som den gamle version ikke har (for eksempel: AES -modul, IO -beskyttelsesmodul …).

Hvorfor dette projekt?

Jeg arbejder inden for CyberSecurity og som alle elskede jeg programmering og elektronik. Under mine studier får jeg en konference med en specialist om IoT -sikkerhed, der viste os, at Industrial ikke bruger sikkerhed i deres IoT -objekt. Jeg viste os en hængelås, der kan være åben med din smartphone via Bluetooth. På hængelåsen sagde en sætning "Denne hængelås er mest sikker end en nøglelås!". Denne sætning får ham til at smile, og han ændrede sætningen "Denne hængelås er den værste hængelås, der nogensinde er bygget!".

Han viste os med sin egen pc og en Bluetooth -sniffer, at hver kommando sendt af smartphonen er den samme hver gang, og det er meget enkelt at kopiere denne kommando og sende den med din smartphone. Han forklarede os, at "Sikkerhed" for "Industriel" ikke er hovedproblemet. Han viste os chips (mindre end 0,60 $), der kunne tilføje et lag af sikkerhed til disse objekter.

Efter denne demonstration forsøgte jeg at finde et Open Source -projekt, der tilføjede sikkerhedslag til IoT -objekt, men jeg fandt det aldrig.

Så jeg besluttede at arbejde på et projekt, der bruger sikkerhedslag til kommunikation mellem to IoT -objekter.

Hvad er min idé?

Under en kommunikation mellem to IoT -objekter kan der være flere angreb: Man Of the mild, kopi af oplysninger og mere.. Så min idé er meget enkel:

1. Udnyttelse af krypterede data mellem to eller flere IoT -objekter.
2. Lavprisudstyr
3. Kan arbejde med en Arduino UNO

Nu vil jeg forklare dig, hvordan jeg implementerede dette abstrakte billede med en Arduino og en Atecc608a -chip. I denne artikel vil jeg forklare dig, hvordan du bruger Arduino UNO med ATECC608A.

Jeg vil skrive en artikel om kommunikation af to objekter næste gang.

Forbrugsvarer

Du har brug for nogle få ting til dette projekt:

1. Arduino UNO eller MEGA (Chip skal være Atmega 328 eller ATMEGA 2560)
2. Atecc608A -chip (koster mindre end 0,80 $ hver, let at finde på dit leverandørs websted)
3. 8-benet SOIC-adapter
4. Nogle ledninger og modstande

Databladet for den tidligere version af denne chip (Atecc508a) er tilgængeligt her -> Datablad Atecc508a

Trin 1: Trin for trin

I denne artikel vil jeg vise dig, hvordan du ændrer konfigurationen af denne chip og efter, hvordan du krypterer data ved hjælp af AES CBC -algoritmen.

Vi vil følge disse trin:

1. Design af kredsløbet
2. Konfiguration af denne chip
3. Udnyttelse af AES CBC -modulet
4. Hvorfor skal du bruge denne chip

For hvert trin beskriver jeg alt for dig. Jeg tilføjede også min kode i min Github med kommentarer til hver funktion. Hvis du har nogle spørgsmål om min kode eller dette projekt, svarer jeg det gerne.

Min Github: Min Github

Trin 2: Advarsel om Atecc608a

Atecc608a -chippen er ikke en "let" chip.

For det første er dokumentationen af denne chip under NDA, så du ikke finder den fuldstændig på Internettet. Men intet problem med dette, databladet til den tidligere version er tilgængeligt på Internet Datablad Komplet ATECC508A.

For det andet, når du bruger denne chip, skal du låse dens konfiguration, og det er umuligt at ændre chipens konfiguration, hvis den er låst. Så vær forsigtig, når du vil låse Config Zone og Data Zone.

For det tredje skrev biblioteket i C meget stort og komplet, så du skal læse dokumentationen til de funktioner, du vil bruge før.

Fire, biblioteket skrev for denne chip ikke arbejde for Arduino UNO, men det tilføjede funktionaliteter, der er nødvendige for at arbejde med Arduino UNO.

Chippen ATECC608A

Du kan kommunikere med denne chip ved I2C. Adressen på denne chip kan ændres i konfigurationen.

Denne chip indeholder 16 forskellige slots, der kan indeholde forskellige typer data:

1. ECC -nøgle (privat eller offentlig)
2. AES -nøgle
3. Andre data (som Sha hash eller bare ord)

I vores tilfælde vil vi gemme AES -nøgle i en slot.

Trin 3: 1. Udformning af kredsløbet

1. Design af kredsløbet

Skemaet for dette kredsløb er meget enkelt!

Du skal bruge 3.3V strøm, fordi anbefalingen er mellem 2.0V og 5.5V, men jeg foretrak at bruge 3.3V.

For denne chip har du normalt en prik på et hjørne af chippen, denne prik er Pin 1 på dette kort. Jeg tilføjede ovenfra af Atecc608a med PIN-nummer, fordi det er en 8-Lead SOIC, så chippen er meget lille.

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)

Du skal bruge 3.3V strøm, fordi anbefalingen er mellem 2.0V og 5.5V, men jeg foretrak at bruge 3.3V.

Jeg tilføjede topvisningen af Atecc608a, fordi det er en 8-Lead SOIC, så chippen er meget lille. Hvis du foretrækker det, så leverandører bygger noget bræt med spånloddet, kan det være lettere for dig.

Advarsel: I mit tilfælde skal jeg tilføje en modstand mellem SDA'en for Arduino og chippen (også til SDL). Jeg tilføjede en 4,7Kohm modstand til hver.

Trin 4: 2. Konfiguration af chippen (Atecc608a)

Før du bruger funktionen til kryptering eller dekryptering, skal du konfigurere chippen. I dette trin beskriver jeg alle trin, du skal gøre for konfigurationen af denne chip.

Advarsel: dette trin er meget vigtigt, og hvis du låser zoner inden slutningen, kan du ikke ændre dem.

Som forklaret før fik denne chip to zoner:

1. Config Zone
2. Datazone

Konfigurationszonen fik en størrelse på 128 bytes, men de første 16 bytes kan ikke ændres.

For at konfigurere denne chip skal du to følge disse trin. Det er meget vigtigt at følge hvert trin i rækkefølge, ellers fungerer din konfiguration ikke, og din chip vil være låst og ubrugelig. Disse trin er:

1. Opret en konfigurationsskabelon
2. Skriv denne skabelon til chippen
3. Lås konfigurationszonen
4. Skriv din AES -nøgle (128 bits) i en slot
5. Lås datazonen

Information

Nedenfor beskriver jeg hvert trin i konfigurationen med min kode, men ingen bekymringer, jeg tilføjede et komplet eksempel på konfiguration i min Github. Jeg lægger kommentarer til hver funktion, og en *.ino -fil er tilgængelig med hvert trin for dig.

• Min Github: Min Github
• Eksempelsti til konfiguration: konfiguration_eksempel.ino

Første trin: Opret en konfigurationsskabelon

Som forklaret før får konfigurationszonen en størrelse på 128 bit, men de første 16 bit kan ikke ændres. Denne zone består af flere dele, men du behøver kun at kende 3 dele af denne konfigurationszone til dette projekt:

1. Bytes 16 -> Dette er chipens I2C -adresse
2. Bytes 20 til 51 -> Du kan her ændre typen af slot til de 16 slots i denne chip
3. Bytes 96 til 127 -> Du kan her angive nøgletype eller data, der bruges i hvert slot.

(Hvis du har brug for mere forklaring af hele denne zone, bedes du læse dokumentationen (side 13, afsnit 2.2))

Her oplyser jeg hver Bytes/Dele af 112 bytes i konfigurationen af en chip. Dette er et eksempel, hver købte chip kan have en anden konfiguration:

0xC0, // I2C -adresse

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, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x00, // Key Config Slot 1 0x33, 0x00, // Key Config Slot 2 0x33, 0x00, // Key Config Slot 3 0x1C, 0x00, // Key Config Slot 4 0x1C, 0x00, // Key Config Slot 5 0x 1C, 0x00, // Key Config Slot 6 0x1C, 0x00, // Key Config Slot 7 0x3C, 0x00, // Key Config Slot 8 0x1A, 0x00, // Key Config Slot 9 0x3A, 0x00, // Key Config Slot 10 0x1A, 0x00, // Key Config Slot 11 0x3A, 0x00, // Key Config Slot 12 0x3A, 0x00, // Key Config Slot 13 0x3C, 0x00, // Key Config Slot 14 0x3C, 0x00, // Key Config Slot 15 0x1C, 0x00 // Key Config Slot 16

Som jeg har set, har jeg lagt nogle kommentarer i denne kode for at forstå mere denne konfiguration.

I dit tilfælde behøver du kun at forstå tre ting:

1. Bytes 16 -> Dette er chipens I2C -adresse
2. Bytes 20 til 51 -> Du kan her ændre typen af slot til de 16 slots i denne chip
3. Byte 96 til 127 -> Du kan her angive nøgletype eller data, der bruges i hvert slot.

Jeg vil ikke forklare konfigurationstypen, og hvorfor jeg brugte dette og ikke en anden, fordi det er kompliceret at forklare alt. Hvis du har brug for flere oplysninger, skal du gå til dokumentationen, side 16 afsnit 2.2.1 for "SlotConfig" og side 19 afsnit 2.2.5 for "KeyConfig"

I dette eksempel vil du bruge slot 9 til at gemme en AES -nøgle.

Til dette skal vi sætte (hvis du har brug for det, kan du kopiere eksemplet ovenfor, ændringen er foretaget i det):

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

Hvorfor har jeg indstillet denne konfiguration: For hver slot i denne chip kan du indstille parametre til at sige til chippen, hvilken type data der vil blive gemt. Du har flere parametre:

• Slot kan være skrive eller læse (ryd eller krypter handling)
• Type data gemt (ECC -nøgle, Offentlig nøgle, SHA Hash, AES -nøgle …)
• Slot kan være låsbar
• Generering af nøgler er tilladt
• …

Med byte 36 og 37 sat til "0x0F8F":

• Data kan skrives i Clear
• Indholdet i denne slot er hemmeligt og kan ikke læses
• Slot kan ikke bruges til CheckMac Copy -kommandoen

Med byte 112 og 113 indstillet til "0x001A":

Slot kan gemme op til fire AES 128-bit symmetriske taster (KeyType = 0x6)

Andet trin: Skriv denne konfiguration

Dette trin er meget vigtigt, fordi vi vil indstille chippen med vores konfiguration, og hvis denne konfiguration ikke er god, vil du bruge denne chip.

Men bare rolig, så længe konfigurationen ikke er låst, kan du ændre din konfiguration.

Her er denne kode, der bruges til at skrive konfigurationen til chippen:

/** / brief Skriv en ny konfiguration til chippen.

* / param cfg Logisk interface -konfiguration. Nogle foruddefinerede * konfigurationer kan findes i atca_cfgs.h * / param config Array uint8_t af konfiguration (længde 112) * / param [in] len Størrelse på konfigurations array * / return ATCA_SUCCESS på succes, ellers en fejlkode. */ ATCA_STATUS skrivekonfiguration (ATCAIfaceCfg *cfg, uint8_t *config, size_t len) {hvis (len! = 112) returnerer ATCA_BAD_PARAM; ATCA_STATUS status; status = atcab_init (cfg); hvis (status == ATCA_SUCCESS) {// Skriv konfigurations Array til chippen // Padding af 16 byte (16 første bytes kan ikke skrives) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); tilbagevenden status; } status tilbage }

Denne funktion skriver din konfiguration i chippen.

Tredje trin: lås konfigurationszonen

Advarsel: Vær forsigtig med dette trin, hvis du låser denne zone, og din konfiguration ikke er god, er chippen ubrugelig, og du kan ikke ændre denne zone

Til denne handling vil vi bruge denne funktion:

/** / brief Kontroller, om en DATA_ZONE eller CONFIG_ZONE er låst

* / param cfg Logisk interface -konfiguration. Nogle foruddefinerede * konfigurationer kan findes i atca_cfgs.h * / param zone LOCK_ZONE_DATA eller LOCK_ZONE_CONFIG * / return ATCA_SUCCESS efter succes, ellers en fejlkode. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS status; bool lock = falsk; hvis (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) returnerer ATCA_BAD_PARAM; status = atcab_init (cfg); hvis (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zone, og lås))) {return ATCA_FUNC_FAIL; } hvis (! lås) {return ATCA_NOT_LOCKED; } returner ATCA_SUCCESS; } returner ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Fjerde trin: Skriv dig en AES -nøgle i en plads

I denne del indstiller du din personlige AES -nøgle i den slot, du har defineret i konfigurationen af chippen.

I dette eksempel vil jeg bruge slot nummer 9 på chippen.

Du skal vide: En særlig funktion ved denne chip er, at du kun kan skrive data i slot med 4 bytes eller 32 bytes. Til AES har vi brug for 128 bits nøgle, så 16 bytes data. Så jeg besluttede at skrive til nøgle på 16 bytes hver i denne slot for at have 32 bytes data.

Nu vil jeg vise dig den anvendte kode:

/** / brief Skriv AES -nøgle i en given slot. * / param [in] cfg Logisk interface -konfiguration. Nogle foruddefinerede * konfigurationer kan findes i atca_cfgs.h * / param nøgletastnummer * * param [in] datakey key array uint8_t * / param [in] len Størrelse på nøglematrisen * / return ATCA_SUCCESS på succes, ellers en fejlkode. */ ATCA_STATUS write_key_slot (ATCAIfaceCfg *cfg, uint8_t key, uint8_t *datakey, size_t len) {if (key 16) return ATCA_BAD_PARAM; hvis (len! = 32) returnerer ATCA_BAD_PARAM; ATCA_STATUS status = atcab_init (cfg); hvis (status == ATCA_SUCCESS) {status = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) nøgle, 0, 0, datakey, 32); hvis (status! = ATCA_SUCCESS) returnerer status; } status tilbage }

I dette eksempel vil jeg bruge to AES -taster på hver 16 bytes:

// Eksempel på AES KEY (len 32) uint8_t example_of_key [32] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; write_key_slot (& cfg, 9, eksempel_of_key, sizeof (eksempel_of_key));

Hvis denne handling er god, skal du nu passere det sidste trin "lås datazonen"

Sidste trin: Lås datazonen

Advarsel: Vær forsigtig med dette trin, hvis du låser denne zone, og dine data ikke er indstillet, er chippen ubrugelig, og du kan ikke ændre denne zone

Til denne handling vil vi bruge denne funktion:

/** / brief Kontroller, om en DATA_ZONE eller CONFIG_ZONE er låst

* / param [in] cfg Logisk interface -konfiguration. Nogle foruddefinerede * konfigurationer kan findes i atca_cfgs.h * / param zone LOCK_ZONE_DATA eller LOCK_ZONE_CONFIG * / return ATCA_SUCCESS på succes, ellers en fejlkode. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS status; bool lock = falsk; hvis (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) returnerer ATCA_BAD_PARAM; status = atcab_init (cfg); hvis (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zone, og lås))) {return ATCA_FUNC_FAIL; } hvis (! lås) {return ATCA_NOT_LOCKED; } returner ATCA_SUCCESS; } returner ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Hvis denne handling er god, er din chip klar til brug

Trin 5: 3. Udnyttelse af AES CBC -modulet

Jeg vil forklare, hvordan man krypterer og dekrypterer data med algoritmen AES CBC og chippen Atecc608a.

Husk: Før du bruger denne funktion, skal du konfigurere chippen. For at gøre dette, følg trin 2 i denne artikel

Denne chip har flere typer AES -modul (AES 128 bit), kun AES 128 bit er mulig:

1. AES normal
2. AES CBC
3. AES GCM (med GFM -hash) (se wikipedia for mere forklaring)

For at gøre det lettere at bruge, oprettede jeg to funktioner:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Disse to funktioner er tilgængelige på min Github.

Forklaring

Jeg vælger at bruge AES CBC -algoritmen, fordi den er sikrere end de grundlæggende AES 128 bit. Denne algoritme bruger en initialvektor til at kryptere dine data.

Information

Nedenfor beskriver jeg hvert trin i krypterings- og dekrypteringsmetoden. Men jeg skrev en kode til Arduino, der bruger begge disse funktioner. Du kan se denne kode i min Github:

• Github: Min Github
• Eksempel på kode "Krypter/dekrypter": AES_crypto_example.ino

Første trin: Krypter dine data

I denne del vil jeg vise dig, hvordan du krypterer dine data.

Først skal du bruge denne funktion:

/** / brief Krypter data ved hjælp af AES CBC -algoritme* / param cfg Logisk interface -konfiguration. Nogle foruddefinerede * konfigurationer findes i atca_cfgs.h * / param data Ord, der skal encykteres (skal divideres med 16, maks. Længde 240) * / param [in] len længde af ord, der skal encykteres (skal divideres med 16, maks længde 240) * / param [ud] iv Initialvektor, der bruges i AES CBC (returner vektoren i denne var) * / param [ud] ciffertekstretur her Cypher -teksten * / param [in] -nøglen Slotnummer på nøgle * / return ATCA_SUCCESS på succes, ellers en fejlkode. */ 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; hvis (len> LIMIT_DATA_SIZE_CBC && len % 16! = 0) {Serial.print (F ("FEJL: ATCA_BAD_PARAM")); returner ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS status = atcab_init (cfg); hvis (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 (status, HEX); Vend tilbage; } 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]); } hvis (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (status, HEX); } status tilbage } status tilbage }

Denne funktion er enkel at bruge, du skal indstille to ting:

1. En tom IV (initialvektor) på 16 Bytes
2. Data, der skal krypteres (maks. Størrelse 240 Bytes)

Her et eksempel "hvordan man bruger denne funktion".

Jeg vil kryptere ordet "AAAAAAAAAAAAAAA", med min nøgle skrevet i slot nummer "9":

ATCA_STATUS status = atcab_init (& cfg); hvis (status! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () mislykkedes: Kode -> 0x")); Serial.println (status, HEX); } uint8_t plaintext [16] = "AAAAAAAAAAAAAAAA"; // Originaltekst uint8_t iv [IV_LENGTH_CBC]; // Initial Vector uint8_t cypherdata [sizeof (plaintext)]; // Datakrypteret status = aes_cbc_encrypt (& cfg, plaintext, sizeof (plaintext), iv, cypherdata, 9);

Hvis handlingen er god, har du de krypterede data i variablen "cypherdata" og den indledende vektor i variablen "IV".

Behold disse to variabler for at dekryptere din tekst!

Andet trin: dekrypter dine data

For at dekryptere dine data skal du bruge to ting:

1. Den indledende vektor
2. Cypher -data (krypterede data)

For at dekryptere dine data skal du bruge denne funktion:

/** / brief Dekrypter data ved hjælp af AES CBC -algoritme* / param cfg Logisk interface -konfiguration. Nogle foruddefinerede * konfigurationer findes i atca_cfgs.h * / param [in] ciphertext Words to decypt (skal divideres med 16, max længde 240) * / param [in] len længde af Words to decypt (skal divideres med 16, maks længde 240) * / param [in] iv Initial Vector til brug i AES CBC * / param [out] klartekst returner her den dekrypterede tekst * / param [in] nøgle Slotnummer for nøglen * / return ATCA_SUCCESS på succes, ellers en fejlkode. */ 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; hvis (len> LIMIT_DATA_SIZE_CBC || len % 16! = 0) {Serial.print (F ("FEJL dekrypter: ATCA_BAD_PARAM")); returner ATCA_BAD_PARAM; } ATCA_STATUS status = atcab_init (cfg); hvis (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 (status, HEX); Vend tilbage; } int max = len / 16; for (int j = 0; j <max; j ++) {status = atcab_aes_cbc_decrypt_block (& ctx, & ciphertext [j * 16], & plaintext [j * 16]); } hvis (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (status, HEX); } status tilbage } status tilbage }

Jeg vil dekryptere mine tidligere data (se nedenfor, Første trin). Til dette vil jeg gøre dette:

uint8_t plaintext [16] = "AAAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (almindelig tekst)]; uint8_t decryptdata [sizeof (plaintext)]; status = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) {Serial.print ("Dekrypteret tekst er:"); for (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } ellers {// Se filen atca_status.h for koden Fejl Serial.print (F ("Umulig gør dekrypteringen | Kodefejl 0x")); Serial.println (status, HEX); Vend tilbage; }

Hvis handlingen er god, vil du have de dekrypterede data i variablen "dekrypteringsdata".

Nu ved du, hvordan du bruger kryptering og dekryptering med chippen Atecc608a

Trin 6: 5. Hvorfor skal du bruge denne chip

Krypterede data er meget nyttige, fordi du kan skjule dine oplysninger og sende dem via Wireless eller bare gemme dem.

Her er et eksempel på brug:

1. Lagrede data til en ekstern EEPROM: Du kan sikre data fra en ekstern EEPROM, og hvis nogen stadig har denne EEPROM, skal han bruge nøglen og IV'en til dekrypteringen
2. Send trådløse data: Du kan sende disse krypterede data via Wireless (nrf24L01, RFM95W …), og hvis nogen opsnapper dine data, vil disse data være sikre
3. Lagret adgangskode
4. …

Du kan gøre flere ting med denne chip. Det kan bruges i flere projekter. Hvis du har tid, så sig mig i hvilket projekt, du vil bruge denne chip?

Et sidste råd, hvis du bygger et trådløst projekt eller gemmer nogle rådata, skal du være forsigtig, sikkerhed er meget vigtig, og hvis du ved, hvordan det er enkelt for en "noob" at opfange eller stjæle dine data. Nu med Internettet kan alle have scripts til at starte på deres computer bare for at "hacke" dig!

Trin 7: Konklusion

Jeg håber, at denne artikel vil være nyttig for dig. Beklager, hvis jeg tog fejl i min tekst, men engelsk er ikke mit hovedsprog, og jeg taler bedre, end jeg skriver.

Tak fordi du læste alt.

Nyd det.