Անվտանգություն Arduino- ով. Atecc608a: 7 քայլ

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:46

Թեմա

Ողջույն բոլորին !

Սա իմ առաջին հրահանգների հոդվածն է, ուստի հուսով եմ, որ այն հետաքրքիր կլինի բոլորիդ համար:

Այս հոդվածում ես ձեզ կբացատրեմ, թե ինչպես օգտագործել «ATECC608A» կոչվող միկրո չիպը, որն ապահովում է անվտանգության բազմաթիվ գործիքներ:

Այս չիպը նախագծվել է MicroChip- ի կողմից և հանդիսանում է «CryptoAuthentication chip» - ի վերջին տարբերակը: Այս տարբերակից առաջ կար «ATSHA204A» և «ATECC508A»:

Ինչու՞ որոշեցի օգտագործել վերջին և ոչ թե նախորդ տարբերակը:

Այս տարբերակը ամենաառաջադեմ չիպն է և ստացել է այնպիսի գործառույթներ, որոնք չունի հին տարբերակը (օրինակ ՝ AES մոդուլ, IO պաշտպանության մոդուլ…):

Ինչու՞ այս նախագիծը:

Ես աշխատում եմ CyberSecurity- ի տիրույթում և ինչպես բոլորը, ես սիրում էի ծրագրավորում և էլեկտրոնիկա: Ուսումնառության ընթացքում ես հանդիպում եմ ունենում IoT Security- ի մասնագետի հետ, ով մեզ ցույց տվեց, որ Industrial- ը չի օգտագործում Security իրենց IoT օբյեկտում: Ես մեզ ցույց տվեցի կողպեք, որը կարող է բացվել ձեր սմարթֆոնի միջոցով Bluetooth- ով: Կողպեքի վրա մի նախադասություն էր ասում `« Այս կողպեքը ամենաապահովն է, քան առանցքային կողպեքը »: Այս նախադասությունը ստիպեց նրան ժպտալ, և նա փոփոխեց «Այս կողպեքը երբևէ կառուցված ամենավատ կողպեքն է» նախադասությունը:

Նա մեզ ցույց տվեց իր անհատական համակարգչով և Bluetooth դիպուկ սարքով, որ սմարթֆոնի ուղարկած յուրաքանչյուր հրաման ամեն անգամ նույնն է, և շատ պարզ է պատճենել այս հրամանը և այն ուղարկել ձեր սմարթֆոնով: Նա մեզ բացատրեց, որ «Արդյունաբերական» -ի համար «անվտանգությունը» հիմնական խնդիրը չէ: Նա մեզ ցույց տվեց չիպսեր (0.60 դոլարից պակաս), որոնք կարող էին ապահովության շերտ ավելացնել այս օբյեկտներին:

Այս ցուցադրությունից հետո ես փորձեցի գտնել բաց կոդով նախագիծ, որը IoT օբյեկտին ավելացնում է անվտանգության շերտ, բայց այդպես էլ չգտա:

Այսպիսով, ես որոշեցի աշխատել մի նախագծի վրա, որն օգտագործում է անվտանգության շերտ երկու IoT օբյեկտների միջև հաղորդակցության համար:

Ո՞րն է իմ գաղափարը:

Երկու IoT օբյեկտի միջև հաղորդակցության ընթացքում կարող են լինել բազմաթիվ հարձակումներ. Մարդը մեղմ է, տեղեկատվության պատճենը և ավելին: Այսպիսով, իմ գաղափարը շատ պարզ է.

1. Երկու կամ ավելի IoT օբյեկտի միջև կոդավորված տվյալների օգտագործումը:
2. Lowածր արժեքի մատակարարումներ
3. Կարող է աշխատել Arduino UNO- ի հետ

Այժմ ես ձեզ կբացատրեմ, թե ինչպես եմ ես իրականացրել այս վերացական նկարը Arduino- ով և Atecc608a չիպով: Այս հոդվածում ես ձեզ կբացատրեմ, թե ինչպես օգտագործել Arduino UNO- ն ATECC608A- ի հետ:

Ես հաջորդ անգամ երկու օբյեկտի հաղորդակցության մասին հոդված կգրեմ:

Պարագաներ

Այս նախագծի համար ձեզ հարկավոր են մի քանի բան.

1. Arduino UNO կամ MEGA (չիպը պետք է լինի Atmega 328 կամ ATMEGA 2560)
2. Atecc608A չիպ (յուրաքանչյուրի արժեքը 0.80 դոլարից պակաս է, հեշտ է գտնել ձեր մատակարարի կայքում)
3. 8-պինյա SOIC ադապտեր
4. Որոշ լարեր և ռեզիստորներ

Այս չիպի (Atecc508a) նախորդ տարբերակի տվյալների թերթիկը հասանելի է այստեղ -> Տվյալների թերթ Atecc508a

Քայլ 1: Քայլ առ քայլ

Այս հոդվածում ես ձեզ ցույց կտամ, թե ինչպես կարելի է փոփոխել այս չիպի կազմաձևը և այն բանից հետո, թե ինչպես կարելի է ծածկագրել տվյալները ՝ օգտագործելով AES CBC ալգորիթմը:

Մենք հետևելու ենք այդ քայլերին.

1. Շղթայի ձևավորում
2. Այս չիպի կազմաձևումը
3. AES CBC մոդուլի օգտագործումը
4. Ինչու՞ է պետք օգտագործել այս չիպը

Յուրաքանչյուր քայլի համար ես ամեն ինչ կմանրամասնեմ ձեզ համար: Բացի այդ, ես ավելացրել եմ իմ կոդը իմ Github- ում `յուրաքանչյուր գործառույթի մեկնաբանություններով: Եթե ունեք հարցեր իմ կոդի կամ այս նախագծի վերաբերյալ, ես ուրախ կլինեմ պատասխանել դրան:

Իմ Github: Իմ Github

Քայլ 2: arnգուշացում Atecc608a- ի մասին

Atecc608a չիպը «հեշտ» չիպ չէ:

Նախ, այս չիպի փաստաթղթերը գտնվում են NDA- ի ներքո, այնպես որ այն ամբողջությամբ ինտերնետում չեք գտնի: Բայց դրա համար խնդիր չկա, նախորդ տարբերակի տվյալների թերթիկը հասանելի է ինտերնետային տվյալների ամբողջական էջում ՝ ATECC508A:

Երկրորդ, երբ դուք օգտագործում եք այս չիպը, դուք պետք է կողպեք դրա կազմաձևումը և անհնար է փոփոխել չիպի կազմաձևը, եթե այն կողպված է: Այսպիսով, զգույշ եղեք, երբ կողպեք Config Zone- ը և Data Zone- ը:

Երրորդ, C- ով գրադարանը շատ մեծ է և ամբողջական, այնպես որ դուք պետք է կարդաք այն գործառույթների փաստաթղթերը, որոնք նախկինում կօգտագործեք:

Չորրորդ, գրադարանն այս չիպի համար գրել է, որ չի աշխատում Arduino UNO- ի համար, բայց ավելացրել է, որ այն պետք է ունենա գործառույթներ Arduino UNO- ի հետ աշխատելու համար:

ATPC608A չիպը

Այս չիպի հետ կարող եք շփվել I2C- ով: Այս չիպի հասցեն կարող է փոփոխվել կազմաձևում:

Այս չիպը պարունակում է 16 տարբեր slots, որոնք կարող են պարունակել տարբեր տեսակի տվյալներ.

1. ECC բանալին (մասնավոր կամ հանրային)
2. AES բանալին
3. Այլ տվյալներ (ինչպես Sha hash- ը կամ պարզապես բառերը)

Մեր դեպքում մենք AES Key- ը կպահենք մեկ բնիկում:

Քայլ 3. 1. Շրջանի ձևավորում

1. Շղթայի նախագծում

Այս սխեմայի սխեման շատ պարզ է:

Դուք պետք է օգտագործեք 3.3 Վ էլեկտրաէներգիա, քանի որ առաջարկությունը գտնվում է 2.0 Վ -ից մինչև 5.5 Վ, բայց ես նախընտրեցի օգտագործել 3.3 Վ:

Այս չիպի համար, սովորաբար, դուք կետ ունեք մի չիպի մի անկյունում, սա այս տախտակի Pin 1 -ն է: Ես ավելացրել եմ Atecc608a- ի Top view- ը PIN համարով, քանի որ այն 8 կապարից SOIC է, ուստի չիպը շատ փոքր է:

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)

