Beveiliging met Arduino: Atecc608a: 7 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:24

Onderwerp

Hallo almal !

Dit is my eerste Instructables -artikel, so ek hoop dat dit vir u almal interessant sal wees.

In hierdie artikel sal ek u verduidelik hoe u 'n mikroskyfie genaamd "ATECC608A" kan gebruik wat verskeie beveiligingsinstrumente bied.

Hierdie chip is ontwerp deur MicroChip en dit is die laaste weergawe van 'CryptoAuthentication chip'. Voor hierdie weergawe was daar 'ATSHA204A' en 'ATECC508A'.

Waarom het ek besluit om die laaste weergawe te gebruik en nie die vorige weergawe nie?

Hierdie weergawe is die mees gevorderde chip en het funksies wat die ou weergawe nie het nie (byvoorbeeld: AES -module, IO -beskermingsmodule …).

Waarom hierdie projek?

Ek werk op die gebied van die CyberSecurity en ek was lief vir programmering en elektronika soos almal. Tydens my studie kry ek 'n konferensie met 'n spesialis oor IoT Security wat ons gewys het dat Industrial nie sekuriteit in hul IoT -voorwerp gebruik nie. Ek het vir ons 'n hangslot gewys wat via Bluetooth met u slimfoon oopgemaak kan word. Op die hangslot het 'n sin gesê: "Hierdie hangslot is die veiligste as 'n sleutelslot!". Hierdie sin laat hom glimlag en hy verander die sin "Hierdie hangslot is die ergste hangslot wat ooit gebou is!".

Hy het ons met sy eie rekenaar en 'n Bluetooth -sniffer gewys dat elke opdrag wat deur die slimfoon gestuur word elke keer dieselfde is, en dit is baie eenvoudig om hierdie opdrag te kopieer en met u slimfoon te stuur. Hy het ons verduidelik dat 'sekuriteit' vir 'nywerheid' nie die grootste probleem is nie. Hy het vir ons skyfies (minder as 0,60 $) gewys wat 'n laag beveiliging by hierdie voorwerpe kan voeg.

Na hierdie demonstrasie het ek probeer om 'n Open Source -projek te vind wat 'n veiligheidslaag by IoT -voorwerp voeg, maar ek het dit nooit gevind nie.

Daarom het ek besluit om aan 'n projek te werk wat 'n veiligheidslaag gebruik vir kommunikasie tussen twee IoT -voorwerpe.

Wat is my idee?

Tydens 'n kommunikasie tussen twee IoT -voorwerpe kan daar verskeie aanvalle wees: Man Of the mild, afskrif van inligting en meer.. My idee is dus baie eenvoudig:

1. Gebruik van geïnkripteer data tussen twee of meer IoT -voorwerpe.
2. Goedkoop voorrade
3. Kan werk met 'n Arduino UNO

Nou sal ek u verduidelik hoe ek hierdie abstrakte prentjie geïmplementeer het met 'n Arduino en 'n Atecc608a -chip. In hierdie artikel sal ek u verduidelik hoe u die Arduino UNO met die ATECC608A kan gebruik.

Ek sal volgende keer 'n artikel skryf oor die kommunikasie van twee voorwerpe.

Voorrade

U benodig 'n paar dinge vir hierdie projek:

1. Arduino UNO of MEGA (chip moet Atmega 328 of ATMEGA 2560 wees)
2. Atecc608A -chip (kos minder as 0,80 $ elk, maklik om op u webwerf van die verskaffer te vind)
3. 8-pins SOIC-adapter
4. 'N Paar drade en weerstande

Die datablad van die vorige weergawe van hierdie chip (Atecc508a) is hier beskikbaar -> Gegevensblad Atecc508a

Stap 1: Stap vir stap

In hierdie artikel sal ek u wys hoe u die konfigurasie van hierdie chip kan verander en hoe u data kan versleutel met behulp van die AES CBC -algoritme.

Ons sal hierdie stappe volg:

1. Ontwerp van die kring
2. Opstelling van hierdie chip
3. Gebruik van die AES CBC -module
4. Waarom moet u hierdie chip gebruik?

