Beveiliging met Arduino: Atecc608a - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Onderwerp

Dag iedereen !

Dit is mijn eerste Instructables-artikel, dus ik hoop dat het voor jullie allemaal interessant zal zijn.

In dit artikel zal ik je uitleggen hoe je een microchip genaamd "ATECC608A" gebruikt die meerdere beveiligingstools biedt.

Deze chip is ontworpen door MicroChip en het is de laatste versie van de "CryptoAuthentication-chip". Voor deze versie was er "ATSHA204A" en de "ATECC508A".

Waarom heb ik besloten om de laatste versie te gebruiken en niet de vorige versie?

Deze versie is de meest geavanceerde chip en heeft functionaliteiten die de oude versie niet heeft (bijvoorbeeld: AES-module, IO-beveiligingsmodule …).

Waarom dit project?

Ik werk in het domein van de CyberSecurity en zoals iedereen hield ik van programmeren en elektronica. Tijdens mijn studie krijg ik een conferentie met een specialist op het gebied van IoT Security die ons liet zien dat Industrial geen Security gebruikt in hun IoT-object. Ik liet ons een hangslot zien dat via Bluetooth met je smartphone kan worden geopend. Op het hangslot stond een zin: "Dit hangslot is het veiligst dan een sleutelhangslot!". Deze zin deed hem glimlachen en hij wijzigde de zin "Dit hangslot is het slechtste hangslot ooit gebouwd!".

Hij liet ons met zijn eigen pc en een Bluetooth-sniffer zien dat elke opdracht die door de smartphone wordt verzonden, elke keer hetzelfde is en dat het heel eenvoudig is om deze opdracht te kopiëren en met je smartphone te verzenden. Hij legde ons uit dat "Beveiliging" voor "Industrieel" niet het grootste probleem is. Hij liet ons chips (minder dan $ 0,60) zien die een beveiligingslaag aan deze objecten konden toevoegen.

Na deze demonstratie probeerde ik een open source-project te vinden dat een beveiligingslaag aan het IoT-object toevoegt, maar ik heb het nooit gevonden.

Dus besloot ik om aan een project te werken dat een beveiligingslaag gebruikt voor communicatie tussen twee IoT-objecten.

Wat is mijn idee?

Tijdens een communicatie tussen twee IoT-objecten kunnen meerdere aanvallen plaatsvinden: Man Of the mild, Copy of information and more.. Dus mijn idee is heel eenvoudig:

1. Gebruik van versleutelde gegevens tussen twee of meer IoT-objecten.
2. Goedkope benodigdheden
3. Kan werken met een Arduino UNO

Nu zal ik je uitleggen hoe ik deze abstracte afbeelding heb geïmplementeerd met een Arduino en een Atecc608a-chip. In dit artikel leg ik je uit hoe je de Arduino UNO gebruikt met de ATECC608A.

Ik zal de volgende keer een artikel schrijven over de communicatie van twee objecten.

Benodigdheden

Voor dit project heb je een aantal dingen nodig:

1. Arduino UNO of MEGA (Chip moet Atmega 328 of ATMEGA 2560 zijn)
2. Atecc608A-chip (kost minder dan $ 0,80 per stuk, gemakkelijk te vinden op de website van uw leverancier)
3. 8-pins SOIC-adapter
4. Sommige draden en weerstanden

De datasheet van de vorige versie van deze chip (Atecc508a) is hier beschikbaar -> Datasheet Atecc508a

Stap 1: Stap voor stap

In dit artikel laat ik je zien hoe je de configuratie van deze chip kunt wijzigen en daarna hoe je gegevens kunt versleutelen met het AES CBC-algoritme.

We zullen die stappen volgen:

1. Ontwerp van de schakeling
2. Configuratie van deze chip
3. Gebruik van de AES CBC-module
4. Waarom heb je deze chip nodig?

