Saugumas naudojant „Arduino“: „Atecc608a“: 7 žingsniai

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:45

Tema

Sveiki visi !

Tai yra mano pirmasis instrukcinis straipsnis, todėl tikiuosi, kad jis bus įdomus jums visiems.

Šiame straipsnyje aš jums paaiškinsiu, kaip naudoti mikroschemą, pavadintą „ATECC608A“, kuri suteikia kelis saugos įrankius.

Šią mikroschemą sukūrė „MicroChip“ir tai yra paskutinė „CryptoAuthentication chip“versija. Prieš šią versiją buvo „ATSHA204A“ir „ATECC508A“.

Kodėl nusprendžiau naudoti paskutinę versiją, o ne ankstesnę?

Ši versija yra pažangiausia mikroschema ir turi funkcijų, kurių neturi senoji versija (pavyzdžiui: AES modulis, IO apsaugos modulis …).

Kodėl šis projektas?

Aš dirbu „CyberSecurity“srityje ir, kaip ir visi, man patiko programavimas ir elektronika. Studijų metu dalyvauju konferencijoje su specialistu, skirtu daiktų interneto saugai, kuris mums parodė, kad „Industrial“nenaudoja saugumo savo daiktų interneto objekte. Parodžiau spyną, kurią galima atidaryti naudojant išmanųjį telefoną „Bluetooth“ryšiu. Ant spynos buvo sakinys: „Ši spyna yra saugiausia nei rakto spyna!“. Šis sakinys privertė jį nusišypsoti ir jis pakeitė sakinį „Ši spyna yra blogiausia kada nors pastatyta spyna!“.

Jis parodė mums su savo asmeniniu kompiuteriu ir „Bluetooth“uostikliu, kad kiekviena išmaniojo telefono siunčiama komanda yra ta pati kiekvieną kartą ir labai paprasta šią komandą nukopijuoti ir išsiųsti su savo išmaniuoju telefonu. Jis mums paaiškino, kad „Pramonės“„saugumas“nėra pagrindinė problema. Jis parodė mums lustus (mažiau nei 0,60 USD), kurie galėtų pridėti šių objektų saugumo sluoksnį.

Po šios demonstracijos bandžiau rasti kokį nors atvirojo kodo projektą, kuris pridėtų apsaugos sluoksnį prie daiktų interneto objekto, bet niekada jo neradau.

Taigi nusprendžiau dirbti su projektu, kuris naudoja saugumo sluoksnį dviejų IoT objektų bendravimui.

Kokia mano idėja?

Bendraujant tarp dviejų daiktų interneto objektų gali būti kelios atakos: žmogus iš lengvos, informacijos kopija ir dar daugiau. Taigi mano idėja labai paprasta:

1. Šifruotų duomenų naudojimas tarp dviejų ar daugiau IoT objektų.
2. Pigios prekės
3. Gali dirbti su „Arduino UNO“

Dabar aš jums paaiškinsiu, kaip įgyvendinau šį abstraktų paveikslėlį su „Arduino“ir „Atecc608a“mikroschema. Šiame straipsnyje paaiškinsiu, kaip naudoti „Arduino UNO“su ATECC608A.

Kitą kartą parašysiu straipsnį apie dviejų objektų bendravimą.

Prekės

Šiam projektui jums reikia kelių dalykų:

1. „Arduino UNO“arba „MEGA“(lustas turi būti „Atmega 328“arba „ATMEGA 2560“)
2. „Atecc608A“lustas (kainuoja mažiau nei 0,80 USD, lengva rasti tiekėjo svetainėje)
3. 8 kontaktų SOIC adapteris
4. Kai kurie laidai ir rezistoriai

Ankstesnės šio lusto versijos (Atecc508a) duomenų lapą galite rasti čia -> Duomenų lapas Atecc508a

1 žingsnis: žingsnis po žingsnio