Vir elke stap gee ek alles vir u in detail. Ek het ook my kode in my Github bygevoeg met opmerkings vir elke funksie. As u vrae het oor my kode of hierdie projek, sal ek dit graag beantwoord.

My Github: My Github

Stap 2: Waarskuwing oor die Atecc608a

Die Atecc608a -chip is nie 'n 'maklike' chip nie.

Eerstens is die dokumentasie van hierdie chip onder NDA, sodat u dit nie volledig op die internet kan vind nie. Maar hiervoor is geen probleem nie; die datablad van die vorige weergawe is beskikbaar op die Internet Datasheet Complete ATECC508A.

Tweedens, as u hierdie chip gebruik, moet u die konfigurasie daarvan sluit en dit is onmoontlik om die konfigurasie van die chip te verander as dit gesluit is. Wees dus versigtig wanneer u die Config Zone en die Data Zone sal sluit.

Ten derde, die biblioteek wat in C geskryf is, is baie groot en volledig, dus moet u die dokumentasie lees van die funksies wat u voorheen sal gebruik.

Vier, die biblioteek het geskryf dat hierdie chip nie werk vir Arduino UNO nie, maar dit het bygevoeg dat die funksies nodig is om met Arduino UNO te werk.

Die chip ATECC608A

U kan met hierdie chip kommunikeer deur I2C. Die adres van hierdie chip kan in die konfigurasie verander word.

Hierdie chip bevat 16 verskillende gleuwe wat verskillende soorte data kan bevat:

1. ECC -sleutel (privaat of publiek)
2. AES -sleutel
3. Ander data (soos Sha hash of net woorde)

In ons geval sal ons die AES -sleutel in een gleuf stoor.

Stap 3: 1. Ontwerp van die stroombaan

1. Ontwerp van die kring

Die skema van hierdie kring is baie eenvoudig!

U moet 3.3V -krag gebruik, want die aanbeveling is tussen 2.0V en 5.5V, maar ek verkies om die 3.3V te gebruik.

Vir hierdie chip het u gewoonlik 'n kolletjie op 'n hoek van die chip, hierdie punt is die pen 1 van hierdie bord. Ek het die boonste aansig van die Atecc608a met PIN-nommer bygevoeg, want dit is 'n 8-Lead SOIC, sodat die chip baie klein is.

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)

U moet 3.3V -krag gebruik, want die aanbeveling is tussen 2.0V en 5.5V, maar ek verkies om die 3.3V te gebruik.

Ek het die boonste aansig van die Atecc608a bygevoeg omdat dit 'n 8-lood SOIC is, sodat die chip baie klein is. As u verkies, sodat verskaffers 'n bord met die spaandersoldeer bou, kan dit vir u makliker wees.

Waarskuwing: In my geval moet ek 'n weerstand byvoeg tussen die SDA van die Arduino en die chip (ook vir die SDL). Ek het 'n 4.7Kohm -weerstand vir elk bygevoeg.

Stap 4: 2. Opstelling van die chip (Atecc608a)

Voordat u die funksie van kodering of dekripsie gebruik, moet u die chip instel. In hierdie stap beskryf ek elke stap wat u moet doen vir die konfigurasie van hierdie chip.

Waarskuwing: hierdie stap is baie belangrik en as u die sones voor die einde sluit, kan u dit nie verander nie.

Soos voorheen verduidelik, het hierdie chip twee sones:

1. Config Zone
2. Datasone

Die konfigurasiesone het 'n grootte van 128 grepe, maar die eerste 16 grepe kan nie verander word nie.

Om hierdie chip op te stel, moet u twee stappe volg. Dit is baie belangrik om elke stap in volgorde te volg, anders werk u opset nie, en u chip is gesluit en onbruikbaar. Daardie stappe is:

1. Skep 'n konfigurasie sjabloon
2. Skryf hierdie sjabloon op die skyfie
3. Sluit die konfig sone
4. Skryf u AES -sleutel (128 bits) in 'n gleuf
5. Sluit die datasone

Inligting

