Segurança com Arduino: Atecc608a: 7 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Tema

Olá pessoal !

Este é o meu primeiro Artigo sobre Instructables, então espero que seja interessante para todos vocês.

Neste artigo, vou explicar como usar um micro chip chamado "ATECC608A" que fornece várias ferramentas de segurança.

Este chip foi projetado pela MicroChip e é a última versão do "chip CryptoAuthentication". Antes desta versão existia o "ATSHA204A" e o "ATECC508A".

Por que decidi usar a última versão e não a anterior?

Esta versão é o chip mais avançado e possui funcionalidades que a versão anterior não possui (Ex: módulo AES, módulo de proteção IO…).

Por que este projeto?

Trabalho no domínio da CyberSecurity e como todos amei programação e electrónica. Durante meus estudos, recebo uma conferência com um especialista em Segurança de IoT que nos mostrou que a Industrial não usa Segurança em seu objeto de IoT. Mostrei-nos um cadeado que pode ser aberto com o seu smartphone por Bluetooth. No cadeado, uma frase dizia "Este cadeado é mais seguro do que um cadeado com chave!". Esta frase o fez sorrir e ele modificou a frase "Este cadeado é o pior cadeado já construído!".

Ele nos mostrou com seu próprio PC e um sniffer Bluetooth que todos os comandos enviados pelo smartphone são iguais todas as vezes e é muito simples copiar esse comando e enviar com seu smartphone. Ele nos explicou que "Segurança" para "Industrial" não é o principal problema. Ele nos mostrou chips (menos de 0,60 $) que poderiam adicionar uma camada de segurança a esses objetos.

Após esta demonstração, tentei encontrar algum projeto de código aberto que adicionasse camada de segurança ao objeto IoT, mas nunca o encontrei.

Então decidi trabalhar em um projeto que usa camada de segurança para comunicação entre dois objetos IoT.

Qual é a minha ideia?

Durante uma comunicação entre dois objetos IoT, vários ataques podem ocorrer: Man Of the light, Cópia de informações e muito mais. Minha ideia é muito simples:

1. Utilização de dados criptografados entre dois ou mais objetos IoT.
2. Suprimentos de baixo custo
3. Pode funcionar com um Arduino UNO

Agora vou explicar como implementei essa imagem abstrata com um Arduino e um chip Atecc608a. Neste artigo, explicarei como usar o Arduino UNO com o ATECC608A.

Escreverei um artigo sobre a comunicação de dois objetos na próxima vez.

Suprimentos

Você precisa de algumas coisas para este projeto:

1. Arduino UNO ou MEGA (o chip deve ser Atmega 328 ou ATMEGA 2560)
2. Chip Atecc608A (custo inferior a 0,80 $ cada, fácil de encontrar no site do seu fornecedor)
3. Adaptador SOIC de 8 pinos
4. Alguns fios e resistores

A ficha técnica da versão anterior deste chip (Atecc508a) está disponível aqui -> Ficha técnica Atecc508a

Etapa 1: passo a passo

Neste artigo, vou mostrar como modificar a configuração deste chip e, depois, como criptografar dados usando o algoritmo AES CBC.

Seguiremos essas etapas:

1. Projeto do circuito
2. Configuração deste chip
3. Utilização do módulo AES CBC
4. Por que você precisa usar este chip

Para cada etapa, detalharei tudo para você. Além disso, adicionei meu código em meu Github com comentários para cada função. Se você tiver alguma dúvida sobre o meu código ou este projeto, terei o maior prazer em respondê-la.

Meu Github: Meu Github

Etapa 2: Aviso sobre o Atecc608a

O chip Atecc608a não é um chip "fácil".

Em primeiro lugar, a documentação deste chip está sob NDA, portanto você não o encontrará completo na Internet. Mas não há problema para isso, o datasheet da versão anterior está disponível no Internet Datasheet Complete ATECC508A.

Em segundo lugar, quando você usa este chip, você precisa bloquear sua configuração e é impossível modificar a configuração do chip se ele estiver bloqueado. Portanto, tenha cuidado ao bloquear a zona de configuração e a zona de dados.

Terceiro, a biblioteca escrita em C é muito grande e completa, então você deve ler a documentação das funções que irá usar antes.

