Turvalisus Arduino abil: Atecc608a: 7 sammu

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:46

Teema

Tere kõigile !

See on minu esimene juhendatav artikkel, nii et loodan, et see on teile kõigile huvitav.

Selles artiklis selgitan teile, kuidas kasutada mikrokiipi nimega "ATECC608A", mis pakub mitut turvatööriista.

Selle kiibi on välja töötanud MicroChip ja see on "CryptoAuthentication chip" viimane versioon. Enne seda versiooni olid "ATSHA204A" ja "ATECC508A".

Miks otsustasin kasutada viimast versiooni, mitte eelmist?

See versioon on kõige arenenum kiip ja sellel on funktsioone, mida vanal versioonil pole (näiteks: AES -moodul, IO -kaitsemoodul …).

Miks just see projekt?

Ma töötan küberturvalisuse valdkonnas ja nagu kõik mulle meeldisid programmeerimine ja elektroonika. Õpingute ajal saan konverentsi asjade Interneti turvalisuse spetsialistiga, kes näitas meile, et Industrial ei kasuta turvalisust oma IoT -objektis. Näitasin tabalukku, mida saab nutitelefoniga Bluetoothi abil avada. Tabalukul oli lause "See tabalukk on kõige turvalisem kui võtmelukk!". See lause paneb teda naeratama ja ta muutis lauset "See tabalukk on kõigi aegade halvim tabalukk!".

Ta näitas meile oma arvuti ja Bluetoothi nuusutajaga, et iga nutitelefoni saadetud käsk on iga kord sama ja selle käsu kopeerimine ning nutitelefoniga saatmine on väga lihtne. Ta selgitas meile, et "Turvalisus" "tööstuse" jaoks pole peamine probleem. Ta näitas meile kiipe (alla 0,60 $), mis võiksid neile objektidele turvakihi lisada.

Pärast seda tutvustamist proovisin leida mõnda avatud lähtekoodiga projekti, mis lisab IoT -objektile turvakihi, kuid ma ei leidnud seda kunagi.

Nii otsustasin töötada projekti kallal, mis kasutab kahe IoT -objekti vaheliseks suhtlemiseks turvakihti.

Mis on minu idee?

Kahe IoT -objekti vahelise suhtluse ajal võib esineda mitmeid rünnakuid: Man Of the mild, teabe koopia ja palju muud. Seega on minu idee väga lihtne:

1. Krüptitud andmete kasutamine kahe või enama IoT -objekti vahel.
2. Madala hinnaga tarned
3. Saab töötada Arduino UNO -ga

Nüüd selgitan teile, kuidas ma rakendasin selle abstraktse pildi Arduino ja Atecc608a kiibiga. Selles artiklis selgitan teile, kuidas kasutada Arduino UNO -d ATECC608A -ga.

Kirjutan järgmisel korral artikli kahe objekti suhtlemisest.

Tarvikud

Selle projekti jaoks vajate mõnda asja:

1. Arduino UNO või MEGA (kiip peab olema Atmega 328 või ATMEGA 2560)
2. Atecc608A kiip (maksab vähem kui 0,80 dollarit, lihtne leida oma tarnija veebisaidilt)
3. 8-kontaktiline SOIC-adapter
4. Mõned juhtmed ja takistid

Selle kiibi eelmise versiooni (Atecc508a) andmeleht on saadaval siin -> Andmeleht Atecc508a

1. samm: samm -sammult

Selles artiklis näitan teile, kuidas muuta selle kiibi konfiguratsiooni ja pärast andmete krüptimist AES CBC algoritmi abil.

Me järgime neid samme:

1. Vooluahela disain
2. Selle kiibi konfiguratsioon
3. AES CBC mooduli kasutamine
4. Miks peate seda kiipi kasutama?

Iga sammu kohta kirjeldan teile kõike üksikasjalikult. Samuti lisasin oma koodi oma Githubisse koos kommentaaridega iga funktsiooni kohta. Kui teil on minu koodi või selle projekti kohta küsimusi, vastan neile hea meelega.

Minu Github: Minu Github

Samm: hoiatus seadme Atecc608a kohta

Atecc608a kiip ei ole "lihtne" kiip.

Esiteks on selle kiibi dokumentatsioon NDA all, nii et te ei leia seda Internetist täielikult. Kuid pole probleemi, eelmise versiooni andmeleht on saadaval Interneti andmelehel Complete ATECC508A.

