Säkerhet med Arduino: Atecc608a: 7 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:39

Ämne

Hej alla !

Detta är min första instruktionsartikel så jag hoppas att det kommer att bli intressant för er alla.

I den här artikeln kommer jag att förklara dig hur du använder ett mikrochip som heter "ATECC608A" som erbjuder flera säkerhetsverktyg.

Detta chip har designats av MicroChip och det är den sista versionen av "CryptoAuthentication chip". Före denna version fanns "ATSHA204A" och "ATECC508A".

Varför bestämde jag mig för att använda den senaste versionen och inte den tidigare versionen?

Denna version är det mest avancerade chipet och har funktioner som den gamla versionen inte har (till exempel: AES -modul, IO -skyddsmodul …).

Varför detta projekt?

Jag arbetar inom området CyberSecurity och som alla älskade jag programmering och elektronik. Under mina studier får jag en konferens med en specialist på IoT -säkerhet som visade oss att Industrial inte använder säkerhet i sina IoT -objekt. Jag visade oss ett hänglås som kan vara öppet med din smartphone via Bluetooth. På hänglåset sa en mening "Detta hänglås är säkrast än ett nyckellås!". Denna mening får honom att le och han ändrade meningen "Detta hänglås är det värsta hänglåset som någonsin byggts!".

Han visade oss med sin egen dator och en Bluetooth -sniffer att varje kommando som skickas av smarttelefonen är samma varje gång och det är väldigt enkelt att kopiera det här kommandot och skicka det med din smartphone. Han förklarade att "Säkerhet" för "Industriell" inte är huvudproblemet. Han visade oss marker (mindre än 0,60 $) som kunde lägga till ett lager av säkerhet till dessa objekt.

Efter denna demonstration försökte jag hitta något Open source -projekt som lägger till säkerhetslager till IoT -objekt men jag hittade det aldrig.

Så jag bestämde mig för att arbeta med ett projekt som använder säkerhetslager för kommunikation mellan två IoT -objekt.

Vad är min idé?

Under en kommunikation mellan två IoT -objekt kan flera attacker finnas: Man Of the mild, kopia av information och mer.. Så min idé är väldigt enkel:

1. Användning av krypterad data mellan två eller flera IoT -objekt.
2. Lågkostnadsmaterial
3. Kan arbeta med en Arduino UNO

Nu ska jag förklara hur jag implementerade denna abstrakta bild med en Arduino och ett Atecc608a -chip. I den här artikeln kommer jag att förklara hur du använder Arduino UNO med ATECC608A.

Jag kommer att skriva en artikel om kommunikation av två objekt nästa gång.

Tillbehör

Du behöver några saker för detta projekt:

1. Arduino UNO eller MEGA (Chip måste vara Atmega 328 eller ATMEGA 2560)
2. Atecc608A -chip (kostar mindre än 0,80 $ styck, lätt att hitta på din leverantörs webbplats)
3. 8-polig SOIC-adapter
4. Några ledningar och motstånd

Databladet för den tidigare versionen av detta chip (Atecc508a) finns här -> Datablad Atecc508a

Steg 1: Steg för steg

I den här artikeln kommer jag att visa dig hur du ändrar konfigurationen av detta chip och efter hur du krypterar data med AES CBC -algoritmen.

Vi kommer att följa dessa steg:

1. Kretsens utformning
2. Konfiguration av detta chip
3. Användning av AES CBC -modulen
4. Varför behöver du använda detta chip

För varje steg kommer jag att beskriva allt för dig. Jag lade också till min kod i min Github med kommentarer för varje funktion. Om du har några frågor om min kod eller det här projektet svarar jag gärna på den.

Min Github: Min Github

Steg 2: Varning för Atecc608a

Atecc608a -chipet är inte ett "enkelt" chip.

För det första finns dokumentationen för detta chip under NDA så att du inte hittar det fullständigt på Internet. Men inga problem för detta, databladet för den tidigare versionen är tillgängligt på Internet Datasheet Complete ATECC508A.

