Suojaus Arduinolla: Atecc608a: 7 vaihetta

2024 Kirjoittaja: John Day | [email protected]. Viimeksi muokattu: 2024-01-30 09:00

Aihe

Hei kaikki !

Tämä on ensimmäinen Instructables -artikkelini, joten toivon sen olevan mielenkiintoinen teille kaikille.

Tässä artikkelissa selitän sinulle kuinka käyttää mikrosirua nimeltä "ATECC608A", joka tarjoaa useita suojaustyökaluja.

Tämä siru on MicroChipin suunnittelema ja se on "CryptoAuthentication -sirun" viimeinen versio. Ennen tätä versiota oli "ATSHA204A" ja "ATECC508A".

Miksi päätin käyttää viimeistä versiota, en edellisenä?

Tämä versio on edistyksellisin siru ja siinä on toimintoja, joita vanhassa versiossa ei ole (esimerkiksi: AES -moduuli, IO -suojausmoduuli …).

Miksi tämä projekti?

Työskentelen CyberSecurityn alalla ja kuten kaikki, rakastin ohjelmointia ja elektroniikkaa. Opintojeni aikana saan konferenssin IoT Security -asiantuntijan kanssa, joka osoitti meille, että Industrial ei käytä tietoturvaa IoT -objektissaan. Näytin meille riippulukon, joka voidaan avata älypuhelimellasi Bluetoothilla. Riippulukossa oli lause "Tämä riippulukko on turvallisin kuin avainlukko!". Tämä lause saa hänet hymyilemään ja hän muutti lausetta "Tämä riippulukko on kaikkien aikojen pahin riippulukko!".

Hän osoitti meille omalla tietokoneellaan ja Bluetooth -haukulla, että jokainen älypuhelimen lähettämä komento on sama joka kerta, ja on erittäin yksinkertaista kopioida tämä komento ja lähettää se älypuhelimesi kanssa. Hän selitti meille, että "turvallisuus" "teollisuudelle" ei ole suurin ongelma. Hän näytti meille pelimerkkejä (alle 0,60 dollaria), jotka voisivat lisätä suojakerroksen näihin kohteisiin.

Tämän esittelyn jälkeen yritin löytää jonkin avoimen lähdekoodin projektin, joka lisää suojakerroksen IoT -objektiin, mutta en koskaan löytänyt sitä.

Joten päätin työskennellä projektin parissa, joka käyttää suojaustasoa kahden IoT -objektin väliseen viestintään.

Mikä on ajatukseni?

Kahden IoT -objektin välisen viestinnän aikana voi esiintyä useita hyökkäyksiä: Man Of the mild, Copy of information ja paljon muuta. Ideani on siis hyvin yksinkertainen:

1. Salatun datan hyödyntäminen kahden tai useamman IoT -objektin välillä.
2. Edulliset tarvikkeet
3. Voi työskennellä Arduino UNO: n kanssa

Nyt selitän sinulle, kuinka toteutin tämän abstraktin kuvan Arduinolla ja Atecc608a -sirulla. Tässä artikkelissa selitän sinulle, miten Arduino UNO: ta käytetään ATECC608A: n kanssa.

Kirjoitan seuraavan kerran artikkelin kahden kohteen viestinnästä.

Tarvikkeet

Tarvitset muutamia asioita tähän projektiin:

1. Arduino UNO tai MEGA (sirun on oltava Atmega 328 tai ATMEGA 2560)
2. Atecc608A -siru (maksaa alle 0,80 dollaria, helppo löytää toimittajan verkkosivustolta)
3. 8-nastainen SOIC-sovitin
4. Jotkut johdot ja vastukset

Tämän sirun edellisen version (Atecc508a) tietolomake on saatavilla täältä -> Tietolomake Atecc508a

Vaihe 1: Vaihe vaiheelta

Tässä artikkelissa näytän sinulle, kuinka tämän sirun kokoonpanoa muutetaan ja kuinka tiedot salataan AES CBC -algoritmin avulla.

