Seguridad Sa Arduino: Atecc608a: 7 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:11

Paksa

Kamusta po kayo lahat!

Ito ang aking unang Artikulo sa Mga Tagubilin kaya't inaasahan kong magiging kawili-wili ito para sa inyong lahat.

Sa artikulong ito, ipapaliwanag ko sa iyo kung paano gumamit ng isang micro chip na tinatawag na "ATECC608A" na nagbibigay ng maraming mga tool sa seguridad.

Ang chip na ito ay dinisenyo ng MicroChip at ito ang huling bersyon ng "CryptoAuthentication chip". Bago ang bersyon na ito, mayroong "ATSHA204A" at ang "ATECC508A".

Bakit ako nagpasya na gamitin ang huling bersyon at hindi ang dating bersyon?

Ang bersyon na ito ay ang pinaka-advanced na maliit na tilad at nakuha ang mga pagpapaandar na ang lumang bersyon ay walang (Halimbawa: AES module, IO proteksyon module …).

Bakit ang proyektong ito?

Nagtatrabaho ako sa domain ng CyberSecurity at bilang lahat na gusto ko ng programa at electronics. Sa panahon ng aking pag-aaral, nakakakuha ako ng isang pagpupulong kasama ang isang dalubhasa sa IoT Security na nagpakita sa amin na hindi ginagamit ng Industrial ang Seguridad sa kanilang IoT object. Nagpakita ako sa amin ng isang padlock na maaaring buksan sa iyong smartphone sa pamamagitan ng Bluetooth. Sa padlock, sinabi ng isang pangungusap na "Ang padlock na ito ay pinaka-ligtas kaysa sa isang key padlock!". Ang pangungusap na ito ay nakangiti sa kanya at binago niya ang pangungusap na "Ang padlock na ito ay ang pinakapangit na padlock na nabuo kailanman!".

Ipinakita niya sa amin gamit ang kanyang sariling PC at isang Bluetooth sniffer na ang bawat utos na ipinadala ng smartphone ay pareho sa bawat oras at napakasimple na kopyahin ang utos na ito at ipinadala ito sa iyong smartphone. Ipinaliwanag niya sa amin na ang "Seguridad" para sa "Pang-industriya" ay hindi ang pangunahing problema. Ipinakita niya sa amin ang mga chips (mas mababa sa 0.60 $) na maaaring magdagdag ng isang layer ng seguridad sa mga bagay na ito.

Matapos ang demonstrasyong ito, sinubukan kong makahanap ng ilang proyekto ng Open source na nagdaragdag ng layer ng seguridad sa IoT object ngunit hindi ko ito nahanap.

Kaya't nagpasya akong magtrabaho sa isang proyekto na gumagamit ng layer ng seguridad para sa komunikasyon sa pagitan ng dalawang bagay na IoT.

Ano ang aking ideya?

Sa panahon ng isang komunikasyon sa pagitan ng dalawang IoT Object, maraming pag-atake ang maaaring mayroon: Man Of the banayad, Kopya ng impormasyon at marami pa.. Kaya't ang aking ideya ay napaka-simple:

1. Paggamit ng naka-encrypt na data sa pagitan ng dalawa o higit pang IoT object.
2. Mga supply ng mababang gastos
3. Maaaring gumana sa isang Arduino UNO

Ngayon ay ipapaliwanag ko sa iyo kung paano ko ipinatupad ang abstract na larawan na ito sa isang Arduino at isang Atecc608a chip. Sa artikulong ito, ipapaliwanag ko sa iyo kung paano gamitin ang Arduino UNO sa ATECC608A.

Susulat ako ng isang artikulo tungkol sa komunikasyon ng dalawang bagay sa susunod.

Mga gamit

Kailangan mo ng ilang mga bagay para sa proyektong ito:

1. Arduino UNO o MEGA (Ang Chip ay dapat na Atmega 328 o ATMEGA 2560)
2. Atecc608A chip (nagkakahalaga ng mas mababa sa 0.80 $ bawat isa, madaling makita sa iyong website ng tagapagtustos)
3. 8-Pin SOIC Adapter
4. Ang ilang mga wire at resistors

Ang datasheet ng nakaraang bersyon ng chip na ito (Atecc508a) ay magagamit dito -> Datasheet Atecc508a