För det andra, när du använder detta chip måste du låsa dess konfiguration och det är omöjligt att ändra chipets konfiguration om det är låst. Så var försiktig när du låser Config Zone och Data Zone.

För det tredje, biblioteket skrev i C är mycket stort och komplett, så du måste läsa dokumentationen för de funktioner som du kommer att använda tidigare.

Fyra, biblioteket skrev för detta chip fungerar inte för Arduino UNO, men det tillade de funktioner som behövs för att fungera med Arduino UNO.

Chippet ATECC608A

Du kan kommunicera med detta chip med I2C. Adressen till detta chip kan ändras i konfigurationen.

Detta chip innehåller 16 olika platser som kan innehålla olika typer av data:

1. ECC -nyckel (privat eller offentlig)
2. AES -nyckel
3. Annan data (som Sha hash eller bara ord)

I vårt fall kommer vi att lagra AES Key i en plats.

Steg 3: 1. Utformning av kretsen

1. Kretsens utformning

Schemat för denna krets är mycket enkelt!

Du måste använda 3,3V effekt eftersom rekommendationen är mellan 2,0V och 5,5V men jag föredrog att använda 3,3V.

För detta chip har du normalt en prick i ett hörn av chipet, denna prick är Pin 1 på detta kort. Jag lade till toppvy av Atecc608a med PIN-nummer eftersom det är en 8-ledig SOIC så att chipet är väldigt litet.

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åste använda 3,3V effekt eftersom rekommendationen är mellan 2,0V och 5,5V men jag föredrog att använda 3,3V.

Jag lade till toppvy av Atecc608a eftersom det är en 8-ledig SOIC så att chipet är väldigt litet. Om du föredrar, så att leverantörer bygger en bräda med spånlödet, kan det vara lättare för dig.

Varning: I mitt fall måste jag lägga till ett motstånd mellan SDA för Arduino och Chip (även för SDL). Jag lade till ett 4,7Kohm -motstånd för varje.

Steg 4: 2. Konfiguration av chipet (Atecc608a)

Innan du använder funktionen för kryptering eller dekryptering måste du konfigurera chipet. I det här steget kommer jag att beskriva alla steg du behöver göra för konfigurationen av detta chip.

Varning: det här steget är mycket viktigt och om du låser zonerna före slutet kan du inte ändra dem.

Som förklarats tidigare fick detta chip två zoner:

1. Config Zone
2. Data Zone

Konfigurationszonen fick en storlek på 128 byte men de första 16 byten kan inte ändras.

För att konfigurera detta chip behöver du två följa dessa steg. Det är mycket viktigt att följa varje steg i ordning annars fungerar din konfiguration inte, och ditt chip kommer att vara låst och oanvändbart. Dessa steg är:

1. Skapa en konfigurationsmall
2. Skriv den här mallen till chipet
3. Lås Config Zone
4. Skriv din AES -nyckel (128 bitar) i en plats
5. Lås datazonen

Information

Nedan beskriver jag varje steg i konfigurationen med min kod, men inga bekymmer, jag lade till ett fullständigt exempel på konfiguration i min Github. Jag lägger kommentarer på varje funktion, och en *.ino -fil är tillgänglig med varje steg för dig.

• Min Github: Min Github
• Sökväg för exempelkonfiguration: configuration_example.ino

Första steget: Skapa en konfigurationsmall

Som förklarats tidigare får konfigurationszonen en storlek på 128 bitar, men de första 16 bitarna kan inte ändras. Denna zon består av flera delar, men du behöver bara veta tre delar av denna konfigurationszon för detta projekt:

1. Bytes 16 -> Detta är chipets I2C -adress
2. Bytes 20 till 51 -> Du kan här ändra typen av plats för de 16 platserna i detta chip
3. Bytes 96 till 127 -> Du kan här ställa in typ av nyckel eller data som används i varje kortplats.

(Om du behöver mer förklaring av hela denna zon, läs dokumentationen (sidan 13, avsnitt 2.2))

Här lägger jag in detaljer om varje byte/delar av 112 byte i konfigurationen av ett chip. Detta är ett exempel, varje chip som köps kan ha en annan konfiguration:

0xC0, // I2C -adress

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 jag ser lägger jag några kommentarer i den här koden för att förstå mer denna konfiguration.

I ditt fall behöver du bara förstå tre saker:

1. Bytes 16 -> Detta är chipets I2C -adress
2. Bytes 20 till 51 -> Du kan här ändra typen av plats för de 16 kortplatserna i detta chip
3. Byte 96 till 127 -> Du kan här ställa in typ av nyckel eller data som används i varje kortplats.

Jag kommer inte att förklara vilken typ av konfiguration och varför jag använde detta och inte en annan eftersom det är komplicerat att förklara allt. Om du behöver mer information gå till dokumentationen, sidan 16 avsnitt 2.2.1 för "SlotConfig" och sidan 19 avsnitt 2.2.5 för "KeyConfig"

I det här exemplet kommer du att använda plats 9 för att lagra en AES -nyckel.

För detta måste vi sätta (om du behöver kan du kopiera exemplet ovan, ändringen har gjorts i det):

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

Varför ställde jag in den här konfigurationen: För varje kortplats i detta chip kan du ställa in parametrar för att säga till chipet vilken typ av data som ska lagras. Du har flera parametrar:

• Slot kan skrivas eller läsas (rensa eller kryptera åtgärd)
• Typ av lagrad data (ECC -nyckel, offentlig nyckel, SHA -hash, AES -nyckel …)
• Slot kan vara låsbar
• Generering av nycklar är tillåten
• …

Med byten 36 och 37 inställd på "0x0F8F":

• Data kan skrivas i Clear
• Innehållet i denna plats är hemligt och kan inte läsas
• Slot kan inte användas för kommandot CheckMac Copy

Med byten 112 och 113 inställd på "0x001A":

Slot kan lagra upp till fyra AES 128-bitars symmetriska nycklar (KeyType = 0x6)

Andra steget: Skriv den här konfigurationen

Det här steget är mycket viktigt eftersom vi kommer att ställa in chipet med vår konfiguration och om denna konfiguration inte är bra kommer du att använda detta chip.

Men oroa dig inte, så länge konfigurationen inte är låst kan du ändra din konfiguration.

Här är koden som används för att skriva konfigurationen till chipet:

/** / brief Skriv en ny konfiguration till chipet.

* / param [in] cfg Logisk gränssnittskonfiguration. Vissa fördefinierade * konfigurationer finns i atca_cfgs.h * / param config Array uint8_t av konfiguration (längd 112) * / param [in] len Storlek på konfigurationsmatrisen * / return ATCA_SUCCESS efter framgång, annars en felkod. */ ATCA_STATUS skrivkonfiguration (ATCAIfaceCfg *cfg, uint8_t *config, size_t len) {if (len! = 112) returnerar ATCA_BAD_PARAM; ATCA_STATUS status; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {// Skriv konfigurationsmatrisen till chipet // Fyllning av 16 byte (16 första byte kan inte skrivas) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); returstatus; } returstatus; }

Denna funktion skriver din konfiguration i chipet.

Tredje steget: lås konfigurationszonen

Varning: var försiktig med detta steg, om du låser den här zonen och din konfiguration inte är bra, är chippet oanvändbart och du kan inte ändra denna zon

För denna åtgärd kommer vi att använda den här funktionen:

/** / brief Kontrollera om en DATA_ZONE eller CONFIG_ZONE är låst

* / param [in] cfg Logisk gränssnittskonfiguration. Vissa fördefinierade * konfigurationer kan hittas i atca_cfgs.h * / param zon LOCK_ZONE_DATA eller LOCK_ZONE_CONFIG * / return ATCA_SUCCESS efter framgång, annars en felkod. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS status; bool lock = falskt; om (zon! = (uint8_t) LOCK_ZONE_CONFIG && zon! = (uint8_t) LOCK_ZONE_DATA) returnerar ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zon, och lås))) {return ATCA_FUNC_FAIL; } om (! lock) {return ATCA_NOT_LOCKED; } returnera ATCA_SUCCESS; } returnera ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Fjärde steget: Skriv en AES -nyckel i en plats

I denna del kommer du att ställa in din personliga AES -nyckel i facket som du har definierat i chipets konfiguration.

I det här exemplet kommer jag att använda plats nummer 9 på chipet.

Du behöver veta: En speciell egenskap hos detta chip är att du bara kan skriva data i plats med 4 byte eller 32 byte. För AES behöver vi 128 bitars nyckel så 16 byte data. Så jag bestämde mig för att skriva till nyckeln på 16 byte vardera i denna plats för att ha 32 bytes data.

Nu ska jag visa dig koden som används:

/** / brief Skriv AES -nyckel i en given plats. * / param [in] cfg Logisk gränssnittskonfiguration. Vissa fördefinierade * konfigurationer finns i atca_cfgs.h * / param [in] nyckelnyckelplats * * param [in] datakey key array uint8_t * / param [in] len Storlek på nyckelmatrisen * / return ATCA_SUCCESS på framgång, annars en felkod. */ ATCA_STATUS write_key_slot (ATCAIfaceCfg *cfg, uint8_t key, uint8_t *datakey, size_t len) {if (key 16) return ATCA_BAD_PARAM; om (len! = 32) returnerar 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) returstatus; } returstatus; }

