Biztonság az Arduino segítségével: Atecc608a: 7 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:40

Téma

Üdv mindenkinek !

Ez az első Instructables cikkem, ezért remélem, hogy érdekes lesz mindannyiótok számára.

Ebben a cikkben elmagyarázom, hogyan kell használni az "ATECC608A" nevű mikrochipet, amely több biztonsági eszközt biztosít.

Ezt a chipet a MicroChip tervezte, és ez a "CryptoAuthentication chip" utolsó verziója. A verzió előtt volt az "ATSHA204A" és az "ATECC508A".

Miért döntöttem úgy, hogy az utolsó verziót használom, és nem az előző verziót?

Ez a verzió a legfejlettebb chip, és olyan funkciókkal rendelkezik, amelyekkel a régi verzió nem rendelkezik (például: AES modul, IO védelmi modul …).

Miért ez a projekt?

A CyberSecurity területén dolgozom, és mint mindenki, szerettem a programozást és az elektronikát. Tanulmányaim során konferenciát kapok az IoT biztonsággal foglalkozó szakemberrel, aki megmutatta nekünk, hogy az Industrial nem használja a Biztonságot az IoT objektumában. Megmutattam egy lakatot, amely Bluetooth -on keresztül nyitható az okostelefonnal. A lakaton egy mondat szólt: "Ez a lakat a legbiztonságosabb, mint a kulcs lakat!". Ez a mondat megmosolyogtatja, és módosította a mondatot: "Ez a lakat a legrosszabb lakat, amit valaha építettek!".

Saját PC -jével és Bluetooth -szippantójával megmutatta nekünk, hogy az okostelefon által küldött összes parancs minden alkalommal ugyanaz, és nagyon egyszerű ezt a parancsot lemásolni, és elküldeni az okostelefonjával. Elmagyarázta nekünk, hogy az "Ipari" "biztonsága" nem a fő probléma. Zsetonokat mutatott nekünk (kevesebb, mint 0,60 dollár), amelyek biztonsági réteget adhatnak ezekhez az objektumokhoz.

A bemutató után megpróbáltam megtalálni egy nyílt forráskódú projektet, amely biztonsági réteget ad hozzá az IoT objektumhoz, de soha nem találtam.

Ezért úgy döntöttem, hogy dolgozom egy olyan projekten, amely biztonsági réteget használ két IoT objektum közötti kommunikációhoz.

Mi az elképzelésem?

Két IoT -objektum közötti kommunikáció során több támadás is előfordulhat: Man Of the enyhe, Információ másolása és egyebek. Tehát az elképzelésem nagyon egyszerű:

1. Titkosított adatok felhasználása két vagy több IoT objektum között.
2. Alacsony költségű kellékek
3. Működhet egy Arduino UNO -val

Most elmagyarázom, hogyan valósítottam meg ezt az absztrakt képet Arduino és Atecc608a chipekkel. Ebben a cikkben elmagyarázom, hogyan kell használni az Arduino UNO -t az ATECC608A -val.

Legközelebb két tárgy kommunikációjáról írok egy cikket.

Kellékek

Ehhez a projekthez szüksége van néhány dologra:

1. Arduino UNO vagy MEGA (a chipnek Atmega 328 -nak vagy ATMEGA 2560 -nak kell lennie)
2. Atecc608A chip (ára kevesebb, mint 0,80 USD, könnyen megtalálható a beszállító webhelyén)
3. 8 tűs SOIC adapter
4. Néhány vezeték és ellenállás

A chip korábbi verziójának (Atecc508a) adatlapja itt érhető el -> Atecc508a adatlap

1. lépés: Lépésről lépésre

Ebben a cikkben megmutatom, hogyan módosíthatja ennek a chipnek a konfigurációját, és hogyan titkosíthatja az adatokat az AES CBC algoritmus használatával.

Ezeket a lépéseket fogjuk követni:

1. Az áramkör kialakítása
2. Ennek a chipnek a konfigurálása
3. Az AES CBC modul használata
4. Miért kell ezt a chipet használni?

Minden lépésnél mindent részletezek az Ön számára. Ezenkívül hozzáadtam a kódomat a Githubban, megjegyzésekkel az egyes funkciókhoz. Ha kérdése van a kódommal vagy ezzel a projekttel kapcsolatban, szívesen válaszolok rá.