Hakbang 1: Hakbang-hakbang

Sa artikulong ito, ipapakita ko sa iyo kung paano baguhin ang pagsasaayos ng chip na ito at pagkatapos kung paano mag-encrypt ng data gamit ang AES CBC Algorithme.

Susundan namin ang mga hakbang na iyon:

1. Disenyo ng circuit
2. Pag-configure ng chip na ito
3. Paggamit ng module ng AES CBC
4. Bakit mo kailangang gamitin ang chip na ito

Para sa bawat hakbang, ididetalye ko ang lahat para sa iyo. Gayundin, idinagdag ko ang aking code sa aking Github na may mga komento para sa bawat pag-andar. Kung mayroon kang ilang mga katanungan tungkol sa aking code o sa proyektong ito, masisiyahan akong sagutin ito.

Aking Github: Aking Github

Hakbang 2: Babala Tungkol sa Atecc608a

Ang Atecc608a chip ay hindi isang "madaling" maliit na tilad.

Una, ang dokumentasyon ng chip na ito ay nasa ilalim ng NDA kaya't hindi mo ito makitang kumpleto sa Internet. Ngunit walang problema para dito, ang datasheet ng nakaraang bersyon ay magagamit sa Internet Datasheet Kumpletuhin ang ATECC508A.

Pangalawa, kapag ginamit mo ang chip na ito kailangan mong i-lock ang pagsasaayos nito at imposibleng baguhin ang pagsasaayos ng maliit na tilad kung ito ay naka-lock. Kaya mag-ingat kung kailan mo mai-lock ang Config Zone at ang Data Zone.

Pangatlo, ang aklatan ay sumulat sa C ay napakalaki at kumpleto, kaya't dapat mong basahin ang dokumentasyon ng mga pagpapaandar na gagamitin mo dati.

Apat, ang silid-aklatan ay nagsulat para sa maliit na tilad na ito ay hindi gagana para sa Arduino UNO, ngunit idinagdag nito na kailangan ito ng mga pagpapaandar upang gumana sa Arduino UNO.

Ang chip ATECC608A

Maaari kang makipag-usap sa chip na ito sa pamamagitan ng I2C. Ang address ng chip na ito ay maaaring mabago sa pagsasaayos.

Naglalaman ang chip na ito ng 16 magkakaibang mga puwang na maaaring maglaman ng iba't ibang uri ng data:

1. ECC Key (pribado o pampubliko)
2. Susi ng AES
3. Iba pang data (tulad ng Sha hash o mga salita lamang)

Sa aming kaso, iimbak namin ang AES Key sa isang puwang.

Hakbang 3: 1. Pagnanasa ng Circuit

1. Disenyo ng circuit

Ang iskema ng circuit na ito ay napaka-simple!

Kailangan mong gumamit ng lakas ng 3.3V dahil ang rekomendasyon ay nasa pagitan ng 2.0V at 5.5V ngunit mas gusto kong gamitin ang 3.3V.

Para sa chip na ito, karaniwang mayroon kang isang tuldok sa isang sulok ng maliit na tilad, ang tuldok na ito ay ang Pin 1 ng board na ito. Idinagdag ko ang Nangungunang view ng Atecc608a na may PIN Number dahil ito ay isang 8-Lead SOIC kaya't napakaliit ng maliit na tilad.

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)

Kailangan mong gumamit ng lakas ng 3.3V dahil ang rekomendasyon ay nasa pagitan ng 2.0V at 5.5V ngunit mas gusto kong gamitin ang 3.3V.

Idinagdag ko ang Nangungunang view ng Atecc608a sapagkat ito ay isang 8-Lead SOIC kaya't napakaliit ng maliit na tilad. Kung gusto mo, kaya't ang mga supplier ay nagtatayo ng ilang board na may chip solder, maaaring mas madali ito para sa iyo.

Babala: Sa aking kaso, kailangan kong magdagdag ng isang risistor sa pagitan ng SDA ng Arduino at ng Chip (para din sa SDL). Nagdagdag ako ng isang 4.7Kohm risistor para sa bawat isa.

Hakbang 4: 2. Pag-configure ng Chip (Atecc608a)