Դուք պետք է օգտագործեք 3.3 Վ էլեկտրաէներգիա, քանի որ առաջարկությունը 2.0 Վ -ից մինչև 5.5 Վ է, բայց ես նախընտրեցի օգտագործել 3.3 Վ -ը:

Ես ավելացրել եմ Atecc608a- ի Top view- ը, քանի որ այն 8-կապար SOIC է, ուստի չիպը շատ փոքր է: Եթե նախընտրում եք, այնպես որ մատակարարները չիպերի զոդման միջոցով որոշ տախտակ են կառուցում, դա ձեզ համար կարող է ավելի հեշտ լինել:

Arnգուշացում. Իմ դեպքում ես պետք է դիմադրություն ավելացնեմ Arduino- ի և Chip- ի SDA- ի միջև (նաև SDL- ի համար): Յուրաքանչյուրի համար ավելացրեցի 4.7 Կմ դիմադրություն:

Քայլ 4: 2. Չիպի կազմաձևում (Atecc608a)

Գաղտնագրման կամ վերծանման գործառույթը օգտագործելուց առաջ անհրաժեշտ է կարգավորել չիպը: Այս քայլում ես մանրամասն կներկայացնեմ այն բոլոր քայլերը, որոնք դուք պետք է կատարեք այս չիպի կազմաձևման համար:

Stepգուշացում. Այս քայլը շատ կարևոր է, և եթե գոտիները կողպեք մինչև վերջ, չեք կարող դրանք փոփոխել:

Ինչպես արդեն բացատրվել էր, այս չիպը ստացել է երկու գոտի.

1. Կարգավորել գոտին
2. Տվյալների գոտի

Կազմաձևման գոտին ստացել է 128 բայթ չափ, սակայն առաջին 16 բայթերը հնարավոր չէ փոփոխել:

Այս չիպը կազմաձևելու համար ձեզ հարկավոր է երկուսը հետևել այդ քայլին: Շատ կարևոր է հետևել յուրաքանչյուր քայլին ըստ հերթականության, հակառակ դեպքում ձեր կազմաձևումը չի գործի, և ձեր չիպը կողպված կլինի և պիտանի չէ: Այդ քայլերն են.

1. Ստեղծեք կազմաձևման ձևանմուշ
2. Գրեք այս կաղապարը չիպի վրա
3. Կողպեք կազմաձևման գոտին
4. Գրեք ձեր AES բանալին (128 բիթ) բնիկում
5. Կողպեք տվյալների գոտին

Տեղեկատվություն

Ստորև ես մանրամասնում եմ կոնֆիգուրացիայի յուրաքանչյուր քայլ իմ ծածկագրով, բայց անհանգստություն չկա, ես ավելացրեցի կազմաձևման ամբողջական օրինակ իմ Github- ում: Մեկնաբանություններ եմ դնում յուրաքանչյուր գործառույթի վրա, և *.ino ֆայլը հասանելի է յուրաքանչյուր քայլին `ձեզ համար:

• Իմ Github: Իմ Github
• Օրինակ `ճանապարհի կազմաձևում. Configuration_example.ino

Առաջին քայլը. Ստեղծեք կազմաձևման ձևանմուշ

Ինչպես բացատրվել է նախկինում, կազմաձևման գոտին ստանում է 128 բիթ չափ, սակայն առաջին 16 բիթերը չեն կարող փոխվել: Այս գոտին բաղկացած է բազմաթիվ մասերից, բայց այս նախագծի համար անհրաժեշտ է իմանալ այս կազմաձևման գոտու ընդամենը 3 մաս.

1. The Bytes 16 -> Սա չիպի I2C հասցեն է
2. Bytes 20 -ից 51 -> Այստեղ կարող եք փոփոխել այս չիպի 16 անցքերի բնիկի տեսակը
3. Bytes 96 -ից 127 -> Այստեղ կարող եք սահմանել բանալին կամ տվյալները, որոնք օգտագործվում են յուրաքանչյուր բնիկում:

(Եթե ձեզ անհրաժեշտ է այս ամբողջ գոտու ավելի շատ բացատրություն, կարդացեք փաստաթղթերը (էջ 13, բաժին 2.2))

Այստեղ ես մանրամասնորեն տեղադրում եմ չիպի կազմաձևման 112 բայթ յուրաքանչյուր բայթ/մաս: Սա օրինակ է, յուրաքանչյուր գնված չիպ կարող է ունենալ այլ կազմաձև.