Šiame straipsnyje aš jums parodysiu, kaip pakeisti šio lusto konfigūraciją ir kaip užšifruoti duomenis naudojant AES CBC algoritmą.

Mes atliksime šiuos veiksmus:

1. Grandinės dizainas
2. Šio lusto konfigūracija
3. AES CBC modulio naudojimas
4. Kodėl jums reikia naudoti šį lustą?

Dėl kiekvieno žingsnio aš jums viską išsamiai aprašysiu. Be to, pridėjau savo kodą savo „Github“su kiekvienos funkcijos komentarais. Jei turite klausimų apie mano kodą ar šį projektą, mielai į juos atsakysiu.

Mano „Github“: „Mano Github“

2 žingsnis: Įspėjimas apie „Atecc608a“

„Atecc608a“lustas nėra „lengvas“lustas.

Pirma, šio lusto dokumentai yra NDA, todėl internete jo nerasite. Tačiau be jokių problemų, ankstesnės versijos duomenų lapą galima rasti interneto duomenų lape „Complete ATECC508A“.

Antra, kai naudojate šį lustą, turite užrakinti jo konfigūraciją ir neįmanoma pakeisti lusto konfigūracijos, jei jis užrakintas. Taigi būkite atsargūs, kai užrakinsite konfigūracijos zoną ir duomenų zoną.

Trečia, biblioteka, parašyta C, yra labai didelė ir išsami, todėl turite perskaityti anksčiau naudojamų funkcijų dokumentaciją.

Ketvirta, biblioteka parašė, kad šis lustas neveikia „Arduino UNO“, tačiau pridėjo funkcijų, kurių reikia norint dirbti su „Arduino UNO“.

Lustas ATECC608A

Su šiuo lustu galite bendrauti „I2C“. Šio lusto adresą galima pakeisti konfigūracijoje.

Šiame luste yra 16 skirtingų laiko tarpsnių, kuriuose gali būti skirtingų tipų duomenų:

1. ECC raktas (privatus arba viešas)
2. AES raktas
3. Kiti duomenys (pvz., „Sha hash“ar tik žodžiai)

Mūsų atveju AES raktą laikysime viename lizde.

3 žingsnis: 1. Grandinės projektavimas

1. Grandinės konstrukcija

Šios grandinės schema yra labai paprasta!

Turite naudoti 3,3 V maitinimą, nes rekomendacija yra nuo 2,0 V iki 5,5 V, bet aš norėjau naudoti 3,3 V.

Paprastai šis lustas turi tašką ant lusto kampo, šis taškas yra šios plokštės 1 kaištis. Pridėjau „Atecc608a“vaizdą iš viršaus su PIN numeriu, nes jis yra 8 laidų SOIC, todėl lustas yra labai mažas.

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)

Turite naudoti 3,3 V maitinimą, nes rekomendacija yra nuo 2,0 V iki 5,5 V, bet aš norėjau naudoti 3,3 V.

Pridėjau „Atecc608a“vaizdą iš viršaus, nes jis yra 8 laidų SOIC, todėl lustas yra labai mažas. Jei pageidaujate, todėl tiekėjai kuria tam tikrą plokštę su lusto lydmetaliu, jums gali būti lengviau.

Įspėjimas: mano atveju turiu pridėti rezistorių tarp „Arduino“SDA ir lusto (taip pat ir SDL). Kiekvienam pridėjau 4,7Kohm rezistorių.

4 veiksmas: 2. Lusto konfigūravimas (Atecc608a)

Prieš naudodami šifravimo ar iššifravimo funkciją, turite sukonfigūruoti lustą. Šiame žingsnyje aš išsamiai aprašysiu visus veiksmus, kuriuos reikia atlikti norint konfigūruoti šį lustą.

Įspėjimas: šis žingsnis yra labai svarbus ir jei užrakinate zonas iki pabaigos, negalite jų keisti.

Kaip paaiškinta anksčiau, šis lustas gavo dvi zonas:

1. Konfigūravimo zona
2. Duomenų zona

