Sécurité avec Arduino : Atecc608a : 7 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Sujet

Bonjour à tous !

Il s'agit de mon premier article Instructables donc j'espère qu'il sera intéressant pour vous tous.

Dans cet article, je vais vous expliquer comment utiliser une micro-puce appelée "ATECC608A" qui fournit plusieurs outils de sécurité.

Cette puce a été conçue par MicroChip et c'est la dernière version de "CryptoAuthentication chip". Avant cette version, il y avait le "ATSHA204A" et le "ATECC508A".

Pourquoi ai-je décidé d'utiliser la dernière version et non la version précédente ?

Cette version est la puce la plus avancée et possède des fonctionnalités que l'ancienne version n'a pas (Par exemple: module AES, module de protection IO…).

Pourquoi ce projet ?

Je travaille dans le domaine de la CyberSécurité et comme tout le monde j'ai adoré la programmation et l'électronique. Pendant mes études, j'obtiens une conférence avec un spécialiste de la sécurité IoT qui nous a montré qu'Industriel n'utilise pas la sécurité dans son objet IoT. Je nous ai montré un cadenas qui s'ouvre avec votre smartphone par Bluetooth. Sur le cadenas, une phrase disait "Ce cadenas est plus sûr qu'un cadenas à clé !". Cette phrase le fait sourire et il modifie la phrase "Ce cadenas est le pire cadenas jamais construit !".

Il nous a montré avec son propre PC et un renifleur Bluetooth que chaque commande envoyée par le smartphone est la même à chaque fois et qu'il est très simple de copier cette commande et de l'envoyer avec votre smartphone. Il nous a expliqué que la "Sécurité" pour "Industriel" n'est pas le problème principal. Il nous a montré des puces (moins de 0.60$) qui pourraient ajouter une couche de sécurité à ces objets.

Après cette démonstration, j'ai essayé de trouver un projet Open source qui ajoute une couche de sécurité à l'objet IoT mais je ne l'ai jamais trouvé.

J'ai donc décidé de travailler sur un projet qui utilise une couche de sécurité pour la communication entre deux objets IoT.

Quelle est mon idée ?

Lors d'une communication entre deux objets IoT, plusieurs attaques peuvent exister: Man Of the mild, Copy of information et plus.. Donc mon idée est très simple:

1. Utilisation de données cryptées entre deux ou plusieurs objets IoT.
2. Fournitures à faible coût
3. Peut fonctionner avec un Arduino UNO

Maintenant, je vais vous expliquer comment j'ai implémenté cette image abstraite avec un Arduino et une puce Atecc608a. Dans cet article, je vais vous expliquer comment utiliser l'Arduino UNO avec l'ATECC608A.

J'écrirai un article sur la communication de deux objets la prochaine fois.

Fournitures

Vous avez besoin de quelques éléments pour ce projet:

1. Arduino UNO ou MEGA (la puce doit être Atmega 328 ou ATMEGA 2560)
2. Puce Atecc608A (coût inférieur à 0.80$ pièce, facile à trouver sur le site de votre fournisseur)
3. Adaptateur SOIC 8 broches
4. Quelques fils et résistances

La fiche technique de la version précédente de cette puce (Atecc508a) est disponible ici -> Fiche technique Atecc508a

Étape 1: étape par étape

Dans cet article, je vais vous montrer comment modifier la configuration de cette puce et ensuite comment crypter les données à l'aide de l'algorithme AES CBC.

Nous suivrons ces étapes:

1. Conception du circuit
2. Configuration de cette puce
3. Utilisation du module AES CBC
4. Pourquoi avez-vous besoin d'utiliser cette puce

Pour chaque étape, je vous détaillerai tout. Aussi, j'ai ajouté mon code dans mon Github avec des commentaires pour chaque fonction. Si vous avez des questions sur mon code ou ce projet, je me ferai un plaisir d'y répondre.

Mon Github: Mon Github

Étape 2: Avertissement concernant l'Atecc608a

La puce Atecc608a n'est pas une puce "facile".

Tout d'abord, la documentation de cette puce est sous NDA donc vous ne la trouverez pas en entier sur Internet. Mais pas de problème pour cela, la fiche technique de la version précédente est disponible sur Internet Fiche technique complète ATECC508A.

