Bezpieczeństwo z Arduino: Atecc608a: 7 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:28

Temat

Cześć wszystkim !

To jest mój pierwszy artykuł z instrukcjami, więc mam nadzieję, że będzie interesujący dla was wszystkich.

W tym artykule wyjaśnię, jak korzystać z mikroukładu o nazwie „ATECC608A”, który zapewnia wiele narzędzi zabezpieczających.

Ten chip został zaprojektowany przez MicroChip i jest to ostatnia wersja "chipu CryptoAuthentication". Przed tą wersją istniały „ATSHA204A” i „ATECC508A”.

Dlaczego zdecydowałem się użyć ostatniej wersji, a nie poprzedniej?

Ta wersja jest najbardziej zaawansowanym chipem i posiada funkcje, których nie posiada stara wersja (na przykład: moduł AES, moduł ochrony IO…).

Dlaczego ten projekt?

Pracuję w domenie CyberSecurity i jak wszyscy kochałem programowanie i elektronikę. W trakcie studiów mam konferencję ze specjalistą ds. bezpieczeństwa IoT, który pokazał nam, że Industrial nie używa Security w swoim obiekcie IoT. Pokazałem nam kłódkę, którą można otworzyć smartfonem przez Bluetooth. Na kłódce widniało zdanie „Ta kłódka jest najbezpieczniejsza niż kłódka na klucz!”. To zdanie wywołało u niego uśmiech i zmodyfikował zdanie „Ta kłódka jest najgorszą kłódką, jaką kiedykolwiek zbudowano!”.

Pokazał nam własnym komputerem i snifferem Bluetooth, że każde polecenie wysyłane przez smartfon jest za każdym razem takie samo i bardzo łatwo jest skopiować to polecenie i wysłać je smartfonem. Wyjaśnił nam, że „Bezpieczeństwo” dla „Industrial” nie jest głównym problemem. Pokazał nam żetony (poniżej 0,60$), które mogą dodać warstwę bezpieczeństwa do tych obiektów.

Po tej demonstracji próbowałem znaleźć jakiś projekt Open Source, który dodaje warstwę bezpieczeństwa do obiektu IoT, ale nigdy go nie znalazłem.

Postanowiłem więc pracować nad projektem wykorzystującym warstwę bezpieczeństwa do komunikacji między dwoma obiektami IoT.

Jaki jest mój pomysł?

Podczas komunikacji między dwoma obiektami IoT może wystąpić wiele ataków: Man Of the mild, Copy of information i więcej.. Mój pomysł jest więc bardzo prosty:

1. Wykorzystanie zaszyfrowanych danych między dwoma lub więcej obiektami IoT.
2. Tanie materiały eksploatacyjne
3. Może współpracować z Arduino UNO

Teraz wyjaśnię, jak zaimplementowałem ten abstrakcyjny obraz za pomocą Arduino i układu Atecc608a. W tym artykule wyjaśnię, jak używać Arduino UNO z ATECC608A.

Następnym razem napiszę artykuł o komunikacji dwóch obiektów.

Kieszonkowe dzieci

Potrzebujesz kilku rzeczy do tego projektu:

1. Arduino UNO lub MEGA (chip musi być Atmega 328 lub ATMEGA 2560)
2. Układ Atecc608A (koszt mniej niż 0,80 $ każdy, łatwy do znalezienia na stronie dostawcy)
3. 8-pinowy adapter SOIC
4. Niektóre przewody i rezystory

Arkusz danych poprzedniej wersji tego układu (Atecc508a) jest dostępny tutaj -> Karta danych Atecc508a

Krok 1: Krok po kroku

W tym artykule pokażę, jak zmodyfikować konfigurację tego chipa, a następnie jak zaszyfrować dane za pomocą algorytmu AES CBC.

Podążymy za tymi krokami:

1. Projekt obwodu
2. Konfiguracja tego chipa
3. Wykorzystanie modułu AES CBC
4. Dlaczego musisz użyć tego chipa?

Dla każdego kroku opiszę wszystko za Ciebie. Dodałem również swój kod w moim Github z komentarzami dla każdej funkcji. Jeśli masz jakieś pytania dotyczące mojego kodu lub tego projektu, chętnie na nie odpowiem.

Mój Github: Mój Github

Krok 2: Ostrzeżenie o Atecc608a

Układ Atecc608a nie jest „łatwym” układem.