Konfigūracijos zona gavo 128 baitų dydį, tačiau pirmųjų 16 baitų keisti negalima.

Norėdami sukonfigūruoti šį lustą, turite atlikti du veiksmus. Labai svarbu sekti kiekvieną žingsnį, kad nesuveiktų jūsų konfigūracija, o lustas bus užrakintas ir netinkamas naudoti. Tie žingsniai yra šie:

1. Sukurkite konfigūracijos šabloną
2. Įrašykite šį šabloną į lustą
3. Užrakinkite konfigūracijos zoną
4. Įveskite AES raktą (128 bitai) į angą
5. Užrakinkite duomenų zoną

Informacija

Žemiau išsamiai aprašysiu kiekvieną sukonfigūracijos žingsnį su savo kodu, tačiau nesijaudinkite, pridėjau visą konfigūracijos pavyzdį savo „Github“. Pateikiu komentarus apie kiekvieną funkciją, o *.ino failas yra prieinamas kiekviename žingsnyje, kad jums būtų lengviau.

• Mano „Github“: „Mano Github“
• Konfigūracijos pavyzdžio kelias: configuration_example.ino

Pirmas žingsnis: sukurkite konfigūracijos šabloną

Kaip paaiškinta anksčiau, konfigūracijos zona yra 128 bitų dydžio, tačiau pirmųjų 16 bitų pakeisti negalima. Šią zoną sudaro kelios dalys, tačiau šiam projektui reikia žinoti tik 3 šios konfigūracijos zonos dalis:

1. Baitai 16 -> Tai lusto I2C adresas
2. Baitai nuo 20 iki 51 -> Čia galite pakeisti 16 lusto lizdų tipą
3. Baitai nuo 96 iki 127 -> Čia galite nustatyti rakto tipą arba duomenis, naudojamus kiekviename lizde.

(Jei jums reikia daugiau šios zonos paaiškinimų, perskaitykite dokumentus (13 psl., 2.2 skyrius))

Čia aš išsamiai įdedu kiekvieną lustų konfigūracijos 112 baitų baitus/dalis. Tai yra pavyzdys, kiekviena įsigyta mikroschema gali turėti skirtingą konfigūraciją:

0xC0, // I2C adresas

0x00, 0x00, 0x00, 0x83, 0x20, // Slot Config 1 lizdas 0x85, 0x20, // Slot Config 2 lizdas 0x8F, 0x20, // Slot Config Slot 3 0xC4, 0x8F, // Slot Config 4 lizdas 0x8F, 0x8F, // Slot Config Slot 5 0x8F, 0x8F, // Slot Config Slot 6 0x9F, 0x8F, // Slot Config 7 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 13 lizdas 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, 0xFF 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, // rakto konfigūracijos lizdas 1 0x33, 0x00, // rakto konfigūracijos lizdas 2 0x33, 0x00, // rakto konfigūracijos lizdas 3 0x1C, 0x00, // rakto konfigūracijos lizdas 4 0x1C, 0x00, // Raktų konfigūracijos lizdas 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 // Raktų konfigūracijos lizdas 16

Kaip matote, į šį kodą įdėjau keletą komentarų, kad geriau suprastumėte šią konfigūraciją.

Jūsų atveju reikia suprasti tik tris dalykus:

1. Baitai 16 -> Tai lusto I2C adresas
2. Baitai nuo 20 iki 51 -> Čia galite pakeisti 16 lusto lizdų tipą
3. Baitai nuo 96 iki 127 -> Čia galite nustatyti rakto tipą arba duomenis, naudojamus kiekviename lizde.

Aš nepaaiškinsiu konfigūracijos tipo ir kodėl aš naudoju šią, o ne kitą, nes viską paaiškinti sudėtinga. Jei jums reikia daugiau informacijos, eikite į dokumentaciją, 16 puslapio 2.2.1 skyrių „SlotConfig“ir 19 puslapio 2.2.5 skyrių „KeyConfig“

