ATSHA204A — nRF24 аутентификация. База

В предыдущих статьях мы довольно подробно описали устройство и принципы работы криптомикросхемы ATSHA204A, теперь давайте разберём несколько практических примеров работы с ней.

В IoT большинство датчиков, актуаторов и контроллеров работают по беспроводным протоколам связи, поэтому наши практические примеры будут посвящены задаче аутентификации удалённых беспроводных частей системы (например, датчиков умного дома).

В качестве примеров будет рассмотрена работа двух популярных беспроводных систем — nRF24 и LoRa. Начнём с nRF24.

Постановка задачи

Нам нужно будет создать тестовую систему, состоящую из «базы» и «датчика», связанных по беспроводному nRF24 каналу. Задача будет состоять в том, что базе нужно будет связаться с датчиком и удостовериться, что это именно «легитимный» датчик нашей экосистемы, а не клонированный хакером (чужой) датчик.

Решаться эта задача будет при помощи микросхем ATSHA204A, которые установлены на базе и датчике и соответствующим образом запрограммированы.

Оборудование

В качестве контроллеров для нашего эксперимента (и для базы и для датчика) будут использоваться беспроводные контроллеры uniSensors nRF24, которые имеют на борту всё необходимое:

Микроконтроллер ATmega328
Беспроводной модуль nRF24L01
Микросхему ATSHA204A
и прочие необходимые компоненты

Для работы с uniSensors nRF24 и компиляции скетчей в Arduino IDE в настройках нужно выбирать контроллер Arduino Pro Mini, Atmega328 (3.3V, 8MHz).

Алгоритм работы

Алгоритм работы, обеспечивающий аутентификацию датчика, будет следующим: на базе микросхемой ATSHA204A генерируется (качественное) случайное число (RNG), затем этой же микросхемой при помощи команды MAC (на основе случайного числа и секретного ключа в Data зоне EEPROM памяти ATSHA204A) вычисляется SHA-256 хеш (дайджест). Этот дайджест запоминается для последующего сравнения с ответом датчика.

Затем ранее сгенерированное случайное число по беспроводному nRF24 каналу отсылается датчику, который на его основе (при помощи идентично запрограммированной микросхемы ATSHA204A) также вычисляет SHA-256 хеш и отсылает его обратно базе для проверки и сравнения с заранее вычисленным на базе хешем.

Тот факт, что сгенерировать правильный хеш в ответ на случайное число может только «легитимный» датчик, имеющий в своём составе «правильно» запрограммированную микросхему ATSHA204A с уникальным ключом, является гарантией верной аутентификации датчика базой.

Вот графическое представление работы алгоритма аутентификации:

Более подробно об этом алгоритме и реализации его работы микросхемой ATSHA204A вы можете прочитать в предыдущих статьях этого цикла.

Базовый блок

В этой статье мы подробно рассмотрим работу базы как с криптографической частью, так и работу базы с беспроводной системой nRF24. Работу датчика мы разберём в следующей статье.

Как следует из условий задачи, базовый блок должен сгенерировать случайное число и отослать его датчику, затем сравнить вычисленный самостоятельно и полученный от датчика SHA-256 хеши. Это основной функционал базы, теперь подробнее разберём создание и работу скетча.

Код криптоалгоритма базы

Ниже приведён код криптоалгоритма базы из одной из предыдущих статей (там же вы можете ознакомиться с подробным описанием его работы). Здесь наша задача будет состоять в интеграции этого кода со скетчем беспроводной nRF24 связи.

/* 
  ATSHA204A Project (Base)
*/

#include <sha204_library.h>

const int sha204Pin = A3;

byte challenge[MAC_CHALLENGE_SIZE];
byte hash[MAC_CHALLENGE_SIZE];

byte retCode = 0;

atsha204Class sha204(sha204Pin);


void setup() {
  Serial.begin(115200);
  Serial.println("ATSHA204 Project (Base) start...");
  
  makeRandom();
  Serial.println("Random:");
  printArray(challenge, 32);
  Serial.println();
  
  macChallenge();
  Serial.println("Hash:");
  printArray(hash, 32);
  Serial.println();
}

// Print

void printArray(byte arr[], byte len) {
  for (byte i = 0; i < len; i++) {
    if (arr[i] < 16) {Serial.print('0');}
    Serial.print(arr[i], HEX); Serial.print(' ');
  }
}

// Random

void makeRandom() {
  uint8_t response[RANDOM_RSP_SIZE];
  uint8_t tx_buffer[12] = {0};
  
  retCode = sha204.sha204m_random(tx_buffer, response, RANDOM_NO_SEED_UPDATE);

  for (byte i = 0; i < 32; i++) {
    challenge[i] = response[i];
  }
}