0xC0, // I2C հասցե

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 կարգավորում 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, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0.5 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

Ինչպես տեսնում եմ, ես որոշ մեկնաբանություններ եմ դնում այս ծածկագրում ՝ այս կազմաձևն ավելի հասկանալի դարձնելու համար:

Ձեր դեպքում պետք է հասկանալ միայն երեք բան.

1. The Bytes 16 -> Սա չիպի I2C հասցեն է
2. Bytes 20 -ից 51 -> Այստեղ կարող եք փոփոխել այս չիպի 16 անցքերի բնիկի տեսակը
3. Բայթ 96 -ից մինչև 127 -> Այստեղ կարող եք սահմանել բանալին կամ տվյալները, որոնք օգտագործվում են յուրաքանչյուր բնիկում:

Ես չեմ բացատրի կոնֆիգուրացիայի տեսակը և ինչու եմ օգտագործել սա, այլ ոչ թե մյուսը, քանի որ ամեն ինչ բացատրելը բարդ է: Եթե լրացուցիչ տեղեկությունների կարիք ունեք, գնացեք փաստաթղթեր, էջ 16 բաժին 2.2.1 «SlotConfig» - ի համար և էջ 19 2.2.5 «KeyConfig» - ի համար:

Այս օրինակի համար դուք կօգտագործեք 9 անցքը ՝ AES բանալին պահելու համար:

Դրա համար մենք պետք է դնենք (եթե ձեզ անհրաժեշտ է, կարող եք պատճենել վերը նշված օրինակը, փոփոխությունը կատարվել է դրանում).

1. Բայթ 36 = 0x8F
2. Բայթ 37 = 0x0F
3. Բայթ 112 = 0x1A
4. Բայթ 113 = 0x00

Ինչու՞ դրեցի այս կազմաձևը. Այս չիպի յուրաքանչյուր բնիկի համար կարող եք պարամետրեր սահմանել, որոնք չիպին կասեն, թե ինչ տեսակի տվյալներ են պահվելու: Դուք ունեք բազմաթիվ պարամետրեր.

• Անցքը կարող է գրվել կամ կարդալ (հստակ կամ գաղտնագրված գործողություն)
• Պահված տվյալների տեսակը (ECC բանալին, հանրային բանալին, SHA Hash, AES բանալին …)
• Անցքը կարող է փակվել
• Բանալիների ստեղծում թույլատրվում է
• …