Noudatamme näitä vaiheita:

1. Piirin suunnittelu
2. Tämän sirun kokoonpano
3. AES CBC -moduulin käyttö
4. Miksi sinun on käytettävä tätä sirua

Kerron jokaisesta vaiheesta kaiken puolestasi. Lisäsin myös koodini Githubiini kommentteina jokaiselle toiminnolle. Jos sinulla on kysymyksiä koodistani tai tästä projektista, vastaan mielelläni siihen.

Oma Github: Oma Github

Vaihe 2: Varoitus Atecc608a -laitteesta

Atecc608a -siru ei ole "helppo" siru.

Ensinnäkin tämän sirun dokumentaatio on NDA: n alla, joten et löydä sitä täydellisesti Internetistä. Mutta ei ongelmaa, edellisen version tietolomake on saatavana Internet -tietolomakkeesta ATECC508A.

Toiseksi, kun käytät tätä sirua, sinun on lukittava sen kokoonpano ja sirun kokoonpanoa on mahdotonta muuttaa, jos se on lukittu. Joten ole varovainen, kun lukitset Config Zone ja Data Zone.

Kolmanneksi kirjasto, joka on kirjoitettu C -kirjaimella, on erittäin suuri ja täydellinen, joten sinun on luettava aiemmin käyttämiesi toimintojen dokumentaatio.

Neljänneksi kirjasto kirjoitti, että tämä siru ei toimi Arduino UNO: ssa, mutta se lisäsi, että toiminnot tarvitsevat sitä toimimaan Arduino UNO: n kanssa.

Siru ATECC608A

Voit kommunikoida tämän sirun kanssa I2C: n avulla. Tämän sirun osoitetta voidaan muuttaa kokoonpanossa.

Tämä siru sisältää 16 eri paikkaa, jotka voivat sisältää erityyppisiä tietoja:

1. ECC -avain (yksityinen tai julkinen)
2. AES -avain
3. Muut tiedot (kuten Sha hash tai vain sanat)

Tässä tapauksessa tallennamme AES -avaimen yhteen paikkaan.

Vaihe 3: 1. Piirin suunnittelu

1. Piirin suunnittelu

Tämän piirin kaava on hyvin yksinkertainen!

Sinun on käytettävä 3,3 V: n virtaa, koska suositus on 2,0 V - 5,5 V, mutta käytin mieluummin 3,3 V: ta.

Tätä sirua varten tavallisesti sinulla on piste sirun kulmassa, tämä piste on tämän kortin tappi 1. Lisäsin Atecc608a: n ylhäältä ja PIN-numeron, koska se on 8-kytkentäinen SOIC, joten siru on hyvin pieni.

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)

Sinun on käytettävä 3,3 V: n virtaa, koska suositus on 2,0 V - 5,5 V, mutta käytin mieluummin 3,3 V: ta.

Lisäsin Atecc608a: n ylhäältä, koska se on 8-kytkentäinen SOIC, joten siru on hyvin pieni. Jos haluat, niin toimittajat rakentavat jonkin levyn sirujuotoksella, se voi olla helpompaa sinulle.

Varoitus: Minun tapauksessani minun on lisättävä vastus Arduinon SDA: n ja sirun väliin (myös SDL: lle). Lisäsin 4,7 ohmin vastuksen kullekin.

Vaihe 4: 2. Sirun määritys (Atecc608a)

Ennen kuin käytät salaus- tai salauksenpurkutoimintoa, sinun on määritettävä siru. Tässä vaiheessa kerron yksityiskohtaisesti kaikki vaiheet, jotka sinun on tehtävä tämän sirun konfiguroimiseksi.

Varoitus: tämä vaihe on erittäin tärkeä ja jos lukitset vyöhykkeet ennen loppua, et voi muokata niitä.

Kuten aiemmin selitettiin, tällä sirulla on kaksi vyöhykettä:

1. Määritä alue
2. Tietoalue

