Seguridad con Arduino: Atecc608a: 7 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

Tema

Hola, todos !

Este es mi primer artículo de Instructables, así que espero que sea interesante para todos ustedes.

En este artículo, te explicaré cómo usar un microchip llamado "ATECC608A" que proporciona múltiples herramientas de seguridad.

Este chip ha sido diseñado por MicroChip y es la última versión del "chip CryptoAuthentication". Antes de esta versión, existía "ATSHA204A" y "ATECC508A".

¿Por qué decidí utilizar la última versión y no la anterior?

Esta versión es el chip más avanzado y tiene funcionalidades que la versión anterior no tiene (Por ejemplo: módulo AES, módulo de protección IO…).

¿Por qué este proyecto?

Trabajo en el dominio de la Ciberseguridad y como a todos me encantaba la programación y la electrónica. Durante mis estudios, tengo una conferencia con un especialista en seguridad de IoT que nos mostró que Industrial no usa la seguridad en su objeto de IoT. Nos mostré un candado que se puede abrir con su teléfono inteligente mediante Bluetooth. En el candado, una frase decía "¡Este candado es más seguro que un candado con llave!". Esta frase le hizo sonreír y modificó la frase "¡Este candado es el peor candado jamás construido!".

Nos mostró con su propia PC y un rastreador de Bluetooth que todos los comandos enviados por el teléfono inteligente son iguales cada vez y es muy simple copiar este comando y enviarlo con su teléfono inteligente. Nos explicó que "Seguridad" para "Industrial" no es el principal problema. Nos mostró chips (menos de 0,60 $) que podrían agregar una capa de seguridad a estos objetos.

Después de esta demostración, intenté encontrar algún proyecto de código abierto que agregue una capa de seguridad al objeto de IoT, pero nunca lo encontré.

Entonces decidí trabajar en un proyecto que usa la capa de seguridad para la comunicación entre dos objetos de IoT.

Cual es mi idea?

Durante una comunicación entre dos Objetos de IoT, pueden existir múltiples ataques: Man Of the mild, Copy of information y más.. Entonces mi idea es muy simple:

1. Utilización de datos cifrados entre dos o más objetos de IoT.
2. Suministros de bajo costo
3. Puede trabajar con un Arduino UNO

Ahora te explicaré cómo implementé esta imagen abstracta con un Arduino y un chip Atecc608a. En este artículo, te explicaré cómo usar el Arduino UNO con el ATECC608A.

Escribiré un artículo sobre la comunicación de dos objetos la próxima vez.

Suministros

Necesita algunas cosas para este proyecto:

1. Arduino UNO o MEGA (el chip debe ser Atmega 328 o ATMEGA 2560)
2. Chip Atecc608A (cuesta menos de 0,80 $ cada uno, fácil de encontrar en el sitio web de su proveedor)
3. Adaptador SOIC de 8 pines
4. Algunos cables y resistencias.

La hoja de datos de la versión anterior de este chip (Atecc508a) está disponible aquí -> Hoja de datos Atecc508a

Paso 1: paso a paso

En este artículo, le mostraré cómo modificar la configuración de este chip y luego cómo encriptar datos usando el algoritmo AES CBC.

Seguiremos esos pasos:

1. Diseño del circuito
2. Configuración de este chip
3. Utilización del módulo AES CBC
4. ¿Por qué necesitas usar este chip?

Para cada paso, te detallaré todo. Además, agregué mi código en mi Github con comentarios para cada función. Si tiene alguna pregunta sobre mi código o este proyecto, estaré encantado de responderla.

Mi Github: Mi Github

Paso 2: Advertencia sobre el Atecc608a

El chip Atecc608a no es un chip "fácil".

Primero, la documentación de este chip está bajo NDA, por lo que no la encontrará completa en Internet. Pero no hay problema para esto, la hoja de datos de la versión anterior está disponible en Internet Datasheet Complete ATECC508A.