Githubom: Githubom

2. lépés: Figyelmeztetés az Atecc608a készülékre

Az Atecc608a chip nem "könnyű" chip.

Először is, a chip dokumentációja az NDA alatt található, így nem találja meg teljes egészében az interneten. De ezzel nincs probléma, az előző verzió adatlapja elérhető az ATECC508A Internet adatlapon.

Másodszor, amikor ezt a chipet használja, le kell zárnia annak konfigurációját, és lehetetlen módosítani a chip konfigurációját, ha le van zárva. Ezért legyen óvatos, amikor lezárja a konfigurációs zónát és az adatzónát.

Harmadszor, a C -ben írt könyvtár nagyon nagy és teljes, ezért el kell olvasnia a korábban használt funkciók dokumentációját.

Negyedszer, a könyvtár azt írta, hogy ez a chip nem működik az Arduino UNO esetében, de hozzátette, hogy a funkcióknak szüksége van az Arduino UNO -val való együttműködésre.

Az ATECC608A chip

Ezzel a chipkel az I2C kommunikálhat. Ennek a chipnek a címe módosítható a konfigurációban.

Ez a chip 16 különböző helyet tartalmaz, amelyek különböző típusú adatokat tartalmazhatnak:

1. ECC kulcs (privát vagy nyilvános)
2. AES kulcs
3. Egyéb adatok (például Sha hash vagy csak szavak)

Esetünkben az AES kulcsot egy helyen tároljuk.

3. lépés: 1. Az áramkör tervezése

1. Az áramkör kialakítása

Ennek az áramkörnek a sémája nagyon egyszerű!

3,3 V -os áramot kell használnia, mert az ajánlás 2,0 V és 5,5 V között van, de én inkább a 3,3 V -ot használom.

Ennél a chipnél általában van egy pont a chip sarkán, ez a pont a tábla 1. csapja. Az Atecc608a felülnézetét PIN-számmal adtam hozzá, mert ez egy 8 elvezetéses SOIC, így a chip nagyon kicsi.

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 V -os áramot kell használnia, mert az ajánlás 2,0 V és 5,5 V között van, de én inkább a 3,3 V -ot használom.

Az Atecc608a felülnézetét azért adtam hozzá, mert 8 elvezetésű SOIC, így a chip nagyon kicsi. Ha úgy tetszik, a szállítók valamilyen lapot építenek a forgácsforrasztással, akkor könnyebb lehet az Ön számára.

Figyelmeztetés: Az én esetemben egy ellenállást kell hozzáadnom az Arduino SDA és a chip közé (az SDL -hez is). Mindegyikhez hozzáadtam egy 4,7Kohm ellenállást.

4. lépés: 2. A chip konfigurálása (Atecc608a)

A titkosítás vagy visszafejtés funkció használata előtt konfigurálnia kell a chipet. Ebben a lépésben részletesen ismertetem a chip konfigurálásához szükséges lépéseket.

Figyelmeztetés: ez a lépés nagyon fontos, és ha lezárja a zónákat a vége előtt, nem tudja módosítani őket.

Amint azt korábban kifejtettük, ez a chip két zónát kapott:

1. Config Zone
2. Adatzóna

A konfigurációs zóna 128 bájt méretű, de az első 16 bájt nem módosítható.

Ennek a chipnek a konfigurálásához két lépést kell végrehajtania. Nagyon fontos, hogy kövesse az egyes lépéseket sorrendben, különben a konfiguráció nem fog működni, és a chip zárolva lesz, és használhatatlan. Ezek a lépések:

1. Hozzon létre egy konfigurációs sablont
2. Írja be ezt a sablont a chipbe
3. Zárja be a konfigurációs zónát
4. Írja be az AES -kulcsot (128 bit) egy nyílásba
5. Zárolja az adatzónát

Információ

Az alábbiakban részletezem a konfiguráció minden lépését a kódommal, de nem kell aggódnom, hozzáadtam egy teljes példát a konfigurációhoz a Github -ban. Minden funkcióhoz megjegyzéseket fűzök, és minden lépésnél rendelkezésre áll egy *.ino fájl.