Kokoonpanovyöhykkeen koko on 128 tavua, mutta ensimmäisiä 16 tavua ei voi muokata.

Tämän sirun määrittämiseksi sinun on suoritettava kaksi vaihetta. On erittäin tärkeää seurata jokaista vaihetta järjestyksessä, muuten kokoonpanosi ei toimi, ja sirusi lukitaan ja se on käyttökelvoton. Nämä vaiheet ovat:

1. Luo määritysmalli
2. Kirjoita tämä malli sirulle
3. Lukitse Config Zone
4. Kirjoita AES -avaimesi (128 bittiä) paikkaan
5. Lukitse tietoalue

Tiedot

Alla kerron yksityiskohtaisesti jokaisen kokoonpanon vaiheen koodillani, mutta ei hätää, lisäsin täydellisen esimerkin määrityksistä Githubiin. Kommentoin jokaista toimintoa, ja *.ino -tiedosto on saatavana jokaisessa vaiheessa, jotta voit.

• Oma Github: Oma Github
• Esimerkkikokoonpanon polku: configuration_example.ino

Ensimmäinen vaihe: Luo määritysmalli

Kuten aiemmin selitettiin, kokoonpanovyöhyke saa 128 bitin koon, mutta ensimmäisiä 16 bittiä ei voi muuttaa. Tämä vyöhyke koostuu useista osista, mutta sinun on tiedettävä vain 3 osaa tästä konfigurointivyöhykkeestä tälle projektille:

1. Tavut 16 -> Tämä on sirun I2C -osoite
2. Tavut 20-51 -> Tässä voit muuttaa tämän sirun 16 korttipaikan korttipaikkaa
3. Tavut 96 -127 -> Tässä voit asettaa kullekin korttipaikalle käytettävän avaimen tai datan tyypin.

(Jos tarvitset enemmän selitystä koko vyöhykkeelle, lue dokumentaatio (sivu 13, kohta 2.2))

Tässä laitan yksityiskohtia sirun kokoonpanon 112 tavun jokaiseen tavuun/osaan. Tässä on esimerkki, jokaisella ostetulla sirulla voi olla eri kokoonpano:

0xC0, // I2C -osoite

0x00, 0x00, 0x00, 0x83, 0x20, // Paikan määrityspaikka 1 0x85, 0x20, // Paikan määrityspaikka 2 0x8F, 0x20, // Paikan määrityspaikka 3 0xC4, 0x8F, // Paikan määrityspaikka 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, // Paikan määrityspaikka 10 0x8F, 0x0F, // Paikkamäärityspaikka 11 0x8F, 0x0F, // Paikkamäärityspaikka 12 0x8F, 0x0F, // Paikkamäärityspaikka 13 0x00, 0x00, // Paikkamäärityspaikka 14 0x00, 0x00, // Paikan määrityspaikka 15 0xAF, 0x8F, // Paikkamäärityspaikka 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, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00 0x00, 0x00, 0x33, 0x00, // Avainkonfiguraatio 1 0x33, 0x00, // Avainmäärityspaikka 2 0x33, 0x00, // Avainkonfiguraatiopaikka 3 0x1C, 0x00, // Avainkonfiguraatiopaikka 4 0x1C, 0x00, // Avainmäärityspaikka 5 0x 1C, 0x00, // Avainkonfiguraatio 6 0x1C, 0x00, // Avainkonfiguraatiopaikka 7 0x3C, 0x00, // Avainkonfiguraatiopaikka 8 0x1A, 0x00, // Avainkonfiguraatiopaikka 9 0x3A, 0x00, // Avainkonfiguraatio 10 0x1A, 0x00, // Avainkonfiguraatiopaikka 11 0x3A, 0x00, // Avainkonfiguraatiopaikka 12 0x3A, 0x00, // Avainkonfiguraatiopaikka 13 0x3C, 0x00, // Avainkonfiguraatiopaikka 14 0x3C, 0x00, // Avainmäärityspaikka 15 0x1C, 0x00 // Avainkonfiguraatiopaikka 16