36 և 37 բայթերով `« 0x0F8F »:

• Տվյալները կարող են գրվել Clear- ում
• Այս անցքի բովանդակությունը գաղտնի է և չի կարող կարդալ
• Անցքը չի կարող օգտագործվել CheckMac Copy հրամանի համար

112 և 113 բայթերով «0x001A» - ի վրա դրված ՝

Սլոթը կարող է պահել մինչև չորս AES 128-բիթ սիմետրիկ բանալիներ (KeyType = 0x6)

Երկրորդ քայլ. Գրեք այս կազմաձևը

Այս քայլը շատ կարևոր է, քանի որ մենք կկարգավորենք չիպը մեր կազմաձևով, և եթե այս կազմաձևը լավ չէ, ապա դուք կօգտագործեք այս չիպը:

Բայց մի անհանգստացեք, քանի դեռ կազմաձևումը կողպված չէ, կարող եք փոփոխել ձեր կազմաձևը:

Ահա, այս ծածկագիրը, որը օգտագործվում է չիպին կազմաձևումը գրելու համար.

/** / համառոտ Գրեք չիպի նոր կազմաձև:

* / param [in] cfg Տրամաբանական ինտերֆեյսի կազմաձևում: Որոշ կանխորոշված * կազմաձևեր կարելի է գտնել atca_cfgs.h * / param [in] config Array uint8_t կազմաձևում (երկարություն 112) * / param [in] len Կոնֆիգուրացիայի զանգվածի չափսեր * / վերադարձնել ATCA_SUCCESS- ը հաջողության դեպքում, հակառակ դեպքում ՝ սխալի կոդ: */ ATCA_STATUS write_configuration (ATCAIfaceCfg *cfg, uint8_t *config, size_t len) {if (len! = 112) վերադարձնել ATCA_BAD_PARAM; ATCA_STATUS կարգավիճակ; կարգավիճակ = atcab_init (cfg); եթե (կարգավիճակը == ATCA_SUCCESS) {// Գրեք կազմաձևման զանգվածը չիպին // 16 բայթ (16 առաջին բայթ գրելը հնարավոր չէ) վերադարձի կարգավիճակ; } վերադարձի կարգավիճակ; }

Այս ֆունկցիան չիպի մեջ կգրի ձեր կազմաձևը:

Երրորդ քայլ. Կողպեք կազմաձևման գոտին

Arnգուշացում. Զգույշ եղեք այս քայլից, եթե կողպեք այս Գոտին, և ձեր կազմաձևումը լավ չէ, չիպը պիտանի չէ, և դուք չեք կարող փոփոխել այս գոտին:

Այս գործողության համար մենք կօգտագործենք այս գործառույթը.

/** / համառոտ Ստուգեք, արդյոք a DATA_ZONE- ը կամ CONFIG_ZONE- ը կողպված են

* / param [in] cfg Տրամաբանական ինտերֆեյսի կազմաձևում: Որոշ կանխորոշված * կազմաձևեր կարելի է գտնել atca_cfgs.h * / param [in] գոտում LOCK_ZONE_DATA կամ LOCK_ZONE_CONFIG * / վերադարձնել ATCA_SUCCESS- ը հաջողության դեպքում, հակառակ դեպքում սխալի կոդ: */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t գոտի) {ATCA_STATUS կարգավիճակ; bool lock = կեղծ; եթե (գոտի! = (uint8_t) LOCK_ZONE_CONFIG && գոտի! = (uint8_t) LOCK_ZONE_DATA) վերադարձ ATCA_BAD_PARAM; կարգավիճակ = atcab_init (cfg); եթե (կարգավիճակը == ATCA_SUCCESS) {եթե (ATCA_SUCCESS! = (կարգավիճակը = atcab_is_locked (գոտի, և կողպում))) {վերադարձ ATCA_FUNC_FAIL; } եթե (! կողպեք) {վերադարձ ATCA_NOT_LOCKED; } վերադարձ ATCA_SUCCESS; } վերադարձ ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Չորրորդ քայլ. Գրեք ձեզ AES բանալին անցքի մեջ

Այս մասում դուք ձեր անձնական AES բանալին կդնեք այն անցքի մեջ, որը դուք սահմանել եք չիպի կազմաձևում:

Այս օրինակի համար ես կօգտագործեմ չիպի 9 համարը:

Դուք պետք է իմանաք. Այս չիպի հատուկ առանձնահատկությունն այն է, որ տվյալները կարող եք գրել բնիկում միայն 4 բայթով կամ 32 բայթով: AES- ի համար մեզ անհրաժեշտ է 128 բիթ բանալին, այնպես որ 16 բայթ տվյալներ: Այսպիսով, ես որոշեցի գրել այս անցքի 16 բայթ բանալին `32 բայթ տվյալներ ունենալու համար:

Այժմ ես ձեզ ցույց կտամ օգտագործված ծածկագիրը.

/** / համառոտ Գրեք AES բանալին տվյալ բնիկում: * / param [in] cfg Տրամաբանական ինտերֆեյսի կազմաձևում: Որոշ կանխորոշված * կազմաձևեր կարելի է գտնել atca_cfgs.h * / param [in] key key slot number * / param [in] datakey key array uint8_t * / param [in] len Size of key array * / return ATCA_SUCCESS on success, հակառակ դեպքում սխալի կոդ: */ ATCA_STATUS write_key_slot (ATCAIfaceCfg *cfg, uint8_t բանալի, uint8_t *datakey, size_t len) {եթե (բանալին 16) վերադարձնել ATCA_BAD_PARAM; եթե (len! = 32) վերադարձ ATCA_BAD_PARAM; ATCA_STATUS կարգավիճակ = atcab_init (cfg); if (կարգավիճակ == ATCA_SUCCESS) {կարգավիճակ = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) բանալին, 0, 0, datakey, 32); եթե (կարգավիճակ! = ATCA_SUCCESS) վերադարձի կարգավիճակը; } վերադարձի կարգավիճակ; }

Այս օրինակի համար ես կօգտագործեմ երկու AES ստեղն ՝ 16 բայթ ՝ յուրաքանչյուրը.

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