Quarto, a biblioteca escrita para este chip não funciona para o Arduino UNO, mas adicionou as funcionalidades necessárias para funcionar com o Arduino UNO.

O chip ATECC608A

Você pode se comunicar com este chip por I2C. O endereço deste chip pode ser modificado na configuração.

Este chip contém 16 slots diferentes que podem conter diferentes tipos de dados:

1. Chave ECC (privada ou pública)
2. Chave AES
3. Outros dados (como Sha hash ou apenas palavras)

Em nosso caso, armazenaremos a chave AES em um slot.

Etapa 3: 1. Desing do circuito

1. Projeto do circuito

O esquema deste circuito é muito simples!

Você precisa usar a alimentação de 3,3 V porque a recomendação é entre 2,0 V e 5,5 V, mas eu preferia usar 3,3 V.

Para este chip, normalmente você tem um ponto em um canto do chip, esse ponto é o pino 1 desta placa. Eu adicionei a vista superior do Atecc608a com número PIN porque é um SOIC de 8 derivações, então o chip é muito pequeno.

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)

Você precisa usar a alimentação de 3,3 V porque a recomendação é entre 2,0 V e 5,5 V, mas eu preferia usar 3,3 V.

Eu adicionei a vista superior do Atecc608a porque ele é um SOIC de 8 derivações, então o chip é muito pequeno. Se você preferir, os fornecedores constroem algumas placas com a solda de chip, pode ser mais fácil para você.

Atenção: No meu caso, tenho que adicionar um resistor entre o SDA do Arduino e o Chip (também para o SDL). Eu adicionei um resistor de 4,7 Kohm para cada um.

Etapa 4: 2. Configuração do Chip (Atecc608a)

Antes de usar a função de criptografia ou descriptografia é necessário configurar o chip. Nesta etapa, detalharei todas as etapas que você precisa fazer para a configuração deste chip.

Atenção: esta etapa é muito importante e se você bloquear as zonas antes do final, não poderá modificá-las.

Conforme explicado antes, este chip tem duas zonas:

1. Zona de Configuração
2. Zona de Dados

A zona de configuração tem um tamanho de 128 bytes, mas os primeiros 16 bytes não podem ser modificados.

Para configurar este chip, você precisa seguir essas etapas. É muito importante seguir todas as etapas em ordem ou sua configuração não funcionará e seu chip ficará travado e inutilizável. Essas etapas são:

1. Crie um modelo de configuração
2. Escreva este modelo no chip
3. Bloquear a zona de configuração
4. Escreva sua chave AES (128 bits) em um slot
5. Bloqueie a zona de dados

Em formação

Abaixo eu detalho cada etapa da configuração com meu código, mas não se preocupe, adicionei um exemplo completo de configuração em meu Github. Eu coloco comentários em cada função e um arquivo *.ino está disponível com cada etapa para você.

• Meu Github: Meu Github
• Caminho da configuração de exemplo: configuration_example.ino

Primeira etapa: Criar um modelo de configuração

Conforme explicado anteriormente, a zona de configuração obtém um tamanho de 128 bits, mas os primeiros 16 bits não podem ser alterados. Esta zona é composta de várias partes, mas você precisa saber apenas 3 partes desta zona de configuração para este projeto:

1. The Bytes 16 -> Este é o endereço I2C do chip
2. Os Bytes 20 a 51 -> Você pode modificar aqui o tipo de Slot para os 16 slots deste chip
3. The Bytes 96 a 127 -> Você pode definir aqui o tipo de chave ou dados usados em cada slot.

(Se você precisar de mais explicações de toda esta zona, por favor, leia a documentação (página 13, seção 2.2))

Aqui, coloco em detalhes cada Bytes / Partes dos 112 bytes da configuração de um Chip. Este é um exemplo, cada chip comprado pode ter uma configuração diferente:

0xC0, // endereço 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 de configuração de slot 15 0xAF, 0x8F, // Slot de configuração de 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, 0x00, 0xFF, 0xFF, 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, // Config Chave 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 // Key Config Slot 16

Como podem ver, coloquei alguns comentários neste código para entender mais esta configuração.

No seu caso, precisa entender apenas três coisas:

1. The Bytes 16 -> Este é o endereço I2C do chip
2. Os Bytes 20 a 51 -> Você pode modificar aqui o tipo de Slot para os 16 slots deste chip
3. The Byte 96 to 127 -> Você pode definir aqui o tipo de chave ou dados usados em cada slot.

Não vou explicar o tipo de configuração e porque usei esta e não outra porque é complicado explicar tudo. Se precisar de mais informações, vá para a documentação, página 16 seção 2.2.1 para "SlotConfig" e página 19 seção 2.2.5 para "KeyConfig"

Para este exemplo, você usará o slot 9 para armazenar uma chave AES.

Para isso, precisamos colocar (se precisar, pode copiar o exemplo acima, a modificação já foi feita nele):

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

Por que eu defini esta configuração: Para cada slot deste chip, você pode definir parâmetros para dizer ao chip que tipo de dados será armazenado. Você tem vários parâmetros:

• O slot pode ser escrito ou lido (ação limpar ou criptografar)
• Tipo de dados armazenados (chave ECC, chave pública, SHA Hash, chave AES …)
• O slot pode ser travado
• A geração da chave é permitida
• …

Com o byte 36 e 37 definido como "0x0F8F":

• Os dados podem ser escritos no Clear
• O conteúdo deste slot é secreto e não pode ser lido
• O slot não pode ser usado para o comando CheckMac Copy

Com o byte 112 e 113 definido para "0x001A":

O slot pode armazenar até quatro chaves simétricas AES de 128 bits (KeyType = 0x6)

Segunda etapa: Escreva esta configuração

Esta etapa é muito importante porque iremos ajustar o chip com nossa configuração e se esta configuração não for boa, você usará este chip.

Mas não se preocupe, desde que a configuração não esteja bloqueada, você pode modificar sua configuração.

Aqui, este é o código usado para gravar a configuração no chip:

/ ** / brief Grava uma nova configuração no chip.

* / param [in] cfg Configuração da interface lógica. Algumas configurações * predefinidas podem ser encontradas em atca_cfgs.h * / param [in] config Array uint8_t de configuração (comprimento 112) * / param [in] len Tamanho do array de configuração * / return ATCA_SUCCESS em caso de sucesso, caso contrário, um código de erro. * / 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) {// Grava o array de configuração no chip // Preenchimento de 16 bytes (16 primeiros bytes não podem ser gravados) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); status de retorno; } status de retorno; }

Esta função escreverá sua configuração no chip.

Terceiro passo: bloquear a zona de configuração

Aviso: tenha cuidado com este passo, se você bloquear esta zona e sua configuração não for boa, o chip ficará inutilizável e você não poderá modificar esta zona

Para esta ação, usaremos esta função:

/ ** / brief Verifique se DATA_ZONE ou CONFIG_ZONE está bloqueado

* / param [in] cfg Configuração da interface lógica. Algumas configurações * predefinidas podem ser encontradas em atca_cfgs.h * / param [na] zona LOCK_ZONE_DATA ou LOCK_ZONE_CONFIG * / return ATCA_SUCCESS em caso de sucesso, caso contrário, um código de erro. * / ATCA_STATUS check_lock_zone (ATCAIfaceCfg * cfg, zona uint8_t) {status ATCA_STATUS; bool lock = false; if (zona! = (uint8_t) LOCK_ZONE_CONFIG && zona! = (uint8_t) LOCK_ZONE_DATA) return ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zona, & 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);

Quarta etapa: Escreva sua chave AES em um slot

Nesta parte, você definirá sua chave AES pessoal no slot que definiu na configuração do chip.

Para este exemplo, usarei o slot número 9 do chip.

Você precisa saber: Uma característica especial deste chip é que você pode gravar dados no slot por apenas 4 bytes ou 32 bytes. Para AES, precisamos de uma chave de 128 bits, portanto, 16 bytes de dados. Portanto, decidi gravar uma chave de 16 bytes cada neste slot para ter dados de 32 bytes.

Agora, vou mostrar o código usado:

/ ** / brief Grava a chave AES em um determinado slot. * / param [in] cfg Configuração da interface lógica. Algumas configurações * predefinidas podem ser encontradas em atca_cfgs.h * / param [in] número do slot de chave * / param [in] matriz de chave de datakey uint8_t * / param [em] len Tamanho da matriz de chave * / return ATCA_SUCCESS em caso de sucesso, caso contrário, um código de erro. * / ATCA_STATUS write_key_slot (ATCAIfaceCfg * cfg, chave uint8_t, uint8_t * chave de dados, tamanho_t len) {if (chave 16) return ATCA_BAD_PARAM; if (len! = 32) retorna ATCA_BAD_PARAM; Status 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) status de retorno; } status de retorno; }