Hieronder gee ek 'n volledige uiteensetting van elke stap van die konfigurasie met my kode, maar geen probleem nie; ek het 'n volledige voorbeeld van konfigurasie in my Github bygevoeg. Ek lewer kommentaar op elke funksie, en 'n *.ino -lêer is beskikbaar by elke stap om u te help.

• My Github: My Github
• Pad van voorbeeldkonfigurasie: configuration_example.ino

Eerste stap: Skep 'n konfigurasiesjabloon

Soos voorheen verduidelik, kry die konfigurasiesone 'n grootte van 128 bisse, maar die eerste 16 bisse kan nie verander word nie. Hierdie sone bestaan uit verskeie dele, maar u moet slegs 3 dele van hierdie konfigurasiesone vir hierdie projek ken:

1. Die Bytes 16 -> Dit is die I2C -adres van die skyfie
2. Die Bytes 20 tot 51 -> U kan hier die tipe slot verander vir die 16 gleuwe van hierdie chip
3. Die Bytes 96 tot 127 -> U kan hier die tipe sleutel of data wat in elke gleuf gebruik word, hier stel.

(As u meer inligting oor al hierdie gebiede benodig, lees die dokumentasie (bladsy 13, afdeling 2.2))

Hier het ek elke grepe/dele van die 112 grepe van die opset van 'n chip in besonderhede uiteengesit. Dit is 'n voorbeeld: elke gekoopte chip kan 'n ander konfigurasie hê:

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, 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, // Sleutel Config Slot 5 0x 1C, 0x00, // Key Config Slot 6 0x1C, 0x00, // Key Config Slot 7 0x3C, 0x00, // Key Config Slot 8 0x1A, 0x00, // Key Config Slot 9 0x3A, 0x00, // Key Config Slot 10 0x1A, 0x00, // Key Config Slot 11 0x3A, 0x00, // Key Config Slot 12 0x3A, 0x00, // Key Config Slot 13 0x3C, 0x00, // Key Config Slot 14 0x3C, 0x00, // Key Config Slot 15 0x1C, 0x00 // Sleutel Config Slot 16

Soos gesien, plaas ek 'n paar opmerkings in hierdie kode om hierdie konfigurasie meer te verstaan.

In u geval hoef u slegs drie dinge te verstaan:

1. Die Bytes 16 -> Dit is die I2C -adres van die skyfie
2. Die Bytes 20 tot 51 -> U kan hier die tipe slot verander vir die 16 gleuwe van hierdie chip
3. Die Byte 96 tot 127 -> U kan hier die tipe sleutel of data wat in elke gleuf gebruik word, hier stel.

Ek sal nie die tipe konfigurasie verduidelik nie en hoekom ek dit gebruik het en nie 'n ander nie, want dit is ingewikkeld om alles te verduidelik. As u meer inligting benodig, gaan na die dokumentasie, bladsy 16 afdeling 2.2.1 vir die "SlotConfig" en bladsy 19 afdeling 2.2.5 vir "KeyConfig"

In hierdie voorbeeld gebruik u die gleuf 9 om 'n AES -sleutel te stoor.

Hiervoor moet ons dit plaas (as u dit nodig het, kan u die voorbeeld hierbo kopieer; die wysiging is daarin aangebring):

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

Waarom het ek hierdie konfigurasie gestel: Vir elke gleuf van hierdie chip kan u parameters stel om vir die chip te sê watter tipe data gestoor word. U het verskeie parameters:

• Slot kan geskryf of gelees word (aksie uitvee of enkripteer)
• Tipe gegewens (ECC -sleutel, publieke sleutel, SHA Hash, AES -sleutel …)
• Slot kan afsluitbaar wees
• Die generering van die sleutel word toegelaat
• …

Met die greep 36 en 37 ingestel op "0x0F8F":

• Data kan in die Clear geskryf word
• Die inhoud van hierdie gleuf is geheim en kan nie gelees word nie
• Slot kan nie gebruik word vir die CheckMac Copy -opdrag nie

Met die byte 112 en 113 ingestel op "0x001A":

Slot kan tot vier AES 128-bis simmetriese sleutels stoor (KeyType = 0x6)