Kuten näen, laitoin tähän koodiin joitain kommentteja ymmärtääkseni enemmän tätä kokoonpanoa.

Sinun tapauksessasi sinun on ymmärrettävä vain kolme asiaa:

1. Tavut 16 -> Tämä on sirun I2C -osoite
2. Tavut 20-51 -> Tässä voit muuttaa tämän sirun 16 korttipaikan tyypin
3. Tavu 96 -127 -> Tässä voit asettaa kullekin korttipaikalle käytettävän avaimen tai datan tyypin.

En selitä kokoonpanotyyppiä ja miksi käytin tätä eikä toista, koska kaiken selittäminen on monimutkaista. Jos tarvitset lisätietoja, siirry dokumentaatioon, sivun 16 osio 2.2.1 "SlotConfig" ja sivu 19 osio 2.2.5 "KeyConfig"

Tässä esimerkissä käytät korttipaikkaa 9 AES -avaimen tallentamiseen.

Tätä varten meidän on asetettava (jos tarvitset, voit kopioida yllä olevan esimerkin, muutos on tehty siihen):

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

Miksi asetin tämän kokoonpanon: Tämän sirun jokaiselle paikalle voit asettaa parametrit, jotka sanovat sirulle, millaisia tietoja tallennetaan. Sinulla on useita parametreja:

• Paikka voidaan kirjoittaa tai lukea (tyhjentää tai salata)
• Tallennettujen tietojen tyyppi (ECC -avain, julkinen avain, SHA -hajautus, AES -avain…)
• Paikka voi olla lukittavissa
• Avaimen luominen on sallittua
• …

Kun tavu 36 ja 37 on asetettu arvoon "0x0F8F":

• Tiedot voidaan kirjoittaa Cleariin
• Tämän paikan sisältö on salainen eikä sitä voi lukea
• Paikkaa ei voi käyttää CheckMac Copy -komennolle

Kun tavu 112 ja 113 on asetettu arvoon "0x001A":

Paikka voi tallentaa enintään neljä AES 128-bittistä symmetristä avainta (KeyType = 0x6)

Toinen vaihe: Kirjoita tämä kokoonpano

Tämä vaihe on erittäin tärkeä, koska asetamme sirun kokoonpanollemme ja jos tämä kokoonpano ei ole hyvä, käytät tätä sirua.

Mutta ei hätää, niin kauan kuin määrityksiä ei ole lukittu, voit muuttaa kokoonpanoasi.

Tässä tämä koodi, jota käytettiin konfiguraation kirjoittamiseen sirulle:

/** / lyhyt Kirjoita sirulle uusi kokoonpano.

* / param [in] cfg Loogisen rajapinnan määritys. Joitakin ennalta määritettyjä * kokoonpanoja löytyy osoitteesta atca_cfgs.h * / param [in] config Array uint8_t kokoonpanosta (pituus 112) * / param [in] len Konfiguraatiotaulukon koko * / return ATCA_SUCCESS on onnistunut, muuten virhekoodi. */ ATCA_STATUS write_configuration (ATCAIfaceCfg *cfg, uint8_t *config, size_t len) {if (len! = 112) return ATCA_BAD_PARAM; ATCA_STATUS -tila; tila = atcab_init (cfg); if (status == ATCA_SUCCESS) {// Kirjoita määritystaulukko sirulle // 16 tavun täyttö (16 ensimmäistä tavua ei voida kirjoittaa) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); palautustila; } palautustila; }

Tämä toiminto kirjoittaa kokoonpanosi sirulle.

Kolmas vaihe: lukitse konfigurointialue

Varoitus: ole varovainen tässä vaiheessa, jos lukitset tämän alueen ja kokoonpanosi ei ole hyvä, siru on käyttökelvoton etkä voinut muuttaa tätä aluetta

Tässä toiminnossa käytämme tätä toimintoa:

/** / lyhyt Tarkista, onko DATA_ZONE tai CONFIG_ZONE lukittu

* / param [in] cfg Loogisen rajapinnan määritys. Joitakin ennalta määritettyjä * kokoonpanoja löytyy osoitteesta atca_cfgs.h * / param [in] vyöhyke LOCK_ZONE_DATA tai LOCK_ZONE_CONFIG * / palauta ATCA_SUCCESS onnistuneesti, muuten virhekoodi. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS -tila; bool lock = epätosi; if (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) palauttaa ATCA_BAD_PARAM; tila = 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; } palauta ATCA_SUCCESS; } palauta ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Neljäs vaihe: Kirjoita AES -avain paikkaan

Tässä osassa asetat henkilökohtaisen AES -avaimen korttipaikkaan, jonka olet määrittänyt sirun kokoonpanossa.

Tässä esimerkissä käytän sirun paikkaa 9.

Sinun on tiedettävä: Tämän sirun erityispiirre on, että voit kirjoittaa dataa korttipaikkaan vain 4 tavua tai 32 tavua. AES: lle tarvitsemme 128 bitin avaimen eli 16 tavua dataa. Joten päätin kirjoittaa 16 tavun avaimelle tässä korttipaikassa, jotta saisimme 32 tavun tiedot.

Näytän nyt käytetyn koodin:

/** / lyhyt Kirjoita AES -avain tiettyyn paikkaan. * / param [in] cfg Loogisen rajapinnan määritys. Joitakin ennalta määritettyjä * kokoonpanoja löytyy osoitteesta atca_cfgs.h * / param [in] avainpaikan numero * / param [in] datakey -avainryhmä uint8_t * / param [in] len Avainryhmän koko * / return ATCA_SUCCESS on menestys, muuten vikakoodi. */ ATCA_STATUS write_key_slot (ATCAIfaceCfg *cfg, uint8_t -avain, uint8_t *datakey, size_t len) {if (avain 16) return ATCA_BAD_PARAM; if (len! = 32) return ATCA_BAD_PARAM; ATCA_STATUS -tila = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) -avain, 0, 0, datakey, 32); if (status! = ATCA_SUCCESS) paluu tila; } palautustila; }

Tässä esimerkissä käytän kahta 16 tavun AES -avainta:

// Esimerkki AES -KEY (len 32) uint8_t example_of_key [32] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; write_key_slot (& cfg, 9, example_of_key, sizeof (example_of_key)));

Jos tämä toiminto on hyvä, sinun on nyt suoritettava viimeinen vaihe "lukitse tietoalue"

Viimeinen vaihe: lukitse Data Zone

Varoitus: ole varovainen tässä vaiheessa, jos lukitset tämän vyöhykkeen ja tietoja ei ole asetettu, siru on käyttökelvoton etkä voinut muuttaa tätä aluetta

Tässä toiminnossa käytämme tätä toimintoa:

/** / lyhyt Tarkista, onko DATA_ZONE tai CONFIG_ZONE lukittu

* / param [in] cfg Loogisen rajapinnan määritys. Joitakin ennalta määritettyjä * kokoonpanoja löytyy osoitteesta atca_cfgs.h * / param [in] vyöhyke LOCK_ZONE_DATA tai LOCK_ZONE_CONFIG * / palauta ATCA_SUCCESS onnistuneesti, muuten virhekoodi. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS -tila; bool lock = epätosi; if (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) palauttaa ATCA_BAD_PARAM; tila = 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; } palauta ATCA_SUCCESS; } palauta ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Jos tämä toiminto on hyvä, sirusi on valmis käytettäväksi

Vaihe 5: 3. AES CBC -moduulin käyttö

Selitän kuinka salata ja purkaa tiedot algoritmilla AES CBC ja sirulla Atecc608a.

Muista: Ennen kuin käytät tätä toimintoa, sinun on määritettävä siru. Noudata tätä varten tämän artikkelin vaihetta 2

Tämä siru sai useita AES -moduuleja (AES 128 bittiä), vain AES 128 bittiä on mahdollista:

1. AES normaali
2. AES CBC
3. AES GCM (GFM -tiivisteellä) (katso lisätietoja wikipediasta)

Käytön helpottamiseksi olen luonut kaksi toimintoa:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Nämä kaksi toimintoa ovat käytettävissä Githubissani.

Selitys

Päätän käyttää AES CBC -algoritmia, koska se on turvallisempi kuin 128 AES -perusbitti. Tämä algoritmi käyttää alkuperäistä vektoria tietojen salaamiseen.

Tiedot

Alla kerron yksityiskohtaisesti salaus- ja salauksenpurkutavan jokaisen vaiheen. Mutta kirjoitin koodin Arduinolle, joka käyttää näitä molempia toimintoja. Näet tämän koodin Githubissani:

• Github: Oma Github
• Esimerkki koodista "Salaa/purkaa": AES_crypto_example.ino

Ensimmäinen vaihe: Salaa tietosi

Tässä osassa näytän sinulle, kuinka salaat tietosi.

Ensin tarvitset tätä toimintoa:

/** / lyhyt Salaa tiedot AES CBC -algoritmilla* / param [in] cfg Loogisen rajapinnan määritys. Joitakin ennalta määritettyjä * kokoonpanoja löytyy osoitteesta atca_cfgs.h * / param [in] data Salatut sanat (on jaettava 16: lla, enimmäispituus 240) * / param [in] len salattujen sanojen pituus (jaettava 16: lla, enimmäispituus 240) * / param [out] iv AES CBC: ssä käytetty alkuvektori (palauta vektori tässä muuttujassa) * / param [out] salakirjoitusteksti palauta tähän salakirjoitusteksti * / param [in] -näppäin avain * / palauta ATCA_SUCCESS onnistumisesta, muuten virhekoodi. */ ATCA_STATUS aes_cbc_encrypt (ATCAIfaceCfg *cfg, uint8_t *data, int len, uint8_t *iv, uint8_t *salakirjoitusteksti, uint8_t -avain) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC && len % 16! = 0) {Serial.print (F ("ERROR: ATCA_BAD_PARAM")); palauta ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS -tila = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, avain, 0, tmp_iv); if (tila! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (tila, HEX); palata; } muisti (iv, tmp_iv, IV_LENGTH_CBC); muisti (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] ja salakirjoitus [j * 16]); } if (tila! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (tila, HEX); } palautustila; } palautustila; }

Tämä toiminto on helppokäyttöinen, sinun on asetettava kaksi asiaa:

1. Tyhjä 16 tavun IV (alkuperäinen vektori)
2. Salatut tiedot (maksimi koko 240 tavua)

Tässä esimerkki "kuinka tätä toimintoa käytetään".

Haluan salata sanan "AAAAAAAAAAAAAAA" ja kirjoittaa avaimeni korttipaikan numeroon "9":

