უსაფრთხოება არდუინოსთან ერთად: Atecc608a: 7 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:16

Თემა

Გამარჯობა ყველას !

ეს არის ჩემი პირველი ინსტრუქციული სტატია, ასე რომ ვიმედოვნებ, რომ საინტერესო იქნება თქვენთვის.

ამ სტატიაში მე აგიხსნით, თუ როგორ გამოიყენოთ მიკრო ჩიპი სახელწოდებით "ATECC608A", რომელიც უზრუნველყოფს უსაფრთხოების მრავალ ინსტრუმენტს.

ეს ჩიპი შექმნილია MicroChip– ის მიერ და ეს არის „CryptoAuthentication chip“- ის ბოლო ვერსია. ამ ვერსიამდე იყო "ATSHA204A" და "ATECC508A".

რატომ გადავწყვიტე გამოვიყენო ბოლო ვერსია და არა წინა ვერსია?

ეს ვერსია არის ყველაზე მოწინავე ჩიპი და მიიღო ის ფუნქციები, რაც ძველ ვერსიას არ გააჩნია (მაგალითად: AES მოდული, IO დაცვის მოდული…).

რატომ ეს პროექტი?

მე ვმუშაობ კიბერუსაფრთხოების სფეროში და როგორც ყველას მიყვარდა პროგრამირება და ელექტრონიკა. სწავლის დროს ვიღებ კონფერენციას IoT Security– ის სპეციალისტთან, რომელმაც დაგვანახა, რომ Industrial არ იყენებს უსაფრთხოებას მათ IoT ობიექტში. მე ვაჩვენე ბოქლომი, რომლის გახსნა შესაძლებელია თქვენი სმარტფონით Bluetooth- ით. ბოქლომზე, ერთ წინადადებაში ნათქვამია: "ეს ბოქლომი ყველაზე უსაფრთხოა ვიდრე გასაღების ბოქლომი!". ამ წინადადებამ მას გაიღიმა და მან შეცვალა წინადადება "ეს ბოქლომი არის ყველაზე ცუდი ბოქლომი, რაც კი ოდესმე შექმნილა!".

მან დაგვანახა საკუთარი კომპიუტერით და Bluetooth სნაიფერით, რომ სმარტფონის მიერ გაგზავნილი ყველა ბრძანება ყოველ ჯერზე ერთნაირია და ძალიან მარტივია ამ ბრძანების კოპირება და გაგზავნა თქვენი სმარტფონით. მან განგვიმარტა, რომ „უსაფრთხოება“„ინდუსტრიალისთვის“არ არის მთავარი პრობლემა. მან გვაჩვენა ჩიპები (0.60 $ -ზე ნაკლები), რომელთაც შეუძლიათ დაამატონ უსაფრთხოების ფენა ამ ობიექტებს.

ამ დემონსტრაციის შემდეგ, მე შევეცადე მეპოვა ღია კოდის პროექტი, რომელიც უსაფრთხოების ფენას მატებს IoT ობიექტს, მაგრამ მე ვერ ვიპოვე.

ამიტომ გადავწყვიტე ვიმუშაო პროექტზე, რომელიც იყენებს უსაფრთხოების ფენას ორ IoT ობიექტს შორის კომუნიკაციისთვის.

რა არის ჩემი იდეა?

ორ IoT ობიექტს შორის კომუნიკაციის დროს შეიძლება განხორციელდეს მრავალი შეტევა: Man Of the mild, ინფორმაციის ასლი და სხვა.. ასე რომ, ჩემი იდეა ძალიან მარტივია:

1. დაშიფრული მონაცემების გამოყენება ორ ან მეტ IoT ობიექტს შორის.
2. დაბალი ღირებულების მარაგები
3. შეუძლია მუშაობა Arduino UNO– სთან

ახლა მე აგიხსნით, როგორ განვახორციელე ეს აბსტრაქტული სურათი არდუინოთი და 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– ში, თითოეული ფუნქციის კომენტარებით. თუ თქვენ გაქვთ რაიმე შეკითხვა ჩემს კოდთან ან ამ პროექტთან დაკავშირებით, მე სიამოვნებით გიპასუხებთ.

ჩემი გიტუბ: ჩემი გიტუბ

ნაბიჯი 2: გაფრთხილება Atecc608a– ს შესახებ

Atecc608a ჩიპი არ არის "მარტივი" ჩიპი.

პირველი, ამ ჩიპის დოკუმენტაცია არის NDA– ს ქვეშ, ასე რომ თქვენ ვერ ნახავთ მას სრულად ინტერნეტში. მაგრამ ამის პრობლემა არ არის, წინა ვერსიის მონაცემთა ფურცელი ხელმისაწვდომია ინტერნეტ მონაცემთა ცხრილში სრული ATECC508A.