En segundo lugar, cuando utiliza este chip necesita bloquear su configuración y es imposible modificar la configuración del chip si está bloqueado. Así que tenga cuidado cuando bloquee la Zona de configuración y la Zona de datos.

En tercer lugar, la biblioteca escrita en C es muy grande y completa, por lo que debes leer la documentación de las funciones que usarás antes.

Cuatro, la biblioteca escribió para este chip que no funciona para Arduino UNO, pero agregó las funcionalidades que necesitan para trabajar con Arduino UNO.

El chip ATECC608A

Puede comunicarse con este chip por I2C. La dirección de este chip se puede modificar en la configuración.

Este chip contiene 16 ranuras diferentes que pueden contener diferentes tipos de datos:

1. Clave ECC (privada o pública)
2. Clave AES
3. Otros datos (como Sha hash o solo palabras)

En nuestro caso, almacenaremos la clave AES en una ranura.

Paso 3: 1. Diseño del circuito

1. Diseño del circuito

¡El esquema de este circuito es muy simple!

Necesita usar una potencia de 3.3V porque la recomendación es entre 2.0V y 5.5V, pero yo prefiero usar 3.3V.

Para este chip, normalmente tiene un punto en una esquina del chip, este punto es el Pin 1 de esta placa. Agregué la vista superior del Atecc608a con número PIN porque es un SOIC de 8 derivaciones, por lo que el chip es muy pequeño.

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)

Necesita usar una potencia de 3.3V porque la recomendación es entre 2.0V y 5.5V, pero yo prefiero usar 3.3V.

Agregué la vista superior del Atecc608a porque es un SOIC de 8 derivaciones, por lo que el chip es muy pequeño. Si lo prefiere, para que los proveedores construyan una placa con la soldadura de chip, podría ser más fácil para usted.

Advertencia: En mi caso, tengo que agregar una resistencia entre el SDA del Arduino y el Chip (también para el SDL). Agregué una resistencia de 4.7Kohm para cada uno.

Paso 4: 2. Configuración del Chip (Atecc608a)

Antes de utilizar la función de cifrado o descifrado, debe configurar el chip. En este paso, detallaré todos los pasos que debe realizar para la configuración de este chip.

Advertencia: este paso es muy importante y si bloquea las zonas antes del final no podrá modificarlas.

Como se explicó antes, este chip tiene dos zonas:

1. Zona de configuración
2. Zona de datos

La zona de configuración tiene un tamaño de 128 bytes pero los primeros 16 bytes no se pueden modificar.

Para configurar este chip, necesita dos seguir esos pasos. Es muy importante seguir cada paso en orden o su configuración no funcionará y su chip quedará bloqueado e inutilizable. Esos pasos son:

1. Crea una plantilla de configuración
2. Escribe esta plantilla en el chip
3. Bloquear la zona de configuración
4. Escriba su clave AES (128 Bits) en una ranura
5. Bloquear la zona de datos

Información

A continuación, detallo cada paso de la configuración con mi código, pero no se preocupe, agregué un ejemplo completo de configuración en mi Github. Pongo comentarios sobre cada función, y un archivo *.ino está disponible con cada paso en orden para ti.

• Mi Github: Mi Github
• Ruta de configuración de ejemplo: configuration_example.ino

Primer paso: crear una plantilla de configuración

Como se explicó anteriormente, la zona de configuración tiene un tamaño de 128 bits, pero los primeros 16 bits no se pueden cambiar. Esta zona se compone de varias partes, pero solo necesita conocer 3 partes de esta zona de configuración para este proyecto:

1. Bytes 16 -> Esta es la dirección I2C del chip
2. Los Bytes 20 a 51 -> Aquí puedes modificar el tipo de Slot para los 16 slots de este chip
3. Los Bytes 96 a 127 -> Aquí puede establecer el Tipo de clave o datos utilizados en cada ranura.

