Sikkerhet med Arduino: Atecc608a: 7 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:21

Emne

Hei alle sammen !

Dette er min første instruksjonsartikkel, så jeg håper det blir interessant for dere alle.

I denne artikkelen vil jeg forklare deg hvordan du bruker en mikrobrikke kalt "ATECC608A" som gir flere sikkerhetsverktøy.

Denne brikken er designet av MicroChip, og den er den siste versjonen av "CryptoAuthentication chip". Før denne versjonen var det "ATSHA204A" og "ATECC508A".

Hvorfor bestemte jeg meg for å bruke den siste versjonen og ikke den forrige versjonen?

Denne versjonen er den mest avanserte brikken og har funksjoner som den gamle versjonen ikke har (for eksempel: AES -modul, IO -beskyttelsesmodul …).

Hvorfor dette prosjektet?

Jeg jobber på domenet til CyberSecurity og som alle elsket jeg programmering og elektronikk. I løpet av studiene får jeg en konferanse med en spesialist på IoT Security som viste oss at Industrial ikke bruker sikkerhet i IoT -objektet. Jeg viste oss en hengelås som kan være åpen med smarttelefonen din via Bluetooth. På hengelåsen sa en setning "Denne hengelåsen er sikrest enn en nøkkelhengelås!". Denne setningen får ham til å smile, og han endret setningen "Denne hengelåsen er den verste hengelåsen som noen gang er bygget!".

Han viste oss med sin egen PC og en Bluetooth -sniffer at hver kommando sendt av smarttelefonen er den samme hver gang, og det er veldig enkelt å kopiere denne kommandoen og sende den med smarttelefonen din. Han forklarte oss at "Sikkerhet" for "Industriell" ikke er hovedproblemet. Han viste oss sjetonger (mindre enn 0,60 $) som kan tilføre et lag med sikkerhet til disse objektene.

Etter denne demonstrasjonen prøvde jeg å finne et Open Source -prosjekt som legger til sikkerhetslag til IoT -objekt, men jeg fant det aldri.

Så jeg bestemte meg for å jobbe med et prosjekt som bruker sikkerhetslag for kommunikasjon mellom to IoT -objekter.

Hva er tanken min?

Under en kommunikasjon mellom to IoT -objekter kan det eksistere flere angrep: Man Of the mild, kopi av informasjon og mer.. Så ideen min er veldig enkel:

1. Utnyttelse av krypterte data mellom to eller flere IoT -objekter.
2. Lavprisrekvisita
3. Kan jobbe med en Arduino UNO

Nå skal jeg forklare deg hvordan jeg implementerte dette abstrakte bildet med en Arduino og en Atecc608a -brikke. I denne artikkelen vil jeg forklare deg hvordan du bruker Arduino UNO med ATECC608A.

Jeg skal skrive en artikkel om kommunikasjon av to objekter neste gang.

Rekvisita

Du trenger noen få ting for dette prosjektet:

1. Arduino UNO eller MEGA (Chip må være Atmega 328 eller ATMEGA 2560)
2. Atecc608A -brikke (koster mindre enn 0,80 $ hver, lett å finne på leverandørens nettsted)
3. 8-pinners SOIC-adapter
4. Noen ledninger og motstander

Databladet til den forrige versjonen av denne brikken (Atecc508a) er tilgjengelig her -> Datablad Atecc508a

Trinn 1: Trinn for trinn

I denne artikkelen vil jeg vise deg hvordan du endrer konfigurasjonen av denne brikken og etter hvordan du krypterer data ved hjelp av AES CBC -algoritmen.

Vi vil følge disse trinnene:

1. Kretsens utforming
2. Konfigurasjon av denne brikken
3. Utnyttelse av AES CBC -modulen
4. Hvorfor trenger du å bruke denne brikken?

For hvert trinn vil jeg beskrive alt for deg. Jeg la også til koden min i Github med kommentarer for hver funksjon. Hvis du har noen spørsmål om koden min eller dette prosjektet, svarer jeg det gjerne.

Min Github: Min Github

Trinn 2: Advarsel om Atecc608a