Tweede stap: Skryf hierdie opset

Hierdie stap is baie belangrik, want ons sal die chip met ons konfigurasie stel en as hierdie konfigurasie nie goed is nie, sal u hierdie chip gebruik.

Maar geen probleem nie, solank die konfigurasie nie gesluit is nie, kan u u konfigurasie verander.

Hier is die kode wat gebruik word om die konfigurasie na die chip te skryf:

/** / brief Skryf 'n nuwe konfigurasie op die chip.

* / param [in] cfg Logiese koppelvlakkonfigurasie. Sommige vooraf gedefinieerde * konfigurasies kan gevind word in atca_cfgs.h * / param [in] config Array uint8_t van konfigurasie (lengte 112) * / param [in] len Grootte van die konfigurasie skikking * / return ATCA_SUCCESS op sukses, anders 'n foutkode. */ ATCA_STATUS skryfkonfigurasie (ATCAIfaceCfg *cfg, uint8_t *config, size_t len) {if (len! = 112) gee ATCA_BAD_PARAM terug; ATCA_STATUS status; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {// Skryf die opset Array op die chip // Vulling van 16 byte (16 eerste grepe kan nie geskryf word nie) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); terugstatus; } terugstatus; }

Hierdie funksie skryf u konfigurasie in die chip.

Derde stap: sluit die konfigurasiesone

Waarskuwing: wees versigtig met hierdie stap; as u hierdie sone sluit en u konfigurasie nie goed is nie, is die chip onbruikbaar en kan u hierdie sone nie verander nie

Vir hierdie aksie gebruik ons hierdie funksie:

/** / brief Kyk of a die DATA_ZONE of CONFIG_ZONE gesluit is

* / param [in] cfg Logiese koppelvlakkonfigurasie. Sommige vooraf gedefinieerde * konfigurasies kan gevind word in atca_cfgs.h * / param [in] sone LOCK_ZONE_DATA of LOCK_ZONE_CONFIG * / return ATCA_SUCCESS op sukses, anders 'n foutkode. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS status; bool slot = vals; as (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) terugkeer ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zone, & lock)))) {return ATCA_FUNC_FAIL; } as (! slot) {opgawe ATCA_NOT_LOCKED; } stuur ATCA_SUCCESS terug; } stuur ATCA_BAD_PARAM terug; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Vierde stap: Skryf vir u AES -sleutel in 'n gleuf

In hierdie deel stel u u persoonlike AES -sleutel in die gleuf wat u in die konfigurasie van die skyfie gedefinieer het.

Vir hierdie voorbeeld gebruik ek die gleuf nommer 9 van die skyfie.

U moet weet: 'n Spesiale kenmerk van hierdie chip is dat u slegs 4 bytes of 32 grepe in die gleuf kan skryf. Vir AES benodig ons 128 bits Key, dus 16 grepe data. Daarom het ek besluit om op die sleutel van 16 grepe elk in hierdie gleuf te skryf om 32 grepe data te hê.

Nou sal ek u die gebruikte kode wys:

/** / brief Skryf AES -sleutel in 'n gegewe gleuf. * / param [in] cfg Logiese koppelvlakkonfigurasie. Sommige vooraf gedefinieerde * konfigurasies kan gevind word in atca_cfgs.h * / param [in] sleutel sleutelsleutel nommer * / param [in] datakey sleutel skikking uint8_t * / param [in] len Grootte van die sleutel skikking * / return ATCA_SUCCESS op sukses, anders 'n foutkode. */ ATCA_STATUS write_key_slot (ATCAIfaceCfg *cfg, uint8_t key, uint8_t *datakey, size_t len) {if (key 16) return ATCA_BAD_PARAM; as (len! = 32) terugkeer ATCA_BAD_PARAM; ATCA_STATUS status = atcab_init (cfg); as (status == ATCA_SUCCESS) {status = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) sleutel, 0, 0, datakey, 32); as (status! = ATCA_SUCCESS) terugstatus; } terugstatus; }

Vir hierdie voorbeeld gebruik ek twee AES -sleutels van 16 grepe elk:

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