Voor elke stap zal ik alles voor u in detail beschrijven. Ook heb ik mijn code in mijn Github toegevoegd met opmerkingen voor elke functie. Als je vragen hebt over mijn code of dit project, zal ik deze graag beantwoorden.

Mijn Github: Mijn Github

Stap 2: Waarschuwing over de Atecc608a

De Atecc608a-chip is geen "gemakkelijke" chip.

Ten eerste is de documentatie van deze chip onder NDA, dus u zult deze niet volledig op internet vinden. Maar geen probleem hiervoor, de datasheet van de vorige versie is beschikbaar op Internet Datasheet Complete ATECC508A.

Ten tweede, wanneer u deze chip gebruikt, moet u de configuratie vergrendelen en het is onmogelijk om de configuratie van de chip te wijzigen als deze is vergrendeld. Wees dus voorzichtig wanneer u de Config Zone en de Data Zone vergrendelt.

Ten derde is de bibliotheek die in C is geschreven erg groot en compleet, dus je moet de documentatie lezen van de functies die je eerder gaat gebruiken.

Ten vierde, de bibliotheek schreef voor deze chip die niet werkt voor Arduino UNO, maar het voegde de functionaliteiten toe die nodig zijn om met Arduino UNO te werken.

De chip ATECC608A

U kunt met deze chip communiceren via I2C. Het adres van deze chip kan worden gewijzigd in de configuratie.

Deze chip bevat 16 verschillende slots die verschillende soorten gegevens kunnen bevatten:

1. ECC-sleutel (privé of openbaar)
2. AES-sleutel
3. Andere gegevens (zoals Sha hash of alleen woorden)

In ons geval bewaren we AES Key in één slot.

Stap 3: 1. Ontwerp van het circuit

1. Ontwerp van het circuit

Het schema van dit circuit is heel eenvoudig!

Je moet 3,3V stroom gebruiken omdat de aanbeveling tussen 2,0V en 5,5V ligt, maar ik gebruik liever de 3,3V.

Voor deze chip heb je normaal gesproken een stip op een hoek van de chip, deze stip is de Pin 1 van dit bord. Ik heb het bovenaanzicht van de Atecc608a met pincode toegevoegd omdat het een 8-lead SOIC is, dus de chip is erg klein.

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)

Je moet 3,3V stroom gebruiken omdat de aanbeveling tussen 2,0V en 5,5V ligt, maar ik gebruik liever de 3,3V.

Ik heb het bovenaanzicht van de Atecc608a toegevoegd omdat het een 8-afleidingen SOIC is, dus de chip is erg klein. Als je dat liever hebt, dus leveranciers bouwen een bord met het chipsoldeer, kan het voor jou gemakkelijker zijn.

Waarschuwing: In mijn geval moet ik een weerstand toevoegen tussen de SDA van de Arduino en de Chip (ook voor de SDL). Ik heb voor elk een weerstand van 4,7 Kohm toegevoegd.

Stap 4: 2. Configuratie van de chip (Atecc608a)

Voordat u de functie van codering of decodering gebruikt, moet u de chip configureren. In deze stap zal ik alle stappen beschrijven die u moet doen voor de configuratie van deze chip.

Waarschuwing: deze stap is erg belangrijk en als u de zones voor het einde vergrendelt, kunt u ze niet wijzigen.

Zoals eerder uitgelegd, heeft deze chip twee zones:

1. Configuratiezone
2. Gegevenszone

De configuratiezone heeft een grootte van 128 bytes, maar de eerste 16 bytes kunnen niet worden gewijzigd.

Om deze chip te configureren, moet u twee die stap volgen. Het is erg belangrijk om alle stappen in volgorde te volgen, anders werkt uw configuratie niet en wordt uw chip vergrendeld en onbruikbaar. Die stappen zijn:

1. Een configuratiesjabloon maken
2. Schrijf dit sjabloon naar de chip
3. De configuratiezone vergrendelen
4. Schrijf uw AES-sleutel (128 bits) in een sleuf
5. De gegevenszone vergrendelen

Informatie