// MAC

void macChallenge() {
  uint8_t command[MAC_COUNT_LONG];
  uint8_t response[MAC_RSP_SIZE];

  retCode = sha204.sha204m_execute(SHA204_MAC,
                                   0, 0,
                                   MAC_CHALLENGE_SIZE, (uint8_t *) challenge,
                                   0, NULL,
                                   0, NULL,
                                   sizeof(command),   &command[0],
                                   sizeof(response), &response[0]);

  for (byte i = 0; i < 32; i++) {
    hash[i] = response[i];
  }
}

void loop() {
  
}

Подсистема nRF24

Работа с беспроводной системой nRF24 является сама по себе большой и сложной темой и выходит за рамки этой статьи, поэтому здесь мы только приведём готовый nRF24 скетч базы (без крипто-функций), а затем создадим финальный код скетча, который будет сочетать в себе и крипто-функционал (базы) и возможности беспроводной nRF24 связи.

Для работы этого скетча и вообще для работы с nRF24 подсистемой вам понадобится библиотека nRF24.

/*
  nrf24 Base
*/

#include <SPI.h>
#include "RF24.h"

#define RF_PIN A1

RF24 radio(6, 7); // CE, CSN
byte addresses[][6] = {"1Node", "2Node"};

#define PACKET_MAX_BYTES 32
byte buffRx[PACKET_MAX_BYTES];

byte buffTx[PACKET_MAX_BYTES] = {
  0x23, 0x47, 0x3B, 0x1D, 0x89, 0xEA, 0x07, 0x80,
  0x07, 0x5A, 0xEE, 0xD9, 0xEC, 0x8D, 0xF5, 0x68,
  0x88, 0xAC, 0x3B, 0x36, 0x50, 0xF4, 0x03, 0xA4,
  0xDF, 0xB3, 0x38, 0xA7, 0x16, 0xBA, 0x4A, 0xF5
};

void setup() {
  Serial.begin(115200);
  Serial.println(F("RF24 Base start..."));

  pinMode(RF_PIN, OUTPUT);
  digitalWrite(RF_PIN, LOW);
  delay(500);
  
  radio.begin();
  radio.setPALevel(RF24_PA_MIN);
  radio.openWritingPipe(   addresses[1]);
  radio.openReadingPipe(1, addresses[0]);
}

void printArray(byte arr[], byte len) {
  for (byte i = 0; i < len; i++) {
    if (arr[i] < 16) {Serial.print('0');}
    Serial.print(arr[i], HEX); Serial.print(' ');
  }
}

bool match(byte arr1[], byte arr2[], byte len) {
  bool res = true;
  for (byte i = 0; i < len; i++) {
    if (arr1[i] != arr2[i]) {
      res = false;
      break;
    }
  }
  return res;
}

void loop() {
  radio.stopListening();

  Serial.print(F("Sending..."));

  unsigned long start_time = micros();
     
  if (!radio.write(&buffTx, PACKET_MAX_BYTES)) {
    Serial.println(F("failed"));
  }

  radio.startListening();

  unsigned long started_waiting_at = micros();
  boolean timeout = false;

  while (!radio.available()) {
    if (micros() - started_waiting_at > 200000 ) { // 200ms
      timeout = true;
      break;
    }      
  }

  if (timeout) {
    Serial.println(F("Failed response."));
  } else {
    radio.read(&buffRx, PACKET_MAX_BYTES);
    
    Serial.print(F("Response: ")); printArray(buffRx, 32); Serial.print(F(" "));

    if (match(buffTx, buffRx, 32)) {Serial.println(F("Match!"));}
                              else {Serial.println(F("Not match!"));}
  }
  delay(3000);
}

Этот скетч выполняет всего несколько простых функций: отсылает тестовый 32-байтовый массив buffTx на датчик и принимает от датчика ответный, тоже 32-байтовый массив. Затем сравнивает эти два массива и выносит вердикт «совпадает» (Match!) или «не совпадает» (Not match!).

Вначале мы подключаем необходимые библиотеки для работы с nRF24 частью.

#include <SPI.h>
#include "RF24.h"

Затем определяем пин включения питания радиомодуля на контроллерах uniSensors nRF24.

#define RF_PIN A1

Создаём объект для управления модулем nRF24L01 и указываем номера GPIO для подключения его CE и CSN выводов.

RF24 radio(6, 7); // CE, CSN

Задаём адреса для связи базы и датчика.

byte addresses[][6] = {"1Node", "2Node"};

И тестовый 32-байтовый массив для отсылки датчику.