ATCA_STATUS status = atcab_init (& cfg); if (tila! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () epäonnistui: koodi -> 0x")); Serial.println (tila, HEX); } uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; // Alkuperäinen teksti uint8_t iv [IV_LENGTH_CBC]; // Alkuperäinen vektori uint8_t cypherdata [sizeof (tavallinen teksti)]; // Tietojen salattu tila = aes_cbc_encrypt (& cfg, selkeä teksti, sizeof (selväteksti), iv, salatiedot, 9);

Jos toiminta on hyvä, salatut tiedot ovat muuttujassa "cypherdata" ja Initial Vector muuttujassa "IV".

Säilytä nämä kaksi muuttujaa salataksesi tekstisi!

Toinen vaihe: purkaa tietojen salaus

Tietojen salauksen purkamiseen tarvitaan kaksi asiaa:

1. Alkuperäinen vektori
2. Cypher -tiedot (salatut tiedot)

Tietojen salauksen purkamiseen tarvitset tämän toiminnon:

/** / lyhyt Salauksen purkaminen AES CBC -algoritmilla* / param [in] cfg Loogisen rajapinnan määritys. Joitakin ennalta määritettyjä * kokoonpanoja löytyy osoitteesta atca_cfgs.h * / param [in] salakirjoitustekstit Purkavat sanat (on jaettava 16, maksimipituus 240) * / param [in] len pituus purettavista sanoista (jaettava 16: lla, enimmäispituus 240) * / param [in] iv AES CBC: ssä käytettävä alkuvektori * / param [out] selkeä teksti palauttaa tänne salatun tekstin * / param [in] -avain Avaimen paikan numero * / return ATCA_SUCCESS on success, muuten virhekoodi. */ ATCA_STATUS aes_cbc_decrypt (ATCAIfaceCfg *cfg, uint8_t *salakirjoitusteksti, int len, uint8_t *iv, uint8_t *pelkkä teksti, uint8_t -avain) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC || len % 16! = 0) {Serial.print (F ("ERROR Decrypt: ATCA_BAD_PARAM")); palauta ATCA_BAD_PARAM; } ATCA_STATUS status = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, avain, 0, iv); if (tila! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (tila, HEX); palata; } int max = len / 16; for (int j = 0; j <max; j ++) {status = atcab_aes_cbc_decrypt_block (& ctx, & salakirjoitusteksti [j * 16] ja tavallinen teksti [j * 16]); } if (tila! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (tila, HEX); } palautustila; } palautustila; }

Haluan purkaa aiempien tietojen salauksen (katso alla, Ensimmäinen vaihe). Tätä varten teen tämän:

uint8_t selkeä teksti [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (tavallinen teksti)]; uint8_t decryptdata [sizeof (tavallinen teksti)]; tila = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) {Serial.print ("Salattu teksti on:"); for (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Sarja.println (""); } else {// Katso koodista Virhe Serial.print tiedoston tiedosto atca_status.h (F ("Mahdoton salauksen purku | Koodivirhe 0x")); Serial.println (tila, HEX); palata; }

Jos toiminto on hyvä, salauksen purkamat tiedot ovat muuttujassa "decryptdata".

Nyt tiedät kuinka käyttää salausta ja salauksen purkua Atecc608a -sirun kanssa

Vaihe 6: 5. Miksi sinun on käytettävä tätä sirua

Salatut tiedot ovat erittäin hyödyllisiä, koska voit piilottaa tietosi ja lähettää ne langattomasti tai vain tallentaa ne.

Tässä muutama esimerkki hyödyntämisestä:

1. Tallennetut tiedot ulkoiseen EEPROM -järjestelmään: Voit suojata ulkoisen EEPROM -laitteen tiedot, ja jos joku edelleen käyttää tätä EEPROM -laitetta, hän tarvitsee avaimen ja IV -koodin salauksen purkuun.
2. Lähetä langattomia tietoja: Voit lähettää nämä salatut tiedot langattomasti (nrf24L01, RFM95W…) ja jos joku sieppaa tietosi, nämä tiedot ovat turvassa
3. Tallennettu salasana
4. …

Tällä sirulla voit tehdä useita asioita. Sitä voidaan käyttää useissa projekteissa. Jos sinulla on aikaa, kerro minulle, missä projektissa käytät tätä sirua?

Viimeinen neuvo, jos rakennat langatonta projektia tai tallennat raakadataa, ole varovainen, turvallisuus on erittäin tärkeää ja jos tiedät kuinka "noob" on helppo siepata tai varastaa tietosi. Nyt Internetin avulla jokaisella voi olla skriptejä käynnistääkseen tietokoneensa vain "hakatakseen" sinua!

Vaihe 7: Johtopäätös

Toivottavasti tästä artikkelista on sinulle hyötyä. Anteeksi, jos tein virheen tekstissäni, mutta englanti ei ole pääkieleni ja puhun paremmin kuin kirjoitan.

Kiitos, että luit kaiken.

Nauti siitä.