Para este exemplo, usarei duas chaves AES de 16 bytes cada:

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

Se esta ação for boa, agora você tem que passar a última etapa "bloquear a zona de dados"

Última etapa: bloquear a zona de dados

Aviso: tenha cuidado com esta etapa, se você bloquear esta zona e seus dados não forem configurados, o chip ficará inutilizável e você não poderá modificar esta zona

Para esta ação, usaremos esta função:

/ ** / brief Verifique se DATA_ZONE ou CONFIG_ZONE está bloqueado

* / param [in] cfg Configuração da interface lógica. Algumas configurações * predefinidas podem ser encontradas em atca_cfgs.h * / param [na] zona LOCK_ZONE_DATA ou LOCK_ZONE_CONFIG * / return ATCA_SUCCESS em caso de sucesso, caso contrário, um código de erro. * / ATCA_STATUS check_lock_zone (ATCAIfaceCfg * cfg, zona uint8_t) {status ATCA_STATUS; bool lock = false; if (zona! = (uint8_t) LOCK_ZONE_CONFIG && zona! = (uint8_t) LOCK_ZONE_DATA) return ATCA_BAD_PARAM; status = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (zona, & 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);

Se esta ação for boa, seu chip está pronto para ser usado

Etapa 5: 3. Utilização do Módulo AES CBC

Explicarei como criptografar e descriptografar dados com o algoritmo AES CBC e o chip Atecc608a.

Lembre-se: Antes de usar esta função, você precisa configurar o chip. Para isso, siga a etapa 2 deste artigo

Este chip possui vários tipos de módulo AES (AES 128 bits), apenas AES 128 bits é possível:

1. AES normal
2. AES CBC
3. AES GCM (com hash GFM) (veja wikipedia para mais explicações)

Para facilitar o uso, criei duas funções:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Essas duas funções estão disponíveis no meu Github.

Explicação

Eu escolhi usar o algoritmo AES CBC porque ele é mais seguro do que o AES 128 bits básico. Este algoritmo usa um vetor inicial para criptografar seus dados.

Em formação

Abaixo, detalho cada etapa do método de criptografia e descriptografia. Mas eu escrevi um código para o Arduino que usa essas duas funções. Você pode ver este código no meu Github:

• Github: Meu Github
• Exemplo de código "Criptografar / Descriptografar": AES_crypto_example.ino

Primeira etapa: criptografar seus dados

Nesta parte, vou mostrar como criptografar seus dados.

Primeiro você precisará desta função:

/ ** / brief Criptografar dados usando o algoritmo AES CBC * / param [in] cfg Configuração da interface lógica. Algumas configurações * predefinidas podem ser encontradas em atca_cfgs.h * / param [in] data Palavras a codificar (deve ser dividido por 16, comprimento máximo 240) * / param [em] comprimento comprimento das Palavras a codificar (deve ser dividido por 16, comprimento máximo 240) * / param [out] iv Vetor inicial usado no AES CBC (retornar o vetor nesta var) * / param [out] ciphertext retornar aqui o texto Cypher * / param [in] key Número do slot do chave * / return ATCA_SUCCESS em caso de sucesso, caso contrário, um código de erro. * / ATCA_STATUS aes_cbc_encrypt (ATCAIfaceCfg * cfg, uint8_t * dados, int len, uint8_t * iv, uint8_t * ciphertext, chave 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]; Status ATCA_STATUS = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, chave, 0, tmp_iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (status, HEX); Retorna; } memcpy (iv, tmp_iv, IV_LENGTH_CBC); memcpy (tmp_data, data, len); int max = len / 16; para (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 (status, HEX); } status de retorno; } status de retorno; }

Esta função é simples de usar, você deve definir duas coisas:

1. Um IV vazio (vetor inicial) de 16 bytes
2. Dados para criptografar (tamanho máximo de 240 bytes)