Po pierwsze, dokumentacja tego układu jest objęta NDA, więc nie znajdziesz jej pełnej w Internecie. Ale nie ma problemu, arkusz danych poprzedniej wersji jest dostępny w Internet Datasheet Complete ATECC508A.

Po drugie, kiedy używasz tego chipa, musisz zablokować jego konfigurację i nie można zmienić konfiguracji chipa, jeśli jest zablokowany. Dlatego bądź ostrożny, gdy zablokujesz Strefę Konfiguracji i Strefę Danych.

Po trzecie, biblioteka napisana w C jest bardzo duża i kompletna, więc musisz wcześniej przeczytać dokumentację funkcji, z których będziesz korzystać.

Po czwarte, biblioteka napisała, że ten układ nie działa dla Arduino UNO, ale dodała funkcje potrzebne do pracy z Arduino UNO.

Układ ATECC608A

Możesz komunikować się z tym chipem przez I2C. Adres tego chipa można zmodyfikować w konfiguracji.

Ten chip zawiera 16 różnych gniazd, które mogą zawierać różne typy danych:

1. Klucz ECC (prywatny lub publiczny)
2. Klucz AES
3. Inne dane (takie jak hash Sha lub tylko słowa)

W naszym przypadku będziemy przechowywać klucz AES w jednym slocie.

Krok 3: 1. Projekt obwodu

1. Projekt obwodu

Schemat tego obwodu jest bardzo prosty!

Musisz użyć zasilania 3,3 V, ponieważ zalecane jest między 2,0 V a 5,5 V, ale wolałem używać 3,3 V.

W przypadku tego chipa zwykle masz kropkę w rogu chipa, ta kropka to Pin 1 tej płyty. Dodałem widok z góry Atecc608a z numerem PIN, ponieważ jest to 8-odprowadzeniowy układ SOIC, więc chip jest bardzo mały.

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)

Musisz użyć zasilania 3,3V, ponieważ zalecane jest między 2,0V a 5,5V, ale wolałem używać 3,3V.

Dodałem widok z góry Atecc608a, ponieważ jest to 8-odprowadzeniowy układ SOIC, więc chip jest bardzo mały. Jeśli wolisz, więc dostawcy zbudują płytkę za pomocą lutu chipowego, może to być dla ciebie łatwiejsze.

Ostrzeżenie: W moim przypadku muszę dodać rezystor między SDA Arduino a układem (również dla SDL). Do każdego dodałem rezystor 4,7Kohm.

Krok 4: 2. Konfiguracja chipa (Atecc608a)

Przed użyciem funkcji szyfrowania lub deszyfrowania należy skonfigurować chip. W tym kroku opiszę wszystkie kroki, które należy wykonać, aby skonfigurować ten układ.

Uwaga: ten krok jest bardzo ważny i jeśli zablokujesz strefy przed końcem, nie możesz ich modyfikować.

Jak wyjaśniono wcześniej, ten chip ma dwie strefy:

1. Strefa konfiguracji
2. Strefa danych

Strefa konfiguracji ma rozmiar 128 bajtów, ale pierwszych 16 bajtów nie można modyfikować.

Aby skonfigurować ten układ, potrzebujesz dwóch, wykonaj ten krok. Bardzo ważne jest, aby wykonać wszystkie kroki w kolejności, w przeciwnym razie konfiguracja nie będzie działać, a chip będzie zablokowany i bezużyteczny. Te kroki to:

1. Utwórz szablon konfiguracji
2. Napisz ten szablon do chipa
3. Zablokuj strefę konfiguracji
4. Wpisz swój klucz AES (128 bitów) w gnieździe
5. Zablokuj strefę danych

Informacja

Poniżej szczegółowo opisuję każdy krok konfiguracji za pomocą mojego kodu, ale bez obaw, dodałem pełny przykład konfiguracji na moim Github. Do każdej funkcji zamieszczam komentarze, a plik *.ino jest dostępny z każdym krokiem w kolejności dla Ciebie.

• Mój Github: Mój Github
• Ścieżka przykładowej konfiguracji: configuration_example.ino

Pierwszy krok: Utwórz szablon konfiguracji

Jak wyjaśniono wcześniej, strefa konfiguracji ma rozmiar 128 bitów, ale pierwszych 16 bitów nie można zmienić. Ta strefa składa się z wielu części, ale musisz znać tylko 3 części tej strefy konfiguracji dla tego projektu:

1. Bajty 16 -> To jest adres I2C chipa
2. Bajty od 20 do 51 -> Możesz tutaj zmienić typ gniazda dla 16 gniazd tego chipa
3. Bajty 96 do 127 -> Tutaj można ustawić typ klucza lub danych używanych w każdym gnieździe.

(Jeśli potrzebujesz więcej informacji na temat całej tej strefy, zapoznaj się z dokumentacją (strona 13, rozdział 2.2))

Tutaj umieściłem szczegółowo każdy bajt/części ze 112 bajtów konfiguracji chipa. To jest przykład, każdy zakupiony chip może mieć inną konfigurację:

0xC0, // adres I2C

0x00, 0x00, 0x00, 0x83, 0x20, // Konfiguracja slotów Slot 1 0x85, 0x20, // Konfiguracja slotów Slot 2 0x8F, 0x20, // Konfiguracja slotów Slot 3 0xC4, 0x8F, // Konfiguracja slotów Slot 4 0x8F, 0x8F, // Konfiguracja slotów Slot 5 0x8F, 0x8F, // Konfiguracja slotów Slot 6 0x9F, 0x8F, // Konfiguracja slotów Slot 7 0x0F, 0x0F, // Konfiguracja slotów Slot 8 0x8F, 0x0F, // Konfiguracja slotów Slot 9 0x8F, 0x0F, // Konfiguracja slotów Slot 10 0x8F, 0x0F, // Konfiguracja slotów Slot 11 0x8F, 0x0F, // Konfiguracja slotów Slot 12 0x8F, 0x0F, // Konfiguracja slotów Slot 13 0x00, 0x00, // Konfiguracja slotów Slot 14 0x00, 0x00, // Slot Config Slot 15 0xAF, 0x8F, // Slot Config Slot 16 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x00, // Konfiguracja klawiszy, gniazdo 1 0x33, 0x00, // Konfiguracja klawiszy, gniazdo 2 0x33, 0x00, // Konfiguracja klawiszy, gniazdo 3 0x1C, 0x00, // Konfiguracja klawiszy, gniazdo 4 0x1C, 0x00, // Gniazdo konfiguracji klucza 5 0x 1C, 0x00, // Konfiguracja klawiszy, gniazdo 6 0x1C, 0x00, // Konfiguracja klawiszy, gniazdo 7 0x3C, 0x00, // Konfiguracja klawiszy, gniazdo 8 0x1A, 0x00, // Konfiguracja klawiszy, gniazdo 9 0x3A, 0x00, // Konfiguracja klawiszy, gniazdo 10 0x1A, 0x00, // Slot 11 konfiguracji klawiszy 0x3A, 0x00, // Slot 12 konfiguracji klawiszy 0x3A, 0x00, // Slot 13 konfiguracji klawiszy 0x3C, 0x00, // Slot 14 konfiguracji klawiszy 0x3C, 0x00, // Slot 15 konfiguracji klawiszy 0x1C, 0x00 // Gniazdo konfiguracji klawiszy 16

Jak widać, umieściłem kilka komentarzy w tym kodzie, aby lepiej zrozumieć tę konfigurację.

W twoim przypadku musisz zrozumieć tylko trzy rzeczy:

1. Bajty 16 -> To jest adres I2C chipa
2. Bajty od 20 do 51 -> Tutaj możesz zmienić typ gniazda dla 16 gniazd tego chipa
3. Bajt 96 do 127 -> Tutaj można ustawić typ klucza lub danych używanych w każdym gnieździe.

Nie będę wyjaśniał typu konfiguracji i dlaczego użyłem tej a nie innej, ponieważ wyjaśnienie wszystkiego jest skomplikowane. Jeśli potrzebujesz więcej informacji, przejdź do dokumentacji, strona 16 sekcja 2.2.1 dla "SlotConfig" i strona 19 sekcja 2.2.5 dla "KeyConfig"

W tym przykładzie użyjesz gniazda 9 do przechowywania klucza AES.

W tym celu musimy wstawić (jeśli potrzebujesz, możesz skopiować powyższy przykład, modyfikacja została w nim wykonana):

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

Dlaczego ustawiłem tę konfigurację: Dla każdego gniazda tego chipa możesz ustawić parametry, aby powiedzieć chipowi, jaki rodzaj danych będzie przechowywany. Masz wiele parametrów:

• Slot może być zapisywany lub odczytywany (akcje wyczyść lub zaszyfruj)
• Rodzaj przechowywanych danych (klucz ECC, klucz publiczny, skrót SHA, klucz AES…)
• Slot może być zamykany
• Generowanie klucza jest dozwolone
• …

Z bajtem 36 i 37 ustawionym na "0x0F8F":

• Dane można zapisać w Clear
• Zawartość tego slotu jest tajna i nie można jej odczytać
• Slot nie może być użyty do polecenia CheckMac Copy

Z bajtem 112 i 113 ustawionym na „0x001A”:

Slot może przechowywać do czterech 128-bitowych kluczy symetrycznych AES (KeyType = 0x6)

Drugi krok: Napisz tę konfigurację

Ten krok jest bardzo ważny, ponieważ ustawimy chip z naszą konfiguracją i jeśli ta konfiguracja nie będzie dobra, użyjesz tego chipa.

Ale nie martw się, dopóki konfiguracja nie jest zablokowana, możesz modyfikować swoją konfigurację.

Oto kod użyty do zapisania konfiguracji do chipa:

/** \brief Zapisz nową konfigurację do układu.

* \param[in] cfg Konfiguracja interfejsu logicznego. Niektóre predefiniowane * konfiguracje można znaleźć w atca_cfgs.h * \param[in] config Tablica uint8_t konfiguracji (długość 112) * \param[in] len Rozmiar tablicy konfiguracyjnej * \return ATCA_SUCCESS w przypadku powodzenia, w przeciwnym razie kod błędu. */ ATCA_STATUS write_configuration(ATCAIfaceCfg *cfg, uint8_t *config, size_t len) { if (len != 112) return ATCA_BAD_PARAM; status ATCA_STATUS; status = atcab_init(cfg); if (status == ATCA_SUCCESS) { // Zapisz tablicę konfiguracji do układu // Dopełnienie 16 bajtów (16 pierwszych bajtów nie można zapisać) status = atcab_write_bytes_zone(ATCA_ZONE_CONFIG, 0, 16, (uint8_t *)config, len); status zwrotu; } status powrotu; }

Ta funkcja zapisze twoją konfigurację w chipie.

Trzeci krok: zablokuj strefę konfiguracji

Uwaga: uważaj na ten krok, jeśli zablokujesz tę strefę, a twoja konfiguracja nie jest dobra, chip jest bezużyteczny i nie możesz zmodyfikować tej strefy

Do tej akcji użyjemy tej funkcji:

/** \brief Sprawdź, czy strefa DATA_ZONE lub CONFIG_ZONE jest zablokowana

* \param[in] cfg Konfiguracja interfejsu logicznego. Niektóre predefiniowane * konfiguracje można znaleźć w atca_cfgs.h * \param[in] zone LOCK_ZONE_DATA lub LOCK_ZONE_CONFIG * \return ATCA_SUCCESS w przypadku powodzenia, w przeciwnym razie kod błędu. */ ATCA_STATUS check_lock_zone(ATCAIfaceCfg *cfg, uint8_t zone) { ATCA_STATUS status; blokada logiczna = fałsz; if (strefa != (uint8_t)LOCK_ZONE_CONFIG && strefa != (uint8_t)LOCK_ZONE_DATA) return ATCA_BAD_PARAM; status = atcab_init(cfg); if (status == ATCA_SUCCESS) { if (ATCA_SUCCESS != (stan = atcab_is_locked(zone, &lock))) { return ATCA_FUNC_FAIL; } if (!lock) { return ATCA_NOT_LOCKED; } powrót ATCA_SUCCESS; } zwróć ATCA_BAD_PARAM; } check_lock_zone(&cfg, LOCK_ZONE_CONFIG);

Czwarty krok: wpisz klucz AES w gnieździe

W tej części ustawisz swój osobisty klucz AES w slocie, który zdefiniowałeś w konfiguracji chipa.

W tym przykładzie użyję gniazda numer 9 w chipie.

Musisz wiedzieć: Specjalną cechą tego układu jest możliwość zapisu danych w slocie tylko o 4 bajty lub 32 bajty. Do AES potrzebujemy 128 bitów klucza, czyli 16 bajtów danych. Postanowiłem więc napisać do klucza 16 bajtów każdy w tym slocie, aby mieć 32 bajty danych.

Teraz pokażę Ci użyty kod:

/** \brief Zapis klucza AES w określonym gnieździe. * \param[in] cfg Konfiguracja interfejsu logicznego. Niektóre predefiniowane * konfiguracje można znaleźć w atca_cfgs.h * \param[in] numer gniazda klucza * \param[in] tablica kluczy danych uint8_t * \param[in] len Rozmiar tablicy kluczy * \return ATCA_SUCCESS w przypadku powodzenia, w przeciwnym razie kod błędu. */ ATCA_STATUS write_key_slot(ATCAIfaceCfg *cfg, uint8_t klucz, uint8_t *datakey, size_t len) { if (klucz 16) return ATCA_BAD_PARAM; if (len != 32) zwraca ATCA_BAD_PARAM; ATCA_STATUS status = atcab_init(cfg); if (status == ATCA_SUCCESS) { status = atcab_write_zone(ATCA_ZONE_DATA, (uint16_t)key, 0, 0, datakey, 32); if (status != ATCA_SUCCESS) zwraca status; } status powrotu; }

W tym przykładzie użyję dwóch kluczy AES po 16 bajtów każdy:

// Przykład klucza AES (długość 32)uint8_t example_of_key[32] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; write_key_slot(&cfg, 9, example_of_key, sizeof(example_of_key));

Jeśli ta akcja jest dobra, teraz musisz przejść ostatni krok „zablokuj strefę danych”

Ostatni krok: zablokuj strefę danych

Uwaga: zachowaj ostrożność przy tym kroku, jeśli zablokujesz tę strefę, a twoje dane nie są ustawione, chip jest bezużyteczny i nie możesz zmodyfikować tej strefy

Do tej akcji użyjemy tej funkcji:

/** \brief Sprawdź, czy strefa DATA_ZONE lub CONFIG_ZONE jest zablokowana

* \param[in] cfg Konfiguracja interfejsu logicznego. Niektóre predefiniowane * konfiguracje można znaleźć w atca_cfgs.h * \param[in] zone LOCK_ZONE_DATA lub LOCK_ZONE_CONFIG * \return ATCA_SUCCESS w przypadku powodzenia, w przeciwnym razie kod błędu. */ ATCA_STATUS check_lock_zone(ATCAIfaceCfg *cfg, uint8_t zone) { ATCA_STATUS status; blokada logiczna = fałsz; if (strefa != (uint8_t)LOCK_ZONE_CONFIG && strefa != (uint8_t)LOCK_ZONE_DATA) return ATCA_BAD_PARAM; status = atcab_init(cfg); if (status == ATCA_SUCCESS) { if (ATCA_SUCCESS != (stan = atcab_is_locked(zone, &lock))) { return ATCA_FUNC_FAIL; } if (!lock) { return ATCA_NOT_LOCKED; } powrót ATCA_SUCCESS; } zwróć ATCA_BAD_PARAM; } check_lock_zone(&cfg, LOCK_ZONE_DATA);

Jeśli ta akcja jest dobra, Twój chip jest gotowy do użycia

Krok 5: 3. Wykorzystanie modułu AES CBC

Wyjaśnię jak szyfrować i odszyfrowywać dane algorytmem AES CBC i chipem Atecc608a.

Pamiętaj: Przed użyciem tej funkcji musisz skonfigurować chip. W tym celu wykonaj krok 2 tego artykułu

Ten układ ma wiele typów modułu AES (AES 128 bitów), możliwe jest tylko 128 bitów AES:

1. AES normalny
2. AES CBC
3. AES GCM (z hashem GFM) (więcej informacji znajdziesz w Wikipedii)

Aby ułatwić korzystanie, stworzyłem dwie funkcje:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Te dwie funkcje są dostępne na moim Github.

Rozwinięcie

Wybieram algorytm AES CBC, ponieważ jest bezpieczniejszy niż podstawowe 128 bitów AES. Ten algorytm używa wektora początkowego do szyfrowania danych.

Informacja

Poniżej szczegółowo opisuję każdy krok metody szyfrowania i deszyfrowania. Ale napisałem kod dla Arduino, który używa tych obu funkcji. Możesz zobaczyć ten kod na moim Github:

• Github: Mój Github
• Przykład kodu „Szyfruj/Odszyfruj”: AES_crypto_example.ino

Pierwszy krok: zaszyfruj swoje dane

W tej części pokażę, jak zaszyfrować swoje dane.

Najpierw będziesz potrzebować tej funkcji:

/** \brief Szyfrowanie danych za pomocą algorytmu AES CBC * \param[in] cfg Konfiguracja interfejsu logicznego. Niektóre predefiniowane * konfiguracje można znaleźć w atca_cfgs.h * \param[in] data Słowa do encypt (musi być podzielone przez 16, maksymalna długość 240) * \param[in] len długość słów do encypt (musi być podzielona przez 16, maksymalna długość 240) * \param[out] iv Wektor początkowy użyty w AES CBC (zwróć wektor w tej zmiennej) * \param[out] tekst zaszyfrowany zwróć tutaj tekst zaszyfrowany * klucz \param[in] Numer gniazda klucz * \return ATCA_SUCCESS w przypadku powodzenia, w przeciwnym razie kod błędu. */ ATCA_STATUS aes_cbc_encrypt(ATCAIfaceCfg *cfg, uint8_t *data, int len, uint8_t *iv, uint8_t *ciphertext, uint8_t key) { atca_aes_cbc_ctx_t ctx; if (len > LIMIT_DATA_SIZE_CBC && len % 16 != 0) { Serial.print(F("BŁĄD: ATCA_BAD_PARAM")); zwróć ATCA_BAD_PARAM; } uint8_t tmp_iv[IV_LENGTH_CBC]; uint8_t tmp_data[len]; ATCA_STATUS status = atcab_init(cfg); if (status == ATCA_SUCCESS) { status = atcab_aes_cbc_init(&ctx, klucz, 0, tmp_iv); if (status != ATCA_SUCCESS) { Serial.print(F("BŁĄD Szyfrowania: atcab_aes_cbc_init, Błąd kodu 0x")); Serial.println(stan, HEX); powrót; } memcpy(iv, tmp_iv, IV_LENGTH_CBC); memcpy(tmp_data, dane, 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 (status != ATCA_SUCCESS) { Serial.print(F("BŁĄD Szyfrowania: atcab_aes_cbc_encrypt_block, Błąd kodu 0x")); Serial.println(stan, HEX); } status powrotu; } status powrotu; }

Ta funkcja jest prosta w użyciu, musisz ustawić dwie rzeczy:

1. Pusta IV (wektor początkowy) 16 bajtów
2. Dane do zaszyfrowania (maksymalny rozmiar 240 bajtów)

Oto przykład „jak korzystać z tej funkcji”.

Chcę zaszyfrować słowo "AAAAAAAAAAAAAAAA", moim kluczem wpisanym w slocie numer "9":

ATCA_STATUS status = atcab_init(&cfg); if (status != ATCA_SUCCESS) { Serial.println(F("atcab_init() nie powiodło się: Kod -> 0x")); Serial.println(stan, HEX); } uint8_t zwykły tekst[16] = "AAAAAAAAAAAAAAAA"; // Tekst oryginalny uint8_t iv[IV_LENGTH_CBC]; // Wektor początkowy uint8_t cypherdata[sizeof(zwykły tekst)]; // Stan zaszyfrowania danych = aes_cbc_encrypt(&cfg, zwykły tekst, sizeof(zwykły tekst), iv, cypherdata, 9);

Jeśli akcja jest dobra, będziesz miał zaszyfrowane dane w zmiennej „cypherdata”, a wektor początkowy w zmiennej „IV”.

Zachowaj te dwie zmienne, aby odszyfrować swój tekst!

Drugi krok: odszyfruj swoje dane

Aby odszyfrować swoje dane, będziesz potrzebować dwóch rzeczy:

1. Wektor początkowy
2. Dane Cypher (dane zaszyfrowane)

Aby odszyfrować swoje dane, będziesz potrzebować tej funkcji:

/** \brief Odszyfruj dane za pomocą algorytmu AES CBC * \param[in] cfg Konfiguracja interfejsu logicznego. Niektóre predefiniowane * konfiguracje można znaleźć w atca_cfgs.h * \param[in] tekst zaszyfrowany Słowa do decypt (musi być podzielone przez 16, maksymalna długość 240) * \param[in] len długość słów do decypt (musi być podzielona przez 16, maksymalna długość 240) * \param[in] iv Wektor początkowy do użycia w AES CBC * \param[out] tekst jawny zwraca tutaj odszyfrowany tekst * klucz \param[in] Numer gniazda klucza * \return ATCA_SUCCESS w przypadku powodzenia, w przeciwnym razie kod błędu. */ ATCA_STATUS aes_cbc_decrypt(ATCAIfaceCfg *cfg, uint8_t *tekst zaszyfrowany, int len, uint8_t *iv, uint8_t *tekst zwykły, klucz uint8_t) { atca_aes_cbc_ctx_t ctx; if (len > LIMIT_DATA_SIZE_CBC || len % 16 != 0) { Serial.print(F("BŁĄD Odszyfruj: ATCA_BAD_PARAM")); zwróć ATCA_BAD_PARAM; } ATCA_STATUS status = atcab_init(cfg); if (status == ATCA_SUCCESS) { status = atcab_aes_cbc_init(&ctx, klucz, 0, iv); if (status != ATCA_SUCCESS) { Serial.print(F("BŁĄD Odszyfruj: atcab_aes_cbc_init, Błąd kodu 0x")); Serial.println(stan, HEX); powrót; } int max = dł / 16; for (int j = 0; j < max; j++) { status = atcab_aes_cbc_decrypt_block(&ctx, &ciphertext[j * 16], &plaintext[j * 16]); } if (status != ATCA_SUCCESS) { Serial.print(F("BŁĄD Odszyfruj: atcab_aes_cbc_encrypt_block, Błąd kodu 0x")); Serial.println(stan, HEX); } status powrotu; } status powrotu; }

Chcę odszyfrować moje poprzednie dane (patrz poniżej, pierwszy krok). W tym celu zrobię to:

uint8_t zwykły tekst[16] = "AAAAAAAAAAAAAAAA"; uint8_t iv[IV_LENGTH_CBC]; uint8_t cypherdata[sizeof(zwykły tekst)]; uint8_t decryptdata[sizeof(zwykły tekst)]; status = aes_cbc_decrypt(&cfg, cypherdata, sizeof(cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) { Serial.print("Odszyfrowany tekst to: "); for (size_t i = 0; i < sizeof(decryptdata); i++) { Serial.print((char)decryptdata); } Serial.println(""); } else { // Zobacz plik atca_status.h dla kodu Error Serial.print(F("Niemożliwe odszyfrowanie | Błąd kodu 0x")); Serial.println(stan, HEX); powrót; }

Jeśli akcja jest dobra, odszyfrowane dane będą znajdować się w zmiennej „decryptdata”.

Teraz wiesz, jak korzystać z szyfrowania i deszyfrowania za pomocą chipa Atecc608a

Krok 6: 5. Dlaczego musisz używać tego chipa?

Zaszyfrowane dane są bardzo przydatne, ponieważ możesz ukryć swoje informacje i wysłać je bezprzewodowo lub po prostu je przechowywać.

Oto kilka przykładów wykorzystania:

1. Przechowywane dane do zewnętrznej pamięci EEPROM: Możesz zabezpieczyć dane zewnętrznej pamięci EEPROM i jeśli ktoś nadal ten EEPROM będzie potrzebował klucza i IV do odszyfrowania
2. Wyślij dane bezprzewodowe: Możesz wysłać te zaszyfrowane dane przez sieć bezprzewodową (nrf24L01, RFM95W…), a jeśli ktoś przechwyci Twoje dane, dane te będą bezpieczne
3. Zapisane hasło
4. …

Z tym chipem możesz zrobić wiele rzeczy. Może być używany w wielu projektach. Jeśli masz czas powiedz mi w jakim projekcie użyjesz tego chipa ?

Ostatnia rada, jeśli budujesz projekt bezprzewodowy lub przechowujesz surowe dane, bądź ostrożny, bezpieczeństwo jest bardzo ważne i jeśli wiesz, jak łatwo jest przechwycić lub ukraść dane „noobowi”. Teraz, dzięki Internetowi, każdy może mieć skrypty do uruchomienia na swoim komputerze, aby Cię "zhakować"!

Krok 7: Wniosek

Mam nadzieję, że ten artykuł będzie dla Ciebie przydatny. Przepraszam, jeśli pomyliłem się w tekście, ale angielski nie jest moim głównym językiem i mówię lepiej niż piszę.

Dzięki za przeczytanie wszystkiego.

Ciesz się tym.