Teiseks, kui kasutate seda kiipi, peate selle konfiguratsiooni lukustama ja kiibi konfiguratsiooni on võimatu muuta, kui see on lukustatud. Nii et olge konfiguratsioonitsooni ja andmetsooni lukustamisel ettevaatlik.

Kolmandaks, raamatukogu, mis on kirjutatud C -vormingus, on väga suur ja täielik, seega peate lugema varem kasutatavate funktsioonide dokumentatsiooni.

Neljandaks kirjutas raamatukogu, et see kiip ei tööta Arduino UNO puhul, kuid lisas, et funktsionaalsus vajab seda Arduino UNO -ga töötamiseks.

Kiip ATECC608A

Selle kiibiga saate suhelda I2C abil. Selle kiibi aadressi saab konfiguratsioonis muuta.

See kiip sisaldab 16 erinevat pesa, mis võivad sisaldada erinevat tüüpi andmeid:

1. ECC võti (privaatne või avalik)
2. AES võti
3. Muud andmed (nt Sha hash või lihtsalt sõnad)

Meie puhul salvestame AES -võtme ühte pesasse.

3. etapp: 1. Ringkonnakohtu kujundamine

1. Ringkonnakohtu disain

Selle vooluahela skeem on väga lihtne!

Peate kasutama 3,3 V toite, kuna soovitus on vahemikus 2,0 V kuni 5,5 V, kuid eelistasin kasutada 3,3 V pinget.

Selle kiibi puhul on tavaliselt kiibi nurgal punkt, see punkt on selle plaadi tihvt 1. Lisasin Atecc608a PIN-numbriga pealtvaate, kuna see on 8-juhtmeline SOIC, seega on kiip väga väike.

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)

Peate kasutama 3,3 V toite, kuna soovitus on vahemikus 2,0 V kuni 5,5 V, kuid eelistasin kasutada 3,3 V pinget.

Lisasin Atecc608a pealtvaate, kuna see on 8-juhtmeline SOIC, seega on kiip väga väike. Kui soovite, ehitavad tarnijad kiipjoodisega mõne tahvli, võib see teile lihtsam olla.

Hoiatus: minu puhul pean lisama takisti Arduino SDA ja kiibi vahele (ka SDL -i jaoks). Lisasin igale 4,7Kohm takisti.

Samm 4: 2. Kiibi konfigureerimine (Atecc608a)

Enne krüpteerimis- või dekrüpteerimisfunktsiooni kasutamist peate kiibi konfigureerima. Selles etapis kirjeldan kõiki samme, mida peate selle kiibi konfigureerimiseks tegema.

Hoiatus: see samm on väga oluline ja kui te tsoonid enne lõppu lukustate, ei saa te neid muuta.

Nagu varem selgitatud, sai see kiip kaks tsooni:

1. Konfiguratsiooni tsoon
2. Andmetsoon

Konfiguratsioonitsooni suurus oli 128 baiti, kuid esimesi 16 baiti ei saa muuta.

Selle kiibi konfigureerimiseks peate neid samme järgima kaks. On väga oluline järgida kõiki samme järjekorras, vastasel juhul ei tööta teie konfiguratsioon ning kiip lukustatakse ja seda ei saa kasutada. Need sammud on järgmised:

1. Looge konfiguratsioonimall
2. Kirjutage see mall kiibile
3. Lukustage konfiguratsioonitsoon
4. Kirjutage oma AES -võti (128 bitti) pessa
5. Andmetsooni lukustamine

Teave

Allpool kirjeldan oma koodiga konigureerimise iga sammu, kuid pole muret, lisasin oma Githubis täieliku näite konfiguratsioonist. Ma kommenteerin iga funktsiooni kohta ja teie jaoks on iga sammu jaoks saadaval *.ino fail.

• Minu Github: Minu Github
• Näidiskonfiguratsiooni tee: configuration_example.ino

Esimene samm: looge konfiguratsioonimall

Nagu eelnevalt selgitatud, on konfiguratsioonitsooni suurus 128 bitti, kuid esimest 16 bitti ei saa muuta. See tsoon koosneb mitmest osast, kuid selle projekti jaoks peate teadma ainult kolme selle konfiguratsioonitsooni osa:

1. Baidid 16 -> See on kiibi I2C aadress
2. Baidid 20 kuni 51 -> Siin saate muuta selle kiibi 16 pesa pesa tüüpi
3. Baidid 96 kuni 127 -> Siin saate määrata igas pesas kasutatava võtme või andmete tüübi.

(Kui vajate kogu selle tsooni täpsemat selgitamist, lugege palun dokumentatsiooni (lk 13, jaotis 2.2))

Siin panen üksikasjadesse iga kiibi konfiguratsiooni 112 baidi baiti/osa. See on näide, igal ostetud kiibil võib olla erinev konfiguratsioon:

0xC0, // I2C aadress

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, 0x00, 0x33, 0x00, // võtmekonfiguratsiooni pesa 1 0x33, 0x00, // võtmekonfiguratsiooni pesa 2 0x33, 0x00, // võtmekonfiguratsiooni pesa 3 0x1C, 0x00, // võtmekonfiguratsiooni pesa 4 0x1C, 0x00, // Võtmekonfiguratsiooni pesa 5 0x 1C, 0x00, // Klahvikonfiguratsiooni pesa 6 0x1C, 0x00, // Võtmekonfiguratsiooni pesa 7 0x3C, 0x00, // Võtmekonfiguratsiooni pesa 8 0x1A, 0x00, // Klahvikonfiguratsiooni pesa 9 0x3A, 0x00, // Klahvikonfiguratsiooni pesa 10 0x1A, 0x00, // Klahvikonfiguratsiooni pesa 11 0x3A, 0x00, // Võtmekonfiguratsiooni pesa 12 0x3A, 0x00, // Võtmekonfiguratsiooni pesa 13 0x3C, 0x00, // Võtmekonfiguratsiooni pesa 14 0x3C, 0x00, // Klahvikonfiguratsiooni pesa 15 0x1C, 0x00 // Võtmekonfiguratsiooni pesa 16

Nagu näha, panin sellesse koodi mõned kommentaarid, et sellest konfiguratsioonist rohkem aru saada.

Teie puhul peate mõistma ainult kolme asja:

1. Baidid 16 -> See on kiibi I2C aadress
2. Baidid 20 kuni 51 -> Siin saate muuta selle kiibi 16 pesa pesa tüüpi
3. Bait 96 kuni 127 -> Siin saate määrata võtme või andmete tüübi, mida kasutatakse igas pesas.

Ma ei selgita konfiguratsiooni tüüpi ja miks ma seda kasutasin, mitte teist, sest kõike on keeruline seletada. Kui vajate lisateavet, lugege dokumentatsiooni, lehekülje 16 jaotist 2.2.1 "SlotConfig" ja lehekülge 19. jaotis 2.2.5 "KeyConfig" jaoks

Selle näite puhul kasutate pesa 9 AES -võtme salvestamiseks.

Selleks peame panema (kui vaja, saate ülaltoodud näite kopeerida, selles on muudatus tehtud):

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

Miks ma selle konfiguratsiooni määrasin: selle kiibi iga pesa jaoks saate määrata parameetrid, mis ütlevad kiibile, millist tüüpi andmeid salvestatakse. Teil on mitu parameetrit:

• Pesa saab kirjutada või lugeda (kustutada või krüptida)
• Salvestatud andmete tüüp (ECC võti, avalik võti, SHA Hash, AES võti …)
• Pesa saab lukustada
• Võtme genereerimine on lubatud
• …

Kui baitideks 36 ja 37 on seatud "0x0F8F":

• Andmeid saab kirjutada Clear
• Selle pesa sisu on salajane ja seda ei saa lugeda
• Pesa ei saa kasutada käsu CheckMac Copy jaoks

Kui baitide 112 ja 113 väärtuseks on määratud "0x001A":

Pesa mahutab kuni neli AES 128-bitist sümmeetrilist võtit (KeyType = 0x6)

Teine samm: kirjutage see konfiguratsioon

See samm on väga oluline, kuna seadistame kiibi oma konfiguratsiooniga ja kui see konfiguratsioon pole hea, kasutate seda kiipi.

Kuid ärge muretsege, kuni konfiguratsioon pole lukus, saate oma konfiguratsiooni muuta.

Siin on see kood, mida kasutati kiibile konfiguratsiooni kirjutamiseks:

/** / lühike Kirjutage kiibile uus konfiguratsioon.

* / param [in] cfg Loogilise liidese konfiguratsioon. Mõned eelmääratletud * konfiguratsioonid on leitavad atca_cfgs.h * / param [in] config Array uint8_t konfiguratsioonist (pikkus 112) * / param [in] len Konfiguratsioonimassiivi suurus * / tagastama edu korral ATCA_SUCCESS, vastasel juhul veakood. */ ATCA_STATUS write_configuration (ATCAIfaceCfg *cfg, uint8_t *config, size_t len) {if (len! = 112) return ATCA_BAD_PARAM; Olek ATCA_STATUS; olek = atcab_init (cfg); if (status == ATCA_SUCCESS) {// Kirjutage kiibile konfiguratsioonimassiiv // 16 baidi täitmine (16 esimest baiti ei saa kirjutada) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); tagasisaatmise staatus; } tagastamise olek; }

See funktsioon kirjutab teie konfiguratsiooni kiibile.

Kolmas samm: lukustage konfiguratsioonitsoon

Hoiatus: olge selle sammuga ettevaatlik, kui lukustate selle tsooni ja teie konfiguratsioon pole hea, on kiip kasutuskõlbmatu ja te ei saanud seda tsooni muuta

Selle toimingu jaoks kasutame seda funktsiooni:

/** / lühike Kontrollige, kas DATA_ZONE või CONFIG_ZONE on lukustatud

* / param [in] cfg Loogilise liidese konfiguratsioon. Mõnda eelmääratletud * konfiguratsiooni võib leida atca_cfgs.h * / param [in] tsoonis LOCK_ZONE_DATA või LOCK_ZONE_CONFIG * / tagastama edu korral ATCA_SUCCESS, vastasel juhul veakood. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS olek; bool lock = vale; if (tsoon! = (uint8_t) LOCK_ZONE_CONFIG && tsoon! = (uint8_t) LOCK_ZONE_DATA) tagastab ATCA_BAD_PARAM; olek = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (tsoon, & lukk)))) {return ATCA_FUNC_FAIL; } if (! lukk) {return ATCA_NOT_LOCKED; } tagasipöördumine ATCA_SUCCESS; } tagasipöördumine ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Neljas samm: kirjutage pesasse AES -võti

Selles osas määrate teile isikliku AES -võtme pesasse, mille olete kiibi konfiguratsioonis määranud.

Selle näite puhul kasutan kiibi pesa number 9.

Peate teadma: selle kiibi eripära on see, et saate kirjutada andmeid pesasse ainult 4 või 32 baiti. AES -i jaoks vajame 128 -bitist võtit, seega 16 baiti andmeid. Seega otsustasin sellesse pesasse kirjutada 16 -baidisele võtmele, et saada 32 baiti andmeid.

Nüüd näitan teile kasutatud koodi:

/** / lühike Kirjutage antud pesasse AES -võti. * / param [in] cfg Loogilise liidese konfiguratsioon. Mõned eelmääratletud * konfiguratsioonid on leitavad aadressil atca_cfgs.h * / param [in] võtmevõtme pesa number * / param [in] datakey võtmemassiiv uint8_t * / param [in] len Võtmemassiivi suurus * / tagastama edu korral ATCA_SUCCESS, muidu veakood. */ ATCA_STATUS write_key_slot (ATCAIfaceCfg *cfg, uint8_t võti, uint8_t *datakey, size_t len) {if (võti 16) tagastab ATCA_BAD_PARAM; if (len! = 32) tagasta ATCA_BAD_PARAM; ATCA_STATUS olek = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) key, 0, 0, datakey, 32); if (olek! = ATCA_SUCCESS) tagastab oleku; } tagastamise olek; }

Selle näite jaoks kasutan kahte AES -võtit 16 -baidise kumbki:

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

Kui see toiming on hea, peate nüüd läbima viimase sammu "andmete tsooni lukustamine"

Viimane samm: lukustage andmetsoon

Hoiatus: olge selle sammuga ettevaatlik, kui lukustate selle tsooni ja teie andmed pole määratud, on kiip kasutuskõlbmatu ja te ei saanud seda tsooni muuta

Selle toimingu jaoks kasutame seda funktsiooni:

/** / lühike Kontrollige, kas DATA_ZONE või CONFIG_ZONE on lukustatud

* / param [in] cfg Loogilise liidese konfiguratsioon. Mõnda eelmääratletud * konfiguratsiooni võib leida atca_cfgs.h * / param [in] tsoonis LOCK_ZONE_DATA või LOCK_ZONE_CONFIG * / tagastama edu korral ATCA_SUCCESS, vastasel juhul veakood. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS olek; bool lock = vale; if (tsoon! = (uint8_t) LOCK_ZONE_CONFIG && tsoon! = (uint8_t) LOCK_ZONE_DATA) tagastab ATCA_BAD_PARAM; olek = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (tsoon, & lukk)))) {return ATCA_FUNC_FAIL; } if (! lukk) {return ATCA_NOT_LOCKED; } tagasipöördumine ATCA_SUCCESS; } tagasipöördumine ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Kui see toiming on hea, on teie kiip kasutamiseks valmis

5. samm: 3. AES CBC mooduli kasutamine

Selgitan, kuidas andmeid krüptida ja dekrüpteerida algoritmi AES CBC ja kiibiga Atecc608a.

Pidage meeles: enne selle funktsiooni kasutamist peate kiibi seadistama. Selleks järgige käesoleva artikli 2. sammu

Sellel kiibil on mitut tüüpi AES -moodul (AES 128 bitti), võimalik on ainult AES 128 bitti:

1. AES normaalne
2. AES CBC
3. AES GCM (koos GFM -räsiga) (täpsema selgituse saamiseks vt Vikipeediat)

Kasutamise hõlbustamiseks lõin kaks funktsiooni:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Need kaks funktsiooni on saadaval minu Githubis.

Selgitus

Kasutan AES CBC algoritmi, kuna see on turvalisem kui tavalised AES 128 bitid. See algoritm kasutab teie andmete krüptimiseks esialgset vektorit.

Teave

Allpool kirjeldan krüpteerimis- ja dekrüpteerimismeetodi iga sammu. Kuid ma kirjutasin Arduino jaoks koodi, mis kasutab neid mõlemaid funktsioone. Seda koodi näete minu Githubis:

• Github: Minu Github
• Näide koodist "Krüptida/dekrüpteerida": AES_crypto_example.ino

Esimene samm: krüpteerige oma andmed

Selles osas näitan teile, kuidas teie andmeid krüptida.

Kõigepealt vajate seda funktsiooni:

/** / short Krüpteerige andmed AES CBC algoritmi abil* / param [in] cfg Loogilise liidese konfiguratsioon. Mõned eelmääratletud * konfiguratsioonid on leitavad atca_cfgs.h * / param [in] andmetes Krüpteeritavad sõnad (tuleb jagada 16 -ga, maksimaalne pikkus 240) * / param [in] len krüpteeritavate sõnade pikkus (tuleb jagada 16 -ga, max pikkus 240) * / param [out] iv AES CBC -s kasutatav algvektor (tagastage vektor selles variatsioonis) * / param [out] šifreeritud tekst tagastab siia šifriteksti * / param [in] klahvi võti * / tagasta edu korral ATCA_SUCCESS, vastasel juhul veakood. */ 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")); tagasta ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS staatus = atcab_init (cfg); if (olek == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, võti, 0, tmp_iv); if (olek! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (olek, HEX); tagasipöördumine; } mälupulk (iv, tmp_iv, IV_LENGTH_CBC); memcpy (tmp_data, data, len); int max = len / 16; jaoks (int j = 0; j <max; j ++) {status = atcab_aes_cbc_encrypt_block (& ctx, & tmp_data [j * 16], ja šifreeritud tekst [j * 16]); } if (olek! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (olek, HEX); } tagastamise olek; } tagastamise olek; }

Seda funktsiooni on lihtne kasutada, peate määrama kaks asja:

1. Tühi 16 baiti IV (esialgne vektor)
2. Krüpteeritavad andmed (max suurus 240 baiti)

Siin on näide "kuidas seda funktsiooni kasutada".

Tahan krüpteerida sõna "AAAAAAAAAAAAAAA", kirjutades oma võtme pesa numbrisse "9":