Aqui está um exemplo de "como usar esta função".

Quero criptografar a palavra "AAAAAAAAAAAAAAA", com minha chave escrita no slot número "9":

ATCA_STATUS status = atcab_init (& cfg); if (status! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () falhou: Código -> 0x")); Serial.println (status, HEX); } uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; // Texto original uint8_t iv [IV_LENGTH_CBC]; // Vetor inicial uint8_t cypherdata [sizeof (texto plano)]; // Status de dados criptografados = aes_cbc_encrypt (& cfg, texto simples, sizeof (texto simples), iv, cypherdata, 9);

Se a ação for boa, você terá os dados criptografados na variável "cypherdata" e o Vetor Inicial na variável "IV".

Guarde essas duas variáveis para descriptografar seu texto!

Segunda etapa: descriptografar seus dados

Para descriptografar seus dados, você precisará de duas coisas:

1. O Vetor Inicial
2. Os dados Cypher (dados criptografados)

Para descriptografar seus dados, você precisará desta função:

/ ** / brief Descriptografar dados usando o algoritmo AES CBC * / param [in] cfg Configuração da interface lógica. Algumas configurações * predefinidas podem ser encontradas em atca_cfgs.h * / param [no] texto cifrado Palavras a decifrar (deve ser dividido por 16, comprimento máximo 240) * / param [em] comprimento comprimento das Palavras a decifrar (deve ser dividido por 16, comprimento máximo 240) * / param [in] iv Vetor inicial para usar no AES CBC * / param [out] texto simples retorna aqui o texto descriptografado * / param [in] chave Número do slot da chave * / return ATCA_SUCCESS em caso de sucesso, caso contrário, um código de erro. * / ATCA_STATUS aes_cbc_decrypt (ATCAIfaceCfg * cfg, uint8_t * texto cifrado, int len, uint8_t * iv, uint8_t * texto simples, chave uint8_t) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC || len% 16! = 0) {Serial.print (F ("ERROR Decrypt: ATCA_BAD_PARAM")); return ATCA_BAD_PARAM; } ATCA_STATUS status = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, chave, 0, iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Decrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (status, HEX); Retorna; } int max = len / 16; para (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 (status, HEX); } status de retorno; } status de retorno; }

Quero descriptografar meus dados anteriores (veja abaixo, Primeira etapa). Para isso vou fazer o seguinte:

uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (texto simples)]; uint8_t decryptdata [sizeof (texto simples)]; status = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) {Serial.print ("O texto descriptografado é:"); para (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } else {// Veja o arquivo atca_status.h para o código Error Serial.print (F ("Impossível fazer a descriptografia | Código Error 0x")); Serial.println (status, HEX); Retorna; }

Se a ação for boa, você terá os dados descriptografados na variável "decryptdata".

Agora você sabe usar criptografia e descriptografia com o chip Atecc608a

Etapa 6: 5. Por que você precisa usar este chip

Os dados criptografados são muito úteis porque você pode ocultar suas informações e enviá-las por Wireless ou simplesmente armazená-las.

Aqui está um exemplo de utilização:

1. Dados armazenados em uma EEPROM externa: Você pode proteger os dados de uma EEPROM externa e se alguém ainda esta EEPROM, precisará da Chave e do IV para a descriptografia
2. Enviar dados sem fio: Você pode enviar esses dados criptografados por sem fio (nrf24L01, RFM95W …) e se alguém interceptar seus dados, esses dados estarão seguros
3. Senha armazenada
4. …

Você pode fazer várias coisas com este chip. Ele pode ser usado em vários projetos. Se você tiver tempo, diga-me em qual projeto você vai usar esse chip?

Um último conselho, se você construir algum projeto wireless ou armazenar alguns dados brutos, tome cuidado, a segurança é muito importante e se você sabe como é simples para um "noob" interceptar ou roubar seus dados. Agora, com a Internet, todos podem ter scripts para iniciar em seus computadores apenas para "hackear" você!

Etapa 7: Conclusão

Espero que este artigo seja útil para você. Desculpe se me enganei no texto, mas o inglês não é a minha língua principal e falo melhor do que escrevo.

Obrigado por ler tudo.

Aproveite.