Atecc608a -brikken er ikke en "enkel" brikke.

Først er dokumentasjonen for denne brikken under NDA, så du finner den ikke komplett på Internett. Men ikke noe problem for dette, databladet til den forrige versjonen er tilgjengelig på Internett Datablad Komplett ATECC508A.

For det andre, når du bruker denne brikken må du låse konfigurasjonen, og det er umulig å endre brikkens konfigurasjon hvis den er låst. Så vær forsiktig når du vil låse konfigksonen og datasonen.

For det tredje, biblioteket skrev i C er veldig stort og komplett, så du må lese dokumentasjonen til funksjonene du vil bruke før.

Fire, biblioteket skrev for denne brikken fungerer ikke for Arduino UNO, men den la til at funksjonalitetene trenger den for å fungere med Arduino UNO.

Brikken ATECC608A

Du kan kommunisere med denne brikken med I2C. Adressen til denne brikken kan endres i konfigurasjonen.

Denne brikken inneholder 16 forskjellige spor som kan inneholde forskjellige typer data:

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

I vårt tilfelle vil vi lagre AES Key i ett spor.

Trinn 3: 1. Utforming av kretsen

1. Utforming av kretsen

Skjemaet for denne kretsen er veldig enkelt!

Du må bruke 3.3V strøm fordi anbefalingen er mellom 2.0V og 5.5V, men jeg foretrakk å bruke 3.3V.

For denne brikken har du vanligvis en prikk på et hjørne av brikken, denne prikken er pin 1 på dette brettet. Jeg la til toppvisningen av Atecc608a med PIN-nummer fordi det er en 8-bly SOIC, så brikken er veldig liten.

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 må bruke 3.3V strøm fordi anbefalingen er mellom 2.0V og 5.5V, men jeg foretrakk å bruke 3.3V.

Jeg la til toppvisningen av Atecc608a fordi det er en 8-bly SOIC, så brikken er veldig liten. Hvis du foretrekker det, så leverandører bygger et brett med flisloddet, kan det være lettere for deg.

Advarsel: I mitt tilfelle må jeg legge til en motstand mellom SDA for Arduino og Chip (også for SDL). Jeg la til en 4,7Kohm motstand for hver.

Trinn 4: 2. Konfigurasjon av brikken (Atecc608a)

Før du bruker krypterings- eller dekrypteringsfunksjonen, må du konfigurere brikken. I dette trinnet vil jeg beskrive alle trinnene du må gjøre for konfigurasjonen av denne brikken.

Advarsel: dette trinnet er veldig viktig, og hvis du låser sonene før slutten, kan du ikke endre dem.

Som forklart før har denne brikken to soner:

1. Config Zone
2. Datasone

Konfigurasjonssonen har en størrelse på 128 byte, men de første 16 byte kan ikke endres.

For å konfigurere denne brikken må du følge disse trinnene. Det er veldig viktig å følge hvert trinn i rekkefølge, ellers fungerer konfigurasjonen ikke, og brikken din blir låst og ubrukelig. Disse trinnene er:

1. Lag en konfigurasjonsmal
2. Skriv denne malen til brikken
3. Lås konfigurasjonssonen
4. Skriv din AES -nøkkel (128 bits) i et spor
5. Lås datasonen

Informasjon

Nedenfor beskriver jeg hvert trinn i konfigurasjonen med koden min, men ingen bekymringer, jeg la til et komplett eksempel på konfigurasjon i min Github. Jeg legger kommentarer til hver funksjon, og en *.ino -fil er tilgjengelig for hvert trinn for deg.

• Min Github: Min Github
• Konfigurasjonseksempel: konfigurasjonseksempel.ino

Første trinn: Lag en konfigurasjonsmal

Som forklart tidligere får konfigurasjonssonen en størrelse på 128 bits, men de første 16 bitene kan ikke endres. Denne sonen består av flere deler, men du trenger bare å kjenne 3 deler av denne konfigurasjonssonen for dette prosjektet:

1. Bytes 16 -> Dette er I2C -adressen til brikken
2. Bytes 20 til 51 -> Du kan her endre typen Slot for de 16 sporene på denne brikken
3. Bytes 96 til 127 -> Du kan her angi nøkkeltype eller data som brukes i hvert spor.