Եթե այս գործողությունը լավ է, ապա հիմա պետք է անցնեք «տվյալների գոտին կողպեք» վերջին քայլը

Վերջին քայլը ՝ կողպեք Տվյալների գոտին

Stepգուշացում. Զգույշ եղեք այս քայլի դեպքում, եթե կողպեք այս Գոտին, և ձեր տվյալները կարգավորված չեն, չիպը պիտանի չէ, և դուք չեք կարող փոփոխել այս գոտին:

Այս գործողության համար մենք կօգտագործենք այս գործառույթը.

/** / համառոտ Ստուգեք, արդյոք a DATA_ZONE- ը կամ CONFIG_ZONE- ը կողպված են

* / param [in] cfg Տրամաբանական ինտերֆեյսի կազմաձևում: Որոշ կանխորոշված * կազմաձևեր կարելի է գտնել atca_cfgs.h * / param [in] գոտում LOCK_ZONE_DATA կամ LOCK_ZONE_CONFIG * / վերադարձնել ATCA_SUCCESS- ը հաջողության դեպքում, հակառակ դեպքում սխալի կոդ: */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t գոտի) {ATCA_STATUS կարգավիճակ; bool lock = կեղծ; եթե (գոտի! = (uint8_t) LOCK_ZONE_CONFIG && գոտի! = (uint8_t) LOCK_ZONE_DATA) վերադարձ ATCA_BAD_PARAM; կարգավիճակ = atcab_init (cfg); եթե (կարգավիճակը == ATCA_SUCCESS) {եթե (ATCA_SUCCESS! = (կարգավիճակը = atcab_is_locked (գոտի, և կողպում))) {վերադարձ ATCA_FUNC_FAIL; } եթե (! կողպեք) {վերադարձ ATCA_NOT_LOCKED; } վերադարձ ATCA_SUCCESS; } վերադարձ ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Եթե այս գործողությունը լավ է, ձեր չիպը պատրաստ է օգտագործման համար:

Քայլ 5: 3. AES CBC մոդուլի օգտագործումը

Ես կբացատրեմ, թե ինչպես կարելի է գաղտնագրել և վերծանել տվյալները AES CBC ալգորիթմով և Atecc608a չիպով:

Հիշեք. Այս գործառույթն օգտագործելուց առաջ դուք պետք է կարգավորեք չիպը: Դրա համար հետևեք այս հոդվածի 2 -րդ քայլին

Այս չիպը ստացել է AES մոդուլի բազմաթիվ տեսակներ (AES 128 բիթ), հնարավոր է միայն AES 128 բիթ:

1. AES նորմալ է
2. AES CBC
3. AES GCM (GFM հեշով) (ավելի մանրամասն տես վիքիպեդիան)

Օգտագործումն ավելի դյուրին դարձնելու համար ես ստեղծեցի երկու գործառույթ.

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Այդ երկու գործառույթները հասանելի են իմ Github- ում:

Պարզաբանում

Ես ընտրում եմ օգտագործել AES CBC ալգորիթմը, քանի որ այն ավելի անվտանգ է, քան հիմնական AES 128 բիթը: Այս ալգորիթմը օգտագործում է Նախնական վեկտոր ՝ ձեր տվյալները կոդավորելու համար:

Տեղեկատվություն

Ստորև ես մանրամասն նկարագրում եմ գաղտնագրման և վերծանման մեթոդի յուրաքանչյուր քայլ: Բայց ես Arduino- ի համար գրել եմ մի կոդ, որն օգտագործում է այդ երկու գործառույթները: Այս կոդը կարող եք տեսնել իմ Github- ում ՝

• Github: Իմ Github
• «Գաղտնագրել/վերծանել» կոդի օրինակ ՝ AES_crypto_example.ino

Առաջին քայլ. Գաղտնագրեք ձեր տվյալները

Այս մասում ես ձեզ ցույց կտամ, թե ինչպես ծածկագրել ձեր տվյալները:

Նախ ձեզ անհրաժեշտ կլինի այս գործառույթը.

/** / համառոտ Տվյալների կոդավորումը AES CBC ալգորիթմի միջոցով* / param [in] cfg Տրամաբանական ինտերֆեյսի կազմաձևում: Որոշ կանխորոշված * կազմաձևեր կարելի է գտնել atca_cfgs.h * / param [in] տվյալների մեջ: Հանրագրման ենթակա բառեր (պետք է բաժանել 16 -ի, առավելագույն երկարությունը `240) * / param [in] len length of Words to encypt (պետք է բաժանել 16 -ի, առավելագույն երկարությունը 240) * / param [out] iv AES CBC- ում օգտագործվող սկզբնական վեկտորը (վերադարձնել վեկտորը այս տարբերակում) * / param [out] ciphertext այստեղ վերադարձնել Cypher տեքստը * / param [in] key key Slot of the բանալին * / վերադարձնել ATCA_SUCCESS- ը հաջողության դեպքում, հակառակ դեպքում սխալի կոդ: */ ATCA_STATUS aes_cbc_encrypt (ATCAIfaceCfg *cfg, uint8_t *data, int len, uint8_t *iv, uint8_t *ciphertext, uint8_t բանալին) {atca_aes_cbc_ctx_t ctx; եթե (len> LIMIT_DATA_SIZE_CBC && len % 16! = 0) {Serial.print (F ("ՍԽԱԼ: ATCA_BAD_PARAM")); վերադարձ ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS կարգավիճակ = atcab_init (cfg); եթե (կարգավիճակ == ATCA_SUCCESS) {կարգավիճակ = atcab_aes_cbc_init (& ctx, բանալին, 0, tmp_iv); if (կարգավիճակ! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (կարգավիճակը, HEX); վերադարձ; } memcpy (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], & ciphertext [j * 16]); } if (կարգավիճակ! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (կարգավիճակ, HEX); } վերադարձի կարգավիճակ; } վերադարձի կարգավիճակ; }