I det här exemplet kommer jag att använda två AES -nycklar på 16 byte vardera:

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

Om denna åtgärd är bra, nu måste du klara det sista steget "lås datazonen"

Sista steget: lås datazonen

Varning: var försiktig med detta steg, om du låser den här zonen och dina data inte är inställda är chippet oanvändbart och du kan inte ändra denna zon

För denna åtgärd kommer vi att använda den här funktionen:

/** / brief Kontrollera om en DATA_ZONE eller CONFIG_ZONE är låst

* / param [in] cfg Logisk gränssnittskonfiguration. Vissa fördefinierade * konfigurationer kan hittas i atca_cfgs.h * / param zon LOCK_ZONE_DATA eller LOCK_ZONE_CONFIG * / return ATCA_SUCCESS efter framgång, annars en felkod. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS status; bool lock = false; om (zon! = (uint8_t) LOCK_ZONE_CONFIG && zon! = (uint8_t) LOCK_ZONE_DATA) returnerar ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zon, och lås))) {return ATCA_FUNC_FAIL; } om (! lock) {return ATCA_NOT_LOCKED; } returnera ATCA_SUCCESS; } returnera ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Om den här åtgärden är bra är ditt chip redo att användas

Steg 5: 3. Användning av AES CBC -modulen

Jag kommer att förklara hur man krypterar och dekrypterar data med algoritmen AES CBC och chipet Atecc608a.

Kom ihåg: Innan du använder den här funktionen måste du konfigurera chippet. För detta, följ steg 2 i den här artikeln

Detta chip har flera AES -moduler (AES 128 bitar), endast AES 128 bitar är möjliga:

1. AES normalt
2. AES CBC
3. AES GCM (med GFM -hash) (se wikipedia för mer förklaring)

För att göra det enklare att använda skapade jag två funktioner:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Dessa två funktioner är tillgängliga på min Github.

Explikation

Jag väljer att använda AES CBC -algoritmen eftersom den är säkrare än de grundläggande AES 128 bitarna. Denna algoritm använder en initialvektor för att kryptera dina data.

Information

Nedan beskriver jag varje steg i krypterings- och dekrypteringsmetoden. Men jag skrev en kod för Arduino som använder de båda funktionerna. Du kan se den här koden i min Github:

• Github: Min Github
• Exempel på kod "Kryptera/dekryptera": AES_crypto_example.ino

Första steget: Kryptera dina data

I den här delen kommer jag att visa dig hur du krypterar dina data.

Först behöver du denna funktion:

/** / brief Kryptera data med AES CBC -algoritm* / param cfg Logisk gränssnittskonfiguration. Vissa fördefinierade * konfigurationer kan hittas i atca_cfgs.h * / param [in] data Words to encrypt (måste divideras med 16, maxlängd 240) * / param [in] len längd på Words to encrypt (måste divideras med 16, maxlängd 240) * / param [out] iv Initialvektor som används i AES CBC (returnera vektorn i denna var) * / param [out] ciphertext return here the Cypher text * / param [in] key Slot number of the nyckel * / return ATCA_SUCCESS på framgång, annars en felkod. */ 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 ("ERROR: ATCA_BAD_PARAM")); returnera ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS status = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, key, 0, tmp_iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (status, HEX); lämna tillbaka; } memcpy (iv, tmp_iv, IV_LENGTH_CBC); memcpy (tmp_data, data, len); int max = len / 16; för (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; }