Šiame pavyzdyje AES raktui saugoti naudosite lizdą 9.

Tam turime įdėti (jei reikia, galite nukopijuoti aukščiau pateiktą pavyzdį, jame buvo atliktas pakeitimas):

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

Kodėl aš nustatiau šią konfigūraciją: kiekvienam šio lusto lizdui galite nustatyti parametrus, kurie pasakytų mikroschemai, kokio tipo duomenys bus saugomi. Turite kelis parametrus:

• Lizdas gali būti rašomas arba skaitomas (aiškus arba užšifruotas veiksmas)
• Saugomų duomenų tipas (ECC raktas, viešasis raktas, SHA maišymas, AES raktas …)
• Lizdas gali būti užrakinamas
• Leidžiama generuoti raktą
• …

Kai 36 ir 37 baitai nustatyti į „0x0F8F“:

• Duomenis galima įrašyti į „Clear“
• Šio lizdo turinys yra slaptas ir jo negalima perskaityti
• Lizdas negali būti naudojamas komandai „CheckMac Copy“

Kai 112 ir 113 baitai nustatyti į „0x001A“:

Lizdas gali saugoti iki keturių AES 128 bitų simetrinių raktų (KeyType = 0x6)

Antras žingsnis: parašykite šią konfigūraciją

Šis žingsnis yra labai svarbus, nes mes nustatysime lustą pagal savo konfigūraciją ir jei ši konfigūracija nebus gera, jūs naudosite šį lustą.

Tačiau nesijaudinkite, kol konfigūracija nėra užrakinta, galite keisti savo konfigūraciją.

Čia yra kodas, naudojamas konfigūracijai įrašyti į lustą:

/** / short Įrašykite naują mikroschemos konfigūraciją.

* / param [in] cfg Loginės sąsajos konfigūracija. Kai kurias iš anksto nustatytas * konfigūracijas galima rasti atca_cfgs.h * / param [in] config Masyvo uint8_t konfigūracija (ilgis 112) * / param [in] len Sąrankos masyvo dydis * / return ATCA_SUCCESS sėkmės atveju, kitaip - klaidos kodas. */ ATCA_STATUS write_configuration (ATCAIfaceCfg *cfg, uint8_t *config, size_t len) {if (len! = 112) return ATCA_BAD_PARAM; ATCA_STATUS būsena; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {// Į mikroschemą įrašykite konfigūracijos masyvą // 16 baitų užpildymas (16 pirmųjų baitų įrašyti negalima) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); grąžinimo būsena; } grąžinimo būsena; }

Ši funkcija įrašys jūsų konfigūraciją į lustą.

Trečias žingsnis: užrakinkite konfigūracijos zoną

Įspėjimas: būkite atsargūs atlikdami šį veiksmą, jei užrakinate šią zoną ir jūsų konfigūracija nėra gera, lustas yra netinkamas naudoti ir jūs negalite pakeisti šios zonos

Šiam veiksmui naudosime šią funkciją:

/** / trumpas Patikrinkite, ar DATA_ZONE arba CONFIG_ZONE nėra užrakintas

* / param [in] cfg Loginės sąsajos konfigūracija. Kai kurias iš anksto nustatytas * konfigūracijas galima rasti atca_cfgs.h * / param [in] zonoje LOCK_ZONE_DATA arba LOCK_ZONE_CONFIG * / grąžinti ATCA_SUCCESS sėkmės atveju, kitaip - klaidos kodas. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zona) {ATCA_STATUS status; bool lock = klaidinga; if (zona! = (uint8_t) LOCK_ZONE_CONFIG && zona! = (uint8_t) LOCK_ZONE_DATA) grąžins ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zona, & lock))) {return ATCA_FUNC_FAIL; } if (! lock) {return ATCA_NOT_LOCKED; } grįžti ATCA_SUCCESS; } grįžti ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Ketvirtas žingsnis: įrašykite jums AES raktą į angą

Šioje dalyje lizde, kurį apibrėžėte mikroschemos konfigūracijoje, nustatysite asmeninį AES raktą.

Šiame pavyzdyje naudosiu lusto 9 lizdo numerį.

Turite žinoti: ypatinga šio lusto savybė yra tai, kad galite įrašyti duomenis į lizdą tik 4 baitais arba 32 baitais. AES mums reikia 128 bitų rakto, taigi 16 baitų duomenų. Taigi aš nusprendžiau parašyti į 16 baitų raktą kiekviename šioje angoje, kad būtų 32 baitai.

Dabar parodysiu naudojamą kodą:

/** / short Įrašykite AES raktą į tam tikrą angą. * / param [in] cfg Loginės sąsajos konfigūracija. Kai kurias iš anksto nustatytas * konfigūracijas galima rasti atca_cfgs.h * / param [in] rakto rakto lizdo numeris * / param [in] datakey raktų masyvas uint8_t * / param [in] len Raktų masyvo dydis * / return ATCA_SUCCESS on success, kitu atveju klaidos kodas. */ ATCA_STATUS write_key_slot (ATCAIfaceCfg *cfg, uint8_t raktas, uint8_t *datakey, size_t len) {if (16 raktas) return ATCA_BAD_PARAM; if (len! = 32) return ATCA_BAD_PARAM; ATCA_STATUS statusas = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) raktas, 0, 0, datakey, 32); if (status! = ATCA_SUCCESS) grąžinimo būsena; } grąžinimo būsena; }