Bago gamitin ang pagpapaandar ng pag-encrypt o decryption kailangan mong i-configure ang maliit na tilad. Sa hakbang na ito, idedetalye ko ang bawat hakbang na kailangan mong gawin para sa pagsasaayos ng chip na ito.

Babala: ang hakbang na ito ay napaka-import at kung i-lock mo ang mga zone bago ang katapusan ay hindi mo mababago ang mga ito.

Tulad ng ipinaliwanag dati, ang chip na ito ay nakakuha ng dalawang zone:

1. Config Zone
2. Data Zone

Ang configuration Zone ay nakakuha ng sukat na 128 bytes ngunit ang unang 16 bytes ay hindi maaaring mabago.

Upang mai-configure ang chip na ito, kailangan mo ng dalawang sundin ang hakbang na iyon. Napakahalaga na sundin ang bawat hakbang sa pagkakasunud-sunod o ang iyong pagsasaayos ay hindi gagana, at ang iyong maliit na tilad ay mai-lock at hindi magagamit. Ang mga hakbang na iyon ay:

1. Lumikha ng isang template ng pagsasaayos
2. Isulat ang template na ito sa maliit na tilad
3. I-lock ang Config Zone
4. Isulat ang iyong AES Key (128 Bits) sa isang puwang
5. I-lock ang Data Zone

Impormasyon

Nasa ibaba ko ang mga detalye ng bawat hakbang ng pag-conifgursyon kasama ang aking code, ngunit walang mga alalahanin, nagdagdag ako ng isang buong halimbawa ng pagsasaayos sa aking Github. Naglalagay ako ng mga komento sa bawat pag-andar, at isang *.ino file ang magagamit sa bawat hakbang upang para sa iyo.

• Aking Github: Aking Github
• Landas ng Halimbawa ng Pag-configure: pagsasaayos_example.ino

Unang hakbang: Lumikha ng isang template ng pagsasaayos

Tulad ng ipinaliwanag dati, ang configure zone ay nakakakuha ng sukat na 128 bits, ngunit ang unang 16 na piraso ay hindi mababago. Ang zone na ito ay binubuo ng maraming bahagi, ngunit kailangan mong malaman ang 3 bahagi lamang ng configuration zone para sa proyektong ito:

1. Ang Bytes 16 -> Ito ang I2C address ng maliit na tilad
2. Ang Bytes 20 hanggang 51 -> Maaari mong baguhin dito ang uri ng Slot para sa 16 na puwang ng chip na ito
3. Ang Bytes 96 hanggang 127 -> Maaari mong itakda dito ang Uri ng key o data na ginamit sa bawat puwang.

(Kung kailangan mo ng mas maraming explication ng lahat ng zone na ito, mangyaring basahin ang dokumentasyon (pahina 13, seksyon 2.2))

Dito, inilagay ko ang mga detalye sa bawat Bytes / Bahagi ng 112 bytes ng pagsasaayos ng isang Chip. Ito ay isang halimbawa, ang bawat biniling chip ay maaaring magkaroon ng iba't ibang pagsasaayos:

0xC0, // I2C address

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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, // Key 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 // Key Config Slot 16

Tulad ng nakikita, naglalagay ako ng ilang mga komento sa code na ito upang maunawaan ang higit pang pagsasaayos na ito.

Sa iyong kaso na kailangang maunawaan ang tatlong bagay lamang:

1. Ang Bytes 16 -> Ito ang I2C address ng maliit na tilad
2. Ang Bytes 20 hanggang 51 -> Maaari mong baguhin dito ang uri ng Slot para sa 16 na puwang ng chip na ito
3. Ang Byte 96 hanggang 127 -> Maaari mong itakda dito ang Uri ng key o data na ginamit sa bawat puwang.

Hindi ko ipaliwanag ang uri ng pagsasaayos at kung bakit ko ito ginamit at hindi sa iba dahil kumplikado itong ipaliwanag ang lahat. Kung kailangan mo ng karagdagang impormasyon pumunta sa dokumentasyon, pahina 16 seksyon 2.2.1 para sa "SlotConfig" at pahina 19 seksyon 2.2.5 para sa "KeyConfig"

Para sa halimbawang ito, gagamitin mo ang slot 9 upang mag-imbak ng isang key ng AES.