მეორე, როდესაც თქვენ იყენებთ ამ ჩიპს, თქვენ უნდა ჩაკეტოთ მისი კონფიგურაცია და შეუძლებელია ჩიპის კონფიგურაციის შეცვლა, თუ ის ჩაკეტილია. ასე რომ ფრთხილად იყავით როდის ჩაკეტავთ კონფიგურაციის ზონასა და მონაცემთა ზონას.

მესამე, ბიბლიოთეკა C დაწერილი არის ძალიან დიდი და სრულყოფილი, ასე რომ თქვენ უნდა წაიკითხოთ იმ ფუნქციების დოკუმენტაცია, რომელსაც ადრე გამოიყენებთ.

მეოთხე, ბიბლიოთეკამ დაწერა, რომ ეს ჩიპი არ მუშაობს Arduino UNO– სთვის, მაგრამ მან დაამატა ფუნქციონალურობა, რომელიც საჭიროა Arduino UNO– სთან მუშაობისთვის.

ჩიპი ATECC608A

თქვენ შეგიძლიათ დაუკავშირდეთ ამ ჩიპს I2C– ით. ამ ჩიპის მისამართი შეიძლება შეიცვალოს კონფიგურაციაში.

ეს ჩიპი შეიცავს 16 სხვადასხვა სლოტს, რომელიც შეიძლება შეიცავდეს სხვადასხვა ტიპის მონაცემებს:

1. ECC გასაღები (პირადი ან საჯარო)
2. AES გასაღები
3. სხვა მონაცემები (როგორიცაა შა ჰაში ან უბრალოდ სიტყვები)

ჩვენს შემთხვევაში, ჩვენ შევინახავთ AES Key ერთ სლოტში.

ნაბიჯი 3: 1. სქემის დიზაინი

1. სქემის დიზაინი

ამ სქემის სქემა ძალიან მარტივია!

თქვენ უნდა გამოიყენოთ 3.3 ვ სიმძლავრე, რადგან რეკომენდაცია არის 2.0 ვ - დან 5.5 ვ - მდე, მაგრამ მე ვამჯობინე გამოვიყენო 3.3 ვ.

ამ ჩიპისთვის, ჩვეულებრივ, თქვენ გაქვთ წერტილი ჩიპის კუთხეში, ეს არის ამ დაფის Pin 1. მე დავამატე Atecc608a- ს ზედა ხედი 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– ს ზედა ხედი, რადგან ის არის 8 ტყვიის SOIC, ამიტომ ჩიპი ძალიან მცირეა. თუ თქვენ გირჩევნიათ, რომ მომწოდებლები ააშენონ დაფა ჩიპების შედუღებით, ეს შეიძლება თქვენთვის უფრო ადვილი იყოს.

გაფრთხილება: ჩემს შემთხვევაში, მე უნდა დავამატო რეზისტორი არდუინოს SDA- სა და ჩიპს შორის (ასევე SDL- სთვის). თითოეულს დავამატე 4.7Kohm რეზისტორი.

ნაბიჯი 4: 2. ჩიპის კონფიგურაცია (Atecc608a)

დაშიფვრის ან გაშიფვრის ფუნქციის გამოყენებამდე საჭიროა ჩიპის კონფიგურაცია. ამ ეტაპზე, მე დეტალურად განვმარტავ ყველა იმ ნაბიჯს, რაც თქვენ უნდა გააკეთოთ ამ ჩიპის კონფიგურაციისთვის.

გაფრთხილება: ეს ნაბიჯი ძალიან მნიშვნელოვანია და თუ ზონებს ბოლომდე ჩაკეტავთ, მათ ვერ შეცვლით.

როგორც უკვე ავღნიშნეთ, ამ ჩიპს აქვს ორი ზონა:

1. კონფიგურაციის ზონა
2. მონაცემთა ზონა

კონფიგურაციის ზონამ მიიღო ზომა 128 ბაიტი, მაგრამ პირველი 16 ბაიტი არ შეიძლება შეიცვალოს.

ამ ჩიპის კონფიგურაციისთვის, თქვენ გჭირდებათ ორი, ვინც მიჰყვება ამ ნაბიჯს. ძალიან მნიშვნელოვანია დაიცვას თითოეული ნაბიჯი თანმიმდევრობით, წინააღმდეგ შემთხვევაში თქვენი კონფიგურაცია არ იმუშავებს და თქვენი ჩიპი ჩაკეტილი და გამოუსადეგარი იქნება. ეს ნაბიჯებია:

1. შექმენით კონფიგურაციის შაბლონი
2. ჩაწერეთ ეს შაბლონი ჩიპზე
3. კონფიგურაციის ზონის ჩაკეტვა
4. ჩაწერეთ თქვენი AES გასაღები (128 ბიტი) სლოტში
5. ჩაკეტეთ მონაცემთა ზონა

ინფორმაცია

ქვემოთ მე აღწერს კონფიგურაციის თითოეულ ნაბიჯს ჩემი კოდით, მაგრამ არ ინერვიულოთ, მე დავამატე კონფიგურაციის სრული მაგალითი ჩემს Github– ში. მე ვაყენებ კომენტარებს თითოეულ ფუნქციაზე და *.ino ფაილი ხელმისაწვდომია თითოეულ საფეხურზე თქვენთვის.

• ჩემი გიტუბ: ჩემი გიტუბ
• მაგალითის გზა კონფიგურაცია: configuration_example.ino

პირველი ნაბიჯი: შექმენით კონფიგურაციის შაბლონი

როგორც უკვე აღვნიშნეთ, კონფიგურაციის ზონა მიიღებს 128 ბიტის ზომას, მაგრამ პირველი 16 ბიტის შეცვლა შეუძლებელია. ეს ზონა შედგება მრავალი ნაწილისგან, მაგრამ თქვენ უნდა იცოდეთ ამ კონფიგურაციის ზონის მხოლოდ 3 ნაწილი ამ პროექტისთვის:

1. 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 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, 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, // გასაღების კონფიგურაციის სლოტი 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 // გასაღების კონფიგურაციის სლოტი 16

როგორც ხედავთ, მე დავწერე რამდენიმე კომენტარი ამ კოდში, რომ გავიგოთ მეტი ამ კონფიგურაციისთვის.

თქვენს შემთხვევაში საჭიროა მხოლოდ სამი რამის გაგება:

1. 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 ჩაწერის_კონფიგურაცია (ATCAIfaceCfg *cfg, uint8_t *კონფიგურაცია, size_t len) {თუ (len! = 112) აბრუნებს ATCA_BAD_PARAM; ATCA_STATUS სტატუსი; სტატუსი = atcab_init (cfg); თუ (სტატუსი == ATCA_SUCCESS) {// ჩაწერეთ კონფიგურაციის მასივი ჩიპზე // 16 ბაიტიანი შევსება (16 პირველი ბაიტის ჩაწერა შეუძლებელია) სტატუსი = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) კონფიგურაცია, len); დაბრუნების სტატუსი; } დაბრუნების სტატუსი; }

ეს ფუნქცია ჩაწერს თქვენს კონფიგურაციას ჩიპში.

მესამე ნაბიჯი: ჩაკეტეთ კონფიგურაციის ზონა

გაფრთხილება: ფრთხილად იყავით ამ ნაბიჯთან დაკავშირებით, თუ თქვენ ჩაკეტავთ ამ ზონას და თქვენი კონფიგურაცია არ არის კარგი, ჩიპი გამოუსადეგარია და თქვენ ვერ შეცვლით ამ ზონას

ამ მოქმედებისათვის ჩვენ გამოვიყენებთ ამ ფუნქციას:

/** / მოკლე შეამოწმეთ არის თუ არა 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 zone) {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 ბაიტი თითოეული ამ slot აქვს 32 ბაიტი მონაცემები.

ახლა მე გაჩვენებ გამოყენებულ კოდს:

/** / მოკლე ჩაწერეთ AES გასაღები მოცემულ სლოტში. * / param [in] cfg ლოგიკური ინტერფეისის კონფიგურაცია. ზოგიერთი წინასწარ განსაზღვრული * კონფიგურაცია შეგიძლიათ იხილოთ atca_cfgs.h * / param [in] გასაღების გასაღების სლოტის ნომერი * / param [in] datakey გასაღების მასივი uint8_t * / param [in] len ზომა გასაღების მასივის * / დაბრუნება ATCA_SUCCESS წარმატებაზე, წინააღმდეგ შემთხვევაში შეცდომის კოდი. */ ATCA_STATUS ჩაწერეთ_კეტი_სლოტი (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"; ჩაწერეთ_კლავი_ბლოკი (& cfg, 9, მაგალითი_კლუდი, ზომა (მაგალითი_კლუდი));

თუ ეს ქმედება კარგია, ახლა თქვენ უნდა გაიაროთ ბოლო ნაბიჯი "მონაცემთა ზონის ჩაკეტვა"

ბოლო ნაბიჯი: ჩაკეტეთ მონაცემთა ზონა

გაფრთხილება: ფრთხილად იყავით ამ ნაბიჯთან დაკავშირებით, თუ თქვენ ჩაკეტავთ ამ ზონას და თქვენი მონაცემები არ არის დაყენებული, ჩიპი გამოუსადეგარია და თქვენ ვერ შეცვლით ამ ზონას

ამ მოქმედებისათვის ჩვენ გამოვიყენებთ ამ ფუნქციას:

/** / მოკლე შეამოწმეთ არის თუ არა 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 zone) {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. ნორმალურია
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] შიფრირებული ტექსტი დააბრუნეთ აქ Cypher ტექსტი * / param [in] გასაღების სლოტის ნომერი გასაღები * / დააბრუნეთ 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; if (len> LIMIT_DATA_SIZE_CBC && len % 16! = 0) {Serial.print (F ("ERROR: ATCA_BAD_PARAM")); დაბრუნება ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS სტატუსი = atcab_init (cfg); if (სტატუსი == 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; for (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 ბაიტი)

აქ არის მაგალითი "როგორ გამოვიყენოთ ეს ფუნქცია".

მე მინდა დავაშიფრო სიტყვა "AAAAAAAAAAAAAA", ჩემი გასაღები ჩაწერილია სლოტ ნომერში "9":

ATCA_STATUS სტატუსი = atcab_init (& cfg); if (სტატუსი! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () failed: Code -> 0x")); Serial.println (სტატუსი, HEX); } uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; // ორიგინალური ტექსტი uint8_t iv [IV_LENGTH_CBC]; // საწყისი ვექტორი uint8_t cypherdata [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] შიფრირებული ტექსტში სიტყვები გასაშიფრებლად (უნდა გაიყოს 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; if (len> LIMIT_DATA_SIZE_CBC || len % 16! = 0) {Serial.print (F ("ERROR გაშიფვრა: ATCA_BAD_PARAM")); დაბრუნება ATCA_BAD_PARAM; } ATCA_STATUS სტატუსი = atcab_init (cfg); if (სტატუსი == 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; for (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] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (plaintext)]; uint8_t გაშიფრული მონაცემები [ზომა (უბრალო ტექსტი)]; სტატუსი = 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. რატომ გჭირდებათ ამ ჩიპის გამოყენება

დაშიფრული მონაცემები ძალიან სასარგებლოა, რადგან თქვენ შეგიძლიათ დამალოთ თქვენი ინფორმაცია და გაგზავნოთ უსადენოდ ან უბრალოდ შეინახოთ.

აქ არის გამოყენების მაგალითი:

1. შენახული მონაცემები გარე EEPROM– ში: თქვენ შეგიძლიათ უზრუნველყოთ გარე EEPROM– ის მონაცემები და თუ ვინმეს მაინც აქვს ეს EEPROM, მას დასჭირდება გასაღები და IV გაშიფვრისათვის
2. უკაბელო მონაცემების გაგზავნა: თქვენ შეგიძლიათ გაგზავნოთ ეს დაშიფრული მონაცემები უკაბელო საშუალებით (nrf24L01, RFM95W…) და თუ ვინმე თქვენს მონაცემებს ჩაერევა, ეს მონაცემები დაცული იქნება
3. შენახული პაროლი
4. …

ამ ჩიპით შეგიძლიათ გააკეთოთ მრავალი რამ. ის შეიძლება გამოყენებულ იქნას მრავალ პროექტში. თუ დრო გაქვთ, მითხარით რა პროექტში გამოიყენებთ ამ ჩიპს?

ერთი ბოლო რჩევა, თუ თქვენ აშენებთ რაიმე უკაბელო პროექტს ან ინახავთ რაიმე ნედლეულ მონაცემებს, იყავით ფრთხილად, უსაფრთხოება ძალიან მნიშვნელოვანია და თუ იცით, რამდენად ადვილია "ნოობისთვის" თქვენი მონაცემების ჩაჭრა ან მოპარვა. ახლა ინტერნეტით, ყველას შეუძლია ჰქონდეს სკრიპტები, რომლებიც უნდა დაიწყოს კომპიუტერში მხოლოდ თქვენი "გატეხვის" მიზნით!

ნაბიჯი 7: დასკვნა

ვიმედოვნებ, რომ ეს სტატია თქვენთვის სასარგებლო იქნება. უკაცრავად, თუ მე დავუშვი შეცდომა ჩემს ტექსტში, მაგრამ ინგლისური არ არის ჩემი მთავარი ენა და მე უკეთ ვსაუბრობ ვიდრე ვწერ.

მადლობა რომ კითხულობ ყველაფერს.

Ისიამოვნე.