(Hvis du trenger mer forklaring på hele denne sonen, kan du lese dokumentasjonen (side 13, avsnitt 2.2))

Her legger jeg inn detaljer om hver byte/deler av 112 byte i konfigurasjonen av en brikke. Dette er et eksempel, hver brikke som er kjøpt kan ha en annen konfigurasjon:

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 // Nøkkelkonfigurasjonsspor 16

Som du ser, legger jeg noen kommentarer i denne koden for å forstå mer denne konfigurasjonen.

I ditt tilfelle trenger du bare å forstå tre ting:

1. Bytes 16 -> Dette er I2C -adressen til brikken
2. Bytes 20 til 51 -> Du kan her endre typen Slot for de 16 sporene på denne brikken
3. Byte 96 til 127 -> Du kan her angi nøkkeltype eller data som brukes i hvert spor.

Jeg vil ikke forklare hvilken type konfigurasjon og hvorfor jeg brukte dette og ikke en annen fordi det er komplisert å forklare alt. Hvis du trenger mer informasjon, gå til dokumentasjonen, side 16 avsnitt 2.2.1 for "SlotConfig" og side 19 seksjon 2.2.5 for "KeyConfig"

I dette eksemplet vil du bruke sporet 9 til å lagre en AES -nøkkel.

For dette må vi sette (hvis du trenger det, kan du kopiere eksemplet ovenfor, endringen er gjort i det):

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

Hvorfor satte jeg denne konfigurasjonen: For hvert spor i denne brikken kan du angi parametere for å si til brikken hvilken type data som skal lagres. Du har flere parametere:

• Slot kan skrives eller leses (klar eller krypter handling)
• Datatype lagret (ECC -nøkkel, Offentlig nøkkel, SHA Hash, AES -nøkkel …)
• Sporet kan låses
• Generering av nøkkel er tillatt
• …

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

• Data kan skrives i Clear
• Innholdet i dette sporet er hemmelig og kan ikke leses
• Slot kan ikke brukes til CheckMac Copy -kommandoen

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

Slot kan lagre opptil fire AES 128-biters symmetriske taster (KeyType = 0x6)

Andre trinn: Skriv denne konfigurasjonen

Dette trinnet er veldig viktig fordi vi vil sette brikken med vår konfigurasjon, og hvis denne konfigurasjonen ikke er god, vil du bruke denne brikken.

Men ingen grunn til bekymring, så lenge konfigurasjonen ikke er låst, kan du endre konfigurasjonen.

Her er dette koden som ble brukt til å skrive konfigurasjonen til brikken:

/** / brief Skriv en ny konfigurasjon til brikken.

* / param cfg Logisk grensesnittkonfigurasjon. Noen forhåndsdefinerte * konfigurasjoner finnes i atca_cfgs.h * / param config Array uint8_t av konfigurasjon (lengde 112) * / param [in] len Størrelse på konfigurasjonsarrayet * / return ATCA_SUCCESS på suksess, ellers en feilkode. */ ATCA_STATUS skrivekonfigurasjon (ATCAIfaceCfg *cfg, uint8_t *config, size_t len) {if (len! = 112) returner ATCA_BAD_PARAM; ATCA_STATUS status; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {// Skriv konfigurasjonsmatrisen til brikken // Polstring av 16 byte (16 første byte kan ikke skrives) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); returstatus; } returstatus; }

Denne funksjonen vil skrive konfigurasjonen din i brikken.

Tredje trinn: Lås konfigurasjonssonen

Advarsel: Vær forsiktig med dette trinnet. Hvis du låser denne sonen og konfigurasjonen din ikke er god, er brikken ubrukelig og du kan ikke endre denne sonen

For denne handlingen bruker vi denne funksjonen:

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

* / param cfg Logisk grensesnittkonfigurasjon. Noen forhåndsdefinerte * konfigurasjoner finnes i atca_cfgs.h * / param sone LOCK_ZONE_DATA eller LOCK_ZONE_CONFIG * / return ATCA_SUCCESS på suksess, ellers en feilkode. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS status; bool lock = false; hvis (sone! = (uint8_t) LOCK_ZONE_CONFIG && sone! = (uint8_t) LOCK_ZONE_DATA) returnerer ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (sone, og lås))) {return ATCA_FUNC_FAIL; } hvis (! lock) {return ATCA_NOT_LOCKED; } returner ATCA_SUCCESS; } returner ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Fjerde trinn: Skriv deg en AES -nøkkel i et spor