ATCA_STATUS olek = atcab_init (& cfg); if (olek! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () ebaõnnestus: kood -> 0x")); Serial.println (olek, HEX); } uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; // Originaaltekst uint8_t iv [IV_LENGTH_CBC]; // Esialgne vektor uint8_t cypherdata [sizeof (tavatekst)]; // Andmete krüpteeritud olek = aes_cbc_encrypt (& cfg, lihttekst, sizeof (tavaline tekst), iv, cypherdata, 9);

Kui toiming on hea, on teil krüpteeritud andmed muutuja "cypherdata" ja esialgne vektor muutuja "IV".

Säilitage need kaks muutujat oma teksti dekrüpteerimiseks!

Teine samm: dekrüpteerige oma andmed

Andmete dekrüpteerimiseks vajate kahte asja:

1. Esialgne vektor
2. Cypheri andmed (krüpteeritud andmed)

Andmete dekrüpteerimiseks vajate seda funktsiooni:

/** / lühike Krüpteerige andmed AES CBC algoritmi abil* / param [in] cfg Loogilise liidese konfiguratsioon. Mõnda eelmääratletud * konfiguratsiooni võib leida atca_cfgs.h * / param [in] šifreeritud tekstist Dekrüpteeritavad sõnad (tuleb jagada 16 -ga, maksimaalne pikkus 240) * / param [in] len pikkus dekrüpteeritavad sõnad (tuleb jagada 16 -ga, max pikkus 240) * / param [in] iv AES CBC -s kasutatav esialgne vektor * / param [out] tavatekst tagastab siia dekrüpteeritud teksti * / param [in] klahv Võtme pesa number * / tagasta edu ATCA_SUCCESS, muidu veakood. */ ATCA_STATUS aes_cbc_decrypt (ATCAIfaceCfg *cfg, uint8_t *šifriteksti, int len, uint8_t *iv, uint8_t *tavatekst, uint8_t võti) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC || len % 16! = 0) {Serial.print (F ("ERROR Decrypt: ATCA_BAD_PARAM")); tagasta ATCA_BAD_PARAM; } ATCA_STATUS olek = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, võti, 0, iv); if (olek! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (olek, HEX); tagasipöördumine; } int max = len / 16; jaoks (int j = 0; j <max; j ++) {status = atcab_aes_cbc_decrypt_block (& ctx, & šifreeritud tekst [j * 16] ja tavatekst [j * 16]); } if (olek! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (olek, HEX); } tagastamise olek; } tagastamise olek; }

Soovin oma eelmised andmed dekrüpteerida (vt allpool, esimene samm). Selleks teen seda:

uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (tavaline tekst)]; uint8_t dekrüptaandmed [sizeof (tavaline tekst)]; olek = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (olek == ATCA_SUCCESS) {Serial.print ("Krüptitud tekst on:"); for (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } else {// Vt failist atca_status.h koodi Error Serial.print (F ("Võimatu dekrüpteerimine | Koodiviga 0x")); Serial.println (olek, HEX); tagasipöördumine; }

Kui toiming on hea, on teil dekrüpteeritud andmed muutuja "decryptdata" all.

Nüüd teate, kuidas kasutada krüptimist ja dekrüpteerimist kiibiga Atecc608a

Samm 6: 5. Miks peate seda kiipi kasutama?

Krüptitud andmed on väga kasulikud, kuna saate oma teabe peita ja traadita ühenduse kaudu saata või lihtsalt salvestada.

Siin on mõned näited kasutamisest:

1. Salvestatud andmed välisele EEPROM -ile: saate kaitsta välise EEPROM -i andmeid ja kui keegi veel seda EEPROM -i kasutab, vajab ta dekrüpteerimiseks võtit ja IV -d.
2. Saatke traadita andmeid: saate need krüpteeritud andmed saata traadita ühenduse kaudu (nrf24L01, RFM95W …) ja kui keegi teie andmeid pealt võtab, on need andmed turvalised
3. Salvestatud parool
4. …

Selle kiibiga saate teha mitmeid asju. Seda saab kasutada mitmes projektis. Kui teil on aega, öelge mulle, millises projektis te seda kiipi kasutate?

Viimane nõuanne, kui loote mõne traadita ühenduse projekti või salvestate toorandmeid, olge ettevaatlik, turvalisus on väga oluline ja kui teate, kuidas "noobil" on teie andmeid kinni püüda või varastada. Nüüd, kui teil on Internet, saab igaüks oma arvutisse käivitada skripte, et teid lihtsalt "häkkida"!

Samm 7: Järeldus

Loodan, et see artikkel on teile kasulik. Vabandust, kui tegin oma tekstis vea, kuid inglise keel pole minu peamine keel ja räägin paremini kui kirjutan.

Täname, et lugesite kõike.

Naudi seda.