Deuxièmement, lorsque vous utilisez cette puce, vous devez verrouiller sa configuration et il est impossible de modifier la configuration de la puce si elle est verrouillée. Soyez donc prudent lorsque vous verrouillerez la zone de configuration et la zone de données.

Troisièmement, la bibliothèque écrite en C est très grande et complète, vous devez donc lire la documentation des fonctions que vous utiliserez auparavant.

Quatrièmement, la bibliothèque a écrit pour que cette puce ne fonctionne pas pour Arduino UNO, mais elle a ajouté que les fonctionnalités en ont besoin pour fonctionner avec Arduino UNO.

La puce ATECC608A

Vous pouvez communiquer avec cette puce par I2C. L'adresse de cette puce peut être modifiée dans la configuration.

Cette puce contient 16 slots différents pouvant contenir différents types de données:

1. Clé ECC (privée ou publique)
2. Clé AES
3. Autres données (comme le hachage Sha ou juste des mots)

Dans notre cas, nous stockerons la clé AES dans un emplacement.

Étape 3: 1. Conception du circuit

1. Conception du circuit

Le schéma de ce circuit est très simple !

Vous devez utiliser une alimentation 3,3V car la recommandation se situe entre 2,0V et 5,5V mais j'ai préféré utiliser le 3,3V.

Pour cette puce, normalement vous avez un point sur un coin de la puce, ce point est la broche 1 de cette carte. J'ai ajouté la vue de dessus de l'Atecc608a avec le numéro PIN car il s'agit d'un SOIC à 8 dérivations, donc la puce est très petite.

1. ARDUINO 3.3V -> BROCHE 8 (Atecc608a)
2. ARDUINO GND -> PIN 4 (Atecc608a)
3. ARDUINO A4 (SDL) -> PIN 5 (Atecc608a)
4. ARDUINO A5 (SCL) -> PIN 6 (Atecc608a)

Vous devez utiliser une alimentation 3,3V car la recommandation se situe entre 2,0V et 5,5V mais j'ai préféré utiliser le 3,3V.

J'ai ajouté la vue de dessus de l'Atecc608a car il s'agit d'un SOIC à 8 dérivations, donc la puce est très petite. Si vous préférez, afin que les fournisseurs construisent une carte avec la soudure par puce, cela pourrait être plus facile pour vous.

Attention: Dans mon cas, je dois ajouter une résistance entre le SDA de l'Arduino et la Chip (également pour le SDL). J'ai ajouté une résistance de 4.7Kohm pour chacun.

Étape 4: 2. Configuration de la puce (Atecc608a)

Avant d'utiliser la fonction de cryptage ou de décryptage, vous devez configurer la puce. Dans cette étape, je vais détailler toutes les étapes que vous devez effectuer pour la configuration de cette puce.

Attention: cette étape est très importante et si vous verrouillez les zones avant la fin vous ne pouvez pas les modifier.

Comme expliqué précédemment, cette puce a deux zones:

1. Zone de configuration
2. Zone de données

La zone de configuration a une taille de 128 octets mais les 16 premiers octets ne peuvent pas être modifiés.

Pour configurer cette puce, vous devez suivre ces étapes. Il est très important de suivre chaque étape dans l'ordre ou votre configuration ne fonctionnera pas, et votre puce sera verrouillée et inutilisable. Ces étapes sont:

1. Créer un modèle de configuration
2. Écrivez ce modèle sur la puce
3. Verrouiller la zone de configuration
4. Écrivez votre clé AES (128 bits) dans un emplacement
5. Verrouiller la zone de données

Informations

Ci-dessous je détaille chaque étape de la conifguration avec mon code, mais pas de soucis, j'ai ajouté un exemple complet de configuration dans mon Github. Je mets des commentaires sur chaque fonction, et un fichier *.ino est disponible à chaque étape pour vous.

• Mon Github: Mon Github
• Chemin de l'exemple de configuration: configuration_example.ino

Première étape: Créer un modèle de configuration

Comme expliqué précédemment, la zone de configuration a une taille de 128 bits, mais les 16 premiers bits ne peuvent pas être modifiés. Cette zone est composée de plusieurs parties, mais vous n'avez besoin de connaître que 3 parties de cette zone de configuration pour ce projet:

1. Les octets 16 -> C'est l'adresse I2C de la puce
2. Les Octets 20 à 51 -> Vous pouvez modifier ici le type de Slot pour les 16 slots de cette puce
3. Les octets 96 à 127 -> Vous pouvez définir ici le type de clé ou de données utilisé dans chaque emplacement.

(Si vous avez besoin de plus d'explications sur toute cette zone, veuillez lire la documentation (page 13, section 2.2))

Ici, je détaille chaque octet/partie des 112 octets de la configuration d'une puce. Ceci est un exemple, chaque puce achetée peut avoir une configuration différente:

0xC0, // adresse 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, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x00, // Emplacement de configuration de clé 1 0x33, 0x00, // Emplacement de configuration de clé 2 0x33, 0x00, // Emplacement de configuration de clé 3 0x1C, 0x00, // Emplacement de configuration de clé 4 0x1C, 0x00, // Emplacement de configuration de clé 5 0x 1C, 0x00, // Emplacement de configuration de clé 6 0x1C, 0x00, // Emplacement de configuration de clé 7 0x3C, 0x00, // Emplacement de configuration de clé 8 0x1A, 0x00, // Emplacement de configuration de clé 9 0x3A, 0x00, // Emplacement de configuration de clé 10 0x1A, 0x00, // Emplacement de configuration de clé 11 0x3A, 0x00, // Emplacement de configuration de clé 12 0x3A, 0x00, // Emplacement de configuration de clé 13 0x3C, 0x00, // Emplacement de configuration de clé 14 0x3C, 0x00, // Emplacement de configuration de clé 15 0x1C, 0x00 // Emplacement de configuration de clé 16

Comme vous le voyez, j'ai mis quelques commentaires dans ce code pour mieux comprendre cette configuration.

Dans votre cas, vous n'avez besoin de comprendre que trois choses:

1. Les octets 16 -> C'est l'adresse I2C de la puce
2. Les Octets 20 à 51 -> Vous pouvez modifier ici le type de Slot pour les 16 slots de cette puce
3. L'octet 96 à 127 -> Vous pouvez définir ici le type de clé ou de données utilisé dans chaque emplacement.

Je n'expliquerai pas le type de configuration et pourquoi j'ai utilisé celle-ci et pas une autre car c'est compliqué de tout expliquer. Si vous avez besoin de plus d'informations, consultez la documentation, page 16 section 2.2.1 pour le "SlotConfig" et page 19 section 2.2.5 pour "KeyConfig"

Pour cet exemple, vous utiliserez l'emplacement 9 pour stocker une clé AES.

Pour cela, nous devons mettre (si vous en avez besoin, vous pouvez copier l'exemple ci-dessus, la modification a été faite dedans):

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

Pourquoi ai-je défini cette configuration: Pour chaque emplacement de cette puce, vous pouvez définir des paramètres pour dire à la puce quel type de données sera stocké. Vous avez plusieurs paramètres:

• L'emplacement peut être écrit ou lu (action claire ou cryptée)
• Type de données stockées (Clé ECC, Clé publique, SHA Hash, AES Key…)
• La fente peut être verrouillable
• La génération de clé est autorisée
• …

Avec les octets 36 et 37 mis à "0x0F8F":

• Les données peuvent être écrites en clair
• Le contenu de cet emplacement est secret et ne peut pas être lu
• L'emplacement ne peut pas être utilisé pour la commande CheckMac Copy

Avec les octets 112 et 113 mis à "0x001A":

L'emplacement peut stocker jusqu'à quatre clés symétriques AES 128 bits (KeyType = 0x6)

Deuxième étape: Ecrire cette configuration

Cette étape est très importante car nous allons paramétrer la puce avec notre configuration et si cette configuration n'est pas bonne, vous utiliserez cette puce.

Mais pas de soucis, tant que la Configuration n'est pas verrouillée, vous pouvez modifier votre configuration.

Ici, c'est le code utilisé pour écrire la configuration sur la puce:

/** \brief Écrire une nouvelle configuration sur la puce.

* \param[in] cfg Configuration de l'interface logique. Certaines configurations * prédéfinies peuvent être trouvées dans atca_cfgs.h * \param[in] config Tableau uint8_t de configuration (longueur 112) * \param[in] len Taille du tableau de configuration * \return ATCA_SUCCESS en cas de succès, sinon un code d'erreur. */ ATCA_STATUS write_configuration(ATCAIfaceCfg *cfg, uint8_t *config, size_t len) { if (len !=112) return ATCA_BAD_PARAM; état ATCA_STATUS; statut = atcab_init(cfg); if (status == ATCA_SUCCESS) { // Écrire le tableau de configuration sur la puce // Remplissage de 16 octets (16 premiers octets ne peuvent pas être écrits) status = atcab_write_bytes_zone(ATCA_ZONE_CONFIG, 0, 16, (uint8_t *)config, len); état de retour; } retourner l'état; }

Cette fonction écrira votre configuration dans la puce.

Troisième étape: verrouiller la zone de configuration

Attention: attention à cette étape, si vous verrouillez cette Zone et que votre configuration n'est pas bonne, la puce est inutilisable et vous ne pourrez pas modifier cette zone

Pour cette action, nous utiliserons cette fonction:

/** \brief Vérifie si la DATA_ZONE ou CONFIG_ZONE est verrouillée

* \param[in] cfg Configuration de l'interface logique. Certaines configurations * prédéfinies peuvent être trouvées dans atca_cfgs.h * \param[in] zone LOCK_ZONE_DATA ou LOCK_ZONE_CONFIG * \return ATCA_SUCCESS en cas de succès, sinon un code d'erreur. */ ATCA_STATUS check_lock_zone(ATCAIfaceCfg *cfg, uint8_t zone) { état ATCA_STATUS; bool lock = false; if (zone != (uint8_t)LOCK_ZONE_CONFIG && zone != (uint8_t)LOCK_ZONE_DATA) renvoie ATCA_BAD_PARAM; statut = atcab_init(cfg); if (status == ATCA_SUCCESS) { if (ATCA_SUCCESS != (status = atcab_is_locked(zone, &lock))) { return ATCA_FUNC_FAIL; } if (!lock) { return ATCA_NOT_LOCKED; } renvoie ATCA_SUCCESS; } renvoie ATCA_BAD_PARAM; } check_lock_zone(&cfg, LOCK_ZONE_CONFIG);

Quatrième étape: Écrivez votre clé AES dans un emplacement

Dans cette partie, vous allez définir votre clé AES personnelle dans l'emplacement que vous avez défini dans la configuration de la puce.

Pour cet exemple, j'utiliserai le slot numéro 9 de la puce.

Vous devez savoir: Une particularité de cette puce est que vous ne pouvez écrire des données dans un slot que par 4 octets ou 32 octets. Pour AES, nous avons besoin d'une clé de 128 bits donc 16 octets de données. J'ai donc décidé d'écrire sur une clé de 16 octets chacun dans cet emplacement pour avoir des données de 32 octets.

Maintenant, je vais vous montrer le code utilisé:

/** \brief Ecrit la clé AES dans un slot donné. * \param[in] cfg Configuration de l'interface logique. Certaines configurations * prédéfinies peuvent être trouvées dans atca_cfgs.h * \param[in] key key slot number * \param[in] datakey key array uint8_t * \param[in] len Taille du tableau de clés * \return ATCA_SUCCESS en cas de succès, sinon un code d'erreur. */ ATCA_STATUS write_key_slot(ATCAIfaceCfg *cfg, uint8_t key, uint8_t *datakey, size_t len) { si (clé 16) renvoie ATCA_BAD_PARAM; if (len != 32) renvoie ATCA_BAD_PARAM; état ATCA_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) renvoie le statut; } retourner l'état; }

Pour cet exemple, je vais utiliser deux clés AES de 16 octets chacune:

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

Si cette action est bonne, maintenant, vous devez passer la dernière étape "verrouiller la zone de données"

Dernière étape: verrouiller la Data Zone

Attention: attention à cette étape, si vous verrouillez cette Zone et que vos données ne sont pas renseignées, la puce est inutilisable et vous ne pourrez pas modifier cette zone

Pour cette action, nous utiliserons cette fonction:

/** \brief Vérifie si la DATA_ZONE ou la CONFIG_ZONE est verrouillée

* \param[in] cfg Configuration de l'interface logique. Certaines configurations * prédéfinies peuvent être trouvées dans atca_cfgs.h * \param[in] zone LOCK_ZONE_DATA ou LOCK_ZONE_CONFIG * \return ATCA_SUCCESS en cas de succès, sinon un code d'erreur. */ ATCA_STATUS check_lock_zone(ATCAIfaceCfg *cfg, uint8_t zone) { état ATCA_STATUS; bool lock = false; if (zone != (uint8_t)LOCK_ZONE_CONFIG && zone != (uint8_t)LOCK_ZONE_DATA) renvoie ATCA_BAD_PARAM; statut = atcab_init(cfg); if (status == ATCA_SUCCESS) { if (ATCA_SUCCESS != (status = atcab_is_locked(zone, &lock))) { return ATCA_FUNC_FAIL; } if (!lock) { return ATCA_NOT_LOCKED; } renvoie ATCA_SUCCESS; } renvoie ATCA_BAD_PARAM; } check_lock_zone(&cfg, LOCK_ZONE_DATA);

Si cette action est bonne, votre puce est prête à être utilisée

Étape 5: 3. Utilisation du module AES CBC

Je vais vous expliquer comment crypter et décrypter des données avec l'algorithme AES CBC et la puce Atecc608a.

N'oubliez pas: Avant d'utiliser cette fonction, vous devez configurer la puce. Pour cela, suivez l'étape 2 de cet article

Cette puce possède plusieurs types de module AES (AES 128 bits), seul AES 128 bits est possible:

1. AES normal
2. AES Radio-Canada
3. AES GCM (avec hachage GFM) (voir wikipedia pour plus d'explications)

Pour faciliter son utilisation, j'ai créé deux fonctions:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Ces deux fonctions sont disponibles sur mon Github.

Explication

J'ai choisi d'utiliser l'algorithme AES CBC car il est plus sûr que l'AES 128 bits de base. Cet algorithme utilise un vecteur initial pour crypter vos données.

Informations

Ci-dessous, je détaille chaque étape de la méthode de cryptage et de décryptage. Mais j'ai écrit un code pour l'Arduino qui utilise ces deux fonctions. Vous pouvez voir ce code dans mon Github:

• Github: Mon Github
• Exemple de code "Crypter/Décrypter": AES_crypto_example.ino

Première étape: Crypter vos données

Dans cette partie, je vais vous montrer comment crypter vos données.

Vous aurez d'abord besoin de cette fonction:

/** \brief Crypter les données à l'aide de l'algorithme AES CBC * \param[in] cfg Configuration de l'interface logique. Certaines configurations * prédéfinies peuvent être trouvées dans atca_cfgs.h * \param[in] data Mots à chiffrer (doit être divisé par 16, longueur max 240) * \param[in] len longueur des mots à chiffrer (doit être divisé par 16, longueur max 240) * \param[out] iv Vecteur initial utilisé dans le CBC AES (renvoyer le vecteur dans cette var) * \param[out] texte chiffré renvoie ici le texte chiffré * \param[in] clé Numéro d'emplacement du key * \return ATCA_SUCCESS en cas de succès, sinon un code d'erreur. */ 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("ERROR: ATCA_BAD_PARAM")); renvoie ATCA_BAD_PARAM; } uint8_t tmp_iv[IV_LENGTH_CBC]; uint8_t tmp_data[len]; état ATCA_STATUS = atcab_init(cfg); if (status == ATCA_SUCCESS) { status = atcab_aes_cbc_init(&ctx, key, 0, tmp_iv); if (status != ATCA_SUCCESS) { Serial.print(F("ERROR Encrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println(statut, HEX); revenir; } memcpy(iv, tmp_iv, IV_LENGTH_CBC); memcpy(tmp_data, data, len); int max = longueur/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("ERROR Encrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println(statut, HEX); } retourner l'état; } retourner l'état; }

Cette fonction est simple à utiliser, vous devez régler deux choses:

1. Un IV vide (Vecteur Initial) de 16 octets
2. Données à crypter (taille max 240 octets)

Voici un exemple "comment utiliser cette fonction".

Je veux crypter le mot "AAAAAAAAAAAAAAAA", avec ma clé écrite dans le slot numéro "9":

ATCA_STATUS status = atcab_init(&cfg); if (status != ATCA_SUCCESS) { Serial.println(F("atcab_init() a échoué: Code -> 0x")); Serial.println(statut, HEX); } uint8_t plaintext[16] = "AAAAAAAAAAAAAAAA"; // Texte original uint8_t iv[IV_LENGTH_CBC]; // Initial Vector uint8_t cypherdata[sizeof(plaintext)]; // Statut crypté des données = aes_cbc_encrypt(&cfg, plaintext, sizeof(plaintext), iv, cypherdata, 9);

Si l'action est bonne, vous aurez les données chiffrées dans la variable "cypherdata" et le vecteur initial dans la variable "IV".

Conservez ces deux variables pour décrypter votre texte !

Deuxième étape: décryptez vos données

Pour décrypter vos données vous aurez besoin de deux choses:

1. Le vecteur initial
2. Les données Cypher (données cryptées)

Pour décrypter vos données, vous aurez besoin de cette fonction:

/** \brief Décrypter les données à l'aide de l'algorithme AES CBC * \param[in] cfg Configuration de l'interface logique. Certaines configurations * prédéfinies peuvent être trouvées dans atca_cfgs.h * \param[in] texte chiffré Mots à déchiffrer (doit être divisé par 16, longueur max 240) * \param[in] longueur des mots à déchiffrer (doit être divisé par 16, longueur max 240) * \param[in] iv Vecteur initial à utiliser dans le CBC AES * \param[out] texte en clair renvoie ici le texte déchiffré * \param[in] key Numéro d'emplacement de la clé * \return ATCA_SUCCESS en cas de succès, sinon un code d'erreur. */ 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 Decrypt: ATCA_BAD_PARAM")); renvoie ATCA_BAD_PARAM; } état ATCA_STATUS = atcab_init(cfg); if (status == ATCA_SUCCESS) { status = atcab_aes_cbc_init(&ctx, key, 0, iv); if (status != ATCA_SUCCESS) { Serial.print(F("ERROR Decrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println(statut, HEX); revenir; } int max = longueur / 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("ERROR Decrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println(statut, HEX); } retourner l'état; } retourner l'état; }

Je souhaite décrypter mes données précédentes (voir ci-dessous, Première étape). Pour cela je vais faire ceci:

uint8_t plaintext[16] = "AAAAAAAAAAAAAAAA"; uint8_t iv[IV_LENGTH_CBC]; uint8_t cypherdata[sizeof(plaintext)]; uint8_t decryptdata[sizeof(plaintext)]; status = aes_cbc_decrypt(&cfg, cypherdata, sizeof(cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) { Serial.print("Le texte déchiffré est: "); for (size_t i = 0; i < sizeof(decryptdata); i++) { Serial.print((char)decryptdata); } Serial.println(""); } else { // Voir le fichier atca_status.h pour le code Error Serial.print(F("Impossible de déchiffrer | Code Error 0x")); Serial.println(statut, HEX); revenir; }

Si l'action est bonne, vous aurez les données décryptées dans la variable "decryptdata".

Vous savez maintenant utiliser le cryptage et le décryptage avec la puce Atecc608a

Étape 6: 5. Pourquoi avez-vous besoin d'utiliser cette puce

Les données cryptées sont très utiles car vous pouvez masquer vos informations et les envoyer par Wireless ou simplement les stocker.

Voici quelques exemples d'utilisation:

1. Données stockées dans une EEPROM externe: Vous pouvez sécuriser les données d'une EEPROM externe et si quelqu'un conserve cette EEPROM, il aura besoin de la Clé et de l'IV pour le décryptage
2. Envoyer des données sans fil: Vous pouvez envoyer ces données cryptées par sans fil (nrf24L01, RFM95W…) et si quelqu'un intercepte vos données, ces données seront sécurisées
3. Mot de passe enregistré
4. …

Vous pouvez faire plusieurs choses avec cette puce. Il peut être utilisé dans plusieurs projets. Si vous avez le temps, dites moi dans quel projet vous utiliserez cette puce ?

Un dernier conseil, si vous construisez un projet sans fil ou stockez des données brutes, soyez prudent, la sécurité est très importante et si vous savez à quel point il est simple pour un "noob" d'intercepter ou de voler vos données. Désormais avec Internet, tout le monde peut avoir des scripts à lancer sur son ordinateur juste pour vous "pirater" !

Étape 7: Conclusion

J'espère que cet article vous sera utile. Désolé si je me suis trompé dans mon texte mais l'anglais n'est pas ma langue principale et je parle mieux que j'écris.

Merci d'avoir tout lu.

Profitez-en.