Denna funktion är enkel att använda, du måste ställa in två saker:

1. En tom IV (initialvektor) på 16 bytes
2. Data som ska krypteras (maxstorlek 240 Bytes)

Här är ett exempel "hur man använder den här funktionen".

Jag vill kryptera ordet "AAAAAAAAAAAAAAA", med min nyckel skrev i facket "9":

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

Om åtgärden är bra har du krypterade data i variabeln "cypherdata" och initialvektorn i variabeln "IV".

Behåll dessa två variabler för att dekryptera din text!

Andra steget: dekryptera dina data

För att dekryptera dina data behöver du två saker:

1. Den inledande vektorn
2. Cypher -data (krypterad data)

För att dekryptera dina data behöver du den här funktionen:

/** / brief Dekryptera data med AES CBC -algoritm* / param cfg Logisk gränssnittskonfiguration. Vissa fördefinierade * konfigurationer finns i atca_cfgs.h * / param [in] ciphertext Words to decypt (måste divideras med 16, maxlängd 240) * / param [in] len längd på Words to decypt (måste divideras med 16, maxlängd 240) * / param [in] iv Initialvektor som ska användas i AES CBC * / param [out] klartext returnerar den dekrypterade texten * / param [in] nyckelplatsens nyckel * / return ATCA_SUCCESS på framgång, annars en felkod. */ 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")); returnera ATCA_BAD_PARAM; } ATCA_STATUS status = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, key, 0, iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (status, HEX); lämna tillbaka; } int max = len / 16; för (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; }

Jag vill dekryptera mina tidigare data (se nedan, första steget). För detta kommer jag att göra följande:

uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (klartext)]; uint8_t decryptdata [sizeof (klartext)]; status = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) {Serial.print ("Dekrypterad text är:"); för (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } annat {// Se filen atca_status.h för koden Error Serial.print (F ("Omöjligt att avkryptera | Kodfel 0x")); Serial.println (status, HEX); lämna tillbaka; }

Om åtgärden är bra kommer du att ha de dekrypterade data i variabeln "decryptdata".

Nu vet du hur du använder kryptering och dekryptering med chipet Atecc608a

Steg 6: 5. Varför behöver du använda detta chip?

Krypterad data är mycket användbar eftersom du kan dölja din information och skicka den med Wireless eller bara lagra den.

Här är några exempel på användning:

1. Lagrad data till en extern EEPROM: Du kan säkra data från en extern EEPROM och om någon fortfarande har denna EEPROM behöver han nyckeln och IV: n för dekrypteringen
2. Skicka trådlös data: Du kan skicka denna krypterade data via Wireless (nrf24L01, RFM95W …) och om någon fångar upp dina data kommer dessa data att vara säkra
3. Lagrat lösenord
4. …

Du kan göra flera saker med detta chip. Den kan användas i flera projekt. Om du har tid, säg mig i vilket projekt du kommer att använda detta chip?

Ett sista råd, om du bygger ett trådlöst projekt eller lagrar rådata, var försiktig, säkerheten är mycket viktig och om du vet hur det är enkelt för en "noob" att fånga upp eller stjäla din data. Nu med Internet kan alla ha skript att starta på sin dator bara för att "hacka" dig!

Steg 7: Slutsats

Jag hoppas att den här artikeln kommer att vara användbar för dig. Förlåt om jag gjorde fel i min text men engelska är inte mitt huvudspråk och jag talar bättre än jag skriver.

Tack för att du läste allt.

Njut av det.