(Si necesita más explicaciones de toda esta zona, lea la documentación (página 13, sección 2.2))

Aquí, pongo en detalle cada Bytes / Partes de los 112 bytes de la configuración de un Chip. Este es un ejemplo, cada chip comprado puede tener una configuración diferente:

0xC0, // dirección I2C

0x00, 0x00, 0x00, 0x83, 0x20, // Configuración de ranura Ranura 1 0x85, 0x20, // Configuración de ranura Ranura 2 0x8F, 0x20, // Configuración de ranura Ranura 3 0xC4, 0x8F, // Configuración de ranura Ranura 4 0x8F, 0x8F, // Configuración de ranura Ranura 5 0x8F, 0x8F, // Configuración de ranura Ranura 6 0x9F, 0x8F, // Configuración de ranura Ranura 7 0x0F, 0x0F, // Configuración de ranura Ranura 8 0x8F, 0x0F, // Configuración de ranura Ranura 9 0x8F, 0x0F, // Configuración de ranura Ranura 10 0x8F, 0x0F, // Configuración de ranura Ranura 11 0x8F, 0x0F, // Configuración de ranura Ranura 12 0x8F, 0x0F, // Configuración de ranura Ranura 13 0x00, 0x00, // Configuración de ranura Ranura 14 0x00, 0x00, // Configuración de ranura Ranura 15 0xAF, 0x8F, // Configuración de ranura Ranura 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, 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, // Ranura de configuración de clave 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 // Ranura de configuración de clave 16

Como ves, pongo algunos comentarios en este código para entender más esta configuración.

En su caso, necesitará comprender solo tres cosas:

1. Bytes 16 -> Esta es la dirección I2C del chip
2. Los Bytes 20 a 51 -> Aquí puedes modificar el tipo de Slot para los 16 slots de este chip
3. Byte 96 a 127 -> Aquí puede establecer el tipo de clave o datos utilizados en cada ranura.

No explicaré el tipo de configuración y por qué usé esta y no otra porque es complicado explicarlo todo. Si necesita más información, consulte la documentación, página 16 sección 2.2.1 para "SlotConfig" y página 19 sección 2.2.5 para "KeyConfig"

Para este ejemplo, utilizará la ranura 9 para almacenar una clave AES.

Para esto, necesitamos poner (si lo necesita, puede copiar el ejemplo anterior, la modificación se ha hecho en él):

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

¿Por qué configuré esta configuración? Para cada ranura de este chip, puede configurar parámetros para decirle al chip qué tipo de datos se almacenarán. Tienes varios parámetros:

• La ranura se puede escribir o leer (acción de borrar o encriptar)
• Tipo de datos almacenados (clave ECC, clave pública, SHA Hash, clave AES…)
• La ranura se puede bloquear
• Se permite la generación de claves
• …

Con los bytes 36 y 37 establecidos en "0x0F8F":

• Los datos se pueden escribir en claro
• El contenido de esta ranura es secreto y no se puede leer
• La ranura no se puede utilizar para el comando CheckMac Copy

Con los bytes 112 y 113 establecidos en "0x001A":

La ranura puede almacenar hasta cuatro claves simétricas AES de 128 bits (KeyType = 0x6)

Segundo paso: escribe esta configuración

Este paso es muy importante porque configuraremos el chip con nuestra configuración y si esta configuración no es buena, usarás este chip.

Pero no se preocupe, siempre que la Configuración no esté bloqueada, puede modificar su configuración.

Aquí, este es el código utilizado para escribir la configuración en el chip:

/ ** / brief Escribe una nueva configuración en el chip.