Hieronder beschrijf ik elke stap van de configuratie met mijn code, maar geen zorgen, ik heb een volledig voorbeeld van configuratie toegevoegd in mijn Github. Ik plaats opmerkingen over elke functie en een *.ino-bestand is bij elke stap voor u beschikbaar.

• Mijn Github: Mijn Github
• Pad van voorbeeldconfiguratie: configuration_example.ino

Eerste stap: een configuratiesjabloon maken

Zoals eerder uitgelegd, krijgt de configuratiezone een grootte van 128 bits, maar de eerste 16 bits kunnen niet worden gewijzigd. Deze zone bestaat uit meerdere delen, maar u hoeft slechts 3 delen van deze configuratiezone te kennen voor dit project:

1. The Bytes 16 -> Dit is het I2C-adres van de chip
2. De Bytes 20 tot 51 -> U kunt hier het type slot voor de 16 slots van deze chip wijzigen
3. De Bytes 96 tot 127 -> U kunt hier het type sleutel of data instellen dat in elke sleuf wordt gebruikt.

(Als u meer uitleg over al deze zones nodig heeft, lees dan de documentatie (pagina 13, sectie 2.2))

Hier heb ik elke bytes / delen van de 112 bytes van de configuratie van een chip in detail weergegeven. Dit is een voorbeeld, elke gekochte chip kan een andere configuratie hebben:

0xC0, // I2C-adres

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, 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, // Sleutelconfiguratiesleuf 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 // Sleutelconfiguratiesleuf 16

Zoals u ziet, heb ik enkele opmerkingen in deze code geplaatst om deze configuratie beter te begrijpen.

In uw geval hoeft u slechts drie dingen te begrijpen:

1. The Bytes 16 -> Dit is het I2C-adres van de chip
2. De Bytes 20 tot 51 -> U kunt hier het type slot voor de 16 slots van deze chip wijzigen
3. De Byte 96 tot 127 -> U kunt hier het type sleutel of data instellen dat in elke sleuf wordt gebruikt.

Ik zal het type configuratie niet uitleggen en waarom ik deze heb gebruikt en niet een andere, omdat het ingewikkeld is om alles uit te leggen. Als u meer informatie nodig heeft, ga dan naar de documentatie, pagina 16 sectie 2.2.1 voor "SlotConfig" en pagina 19 sectie 2.2.5 voor "KeyConfig"

Voor dit voorbeeld gebruik je slot 9 om een AES-sleutel op te slaan.

Hiervoor moeten we plaatsen (als je dat nodig hebt, kun je het bovenstaande voorbeeld kopiëren, de wijziging is erin gedaan):

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

Waarom heb ik deze configuratie ingesteld: Voor elk slot van deze chip kun je parameters instellen om aan de chip te zeggen welk type gegevens wordt opgeslagen. Je hebt meerdere parameters:

• Slot kan worden geschreven of gelezen (actie wissen of coderen)
• Type opgeslagen gegevens (ECC-sleutel, openbare sleutel, SHA-hash, AES-sleutel …)
• Slot kan afsluitbaar zijn
• Generatie van sleutel is toegestaan
• …

Met de byte 36 en 37 ingesteld op "0x0F8F":

• Gegevens kunnen worden geschreven in de Clear
• De inhoud van dit slot is geheim en kan niet worden gelezen
• Sleuf kan niet worden gebruikt voor de opdracht CheckMac Copy

Met de byte 112 en 113 ingesteld op "0x001A":

Slot kan maximaal vier AES 128-bit symmetrische sleutels opslaan (KeyType = 0x6)

Tweede stap: Schrijf deze configuratie

Deze stap is erg belangrijk omdat we de chip met onze configuratie zullen instellen en als deze configuratie niet goed is, gebruikt u deze chip.

Maar geen zorgen, zolang de configuratie niet is vergrendeld, kunt u uw configuratie wijzigen.

Hier is dit de code die wordt gebruikt om de configuratie naar de chip te schrijven:

/** \brief Schrijf een nieuwe configuratie naar de chip.

* \param[in] cfg Logische interfaceconfiguratie. Sommige voorgedefinieerde * configuraties zijn te vinden in atca_cfgs.h * \param[in] config Array uint8_t van configuratie (lengte 112) * \param[in] len Grootte van de configuratiearray * \return ATCA_SUCCESS bij succes, anders een foutcode. */ ATCA_STATUS write_configuration(ATCAIfaceCfg *cfg, uint8_t *config, size_t len) {if (len! = 112) retourneer ATCA_BAD_PARAM; ATCA_STATUS-status; status = atcab_init(cfg); if (status == ATCA_SUCCESS) {// Schrijf de configuratiearray naar de chip // Padding van 16 byte (16 eerste bytes kunnen niet worden geschreven) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *)config, len); retourstatus; } retourstatus; }

Deze functie schrijft uw configuratie in de chip.

Derde stap: vergrendel de configuratie Zone

Waarschuwing: wees voorzichtig met deze stap, als u deze zone vergrendelt en uw configuratie niet goed is, is de chip onbruikbaar en kunt u deze zone niet wijzigen

Voor deze actie gebruiken we deze functie:

/** \brief Controleer of de DATA_ZONE of CONFIG_ZONE is vergrendeld

* \param[in] cfg Logische interfaceconfiguratie. Sommige voorgedefinieerde * configuraties zijn te vinden in atca_cfgs.h * \param[in] zone LOCK_ZONE_DATA of LOCK_ZONE_CONFIG * \return ATCA_SUCCESS bij succes, anders een foutcode. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) { ATCA_STATUS-status; bool lock = onwaar; if (zone != (uint8_t)LOCK_ZONE_CONFIG && zone != (uint8_t)LOCK_ZONE_DATA) retourneer ATCA_BAD_PARAM; status = 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; } retourneer ATCA_SUCCESS; } retourneer ATCA_BAD_PARAM; } check_lock_zone(&cfg, LOCK_ZONE_CONFIG);

Vierde stap: schrijf je AES-sleutel in een slot

In dit deel plaatst u uw persoonlijke AES-sleutel in het slot dat u hebt gedefinieerd in de configuratie van de chip.

Voor dit voorbeeld gebruik ik slotnummer 9 van de chip.

U moet weten: Een speciaal kenmerk van deze chip is dat u gegevens in een slot slechts met 4 bytes of 32 bytes kunt schrijven. Voor AES hebben we 128 bits Key nodig, dus 16 bytes aan data. Dus besloot ik naar een sleutel van elk 16 bytes in deze sleuf te schrijven om 32 bytes aan gegevens te hebben.

Nu zal ik je de gebruikte code laten zien:

/** \brief Schrijf de AES-sleutel in een bepaalde sleuf. * \param[in] cfg Logische interfaceconfiguratie. Sommige voorgedefinieerde * configuraties zijn te vinden in atca_cfgs.h * \param[in] key key slot number * \param[in] datakey key array uint8_t * \param[in] len Grootte van de key array * \return ATCA_SUCCESS bij succes, anders een foutcode. */ 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) retourneer 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) retourstatus; } retourstatus; }

Voor dit voorbeeld gebruik ik twee AES-sleutels van elk 16 bytes:

// Voorbeeld van AES KEY (len 32)uint8_t example_of_key[32] = "AAAAAAAAAAAAAAAAAAAAAAAAAAA"; write_key_slot(&cfg, 9, voorbeeld_van_key, sizeof(example_of_key));

Als deze actie goed is, moet je nu de laatste stap "lock the data zone" doorlopen

Laatste stap: de gegevenszone vergrendelen

Waarschuwing: wees voorzichtig met deze stap, als u deze zone vergrendelt en uw gegevens niet zijn ingesteld, is de chip onbruikbaar en kunt u deze zone niet wijzigen

Voor deze actie gebruiken we deze functie:

/** \brief Controleer of de DATA_ZONE of CONFIG_ZONE is vergrendeld

* \param[in] cfg Logische interfaceconfiguratie. Sommige voorgedefinieerde * configuraties zijn te vinden in atca_cfgs.h * \param[in] zone LOCK_ZONE_DATA of LOCK_ZONE_CONFIG * \return ATCA_SUCCESS bij succes, anders een foutcode. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) { ATCA_STATUS-status; bool lock = onwaar; if (zone != (uint8_t)LOCK_ZONE_CONFIG && zone != (uint8_t)LOCK_ZONE_DATA) retourneer ATCA_BAD_PARAM; status = 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; } retourneer ATCA_SUCCESS; } retourneer ATCA_BAD_PARAM; } check_lock_zone(&cfg, LOCK_ZONE_DATA);

Als deze actie goed is, is je chip klaar voor gebruik

Stap 5: 3. Gebruik van de AES CBC-module

Ik zal uitleggen hoe je gegevens versleutelt en ontsleutelt met het algoritme AES CBC en de chip Atecc608a.

Onthoud: Voordat u deze functie gebruikt, moet u de chip instellen. Volg hiervoor stap 2 van dit artikel

Deze chip heeft meerdere typen AES-modules (AES 128 bits), alleen AES 128 bits is mogelijk:

1. AES normaal
2. AES CBC
3. AES GCM (met GFM-hash) (zie wikipedia voor meer uitleg)

Om het gebruik gemakkelijker te maken, heb ik twee functies gemaakt:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Die twee functies zijn beschikbaar op mijn Github.

uitleg

Ik kies ervoor om het AES CBC-algoritme te gebruiken omdat het veiliger is dan de standaard AES 128 bits. Dit algoritme gebruikt een initiële vector om uw gegevens te versleutelen.

Informatie

Hieronder beschrijf ik elke stap van de coderings- en decoderingsmethode. Maar ik schreef een code voor de Arduino die beide functies gebruikt. Je kunt deze code zien in mijn Github:

• Github: Mijn Github
• Voorbeeld van code "Encrypt/Decrypt": AES_crypto_example.ino

Eerste stap: versleutel uw gegevens

In dit deel laat ik u zien hoe u uw gegevens kunt versleutelen.

Eerst heb je deze functie nodig:

/** \brief Gegevens versleutelen met AES CBC-algoritme * \param[in] cfg Logische interfaceconfiguratie. Sommige voorgedefinieerde * configuraties zijn te vinden in atca_cfgs.h * \param[in] data Woorden naar encypt (moet worden gedeeld door 16, maximale lengte 240) * \param[in] len lengte van Words naar encypt (moet worden gedeeld door 16, max lengte 240) * \param[out] iv Initial Vector gebruikt in de AES CBC (retourneer de vector in deze var) * \param[out] ciphertext geef hier de Cypher-tekst terug * \param[in] key Slotnummer van de key * \return ATCA_SUCCESS bij succes, anders een foutcode. */ 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")); retourneer 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); opbrengst; } 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); } retourstatus; } retourstatus; }

Deze functie is eenvoudig te gebruiken, je moet twee dingen instellen:

1. Een lege IV (initiële vector) van 16 bytes
2. Gegevens om te coderen (max. grootte 240 bytes)

Hier een voorbeeld "hoe deze functie te gebruiken".

Ik wil het woord "AAAAAAAAAAAAAAA" versleutelen met mijn sleutel in slotnummer "9":

ATCA_STATUS-status = atcab_init(&cfg); if (status!= ATCA_SUCCESS) {Serial.println(F("atcab_init() failed: Code -> 0x")); Serial.println(status, HEX); } uint8_t plaintext[16] = "AAAAAAAAAAAAAAA"; // Originele tekst uint8_t iv [IV_LENGTH_CBC]; // Initial Vector uint8_t cypherdata [sizeof(plaintext)]; // Gegevens versleutelde status = aes_cbc_encrypt(&cfg, platte tekst, sizeof(platte tekst), iv, cypherdata, 9);