As hierdie aksie goed is, moet u die laaste stap deurloop "sluit die datasone"

Laaste stap: sluit die datasone

Waarskuwing: wees versigtig met hierdie stap; as u hierdie sone sluit en u data nie ingestel is nie, is die chip onbruikbaar en kan u hierdie sone nie verander nie

Vir hierdie aksie gebruik ons hierdie funksie:

/** / brief Kyk of a die DATA_ZONE of CONFIG_ZONE gesluit is

* / param [in] cfg Logiese koppelvlakkonfigurasie. Sommige vooraf gedefinieerde * konfigurasies kan gevind word in atca_cfgs.h * / param [in] sone LOCK_ZONE_DATA of LOCK_ZONE_CONFIG * / return ATCA_SUCCESS op sukses, anders 'n foutkode. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS status; bool slot = vals; as (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) terugkeer ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zone, & lock)))) {return ATCA_FUNC_FAIL; } as (! slot) {opgawe ATCA_NOT_LOCKED; } stuur ATCA_SUCCESS terug; } stuur ATCA_BAD_PARAM terug; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

As hierdie aksie goed is, is u chip gereed om te gebruik

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

Ek sal verduidelik hoe om data te enkripteer en te ontsyfer met die algoritme AES CBC en die chip Atecc608a.

Onthou: voordat u hierdie funksie gebruik, moet u die chip instel. Volg hiervoor stap 2 van hierdie artikel

Hierdie chip het 'n veelvuldige tipe AES -module (AES 128 bis), slegs AES 128 bis is moontlik:

1. AES normaal
2. AES CBC
3. AES GCM (met GFM -hash) (sien wikipedia vir meer verduideliking)

Om dit makliker te maak, het ek twee funksies geskep:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Die twee funksies is beskikbaar op my Github.

Verduideliking

Ek kies om die AES CBC -algoritme te gebruik omdat dit veiliger is as die basiese AES 128 -bis. Hierdie algoritme gebruik 'n aanvanklike vektor om u data te enkripteer.

Inligting

Hieronder beskryf ek elke stap van die enkripsie- en dekripteringsmetode. Maar ek het 'n kode vir die Arduino geskryf wat albei funksies gebruik. U kan hierdie kode in my Github sien:

• Github: My Github
• Voorbeeld van kode "Encrypt/Decrypt": AES_crypto_example.ino

Eerste stap: enkripteer u data

In hierdie gedeelte sal ek u wys hoe u u data kan versleut.

Eerstens benodig u hierdie funksie:

/** / brief Enkripteer data met behulp van AES CBC -algoritme* / param [in] cfg Logiese koppelvlakkonfigurasie. Sommige vooraf gedefinieerde * konfigurasies kan gevind word in atca_cfgs.h * / param [in] data Woorde om in te skryf (moet gedeel word deur 16, maksimum lengte 240) * / param [in] len lengte van die woorde om in te skryf (moet gedeel word met 16, maksimum lengte 240) * / param [out] iv Aanvanklike vektor wat gebruik word in die AES CBC (gee die vektor in hierdie var) * / param [out] ciffertext return here the Cypher text * / param [in] key Slot number of the sleutel * / gee ATCA_SUCCESS terug op sukses, anders 'n foutkode. */ 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 ("FOUT: ATCA_BAD_PARAM")); stuur ATCA_BAD_PARAM terug; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS status = atcab_init (cfg); as (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, sleutel, 0, tmp_iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (status, HEX); terugkeer; } memcpy (iv, tmp_iv, IV_LENGTH_CBC); memcpy (tmp_data, data, len); int max = len / 16; vir (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); } terugstatus; } terugstatus; }

Hierdie funksie is eenvoudig om te gebruik; u moet twee dinge stel:

1. 'N Leë IV (aanvanklike vektor) van 16 Bytes
2. Data om te enkripteer (maksimum grootte van 240 Bytes)

Hier is 'n voorbeeld "hoe om hierdie funksie te gebruik".

Ek wil die woord "AAAAAAAAAAAAAAAA" enkripteer, met my sleutel in die gleufnommer "9":