* / param [in] cfg Configuración de interfaz lógica. Algunas configuraciones * predefinidas se pueden encontrar en atca_cfgs.h * / param [in] config Array uint8_t de configuración (longitud 112) * / param [in] len Tamaño de la matriz de configuración * / return ATCA_SUCCESS en caso de éxito, de lo contrario un código de error. * / ATCA_STATUS write_configuration (ATCAIfaceCfg * cfg, uint8_t * config, size_t len) {if (len! = 112) return ATCA_BAD_PARAM; Estado ATCA_STATUS; estado = atcab_init (cfg); if (status == ATCA_SUCCESS) {// Escribe la configuración Array en el chip // Relleno de 16 bytes (no se pueden escribir 16 primeros bytes) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); estado de devolución; } estado de devolución; }

Esta función escribirá su configuración en el chip.

Tercer paso: bloquear la zona de configuración

Advertencia: tenga cuidado con este paso, si bloquea esta Zona y su configuración no es buena, el chip está inservible y no podrá modificar esta zona

Para esta acción, usaremos esta función:

/ ** / breve Compruebe si la DATA_ZONE o CONFIG_ZONE está bloqueada

* / param [in] cfg Configuración de interfaz lógica. Algunas configuraciones * predefinidas se pueden encontrar en atca_cfgs.h * / param [in] zone LOCK_ZONE_DATA o LOCK_ZONE_CONFIG * / return ATCA_SUCCESS en caso de éxito, de lo contrario un código de error. * / ATCA_STATUS check_lock_zone (ATCAIfaceCfg * cfg, zona uint8_t) {estado ATCA_STATUS; bool lock = falso; if (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) return ATCA_BAD_PARAM; estado = 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; } return ATCA_SUCCESS; } return ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

Cuarto paso: escriba su clave AES en una ranura

En esta parte pondrás tu clave AES personal en la ranura que has definido en la configuración del chip.

Para este ejemplo, usaré la ranura número 9 del chip.

Necesita saber: Una característica especial de este chip es que puede escribir datos en la ranura solo por 4 bytes o 32 bytes. Para AES, necesitamos una clave de 128 bits, por lo que 16 bytes de datos. Así que decidí escribir una clave de 16 bytes cada una en esta ranura para tener 32 bytes de datos.

Ahora, te mostraré el código utilizado:

/ ** / brief Escribe la clave AES en una ranura determinada. * / param [in] cfg Configuración de interfaz lógica. Algunas configuraciones * predefinidas se pueden encontrar en atca_cfgs.h * / param [in] key key slot number * / param [in] datakey key array uint8_t * / param [in] len Tamaño de la matriz de claves * / return ATCA_SUCCESS en caso de éxito, de lo contrario, un código de error. * / ATCA_STATUS write_key_slot (ATCAIfaceCfg * cfg, uint8_t key, uint8_t * datakey, size_t len) {if (clave 16) return ATCA_BAD_PARAM; si (len! = 32) return ATCA_BAD_PARAM; Estado de ATCA_STATUS = atcab_init (cfg); if (estado == ATCA_SUCCESS) {estado = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) clave, 0, 0, clave de datos, 32); if (status! = ATCA_SUCCESS) return status; } estado de devolución; }

Para este ejemplo, usaré dos claves AES de 16 bytes cada una:

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

Si esta acción es buena, ahora debes pasar el último paso "bloquear la zona de datos"

Último paso: bloquear la zona de datos

Advertencia: tenga cuidado con este paso, si bloquea esta Zona y sus datos no están configurados, el chip es inutilizable y no podrá modificar esta zona

Para esta acción, usaremos esta función:

/ ** / breve Compruebe si la DATA_ZONE o CONFIG_ZONE está bloqueada

* / param [in] cfg Configuración de interfaz lógica. Algunas configuraciones * predefinidas se pueden encontrar en atca_cfgs.h * / param [in] zone LOCK_ZONE_DATA o LOCK_ZONE_CONFIG * / return ATCA_SUCCESS en caso de éxito, de lo contrario un código de error. * / ATCA_STATUS check_lock_zone (ATCAIfaceCfg * cfg, zona uint8_t) {estado ATCA_STATUS; bool lock = falso; if (zone! = (uint8_t) LOCK_ZONE_CONFIG && zone! = (uint8_t) LOCK_ZONE_DATA) return ATCA_BAD_PARAM; estado = 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; } return ATCA_SUCCESS; } return ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

