В предыдущих статьях мы довольно подробно описали устройство и принципы работы криптомикросхемы 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 датчика.
Ссылки по теме
ATSHA204 - Библиотека и примеры
ATSHA204A - Чтение зоны конфигурации 1
ATSHA204A - Чтение зоны конфигурации 2
ATSHA204A - Чтение зоны конфигурации 3
ATSHA204A - Запись конфигурации 1
ATSHA204A - Запись конфигурации 2
ATSHA204A - Запись конфигурации 3
ATSHA204A - Запись конфигурации 4
ATSHA204A - Работа в режиме Config Lock
ATSHA204A - Работа с зонами памяти
ATSHA204A - Чтение Data и OTP зон памяти
ATSHA204A - Аутентификация. Базовый блок
ATSHA204A - Криптография и команды
ATSHA204A - nRF24 аутентификация. База
ATSHA204A - nRF24 аутентификация. Датчик