byte buffTx[PACKET_MAX_BYTES] = {
  0x23, 0x47, 0x3B, 0x1D, 0x89, 0xEA, 0x07, 0x80,
  0x07, 0x5A, 0xEE, 0xD9, 0xEC, 0x8D, 0xF5, 0x68,
  0x88, 0xAC, 0x3B, 0x36, 0x50, 0xF4, 0x03, 0xA4,
  0xDF, 0xB3, 0x38, 0xA7, 0x16, 0xBA, 0x4A, 0xF5
};

Затем, в функции setup(), подаём питание на радиомодуль uniSensors nRF24.

  pinMode(RF_PIN, OUTPUT);
  digitalWrite(RF_PIN, LOW);
  delay(500);

Включаем радиомодуль.

  radio.begin();

Устанавливаем минимальную мощность nRF24 передатчика.

  radio.setPALevel(RF24_PA_MIN);

И настраиваем адреса для приёма и передачи данных.

  radio.openWritingPipe(   addresses[1]);
  radio.openReadingPipe(1, addresses[0]);

Далее в цикле loop() посылаем тестовый массив (в эфир) на датчик.

void loop() {
  radio.stopListening();

  Serial.print(F("Sending..."));

  unsigned long start_time = micros();
     
  if (!radio.write(&buffTx, PACKET_MAX_BYTES)) {
    Serial.println(F("failed"));
  }

Принимаем данные от датчика, выводим на печать в Serial и сравниваем исходный и полученный массивы и сообщаем об их совпадении или не совпадении.

radio.read(&buffRx, PACKET_MAX_BYTES);
    
    Serial.print(F("Response: ")); printArray(buffRx, 32); Serial.print(F(" "));

    if (match(buffTx, buffRx, 32)) {Serial.println(F("Match!"));}
                              else {Serial.println(F("Not match!"));}

Код:

  radio.startListening();

  unsigned long started_waiting_at = micros();
  boolean timeout = false;

  while (!radio.available()) {
    if (micros() - started_waiting_at > 200000 ) { // 200ms
      timeout = true;
      break;
    }      
  }

отвечает за включение (в цикле) прослушивания эфира и прерывание этого прослушивания по таймауту (если датчик по какой-то причине не отвечает).

Скетч рассчитан на работу с «ответной» частью (скетчем датчика), который мы рассмотрим в следующей статье.

Далее мы создадим из этих двух (криптографического ATSHA204A и беспроводного nRF24) объединённый финальный скетч базы и подробно разберём его работу.

Скетч nRF24 ATSHA204A Base

Ниже представлен полный код скетча nRF24 ATSHA204A Base, объединяющий в себе криптографическую, беспроводную и функциональную части.

/* 
  nRF24 ATSHA204A Base
*/

#include <SPI.h>
#include "RF24.h"
#include <sha204_library.h>

// nRF24

#define RF_PIN A1
RF24 radio(6, 7); // CE, CSN
byte addresses[][6] = {"1Node", "2Node"};

#define PACKET_MAX_BYTES 32
byte buffRx[PACKET_MAX_BYTES];

// ATSHA204A

const int sha204Pin = A3;

byte challenge[MAC_CHALLENGE_SIZE];
byte hash[MAC_CHALLENGE_SIZE];

byte retCode = 0;

atsha204Class sha204(sha204Pin);


void setup() {
  Serial.begin(115200);
  Serial.println("nRF24 ATSHA204 (Base) start...");

  // ATSHA204A
  makeRandom();
  Serial.print(F("Random: ")); printArray(challenge, 32); Serial.println();
  
  macChallenge();
  Serial.print(F("Hash:   ")); printArray(hash,      32); Serial.println();
  Serial.println();
  
  // nRF24
  pinMode(RF_PIN, OUTPUT);
  digitalWrite(RF_PIN, LOW);
  delay(500);
  
  radio.begin();
  radio.setPALevel(RF24_PA_MIN);
  radio.openWritingPipe(   addresses[1]);
  radio.openReadingPipe(1, addresses[0]);
}

// Print

void printArray(byte arr[], byte len) {
  for (byte i = 0; i < len; i++) {
    if (arr[i] < 16) {Serial.print('0');}
    Serial.print(arr[i], HEX); Serial.print(' ');
  }
}

// Compare

bool match(byte arr1[], byte arr2[], byte len) {
  bool res = true;
  for (byte i = 0; i < len; i++) {
    if (arr1[i] != arr2[i]) {
      res = false;
      break;
    }
  }
  return res;
}

// Random

void makeRandom() {
  uint8_t response[RANDOM_RSP_SIZE];
  uint8_t tx_buffer[12] = {0};
  
  retCode = sha204.sha204m_random(tx_buffer, response, RANDOM_NO_SEED_UPDATE);

  for (byte i = 0; i < 32; i++) {
    challenge[i] = response[i + 1];
  }
}

// MAC

void macChallenge() {
  uint8_t command[MAC_COUNT_LONG];
  uint8_t response[MAC_RSP_SIZE];

  retCode = sha204.sha204m_execute(SHA204_MAC,
                                   0, 0,
                                   MAC_CHALLENGE_SIZE, (uint8_t *) challenge,
                                   0, NULL,
                                   0, NULL,
                                   sizeof(command),   &command[0],
                                   sizeof(response), &response[0]);

  for (byte i = 0; i < 32; i++) {
    hash[i] = response[i + 1];
  }
}

void loop() {
  radio.stopListening();

  Serial.print(F("Sending:  "));

  printArray(challenge, 32);

  unsigned long start_time = micros();
     
  if (!radio.write(&challenge, PACKET_MAX_BYTES)) {
    Serial.print(F("failed"));
  }
  Serial.println();
  
  radio.startListening();

  unsigned long started_waiting_at = micros();
  boolean timeout = false;

  while (!radio.available()) {
    if (micros() - started_waiting_at > 200000 ) { // 200ms
      timeout = true;
      break;
    }      
  }

  if (timeout) {
    Serial.println(F("Failed response."));
  } else {
    radio.read(&buffRx, PACKET_MAX_BYTES);
    
    Serial.print(F("Response: ")); printArray(buffRx, 32); Serial.println();
    Serial.print(F("Hash:     ")); printArray(hash,   32); Serial.println();
    
    if (match(hash, buffRx, 32)) {Serial.println(F("Match!"));}
                            else {Serial.println(F("Not match!"));}
    
    Serial.println();
  }
  delay(3000);
}

Теперь разберём работу тех частей скетча, которые мы ещё не осветили (в этой или предыдущих статьях).

В финальной версии скетча мы объявляем 32-байтовый массив для приёма хеша (дайджеста) от датчика нашей IoT экосистемы.

#define PACKET_MAX_BYTES 32
byte buffRx[PACKET_MAX_BYTES];

Объявляем 2 массива для сгенерированного случайного числа (challenge) и вычисленного на базе хеша SHA-256 (hash).

byte challenge[MAC_CHALLENGE_SIZE];
byte hash[MAC_CHALLENGE_SIZE];

Генерируем (при помощи ATSHA204A) и выводим на печать случайное 32-байтовое число.

// ATSHA204A
  makeRandom();
  Serial.print(F("Random: ")); printArray(challenge, 32); Serial.println();

Вычисляем (при помощи ATSHA204A) и выводим на печать 32-байтовый SHA-256 хеш (дайджест).

  macChallenge();
  Serial.print(F("Hash:   ")); printArray(hash,      32); Serial.println();
  Serial.println();

В цикле посылаем сгенерированное случайное число на датчик.

void loop() {
  radio.stopListening();

  Serial.print(F("Sending:  "));

  printArray(challenge, 32);

  unsigned long start_time = micros();
     
  if (!radio.write(&challenge, PACKET_MAX_BYTES)) {
    Serial.print(F("failed"));
  }
  Serial.println();

Принимаем и выводим на печать присланный датчиком хеш.

    radio.read(&buffRx, PACKET_MAX_BYTES);
    
    Serial.print(F("Response: ")); printArray(buffRx, 32); Serial.println();

Для наглядности также выводим вычисленный базой хеш.

    Serial.print(F("Hash:     ")); printArray(hash,   32); Serial.println();

И, наконец, сравниваем сгенерированный базой и полученный от датчика SHA-256 хеши и выносим вердикт о «легитимности» беспроводного датчика.

    if (match(hash, buffRx, 32)) {Serial.println(F("Match!"));}
                            else {Serial.println(F("Not match!"));}

Вот результат работы нашего финального скетча:

Примечание: в этом эксперименте использовались микросхемы ATSHA204A (установленные на платах uniSensors) без дополнительной прошивки и блокировки зон памяти, поэтому вместо реальных случайных чисел вы видите тестовые последовательности FF FF 00 00 FF FF 00 00, выдаваемые микросхемой ATSHA204A в этом режиме. Если вы воспользуетесь методикой программирования микросхем ATSHA204A, описанной в статьях этого цикла, то сможете записать любой секретный ключ в нулевую (0) ячейку Data зоны вашей микросхемы и (без каких-либо переделок этого скетча) получить полнофункциональную аутентификацию при помощи ATSHA204A в вашей беспроводной nRF24 сети.

Заключение

Здесь мы рассмотрели только первую часть примера криптографической аутентификации при помощи микросхемы ATSHA204A в беспроводной nRF24 сети (работу базы), в следующей статье мы разберём работу ответной части — беспроводного nRF24 датчика.