Այս գործառույթը պարզ է օգտագործման համար, դուք պետք է սահմանեք երկու բան.

1. Դատարկ IV (սկզբնական վեկտոր) 16 բայթից
2. Տվյալները գաղտնագրելու համար (առավելագույն չափը 240 բայթ)

Ահա մի օրինակ «ինչպես օգտագործել այս գործառույթը»:

Ես ուզում եմ ծածկագրել «AAAAAAAAAAAAAAA» բառը, որի բանալին գրված է «9» համարի բնիկում.

ATCA_STATUS կարգավիճակ = atcab_init (& cfg); if (կարգավիճակ! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () failed: Code -> 0x")); Serial.println (կարգավիճակ, HEX); } uint8_t պարզ տեքստ [16] = "AAAAAAAAAAAAAAA"; // Բնագիր տեքստ uint8_t iv [IV_LENGTH_CBC]; // Սկզբնական վեկտոր uint8_t ցիպերդատներ [sizeof (plaintext)]; // Տվյալների կոդավորված կարգավիճակ = aes_cbc_encrypt (& cfg, plaintext, sizeof (plaintext), iv, cypherdata, 9);

Եթե գործողությունը լավ է, դուք կունենաք գաղտնագրված տվյալները «cypherdata» փոփոխականում, իսկ «IV» փոփոխականի մեջ ՝ սկզբնական վեկտորը:

Պահեք այդ երկու փոփոխականները ՝ ձեր տեքստը վերծանելու համար:

Երկրորդ քայլ. Գաղտնագրեք ձեր տվյալները

Ձեր տվյալները գաղտնագրելու համար ձեզ հարկավոր է երկու բան.

1. Նախնական վեկտորը
2. Cypher տվյալները (կոդավորված տվյալներ)

Ձեր տվյալները գաղտնագրելու համար ձեզ հարկավոր կլինի այս գործառույթը.

/** / համառոտ տվյալների գաղտնագրում AES CBC ալգորիթմի միջոցով* / param [in] cfg Տրամաբանական ինտերֆեյսի կազմաձևում: Որոշ կանխորոշված * կազմաձևեր կարելի է գտնել atca_cfgs.h * / param [in] ciphertext Բառեր, որոնք պետք է վերծանվեն (պետք է բաժանել 16 -ի, առավելագույն երկարությունը ՝ 240) * / param [in] len երկարությունը ՝ Բառերի վերծանման (պետք է բաժանել 16 -ի), առավելագույն երկարությունը 240) * / param [in] iv Նախնական վեկտոր ՝ AES CBC- ում օգտագործելու համար * / param [out] պարզ տեքստ այստեղ վերադարձնել գաղտնագրված տեքստը * / param [in] բանալին Բանալու անցքի համարը * / վերադարձ ATCA_SUCCESS հաջողությանը, հակառակ դեպքում սխալի կոդ: */ 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; եթե (len> LIMIT_DATA_SIZE_CBC || len % 16! = 0) {Serial.print (F ("ERROR Decrypt: ATCA_BAD_PARAM")); վերադարձ ATCA_BAD_PARAM; } ATCA_STATUS կարգավիճակ = atcab_init (cfg); եթե (կարգավիճակ == ATCA_SUCCESS) {կարգավիճակ = atcab_aes_cbc_init (& ctx, բանալին, 0, iv); if (կարգավիճակ! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (կարգավիճակ, HEX); վերադարձ; } int max = len / 16; համար (int j = 0; j <max; j ++) {status = atcab_aes_cbc_decrypt_block (& ctx, & ciphertext [j * 16], & plaintext [j * 16]); } if (կարգավիճակ! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (կարգավիճակ, HEX); } վերադարձի կարգավիճակ; } վերադարձի կարգավիճակ; }