• Githubom: Githubom
• A példa konfiguráció elérési útja: configuration_example.ino

Első lépés: Hozzon létre egy konfigurációs sablont

Amint azt korábban kifejtettük, a konfigurációs zóna 128 bit méretű, de az első 16 bit nem módosítható. Ez a zóna több részből áll, de ehhez a projekthez csak a konfigurációs zóna 3 részét kell ismernie:

1. A bájtok 16 -> Ez a chip I2C címe
2. A bájtok 20 -tól 51 -ig -> Itt módosíthatja a slot típusát a chip 16 helyéhez
3. A bájtok 96–127 -> Itt állíthatja be az egyes nyílásokban használt kulcsok vagy adatok típusát.

(Ha további magyarázatra van szüksége a zónához, kérjük, olvassa el a dokumentációt (13. oldal, 2.2. Szakasz))

Itt részletezem a chip konfigurációjának 112 bájtjának minden egyes bájtját/részét. Ez egy példa, minden megvásárolt chip eltérő konfigurációjú lehet:

0xC0, // I2C cím

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 6 Slot 0x9F, 0x8F, // Slot Config 7 Slot 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 13. slot 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, 0xFF 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x00, 0x00, 0x33, 0x00, // 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 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 // Kulcskonfigurációs hely 16

Mint látható, néhány megjegyzést fűztem ehhez a kódhoz, hogy jobban megértsük ezt a konfigurációt.

Az Ön esetében csak három dolgot kell megértenie:

1. A bájtok 16 -> Ez a chip I2C címe
2. A bájtok 20 -tól 51 -ig -> Itt módosíthatja a slot típusát a chip 16 helyéhez
3. A 96 -os bájt -127 -> Itt állíthatja be az egyes nyílásokban használt kulcsok vagy adatok típusát.

Nem fogom elmagyarázni a konfiguráció típusát és azt, hogy miért használtam ezt, és nem másikat, mert bonyolult mindent elmagyarázni. Ha további információra van szüksége, olvassa el a dokumentációt, a 16. oldal 2.2.1. Szakaszát a „SlotConfig” és a 19. oldal 2.2.5. Fejezetet a „KeyConfig” számára

Ebben a példában az AES kulcs tárolására használja a 9 foglalatot.

Ehhez meg kell tennünk (ha szükséges, lemásolhatja a fenti példát, a módosítás megtörtént benne):

1. 36. bájt = 0x8F
2. 37. bájt = 0x0F
3. 112 bájt = 0x1A
4. 113 bájt = 0x00

Miért állítottam be ezt a konfigurációt: Ennek a chipnek minden egyes slotjához beállíthat paramétereket, amelyek megmondják a chipnek, hogy milyen típusú adatokat tárolnak. Több paramétere van:

• A nyílás írható vagy olvasható (törlés vagy titkosítás)
• A tárolt adatok típusa (ECC kulcs, nyilvános kulcs, SHA Hash, AES kulcs…)
• A nyílás zárható
• A kulcs előállítása megengedett
• …

A 36. és 37. bájt "0x0F8F" értékre állítva:

• Az adatok írhatók a Clear -be
• Ennek a nyílásnak a tartalma titkos és nem olvasható
• A rés nem használható a CheckMac Copy parancshoz

A 112 -es és 113 -as bájt "0x001A" értékre állítva:

A foglalatban legfeljebb négy AES 128 bites szimmetrikus kulcs tárolható (KeyType = 0x6)

Második lépés: Írja be ezt a konfigurációt

Ez a lépés nagyon fontos, mert a chipet a konfigurációnknak megfelelően állítjuk be, és ha ez a konfiguráció nem jó, akkor ezt a chipet fogja használni.

De ne aggódjon, amíg a konfiguráció nincs zárolva, módosíthatja a konfigurációt.

Itt ez a kód, amellyel a konfigurációt a chipre írják:

/** / rövid Írjon új konfigurációt a chipre.

* / param [in] cfg Logikai felület konfigurálása. Néhány előre definiált * konfiguráció megtalálható az atca_cfgs.h * / param [in] config Array uint8_t konfigurációban (112 -es hosszúság) * / param [in] len A konfigurációs tömb mérete * / return ATCA_SUCCESS on success, egyébként hibakód. */ ATCA_STATUS write_configuration (ATCAIfaceCfg *cfg, uint8_t *config, size_t len) {if (len! = 112) return ATCA_BAD_PARAM; ATCA_STATUS állapot; állapot = atcab_init (cfg); if (állapot == ATCA_SUCCESS) {// Írja be a konfigurációs tömböt a chipbe // 16 bájtos kitöltés (16 első bájt nem írható) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); visszatérési állapot; } visszatérési állapot; }

Ez a funkció beírja a konfigurációt a chipbe.

Harmadik lépés: zárja be a konfigurációs zónát

Figyelmeztetés: legyen óvatos ezzel a lépéssel, ha lezárja ezt a zónát, és a konfigurációja nem megfelelő, a chip használhatatlan, és nem tudta módosítani ezt a zónát

Ehhez a művelethez ezt a funkciót fogjuk használni:

/** / rövid Ellenőrizze, hogy a DATA_ZONE vagy CONFIG_ZONE le van -e zárva

* / param [in] cfg Logikai felület konfigurálása. Néhány előre meghatározott * konfiguráció megtalálható az atca_cfgs.h * / param [in] LOCK_ZONE_DATA vagy LOCK_ZONE_CONFIG * / zónában. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS állapot; bool lock = hamis; if (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) return ATCA_BAD_PARAM; állapot = atcab_init (cfg); if (állapot == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (állapot = atcab_is_locked (zóna, zár))) {return ATCA_FUNC_FAIL; } if (! zár) {return ATCA_NOT_LOCKED; } return ATCA_SUCCESS; } return ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Negyedik lépés: Írja be az AES kulcsot egy nyílásba

Ebben a részben személyes AES kulcsot állít be a chip konfigurációjában meghatározott nyílásba.

Ebben a példában a chip 9. számú nyílását fogom használni.

Tudnia kell: Ennek a chipnek a sajátossága, hogy csak 4 vagy 32 bájttal írhat adatokat a nyílásba. Az AES -hez 128 bites kulcsra van szükségünk, tehát 16 bájt adatra. Ezért úgy döntöttem, hogy írok a 16 bájtos kulcsba ebben a foglalatban, hogy 32 bájtos adatok legyenek.

Most megmutatom a használt kódot:

/** / rövid Írja be az AES kulcsot egy adott nyílásba. * / param [in] cfg Logikai felület konfigurálása. Néhány előre meghatározott * konfiguráció megtalálható az atca_cfgs.h * / param [in] kulcskulcs számában * / param [in] datakey key array uint8_t * / param [in] len A kulcs tömb mérete * / return ATCA_SUCCESS on success, különben hibakód. */ ATCA_STATUS write_key_slot (ATCAIfaceCfg *cfg, uint8_t key, uint8_t *datakey, size_t len) {if (16. kulcs) return ATCA_BAD_PARAM; if (len! = 32) return ATCA_BAD_PARAM; ATCA_STATUS állapot = atcab_init (cfg); if (állapot == ATCA_SUCCESS) {status = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) kulcs, 0, 0, adatake, 32); if (állapot! = ATCA_SUCCESS) visszatérési állapot; } visszatérési állapot; }

Ebben a példában két 16 bájtos AES -kulcsot fogok használni:

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

Ha ez a művelet jó, akkor most meg kell tennie az utolsó lépést "zárolja az adatzónát"

Utolsó lépés: zárolja az adatzónát

Figyelmeztetés: legyen óvatos ezzel a lépéssel, ha lezárja ezt a zónát, és az adatok nincsenek beállítva, a chip használhatatlan, és nem tudta módosítani ezt a zónát

Ehhez a művelethez ezt a funkciót fogjuk használni:

/** / rövid Ellenőrizze, hogy a DATA_ZONE vagy CONFIG_ZONE le van -e zárva

* / param [in] cfg Logikai felület konfigurálása. Néhány előre meghatározott * konfiguráció megtalálható az atca_cfgs.h * / param [in] LOCK_ZONE_DATA vagy LOCK_ZONE_CONFIG * / zónában. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS állapot; bool lock = hamis; if (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) return ATCA_BAD_PARAM; állapot = atcab_init (cfg); if (állapot == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (állapot = atcab_is_locked (zóna, zár))) {return ATCA_FUNC_FAIL; } if (! zár) {return ATCA_NOT_LOCKED; } return ATCA_SUCCESS; } return ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Ha ez a művelet jó, a chip készen áll a használatra

5. lépés: 3. Az AES CBC modul használata

Elmagyarázom, hogyan lehet titkosítani és visszafejteni az adatokat az AES CBC algoritmus és az Atecc608a chip segítségével.

Ne feledje: A funkció használata előtt be kell állítania a chipet. Ehhez kövesse a cikk 2. lépését

Ez a chip többféle AES modult kapott (AES 128 bit), csak AES 128 bit lehetséges:

1. AES normál
2. AES CBC
3. AES GCM (GFM -kivonattal) (további magyarázatért lásd a wikipédiát)

A használat megkönnyítése érdekében két funkciót hoztam létre:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Ez a két funkció elérhető a Github -on.

Magyarázat

Azért választom az AES CBC algoritmus használatát, mert biztonságosabb, mint az alap AES 128 bit. Ez az algoritmus kezdeti vektort használ az adatok titkosítására.

Információ

Az alábbiakban részletezem a titkosítási és visszafejtési módszer minden lépését. De írtam egy kódot az Arduino -hoz, amely mindkét funkciót használja. Ezt a kódot a Githubomban láthatod:

• Github: Githubom
• Példa az "Encrypt/Decrypt" kódra: AES_crypto_example.ino

Első lépés: Titkosítsa adatait

Ebben a részben megmutatom, hogyan titkosíthatja adatait.

Először is szüksége lesz erre a funkcióra:

/** / rövid Adatok titkosítása AES CBC algoritmussal* / param [in] cfg Logikai interfész konfiguráció. Néhány előre definiált * konfiguráció megtalálható az atca_cfgs.h * / param [in] adatban Titkosítandó szavak (16 -mal kell osztani, maximális hossz 240) * / param [in] len hossza a titkosítandó szavaknak (el kell osztani 16 -tal, max. hosszúság 240) * / param [out] iv Az AES CBC -ben használt kezdeti vektor (adja vissza a vektort ebben a változóban) * / param [out] titkosított szöveg itt adja vissza a Cypher text * / param [in] gombot key * / return ATCA_SUCCESS on success, különben hibakód. */ ATCA_STATUS aes_cbc_encrypt (ATCAIfaceCfg *cfg, uint8_t *data, int len, uint8_t *iv, uint8_t *titkosított szöveg, uint8_t kulcs) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC && len % 16! = 0) {Serial.print (F ("HIBA: ATCA_BAD_PARAM")); vissza ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; ATCA_STATUS állapot = atcab_init (cfg); if (állapot == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, key, 0, tmp_iv); if (állapot! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, 0x kódhiba")); Serial.println (állapot, HEX); Visszatérés; } 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], és titkosított szöveg [j * 16]); } if (állapot! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_encrypt_block, 0x kódhiba")); Serial.println (állapot, HEX); } visszatérési állapot; } visszatérési állapot; }

Ez a funkció egyszerűen használható, két dolgot kell beállítania:

1. Egy üres IV (kezdeti vektor) 16 bájtos
2. Titkosítandó adatok (max. Méret 240 bájt)

Itt egy példa "hogyan kell használni ezt a funkciót".

Titkosítani akarom az "AAAAAAAAAAAAAAA" szót, a kulcsomat a "9" foglalatba írtam:

ATCA_STATUS állapot = atcab_init (& cfg); if (állapot! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () nem sikerült: Kód -> 0x")); Serial.println (állapot, HEX); } uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; // Eredeti szöveg uint8_t iv [IV_LENGTH_CBC]; // Kezdeti vektor uint8_t cypherdata [sizeof (egyszerű szöveg)]; // Adatok titkosított állapota = aes_cbc_encrypt (& cfg, egyszerű szöveg, sizeof (egyszerű szöveg), iv, cypherdata, 9);

Ha a művelet jó, akkor a titkosított adatok a "cypherdata" változóban, a kezdeti vektor pedig az "IV" változóban lesznek.

Tartsa meg ezt a két változót a szöveg visszafejtéséhez!

Második lépés: dekódolja az adatokat

Az adatok visszafejtéséhez két dologra lesz szüksége:

1. A kezdeti vektor
2. A Cypher adatok (titkosított adatok)

Az adatok visszafejtéséhez szüksége lesz erre a funkcióra:

/** / rövid Adatok visszafejtése AES CBC algoritmus használatával* / param [in] cfg Logikai interfész konfiguráció. Néhány előre definiált * konfiguráció megtalálható az atca_cfgs.h * / param [in] titkosított szövegben A dekódolásra szánt szavak (16 -mal kell osztani, maximális hossz 240) * / param [in] len hosszúságú feloldandó szavak (el kell osztani 16 -tal, max. hosszúság 240) * / param [in] iv Az AES CBC -ben használandó kezdeti vektor, különben hibakód. */ ATCA_STATUS aes_cbc_decrypt (ATCAIfaceCfg *cfg, uint8_t *ciphertext, int len, uint8_t *iv, uint8_t *plaintext, uint8_t kulcs) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC || len % 16! = 0) {Serial.print (F ("ERROR Decrypt: ATCA_BAD_PARAM")); vissza ATCA_BAD_PARAM; } ATCA_STATUS állapot = atcab_init (cfg); if (állapot == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, key, 0, iv); if (állapot! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_init, 0x kódhiba")); Serial.println (állapot, HEX); Visszatérés; } int max = len / 16; for (int j = 0; j <max; j ++) {status = atcab_aes_cbc_decrypt_block (& ctx, & titkosított szöveg [j * 16], és egyszerű szöveg [j * 16]); } if (állapot! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_encrypt_block, 0x kódhiba")); Serial.println (állapot, HEX); } visszatérési állapot; } visszatérési állapot; }

Szeretném visszafejteni a korábbi adataimat (lásd alább, Első lépés). Ehhez ezt fogom tenni:

uint8_t egyszerű szöveg [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (egyszerű szöveg)]; uint8_t decryptdata [sizeof (egyszerű szöveg)]; állapot = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (állapot == ATCA_SUCCESS) {Serial.print ("A visszafejtett szöveg:"); for (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Soros.println (""); } else {// Lásd az atca_status.h fájlt az Error Serial.print kódhoz (F ("Lehetetlen a visszafejtés | Kódhiba 0x")); Serial.println (állapot, HEX); Visszatérés; }

Ha a művelet jó, akkor a visszafejtett adatok a "decryptdata" változóban lesznek.

Most már tudja, hogyan kell használni a titkosítást és a visszafejtést az Atecc608a chipen

6. lépés: 5. Miért kell ezt a chipet használni?

A titkosított adatok nagyon hasznosak, mert elrejtheti adatait, és vezeték nélküli kapcsolaton keresztül elküldheti, vagy csak tárolhatja.

Íme néhány példa a felhasználásra:

1. Tárolt adatok külső EEPROM -hoz: Biztonságba hozhatja egy külső EEPROM adatait, és ha valaki még mindig ezen az EEPROM -on van, szüksége lesz a kulcsra és az IV -re a visszafejtéshez.
2. Vezeték nélküli adatok küldése: Ezeket a titkosított adatokat vezeték nélkül is elküldheti (nrf24L01, RFM95W…), és ha valaki elfogja az adatait, ezek az adatok biztonságban lesznek
3. Tárolt jelszó
4. …

Ezzel a chipkel több dolgot is megtehet. Több projektben is használható. Ha van ideje, mondja meg, milyen projektben fogja használni ezt a chipet?

Még egy utolsó tanács: ha vezeték nélküli projektet épít vagy nyers adatokat tárol, legyen óvatos, a biztonság nagyon fontos, és ha tudja, milyen egyszerű egy "noob" számára, hogy elfogja vagy ellopja az adatait. Most már az Internet segítségével mindenkinek lehet szkriptje, amelyet elindíthat a számítógépén, csak hogy "feltörje" Önt!

7. lépés: Következtetés

Remélem, hogy ez a cikk hasznos lesz az Ön számára. Elnézést, ha hibáztam a szövegben, de az angol nem a fő nyelvem, és jobban beszélek, mint írok.

Köszönöm, hogy mindent elolvastál.

Élvezd.