I denne delen vil du sette deg den personlige AES -nøkkelen i sporet som du har definert i konfigurasjonen av brikken.

For dette eksempelet vil jeg bruke sporet nummer 9 på brikken.

Du trenger å vite: En spesiell funksjon ved denne brikken er at du bare kan skrive data i sporet med 4 byte eller 32 byte. For AES trenger vi 128 bits nøkkel så 16 byte data. Så jeg bestemte meg for å skrive til nøkkelen på 16 byte hver i dette sporet for å ha 32 bytes data.

Nå skal jeg vise deg koden som ble brukt:

/** / brief Skriv AES -nøkkel i et gitt spor. * / param cfg Logisk grensesnittkonfigurasjon. Noen forhåndsdefinerte * konfigurasjoner finnes i atca_cfgs.h * / param [in] key key slot number * / param [in] datakey key array uint8_t * / param [in] len Size of the key array * / return ATCA_SUCCESS on success, ellers en feilkode. */ 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økkel, 0, 0, datakey, 32); hvis (status! = ATCA_SUCCESS) returstatus; } returstatus; }

I dette eksemplet vil jeg bruke to AES -taster på 16 byte hver:

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

Hvis denne handlingen er god, må du nå passere det siste trinnet "lås datasonen"

Siste trinn: Lås datasonen

Advarsel: Vær forsiktig med dette trinnet. Hvis du låser denne sonen og dataene dine ikke er angitt, er brikken ubrukelig, og du kan ikke endre denne sonen

For denne handlingen bruker vi denne funksjonen:

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

* / param cfg Logisk grensesnittkonfigurasjon. Noen forhåndsdefinerte * konfigurasjoner finnes i atca_cfgs.h * / param sone LOCK_ZONE_DATA eller LOCK_ZONE_CONFIG * / return ATCA_SUCCESS på suksess, ellers en feilkode. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS status; bool lock = false; hvis (sone! = (uint8_t) LOCK_ZONE_CONFIG && sone! = (uint8_t) LOCK_ZONE_DATA) returnerer ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (sone, og lås))) {return ATCA_FUNC_FAIL; } hvis (! lock) {return ATCA_NOT_LOCKED; } returner ATCA_SUCCESS; } returner ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Hvis denne handlingen er god, er brikken din klar til bruk

Trinn 5: 3. Utnyttelse av AES CBC -modulen

Jeg vil forklare hvordan du krypterer og dekrypterer data med algoritmen AES CBC og brikken Atecc608a.

Husk: Før du bruker denne funksjonen, må du sette opp brikken. For dette, følg trinn 2 i denne artikkelen

Denne brikken har flere typer AES -moduler (AES 128 bits), bare AES 128 bits er mulig:

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

For å gjøre det enklere å bruke, opprettet jeg to funksjoner:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Disse to funksjonene er tilgjengelige på min Github.

Forklaring

Jeg velger å bruke AES CBC -algoritmen fordi den er tryggere enn de grunnleggende AES 128 bitene. Denne algoritmen bruker en initialvektor for å kryptere dataene dine.

Informasjon

Nedenfor beskriver jeg hvert trinn i krypterings- og dekrypteringsmetoden. Men jeg skrev en kode for Arduino som bruker begge funksjonene. Du kan se denne koden i min Github:

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

Første trinn: Krypter dataene dine

I denne delen vil jeg vise deg hvordan du krypterer dataene dine.

Først trenger du denne funksjonen:

/** / brief Krypter data ved hjelp av AES CBC -algoritme* / param cfg Logisk grensesnittkonfigurasjon. Noen forhåndsdefinerte * konfigurasjoner finnes i atca_cfgs.h * / param [in] data Words to encycpt (må deles med 16, maks lengde 240) * / param [in] len lengde på Words to enccypt (må deles med 16, maks lengde 240) * / param [ut] iv Initialvektor som brukes i AES CBC (returner vektoren i denne var) * / param [out] ciphertext return here Cypher text * / param [in] key Slot number of the nøkkel * / return ATCA_SUCCESS på suksess, ellers en feilkode. */ 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 ("FEIL: 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); komme tilbake; } 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 (status, HEX); } returstatus; } returstatus; }

Denne funksjonen er enkel å bruke, du må sette to ting:

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

Her et eksempel "hvordan du bruker denne funksjonen".

Jeg vil kryptere ordet "AAAAAAAAAAAAAAA", med nøkkelen min skrevet i sporet "9":

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

Hvis handlingen er god, vil du ha de krypterte dataene i variabelen "cypherdata" og den første vektoren i variabelen "IV".

Behold de to variablene for å dekryptere teksten din!

Andre trinn: dekrypter dataene dine

For å dekryptere dataene dine trenger du to ting:

1. Den første vektoren
2. Cypher -dataene (krypterte data)

For å dekryptere dataene dine trenger du denne funksjonen:

/** / brief Dekrypter data ved hjelp av AES CBC -algoritme* / param cfg Logisk grensesnittkonfigurasjon. Noen forhåndsdefinerte * konfigurasjoner finnes i atca_cfgs.h * / param [in] ciphertext Words to decypt (må deles med 16, maks lengde 240) * / param [in] len lengde på Words to decypt (må deles med 16, maks lengde 240) * / param [in] iv Initial Vector for bruk i AES CBC * / param [out] ren tekst returner her den dekrypterte teksten * / param [in] key Slot number of the key * / return ATCA_SUCCESS on success, ellers en feilkode. */ 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")); 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); komme tilbake; } int max = len / 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 (status, HEX); } returstatus; } returstatus; }

Jeg vil dekryptere mine tidligere data (se nedenfor, Første trinn). For dette vil jeg gjøre dette:

uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (ren tekst)]; uint8_t dekrypteringsdata [sizeof (ren tekst)]; status = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) {Serial.print ("Dekryptert tekst er:"); for (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } annet {// Se filen atca_status.h for koden Error Serial.print (F ("Impossible do the decryption | Code Error 0x")); Serial.println (status, HEX); komme tilbake; }

Hvis handlingen er god, vil du ha de dekrypterte dataene i variabelen "dekrypteringsdata".

Nå vet du hvordan du bruker kryptering og dekryptering med brikken Atecc608a

Trinn 6: 5. Hvorfor trenger du å bruke denne brikken

Krypterte data er veldig nyttige fordi du kan skjule informasjonen din og sende den med Wireless eller bare lagre den.

Her er et eksempel på bruk:

1. Lagrede data til en ekstern EEPROM: Du kan sikre data fra en ekstern EEPROM, og hvis noen fremdeles bruker denne EEPROM, trenger han nøkkelen og IV for dekrypteringen
2. Send trådløse data: Du kan sende disse krypterte dataene med Wireless (nrf24L01, RFM95W …), og hvis noen fanger opp dataene dine, vil disse dataene være sikre
3. Lagret passord
4. …

Du kan gjøre flere ting med denne brikken. Den kan brukes i flere prosjekter. Hvis du har tid, si meg i hvilket prosjekt du vil bruke denne brikken?

Et siste råd, hvis du bygger et trådløst prosjekt eller lagrer noen rådata, vær forsiktig, sikkerhet er veldig viktig, og hvis du vet hvordan det er enkelt for en "noob" å fange opp eller stjele dataene dine. Nå med Internett kan alle ha skript å starte på datamaskinen bare for å "hacke" deg!

Trinn 7: Konklusjon

Jeg håper denne artikkelen vil være nyttig for deg. Beklager hvis jeg gjorde feil i teksten min, men engelsk er ikke hovedspråket mitt, og jeg snakker bedre enn jeg skriver.

Takk for at du leste alt.

Nyt det.