Šiame pavyzdyje naudosiu du AES raktus po 16 baitų:

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

Jei šis veiksmas yra geras, dabar turite atlikti paskutinį žingsnį „užrakinti duomenų zoną“

Paskutinis žingsnis: užrakinkite duomenų zoną

Įspėjimas: būkite atsargūs atlikdami šį veiksmą, jei užrakinsite šią zoną ir jūsų duomenys nebus nustatyti, lustas bus netinkamas naudoti ir jūs negalėsite pakeisti šios zonos

Šiam veiksmui naudosime šią funkciją:

/** / trumpas Patikrinkite, ar DATA_ZONE arba CONFIG_ZONE yra užrakinti

* / param [in] cfg Loginės sąsajos konfigūracija. Kai kurias iš anksto nustatytas * konfigūracijas galima rasti atca_cfgs.h * / param [in] zonoje LOCK_ZONE_DATA arba LOCK_ZONE_CONFIG * / grąžinti ATCA_SUCCESS sėkmės atveju, kitaip - klaidos kodas. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zona) {ATCA_STATUS status; bool lock = klaidinga; if (zona! = (uint8_t) LOCK_ZONE_CONFIG && zona! = (uint8_t) LOCK_ZONE_DATA) grąžins ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zona, & lock))) {return ATCA_FUNC_FAIL; } if (! lock) {return ATCA_NOT_LOCKED; } grįžti ATCA_SUCCESS; } grįžti ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Jei šis veiksmas yra geras, jūsų lustas yra paruoštas naudoti

5 žingsnis: 3. AES CBC modulio naudojimas

Paaiškinsiu, kaip užšifruoti ir iššifruoti duomenis naudojant algoritmą AES CBC ir lustą Atecc608a.

Atminkite: prieš naudodami šią funkciją, turite nustatyti lustą. Norėdami tai padaryti, atlikite šio straipsnio 2 veiksmą

Šis lustas gavo kelių tipų AES modulį (AES 128 bitai), galimi tik 128 bitų AES:

1. AES normalus
2. AES CBC
3. AES GCM (su GFM maiša) (daugiau paaiškinimų rasite Vikipedijoje)

Kad būtų lengviau naudotis, sukūriau dvi funkcijas:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Šios dvi funkcijos yra mano „Github“.

Paaiškinimas

Aš pasirenku naudoti AES CBC algoritmą, nes jis yra saugesnis nei pagrindiniai AES 128 bitai. Šis algoritmas naudoja pradinį vektorių jūsų duomenims šifruoti.

Informacija

Žemiau aprašysiu kiekvieną šifravimo ir iššifravimo metodo žingsnį. Bet aš parašiau „Arduino“kodą, kuris naudoja abi šias funkcijas. Šį kodą galite pamatyti mano „Github“:

• Github: Mano Github
• Kodo „Šifruoti/iššifruoti“pavyzdys: AES_crypto_example.ino

Pirmas žingsnis: šifruokite savo duomenis

Šioje dalyje aš jums parodysiu, kaip užšifruoti jūsų duomenis.

Pirmiausia jums reikės šios funkcijos:

/** / short Šifruoti duomenis naudojant AES CBC algoritmą* / param [in] cfg Loginės sąsajos konfigūracija. Kai kurias iš anksto nustatytas * konfigūracijas galima rasti atca_cfgs., maksimalus ilgis 240) * / param [out] iv Pradinis vektorius, naudojamas AES CBC (grąžinkite vektorių šiame variante) * / param [out] šifruotas tekstas grąžina čia šifravimo tekstą * / param [in] klavišas Lizdas klavišas * / grąžinkite ATCA_SUCCESS sėkmės atveju, kitaip - klaidos kodas. */ ATCA_STATUS aes_cbc_encrypt (ATCAIfaceCfg *cfg, uint8_t *duomenys, int len, uint8_t *iv, uint8_t *šifruotas tekstas, uint8_t raktas) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC && len % 16! = 0) {Serial.print (F ("KLAIDA: ATCA_BAD_PARAM")); grąžinti ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS statusas = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, raktas, 0, tmp_iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, kodo klaida 0x")); Serial.println (būsena, HEX); grįžti; } atmintinė (iv, tmp_iv, IV_LENGTH_CBC); memcpy (tmp_data, data, len); int max = len / 16; (int j = 0; j <max; j ++) {status = atcab_aes_cbc_encrypt_block (& ctx, & tmp_data [j * 16], ir šifruotas tekstas [j * 16]); } if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (būsena, HEX); } grąžinimo būsena; } grąžinimo būsena; }

Šia funkcija paprasta naudotis, turite nustatyti du dalykus:

1. Tuščias 16 baitų IV (pradinis vektorius)
2. Duomenys, kuriuos reikia užšifruoti (maksimalus dydis 240 baitų)

Štai pavyzdys „kaip naudotis šia funkcija“.

Noriu užšifruoti žodį „AAAAAAAAAAAAAAA“, raktas įrašytas į lizdo numerį „9“:

ATCA_STATUS status = atcab_init (& cfg); if (status! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () nepavyko: kodas -> 0x")); Serial.println (būsena, HEX); } uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; // Originalus tekstas uint8_t iv [IV_LENGTH_CBC]; // Pradinis vektorius uint8_t cypherdata [sizeof (paprastas tekstas)]; // Duomenų užšifruota būsena = aes_cbc_encrypt (& cfg, paprastas tekstas, sizeof (paprastas tekstas), iv, cypherdata, 9);

Jei veiksmas bus geras, užšifruotus duomenis turėsite kintamajame „cypherdata“, o pradinį vektorių - kintamajame „IV“.

Išlaikykite šiuos du kintamuosius, kad iššifruotumėte savo tekstą!

Antras žingsnis: iššifruokite savo duomenis

Norėdami iššifruoti duomenis, jums reikės dviejų dalykų:

1. Pradinis vektorius
2. „Cypher“duomenys (užšifruoti duomenys)

Norėdami iššifruoti duomenis, jums reikės šios funkcijos:

/** / short Iššifruoti duomenis naudojant AES CBC algoritmą* / param [in] cfg Loginės sąsajos konfigūracija. Kai kurias iš anksto nustatytas * konfigūracijas galima rasti atca_cfgs.h * / param [in] šifruotame tekste Iššifruojami žodžiai (turi būti padalyti iš 16, maksimalus ilgis 240) * / param [in] len ilgis žodžių, kuriuos reikia iššifruoti (turi būti padalintas iš 16, maksimalus ilgis 240) * / param [in] iv Pradinis vektorius, naudojamas AES CBC * / param [out] grynasis tekstas, grąžinkite čia iššifruotą tekstą * / param [in] raktas Rakto lizdo numeris * / return ATCA_SUCCESS on success, kitaip - klaidos kodas. */ ATCA_STATUS aes_cbc_decrypt (ATCAIfaceCfg *cfg, uint8_t *šifruotas tekstas, int len, uint8_t *iv, uint8_t *paprastasis tekstas, uint8_t raktas) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC || len % 16! = 0) {Serial.print (F ("ERROR Decrypt: ATCA_BAD_PARAM")); grąžinti ATCA_BAD_PARAM; } ATCA_STATUS status = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, raktas, 0, iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_init, kodo klaida 0x")); Serial.println (būsena, HEX); grįžti; } int max = len / 16; už (int j = 0; j <max; j ++) {status = atcab_aes_cbc_decrypt_block (& ctx, & šifruotas tekstas [j * 16] ir paprastas tekstas [j * 16]); } if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (būsena, HEX); } grąžinimo būsena; } grąžinimo būsena; }

Noriu iššifruoti ankstesnius duomenis (žr. Toliau, Pirmas žingsnis). Tam aš padarysiu taip:

uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (paprastas tekstas)]; uint8_t decryptdata [sizeof (paprastas tekstas)]; status = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) {Serial.print ("Iššifruotas tekstas yra:"); for (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } else {// Žiūrėkite failą atca_status.h, kad gautumėte kodą Error Serial.print (F ("Neįmanoma iššifruoti | Kodo klaida 0x")); Serial.println (būsena, HEX); grįžti; }

Jei veiksmas yra geras, iššifruotus duomenis turėsite kintamajame „decryptdata“.

Dabar jūs žinote, kaip naudoti šifravimą ir iššifravimą naudojant mikroschemą Atecc608a

6 žingsnis: 5. Kodėl jums reikia naudoti šį lustą?

Šifruoti duomenys yra labai naudingi, nes galite paslėpti savo informaciją ir siųsti ją naudodami „Wireless“arba tiesiog saugoti.

Štai keletas panaudojimo pavyzdžių:

1. Išsaugoti duomenys į išorinį EEPROM: galite apsaugoti išorinio EEPROM duomenis ir, jei kas nors vis dar naudojasi šiuo EEPROM, jam reikės rakto ir IV iššifravimui.
2. Siųsti belaidžio ryšio duomenis: šiuos užšifruotus duomenis galite siųsti naudodami „Wireless“(nrf24L01, RFM95W …), o jei kas nors perims jūsų duomenis, šie duomenys bus saugūs
3. Išsaugotas slaptažodis
4. …

Naudodami šį lustą galite atlikti kelis veiksmus. Jis gali būti naudojamas keliuose projektuose. Jei turite laiko, pasakykite man, kokiame projekte naudosite šį lustą?

Paskutinis patarimas: jei kuriate belaidį projektą ar saugote neapdorotus duomenis, būkite atsargūs, saugumas yra labai svarbus ir jei žinote, kaip „niekšui“paprasta perimti ar pavogti jūsų duomenis. Dabar, kai yra internetas, kiekvienas gali turėti savo kompiuteryje paleidžiamus scenarijus, kad tik „nulaužtų“jus!

7 žingsnis: Išvada

Tikiuosi, kad šis straipsnis jums bus naudingas. Atsiprašau, jei suklydau tekste, bet anglų kalba nėra mano pagrindinė kalba ir aš kalbu geriau nei rašau.

Ačiū, kad viską perskaitėte.

Mėgaukis tuo.