Ես ուզում եմ վերծանել իմ նախկին տվյալները (տե՛ս ստորև ՝ Առաջին քայլ): Դրա համար ես կանեմ սա.

uint8_t plaintext [16] = "AAAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (plaintext)]; uint8_t decryptdata [sizeof (plaintext)]; կարգավիճակ = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (կարգավիճակ == ATCA_SUCCESS) {Serial.print ("Գաղտնագրված տեքստն է` "); for (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } else {// Տե՛ս atca_status.h ֆայլը Error Serial.print ծածկագրի համար (F ("Անհնար է անել գաղտնագրումը | Կոդի սխալ 0x")); Serial.println (կարգավիճակ, HEX); վերադարձ; }

Եթե գործողությունը լավ է, ապա գաղտնագրված տվյալները կունենաք «decryptdata» փոփոխականում:

Այժմ դուք գիտեք, թե ինչպես օգտագործել գաղտնագրումն ու վերծանումը Atecc608a չիպի հետ:

Քայլ 6: 5. Ինչու՞ է պետք օգտագործել այս չիպը

Գաղտնագրված տվյալները շատ օգտակար են, քանի որ կարող եք թաքցնել ձեր տվյալները և դրանք ուղարկել Wireless- ով կամ պարզապես պահել դրանք:

Ահա օգտագործման մի քանի օրինակ.

1. Արտաքին EEPROM- ում պահվող տվյալներ. Դուք կարող եք ապահովել արտաքին EEPROM- ի տվյալները, և եթե ինչ -որ մեկը դեռևս այս EEPROM- ն է, ապա գաղտնագրման համար նրան անհրաժեշտ կլինեն Բանալին և IV- ը:
2. Ուղարկեք անլար տվյալներ. Դուք կարող եք այս գաղտնագրված տվյալները ուղարկել անլար (nrf24L01, RFM95W…) միջոցով, և եթե ինչ -որ մեկը գաղտնալսում է ձեր տվյալները, այս տվյալները ապահով կլինեն
3. Պահված գաղտնաբառ
4. …

Այս չիպի միջոցով կարող եք մի քանի բան անել: Այն կարող է օգտագործվել բազմաթիվ նախագծերում: Եթե ժամանակ ունեք, ասեք, թե որ նախագծում եք օգտագործելու այս չիպը:

Մի վերջին խորհուրդ. Եթե անլար նախագիծ եք կառուցում կամ ինչ -որ հում տվյալներ եք պահում, զգույշ եղեք, անվտանգությունը շատ կարևոր է, և եթե գիտեք, թե ինչպես է պարզ մարդկանց համար գաղտնալսելը կամ գողանալը: Այժմ, երբ ինտերնետն է, յուրաքանչյուրը կարող է ունենալ սցենարներ ՝ իր համակարգչում գործարկելու համար, պարզապես ձեզ «կոտրելու» համար:

Քայլ 7: Եզրակացություն

Հուսով եմ, որ այս հոդվածը օգտակար կլինի ձեզ համար: Կներեք, եթե ես սխալվել եմ իմ տեքստում, բայց անգլերենը իմ հիմնական լեզուն չէ, և ես ավելի լավ եմ խոսում, քան գրում եմ:

Շնորհակալություն ամեն ինչ կարդալու համար:

Վայելիր.