ATCA_STATUS status = atcab_init (& cfg); if (status! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () misluk: Kode -> 0x")); Serial.println (status, HEX); } uint8_t plaintext [16] = "AAAAAAAAAAAAAAAA"; // Oorspronklike teks uint8_t iv [IV_LENGTH_CBC]; // Aanvanklike vektor uint8_t cypherdata [sizeof (gewone teks)]; // Data versleutelde status = aes_cbc_encrypt (& cfg, plaintext, sizeof (plaintext), iv, cypherdata, 9);

As die aksie goed is, het u die geïnkripteer data in die veranderlike "cypherdata" en die aanvanklike vektor in die veranderlike "IV".

Hou die twee veranderlikes om u teks te ontsyfer!

Tweede stap: ontsyfer u data

Om u data te ontsyfer, benodig u twee dinge:

1. Die aanvanklike vektor
2. Die Cypher -data (geïnkripteer data)

Om u data te ontsyfer, benodig u hierdie funksie:

/** / kort Dekripteer data met behulp van AES CBC -algoritme* / param [in] cfg Logiese koppelvlakkonfigurasie. Sommige vooraf gedefinieerde * konfigurasies kan gevind word in atca_cfgs.h * / param [in] ciphertext Words to decypt (moet gedeel word deur 16, maksimum lengte 240) * / param [in] len lengte van Words to decept (moet gedeel word met 16, maksimum lengte 240) * / param [in] iv Aanvanklike vektor om in die AES CBC * / param [out] platteks te gebruik, gee hier die gedecodeerde teks * / param [in] sleutel Sleufnommer van die sleutel * / return ATCA_SUCCESS op sukses, anders 'n foutkode. */ 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")); stuur ATCA_BAD_PARAM terug; } ATCA_STATUS status = atcab_init (cfg); as (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, sleutel, 0, iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (status, HEX); terugkeer; } int max = len / 16; vir (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); } terugstatus; } terugstatus; }

Ek wil my vorige data ontsyfer (sien hieronder, eerste stap). Hiervoor sal ek dit doen:

uint8_t plaintext [16] = "AAAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (plaintext)]; uint8_t decryptdata [sizeof (plaintext)]; status = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) {Serial.print ("Gedecodeerde teks is:"); vir (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } anders {// Sien lêer atca_status.h vir die kode Fout Serial.print (F ("Onmoontlik om die dekripsie | Kodefout 0x")); Serial.println (status, HEX); terugkeer; }

As die aksie goed is, sal u die gedecodeerde data in die veranderlike 'decryptdata' hê.

Nou weet u hoe u kodering en dekripsie moet gebruik met die chip Atecc608a

Stap 6: 5. Waarom moet u hierdie skyfie gebruik?

Geënkripteerde data is baie handig omdat u u inligting kan verberg en deur Wireless stuur of dit net kan stoor.

Hier is 'n voorbeeld van gebruik:

1. Gestoorde data na 'n eksterne EEPROM: U kan data van 'n eksterne EEPROM beveilig, en as iemand nog hierdie EEPROM het, benodig hy die sleutel en die IV vir die dekripsie
2. Stuur draadlose data: u kan hierdie geïnkripteer data via Wireless stuur (nrf24L01, RFM95W …) en as iemand u data onderskep, is hierdie data veilig
3. Gestoorde wagwoord
4. …

Met hierdie chip kan u baie dinge doen. Dit kan in verskeie projekte gebruik word. As u tyd het, sê vir my in watter projek u hierdie chip sal gebruik?

'N Laaste advies, as u 'n draadlose projek bou of rou data stoor, wees versigtig, sekuriteit is baie belangrik, en as u weet hoe dit maklik is vir 'n' noob 'om u data te onderskep of te steel. Met die internet, kan almal skripte hê om op hul rekenaar te begin net om u te 'hack'!

Stap 7: Gevolgtrekking

Ek hoop dat hierdie artikel vir u nuttig sal wees. Jammer as ek 'n fout met my teks gemaak het, maar Engels is nie my hooftaal nie en ek praat beter as wat ek skryf.

Dankie dat u alles gelees het.

Geniet dit.