Als de actie goed is, heb je de versleutelde gegevens in de variabele "cypherdata" en de initiële vector in de variabele "IV".

Bewaar die twee variabelen om je tekst te decoderen!

Tweede stap: ontsleutel uw gegevens

Om uw gegevens te decoderen heeft u twee dingen nodig:

1. De eerste vector
2. De Cypher-gegevens (versleutelde gegevens)

Om uw gegevens te decoderen, heeft u deze functie nodig:

/** \brief Gegevens ontsleutelen met AES CBC-algoritme * \param[in] cfg Logische interfaceconfiguratie. Sommige voorgedefinieerde * configuraties zijn te vinden in atca_cfgs.h * \param[in] cijfertekst Te ontcijferen woorden (moet worden gedeeld door 16, maximale lengte 240) * \param[in] len lengte van te ontcijferen woorden (moet worden gedeeld door 16, max lengte 240) * \param[in] iv Initiële vector voor gebruik in de AES CBC * \param[uit] platte tekst retourneer hier de gedecodeerde tekst * \param[in] sleutel Slotnummer van de sleutel * \return ATCA_SUCCESS bij succes, anders een foutcode. */ 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")); retourneer 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); opbrengst; } 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); } retourstatus; } retourstatus; }

Ik wil mijn eerdere gegevens decoderen (zie hieronder, Eerste stap). Hiervoor ga ik dit doen:

uint8_t plaintext[16] = "AAAAAAAAAAAAAAA"; uint8_t iv[IV_LENGTH_CBC]; uint8_t cypherdata [grootte van (platte tekst)]; uint8_t decodeergegevens [grootte van (platte tekst)]; status = aes_cbc_decrypt(&cfg, cypherdata, sizeof(cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) { Serial.print("Gedecodeerde tekst is: "); for (size_t i = 0; i < sizeof(decryptdata); i++) { Serial.print((char)decryptdata); } Serieel.println(""); } else { // Zie bestand atca_status.h voor de code Error Serial.print(F("Onmogelijk om te decoderen | Code Error 0x")); Serial.println(status, HEX); opbrengst; }

Als de actie goed is, heb je de gedecodeerde gegevens in de variabele "decryptdata".

Nu weet je hoe je encryptie en decryptie moet gebruiken met de chip Atecc608a

Stap 6: 5. Waarom moet u deze chip gebruiken?

Versleutelde gegevens zijn erg handig omdat u uw informatie kunt verbergen en draadloos kunt verzenden of gewoon kunt opslaan.

Hier een voorbeeld van gebruik:

1. Opgeslagen gegevens naar een externe EEPROM: u kunt gegevens van een externe EEPROM beveiligen en als iemand deze EEPROM nog steeds heeft, heeft hij de sleutel en de IV nodig voor de decodering
2. Draadloze gegevens verzenden: u kunt deze versleutelde gegevens draadloos verzenden (nrf24L01, RFM95W…) en als iemand uw gegevens onderschept, zijn deze gegevens veilig
3. Opgeslagen wachtwoord
4. …

Met deze chip kun je meerdere dingen doen. Het kan in meerdere projecten worden gebruikt. Als je tijd hebt, zeg me in welk project je deze chip gaat gebruiken?

Nog een laatste advies: als je een draadloos project bouwt of onbewerkte gegevens opslaat, wees dan voorzichtig, beveiliging is erg belangrijk en als je weet hoe eenvoudig het is voor een "noob" om je gegevens te onderscheppen of te stelen. Nu met internet, kan iedereen scripts op zijn computer laten starten om je te "hacken"!

Stap 7: Conclusie

Ik hoop dat dit artikel nuttig voor u zal zijn. Sorry als ik een fout heb gemaakt in mijn tekst, maar Engels is niet mijn hoofdtaal en ik spreek beter dan ik schrijf.

Bedankt voor het lezen van alles.

Geniet ervan.