Si esta acción es buena, ¡su chip está listo para usarse

Paso 5: 3. Utilización del módulo AES CBC

Explicaré cómo cifrar y descifrar datos con el algoritmo AES CBC y el chip Atecc608a.

Recuerde: antes de utilizar esta función, debe configurar el chip. Para ello, siga el paso 2 de este artículo

Este chip tiene varios tipos de módulo AES (AES 128 bits), solo es posible AES 128 bits:

1. AES normal
2. AES CBC
3. AES GCM (con hash GFM) (consulte wikipedia para obtener más explicaciones)

Para que sea más fácil de usar, creé dos funciones:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Esas dos funciones están disponibles en mi Github.

Explicación

Elijo usar el algoritmo AES CBC porque es más seguro que el AES básico de 128 bits. Este algoritmo utiliza un vector inicial para cifrar sus datos.

Información

A continuación, detallo cada paso del método de cifrado y descifrado. Pero escribí un código para Arduino que usa ambas funciones. Puedes ver este código en mi Github:

• Github: Mi Github
• Ejemplo de código "Cifrar / Descifrar": AES_crypto_example.ino

Primer paso: cifre sus datos

En esta parte, le mostraré cómo cifrar sus datos.

Primero necesitará esta función:

/ ** / brief Cifrar datos usando el algoritmo AES CBC * / param [in] cfg Configuración de interfaz lógica. Algunas configuraciones * predefinidas se pueden encontrar en atca_cfgs.h * / param [in] data Palabras para cifrar (debe dividirse entre 16, longitud máxima 240) * / param [in] len longitud de palabras para cifrar (debe dividirse entre 16, longitud máxima 240) * / param [out] iv Vector inicial utilizado en el AES CBC (devuelve el vector en este var) * / param [out] texto cifrado devuelve aquí el texto Cypher * / param [in] key Número de ranura del key * / return ATCA_SUCCESS en caso de éxito, de lo contrario un código de error. * / ATCA_STATUS aes_cbc_encrypt (ATCAIfaceCfg * cfg, uint8_t * datos, int len, uint8_t * iv, uint8_t * texto cifrado, clave uint8_t) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC && len% 16! = 0) {Serial.print (F ("ERROR: ATCA_BAD_PARAM")); return ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; Estado de ATCA_STATUS = atcab_init (cfg); if (estado == ATCA_SUCCESS) {estado = atcab_aes_cbc_init (& ctx, key, 0, tmp_iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Cifrar: atcab_aes_cbc_init, Código de error 0x")); Serial.println (estado, HEX); regreso; } memcpy (iv, tmp_iv, IV_LENGTH_CBC); memcpy (tmp_data, datos, 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 ("ERROR Encrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (estado, HEX); } estado de devolución; } estado de devolución; }

Esta función es fácil de usar, tienes que configurar dos cosas:

1. Un IV vacío (vector inicial) de 16 bytes
2. Datos para cifrar (tamaño máximo 240 bytes)

Aquí un ejemplo de "cómo utilizar esta función".

Quiero cifrar la palabra "AAAAAAAAAAAAAAA", con mi clave escrita en el número de ranura "9":