Para sa mga ito, kailangan naming ilagay (kung kailangan mo, maaari mong kopyahin ang halimbawa sa itaas, ang pagbabago ay nagawa na rito):

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

Bakit ko itinakda ang pagsasaayos na ito: Para sa bawat puwang ng chip na ito, maaari kang magtakda ng mga parameter upang sabihin sa maliit na tilad kung anong uri ng data ang maiimbak. Marami kang mga parameter:

• Ang slot ay maaaring sumulat o mabasa (malinaw o naka-encrypt na aksyon)
• Uri ng data na nakaimbak (ECC key, Public Key, SHA Hash, AES Key…)
• Ang slot ay maaaring ma-lock
• Pinapayagan ang pagbuo ng susi
• …

Sa pamamagitan ng byte 36 at 37 na nakatakda sa "0x0F8F":

• Maaaring isulat ang data sa Malinaw
• Ang nilalaman ng slot na ito ay lihim at hindi mabasa
• Hindi magagamit ang slot para sa utos ng CheckMac Copy

Gamit ang byte 112 at 113 na nakatakda sa "0x001A":

Maaaring mag-imbak ang slot ng hanggang sa apat na AES 128-bit na simetriko na mga key (KeyType = 0x6)

Pangalawang hakbang: Isulat ang pagsasaayos na ito

Napakahalaga ng hakbang na ito dahil itatakda namin ang chip sa aming pagsasaayos at kung ang pagsasaayos na ito ay hindi maganda, gagamitin mo ang chip na ito.

Ngunit walang mga alalahanin, hangga't ang Configuration ay hindi naka-lock, maaari mong baguhin ang iyong pagsasaayos.

Dito, ito ang ginamit na code upang isulat ang pagsasaayos sa maliit na tilad:

/ ** / maikling Sumulat ng isang bagong pagsasaayos sa maliit na tilad.