Estado de ATCA_STATUS = atcab_init (& cfg); if (status! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () falló: Código -> 0x")); Serial.println (estado, HEX); } uint8_t texto sin formato [16] = "AAAAAAAAAAAAAAA"; // Texto original uint8_t iv [IV_LENGTH_CBC]; // Vector inicial uint8_t cypherdata [sizeof (texto plano)]; // Estado de datos cifrados = aes_cbc_encrypt (& cfg, texto sin formato, tamaño de (texto sin formato), iv, cypherdata, 9);

Si la acción es buena, tendrás los datos encriptados en la variable "cypherdata" y el Vector Inicial en la variable "IV".

¡Conserve esas dos variables para descifrar su texto!

Segundo paso: descifra tus datos

Para descifrar sus datos, necesitará dos cosas:

1. El vector inicial
2. Los datos cifrados (datos cifrados)

Para descifrar sus datos, necesitará esta función:

/ ** / brief Descifrar datos usando el algoritmo AES CBC * / param [in] cfg Configuración de interfaz lógica. Algunas configuraciones * predefinidas se pueden encontrar en atca_cfgs.h * / param [in] texto cifrado Palabras para descifrar (debe dividirse entre 16, longitud máxima 240) * / param [in] len longitud de Palabras para descifrar (debe dividirse entre 16, longitud máxima 240) * / param [in] iv Vector inicial para usar en el AES CBC * / param [out] texto sin formato devuelve aquí el texto descifrado * / param [in] clave Número de ranura de la clave * / return ATCA_SUCCESS en caso de éxito, de lo contrario un código de error. * / ATCA_STATUS aes_cbc_decrypt (ATCAIfaceCfg * cfg, uint8_t * texto cifrado, int len, uint8_t * iv, uint8_t * texto sin formato, clave uint8_t) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC || len% 16! = 0) {Serial.print (F ("ERROR Descifrar: ATCA_BAD_PARAM")); return ATCA_BAD_PARAM; } Estado de ATCA_STATUS = atcab_init (cfg); if (estado == ATCA_SUCCESS) {estado = atcab_aes_cbc_init (& ctx, key, 0, iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Descifrar: atcab_aes_cbc_init, Error de código 0x")); Serial.println (estado, HEX); regreso; } 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 (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_encrypt_block, Code Error 0x")); Serial.println (estado, HEX); } estado de devolución; } estado de devolución; }

Quiero descifrar mis datos anteriores (ver más abajo, Primer paso). Para esto haré esto:

uint8_t texto sin formato [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [tamaño de (texto sin formato)]; uint8_t decryptdata [tamaño de (texto sin formato)]; status = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) {Serial.print ("El texto descifrado es:"); for (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } else {// Ver archivo atca_status.h para el código Error Serial.print (F ("Imposible descifrar | Código Error 0x")); Serial.println (estado, HEX); regreso; }

Si la acción es buena, tendrás los datos descifrados en la variable "decryptdata".

¡Ahora ya sabe cómo utilizar el cifrado y el descifrado con el chip Atecc608a

Paso 6: 5. ¿Por qué necesita usar este chip?

Los datos cifrados son muy útiles porque puede ocultar su información y enviarla de forma inalámbrica o simplemente almacenarla.

Aquí un ejemplo de utilización:

1. Datos almacenados en una EEPROM externa: puede proteger los datos de una EEPROM externa y si alguien aún esta EEPROM, necesitará la clave y el IV para el descifrado
2. Enviar datos inalámbricos: puede enviar estos datos encriptados de forma inalámbrica (nrf24L01, RFM95W …) y si alguien intercepta sus datos, estos datos estarán seguros
3. Contraseña almacenada
4. …

Puedes hacer varias cosas con este chip. Se puede utilizar en varios proyectos. Si tienes tiempo, dime ¿en qué proyecto usarás este chip?

Un último consejo, si construyes algún proyecto inalámbrico o almacenas algunos datos sin procesar, ten cuidado, la seguridad es muy importante y si sabes lo sencillo que es para un "novato" interceptar o robar tus datos. ¡Ahora, con Internet, todo el mundo puede tener scripts para ejecutar en su computadora sólo para "hackearlo"!

Paso 7: Conclusión

Espero que este artículo te sea de utilidad. Perdón si me equivoqué en mi texto, pero el inglés no es mi idioma principal y hablo mejor de lo que escribo.

Gracias por leer todo.

Disfrútala.