* / param [in] cfg Lohikal na pagsasaayos ng interface. Ang ilang mga paunang natukoy na * pagsasaayos ay matatagpuan sa atca_cfgs.h * / param [in] config Array uint8_t ng pagsasaayos (haba 112) * / param [in] len Sukat ng array ng pagsasaayos * / ibalik ang ATCA_SUCCESS sa tagumpay, kung hindi man isang error code. * / ATCA_STATUS write_configuration (ATCAIfaceCfg * cfg, uint8_t * config, size_t len) {kung (len! = 112) ibalik ang ATCA_BAD_PARAM; Katayuan ng ATCA_STATUS; katayuan = atcab_init (cfg); kung (status == ATCA_SUCCESS) {// Isulat ang pagsasaayos ng Array sa maliit na til // Padding ng 16 byte (16 unang byte ay hindi maaaring i-writ) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); pagbalik ng katayuan; } katayuan sa pagbabalik; }

Isusulat ng pagpapaandar na ito ang iyong pagsasaayos sa maliit na tilad.

Pangatlong hakbang: i-lock ang Zone ng pagsasaayos

Babala: mag-ingat sa hakbang na ito, kung i-lock mo ang Zone na ito at ang iyong pagsasaayos ay hindi maganda, hindi magagamit ang maliit na tilad at hindi mo mababago ang zone na ito

Para sa pagkilos na ito, gagamitin namin ang pagpapaandar na ito:

/ ** / maikling Suriin kung ang isang DATA_ZONE o CONFIG_ZONE ay naka-lock

* / param [in] cfg Lohikal na pagsasaayos ng interface. Ang ilang mga paunang natukoy na * pagsasaayos ay matatagpuan sa atca_cfgs.h * / param [sa] zone LOCK_ZONE_DATA o LOCK_ZONE_CONFIG * / ibalik ang ATCA_SUCCESS sa tagumpay, kung hindi man isang error code. * / ATCA_STATUS check_lock_zone (ATCAIfaceCfg * cfg, uint8_t zone) {ATCA_STATUS status; bool lock = false; kung (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) ibalik ang ATCA_BAD_PARAM; katayuan = atcab_init (cfg); kung (status == ATCA_SUCCESS) {kung (ATCA_SUCCESS! = (status = atcab_is_locked (zone, & lock)) {return ATCA_FUNC_FAIL; } kung (! lock) {return ATCA_NOT_LOCKED; } ibalik ang ATCA_SUCCESS; } ibalik ang ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Pang-apat na hakbang: Isulat sa iyo ang AES Key sa isang puwang

Sa bahaging ito ay magtatakda ka sa iyo ng personal na key ng AES sa puwang na iyong tinukoy sa pagsasaayos ng maliit na tilad.

Para sa halimbawang ito, gagamitin ko ang slot number 9 ng chip.

Kailangan mong malaman: Ang isang espesyal na tampok ng chip na ito ay maaari kang magsulat ng data sa puwang lamang ng 4 bytes o 32 bytes. Para sa AES kailangan namin ng 128 bits Key kaya 16 bytes ng data. Kaya't nagpasya akong sumulat sa susi ng 16 bytes bawat isa sa puwang na ito upang magkaroon ng 32 data bytes.

Ngayon, ipapakita ko sa iyo ang ginamit na code:

/ ** / maikling Sumulat ng susi ng AES sa isang naibigay na puwang. * / param [in] cfg Lohikal na pagsasaayos ng interface. Ang ilang mga paunang natukoy na * pagsasaayos ay matatagpuan sa atca_cfgs.h * / param [in] key key slot number * / param [in] datakey key array uint8_t * / param [in] len Sukat ng key array * / ibalik ang ATCA_SUCCESS sa tagumpay, kung hindi man isang error code. * / ATCA_STATUS write_key_slot (ATCAIfaceCfg * cfg, uint8_t key, uint8_t * datakey, size_t len) {kung (key 16) ibalik ang ATCA_BAD_PARAM; kung (len! = 32) ibalik ang ATCA_BAD_PARAM; ATCA_STATUS katayuan = atcab_init (cfg); kung (status == ATCA_SUCCESS) {status = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) key, 0, 0, datakey, 32); kung (katayuan! = ATCA_SUCCESS) pagbalik ng katayuan; } katayuan sa pagbabalik; }

Para sa halimbawang ito, gagamit ako ng dalawang AES Keys na 16 bytes bawat isa:

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

Kung ang aksyon na ito ay mabuti, ngayon, kailangan mong ipasa ang huling hakbang na "i-lock ang data zone"

Huling hakbang: i-lock ang Data Zone

Babala: mag-ingat sa hakbang na ito, kung i-lock mo ang Zone na ito at ang iyong data ay hindi nakatakda, ang chip ay hindi magagamit at hindi mo mababago ang zone na ito

Para sa pagkilos na ito, gagamitin namin ang pagpapaandar na ito:

/ ** / maikling Suriin kung ang isang DATA_ZONE o CONFIG_ZONE ay naka-lock

* / param [in] cfg Lohikal na pagsasaayos ng interface. Ang ilang mga paunang natukoy na * pagsasaayos ay matatagpuan sa atca_cfgs.h * / param [sa] zone LOCK_ZONE_DATA o LOCK_ZONE_CONFIG * / ibalik ang ATCA_SUCCESS sa tagumpay, kung hindi man isang error code. * / ATCA_STATUS check_lock_zone (ATCAIfaceCfg * cfg, uint8_t zone) {ATCA_STATUS status; bool lock = false; kung (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) ibalik ang ATCA_BAD_PARAM; katayuan = atcab_init (cfg); kung (status == ATCA_SUCCESS) {kung (ATCA_SUCCESS! = (status = atcab_is_locked (zone, & lock)) {return ATCA_FUNC_FAIL; } kung (! lock) {return ATCA_NOT_LOCKED; } ibalik ang ATCA_SUCCESS; } ibalik ang ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Kung ang aksyon na ito ay mabuti, ang iyong maliit na tilad ay handa nang gamitin

Hakbang 5: 3. Paggamit ng AES CBC Module

Ipapaliwanag ko kung paano i-encrypt at i-decrypt ang data sa algorithm AES CBC at ang chip Atecc608a.

Tandaan: Bago gamitin ang pagpapaandar na ito, kailangan mong i-set up ang maliit na tilad. Para sa mga ito, sundin ang hakbang 2 ng artikulong ito

Ang chip na ito ay nakakuha ng maraming uri ng AES module (AES 128 bits), AES 128 bits lamang ang posible:

1. Normal ang AES
2. AES CBC
3. AES GCM (na may GFM hash) (tingnan ang wikipedia para sa mas maraming explication)

Upang gawing mas madaling gamitin, gumawa ako ng dalawang pag-andar:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Ang dalawang pagpapaandar na iyon ay magagamit sa aking Github.

Paglalahad

Pinili kong gamitin ang AES CBC Algorithm dahil mas ligtas ito kaysa sa pangunahing AES 128 bits. Gumagamit ang algorithm na ito ng isang Paunang Vector upang i-encrypt ang iyong data.

Impormasyon

Sa ibaba ko detalyado ang bawat hakbang ng pamamaraan ng pag-encrypt at pag-decryption. Ngunit nagsulat ako ng isang code para sa Arduino na gumagamit ng parehong mga pag-andar. Maaari mong makita ang code na ito sa aking Github:

• Github: Aking Github
• Halimbawa ng code na "Encrypt / Decrypt": AES_crypto_example.ino

Unang hakbang: I-encrypt ang iyong data

Sa bahaging ito, ipapakita ko sa iyo kung paano i-encrypt ang iyong data.

Una kakailanganin mo ang pagpapaandar na ito:

/ ** / maikling I-encrypt ang data gamit ang AES CBC algorithm * / param [in] cfg Logical interface config. Ang ilang mga paunang natukoy na * pagsasaayos ay matatagpuan sa atca_cfgs.h * / param [sa] data na Mga salita sa enc Egypt (dapat hatiin sa 16, max haba 240) * / param [sa] len haba ng Words to enc Egypt (dapat hatiin sa 16, max haba 240) * / param [out] iv Paunang Vector na ginamit sa AES CBC (ibalik ang vector sa var na ito) * / param [out] ciphertext bumalik dito ang teksto ng Cypher * / param [sa] key ng numero ng Slot ng key * / ibalik ang ATCA_SUCCESS sa tagumpay, kung hindi man isang error code. * / 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; kung (len> LIMIT_DATA_SIZE_CBC && len% 16! = 0) {Serial.print (F ("ERROR: ATCA_BAD_PARAM")); ibalik ang ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS katayuan = atcab_init (cfg); kung (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, key, 0, tmp_iv); kung (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (katayuan, HEX); bumalik; } memcpy (iv, tmp_iv, IV_LENGTH_CBC); memcpy (tmp_data, data, len); int max = len / 16; para sa (int j = 0; j <max; j ++) {status = atcab_aes_cbc_encrypt_block (& ctx, & tmp_data [j * 16], & ciphertext [j * 16]); } kung (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (katayuan, HEX); } katayuan sa pagbabalik; } katayuan sa pagbabalik; }

Ang pagpapaandar na ito ay simpleng gamitin, kailangan mong magtakda ng dalawang bagay:

1. Isang walang laman na IV (Paunang Vector) na 16 Bytes
2. Data na naka-encrypt (max na laki ng 240 Bytes)

Narito ang isang halimbawa "kung paano gamitin ang pagpapaandar na ito".

Gusto kong i-encrypt ang salitang "AAAAAAAAAAAAAAA", gamit ang aking susi na sumulat sa numero ng puwang na "9":

ATCA_STATUS katayuan = atcab_init (& cfg); kung (status! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () bigo: Code -> 0x")); Serial.println (katayuan, HEX); } uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; // Orihinal na teksto uint8_t iv [IV_LENGTH_CBC]; // Initial Vector uint8_t cypherdata [sizeof (plaintext)]; // Status ng naka-encrypt na data = aes_cbc_encrypt (& cfg, plaintext, sizeof (plaintext), iv, cypherdata, 9);

Kung ang aksyon ay mabuti, magkakaroon ka ng naka-encrypt na data sa variable na "cypherdata" at sa Paunang Vector sa variable na "IV".

Panatilihin ang dalawang variable na iyon upang mai-decrypt ang iyong teksto!

Pangalawang hakbang: i-decrypt ang iyong data

Upang mai-decrypt ang iyong data kakailanganin mo ang dalawang bagay:

1. Ang Paunang Vector
2. Ang data ng Cypher (naka-encrypt na data)

Upang mai-decrypt ang iyong data, kakailanganin mo ang pagpapaandar na ito:

/ ** / maikling I-decrypt ang data gamit ang AES CBC algorithm * / param [sa] cfg Logical interface config. Ang ilang mga paunang natukoy na * pagsasaayos ay matatagpuan sa atca_cfgs.h * / param [in] ciphertext Words to dec Egypt (dapat hatiin ng 16, max haba 240) * / param [sa] len haba ng Words to dec Egypt (dapat hatiin sa 16, max haba 240) * / param [in] iv Paunang Vector na gagamitin sa AES CBC * / param [out] plaintext ibabalik dito ang naka-decrypt na teksto * / param [sa] key na Numero ng slot ng susi * / ibalik ang ATCA_SUCCESS sa tagumpay, kung hindi man isang error code. * / 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; kung (len> LIMIT_DATA_SIZE_CBC || len% 16! = 0) {Serial.print (F ("ERROR Decrypt: ATCA_BAD_PARAM")); ibalik ang ATCA_BAD_PARAM; } ATCA_STATUS katayuan = atcab_init (cfg); kung (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, key, 0, iv); kung (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (katayuan, HEX); bumalik; } int max = len / 16; para sa (int j = 0; j <max; j ++) {status = atcab_aes_cbc_decrypt_block (& ctx, & ciphertext [j * 16], & plaintext [j * 16]); } kung (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (katayuan, HEX); } katayuan sa pagbabalik; } katayuan sa pagbabalik; }

Nais kong i-decrypt ang aking dating data (tingnan sa ibaba, Unang hakbang). Para sa mga ito ay gagawin ko ito:

uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (plaintext)]; uint8_t decryptdata [sizeof (plaintext)]; katayuan = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); kung (status == ATCA_SUCCESS) {Serial.print ("Ang naka-decong teksto ay:"); para sa (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } iba pa {// Tingnan ang file atca_status.h para sa code Error Serial.print (F ("Imposibleng gawin ang decryption | Code Error 0x")); Serial.println (katayuan, HEX); bumalik; }

Kung ang aksyon ay mabuti, magkakaroon ka ng decrypted data sa variable na "decryptdata".

Ngayon alam mo kung paano gamitin ang pag-encrypt at decryption gamit ang chip Atecc608a

Hakbang 6: 5. Bakit Kailangan Mong Gamitin ang Chip na Ito

Ang naka-encrypt na data ay lubhang kapaki-pakinabang sapagkat maaari mong itago ang iyong impormasyon at ipadala ito sa pamamagitan ng Wireless o iimbak lamang ito.

Narito ang ilang halimbawa ng paggamit:

1. Naka-imbak na data sa isang panlabas na EEPROM: Maaari kang mag-secure ng data ng isang panlabas na EEPROM at kung ang isang tao pa rin ang EEPROM na ito, kakailanganin niya ang Susi at ang IV para sa decryption
2. Magpadala ng data ng Wireless: Maaari mong ipadala ang naka-encrypt na data sa pamamagitan ng Wireless (nrf24L01, RFM95W…) at kung may humarang sa iyong data, magiging ligtas ang data na ito
3. Nakaimbak na password
4. …

Maaari kang gumawa ng maraming bagay sa chip na ito. Maaari itong magamit sa maraming proyekto. Kung mayroon kang oras, sabihin sa akin sa anong proyekto ang gagamitin mo ang maliit na tilad na ito?

Isang huling payo, kung bumuo ka ng ilang proyekto ng wireless o mag-iimbak ng ilang hilaw na data, mag-ingat, ang seguridad ay napakahalaga at kung alam mo kung paano ito simple para sa isang "noob" na maharang o magnakaw ng iyong data. Ngayon sa Internet, lahat ay maaaring magkaroon ng mga script na ilulunsad sa kanilang computer upang "ma-hack" ka lang!

Hakbang 7: Konklusyon

Inaasahan kong ang artikulong ito ay magiging kapaki-pakinabang para sa iyo. Paumanhin kung nagkamali ako sa aking teksto ngunit ang Ingles ay hindi ang aking pangunahing wika at mas mahusay akong magsalita kaysa sa pagsusulat.

Salamat sa pagbabasa ng lahat.

Tangkilikin mo ito