Esp расшифровка: ABS/ESP . » AudiPiter.ru —

многостраничных BLOB-объектов

По умолчанию двоичные двоичные объекты могут занимать несколько страниц и записываются в формате, указанном в разделе «Структура записи». Если вы намереваетесь использовать более старый формат, утилита предоставляет возможность отключить эту функцию.

Запуск утилиты

Использование :

 python nvs_partition_gen.py [-h] {генерировать, генерировать ключ, шифровать, дешифровать} ...

Необязательные аргументы:
+ ----- + ------------ + ------------------------------ ---------------------------------------- +
| № | Параметр | Описание |
+ ===== + ============ + ============================== ======================================== +
| 1 | -h, --help | показать это справочное сообщение и выйти |
+ ----- + ------------ + ------------------------------ ---------------------------------------- +

Команды:
        Запустите nvs_partition_gen.py {команда} -h для дополнительной помощи
+ ----- + -------------- + ---------------------------- ---------------------------------------- +
| № | Параметр | Описание |
+ + ===== ============== + ============================ ======================================== +
| 1 | генерировать | Создать раздел NVS |
+ ----- + -------------- + ---------------------------- ---------------------------------------- +
| 2 | генерировать ключ | Генерация ключей для шифрования |
+ ----- + -------------- + ---------------------------- ---------------------------------------- +
| 3 | шифровать | Создать зашифрованный раздел NVS |
+ ----- + -------------- + ---------------------------- ---------------------------------------- +
| 4 | расшифровать | Расшифровать зашифрованный раздел NVS |
+ ----- + -------------- + ---------------------------- ---------------------------------------- +
 

Для создания раздела NVS (по умолчанию):

Использование :

 python nvs_partition_gen.py генерирует [-h] [--version {1,2}] [--outdir OUTDIR]
                                     размер ввода-вывода

Позиционные аргументы:
+ -------------- + ---------------------------------- ------------------------------------ +
| Параметр | Описание |
+ ============== + ================================== ==================================== +
| вход | Путь к CSV файлу для разбора |
+ -------------- + ---------------------------------- ------------------------------------ +
| выход | Путь к выводу двоичного файла NVS |
+ -------------- + ---------------------------------- ------------------------------------ +
| размер | Размер раздела NVS в байтах (должен быть кратным 4096) |
+ -------------- + ---------------------------------- ------------------------------------ +


Необязательные аргументы:
+ ----------------- + ------------------------------- ------------------------------------- +
| Параметр | Описание |
+ ================= + =============================== ===================================== +
| -h, --help | показать это справочное сообщение и выйти |
+ ----------------- + ------------------------------- ------------------------------------- +
| --version {1,2} | Установить версию многостраничного блоба.|
| | Версия 1 - поддержка многостраничных блобов отключена. |
| | Версия 2 - включена поддержка многостраничных блобов. |
| | По умолчанию: версия 2 |
| | |
+ ----------------- + ------------------------------- ------------------------------------- +
| --outdir OUTDIR | Выходной каталог для хранения созданных файлов |
| | (По умолчанию: текущий каталог) |
+ ----------------- + ------------------------------- ------------------------------------- +
 

Вы можете запустить утилиту для создания раздела NVS, используя команду ниже: Пример CSV-файла предоставляется вместе с утилитой:

 python nvs_partition_gen.py генерирует sample_singlepage_blob.csv sample.bin 0x3000
 

Для генерации только ключей шифрования:

Использование :

 python nvs_partition_gen.py generate-key [-h] [--keyfile KEYFILE]
                                         [--outdir OUTDIR]

Необязательные аргументы:
+ -------------------- + ---------------------------- ------------------------------------------ +
| Параметр | Описание |
+ ==================== + ============================ ========================================== +
| -h, --help | показать это справочное сообщение и выйти |
+ -------------------- + ---------------------------- ------------------------------------------ +
| --keyfile КЛЮЧЕВОЙ ФАЙЛ | Путь к выходному файлу ключей шифрования |
+ -------------------- + ---------------------------- ------------------------------------------ +
| --outdir OUTDIR | Выходной каталог для хранения созданных файлов.|
| | (По умолчанию: текущий каталог) |
+ -------------------- + ---------------------------- ------------------------------------------ +
 

Вы можете запустить утилиту для генерации только ключей шифрования, используя следующую команду:

 python nvs_partition_gen.py generate-key
 

Для создания зашифрованного раздела NVS:

Использование :

 python nvs_partition_gen.py encrypt [-h] [--version {1,2}] [--keygen]
                                    [--keyfile KEYFILE] [--inputkey INPUTKEY]
                                    [--outdir OUTDIR]
                                    размер ввода-вывода

Позиционные аргументы:
+ -------------- + ---------------------------------- ------------------------------------ +
| Параметр | Описание |
+ ============== + ================================== ==================================== +
| вход | Путь к CSV файлу для разбора |
+ -------------- + ---------------------------------- ------------------------------------ +
| выход | Путь к выводу двоичного файла NVS |
+ -------------- + ---------------------------------- ------------------------------------ +
| размер | Размер раздела NVS в байтах (должен быть кратным 4096) |
+ -------------- + ---------------------------------- ------------------------------------ +


Необязательные аргументы:
+ --------------------- + --------------------------- ----------------------------------------- +
| Параметр | Описание |
+ ===================== + =========================== ========================================= +
| -h, --help | показать это справочное сообщение и выйти |
| | |
+ --------------------- + --------------------------- ----------------------------------------- +
| --version {1,2} | Установить версию многостраничного блоба.|
| | Версия 1 - поддержка многостраничных блобов отключена. |
| | Версия 2 - включена поддержка многостраничных блобов. |
| | По умолчанию: версия 2 |
+ --------------------- + --------------------------- ----------------------------------------- +
| --keygen | Генерирует ключ для шифрования раздела NVS |
+ --------------------- + --------------------------- ----------------------------------------- +
| --keyfile КЛЮЧЕВОЙ ФАЙЛ | Путь к выходному файлу ключей шифрования |
+ --------------------- + --------------------------- ----------------------------------------- +
| --inputkey INPUTKEY | Файл с ключом для шифрования раздела NVS |
+ --------------------- + --------------------------- ----------------------------------------- +
| --outdir OUTDIR | Выходной каталог для хранения созданных файлов |
| | (По умолчанию: текущий каталог) |
+ --------------------- + --------------------------- ----------------------------------------- +
 

Вы можете запустить утилиту для шифрования раздела NVS, используя следующую команду: Пример CSV-файла предоставляется вместе с утилитой:

Примечание

Ключ шифрования следующего формата / keys / keys- .Корзина создана.

Примечание

Ключ шифрования следующего формата /keys/sample_keys.bin создан.

Примечание

Этот вновь созданный файл с ключами шифрования в каталоге keys / совместим со структурой разделов ключей NVS. Обратитесь к разделу ключей NVS для более подробной информации.

Для расшифровки зашифрованного раздела NVS:

Использование :

 python nvs_partition_gen.py decrypt [-h] [--outdir OUTDIR] вывод ключа ввода

Позиционные аргументы:
+ -------------- + ---------------------------------- ------------------------------------ +
| Параметр | Описание |
+ ============== + ================================== ==================================== +
| вход | Путь к зашифрованному файлу раздела NVS для разбора |
+ -------------- + ---------------------------------- ------------------------------------ +
| ключ | Путь к файлу с ключами для расшифровки |
+ -------------- + ---------------------------------- ------------------------------------ +
| выход | Путь к выводу расшифрованного двоичного файла |
+ -------------- + ---------------------------------- ------------------------------------ +


Необязательные аргументы:
+ --------------------- + --------------------------- ----------------------------------------- +
| Параметр | Описание |
+ ===================== + =========================== ========================================= +
| -h, --help | показать это справочное сообщение и выйти |
+ --------------------- + --------------------------- ----------------------------------------- +
| --outdir OUTDIR | Выходной каталог для хранения созданных файлов |
| | (По умолчанию: текущий каталог) |
+ --------------------- + --------------------------- ----------------------------------------- +
 

Вы можете запустить утилиту для расшифровки зашифрованного раздела NVS, используя следующую команду:

 python nvs_partition_gen.py decrypt sample_encr.bin sample_keys.bin sample_decr.bin
 

Вы также можете указать номер версии формата:

отключена (версия 1):

Вы можете запустить утилиту в этом формате, установив для параметра версии значение 1, как показано ниже. Пример CSV-файла предоставляется вместе с утилитой:

 python nvs_partition_gen.py генерировать sample_singlepage_blob.csv sample.bin 0x3000 - версия 1
 

(версия 2):

Вы можете запустить утилиту в этом формате, установив для параметра версии значение 2, как показано ниже.Пример CSV-файла предоставляется вместе с утилитой:

 python nvs_partition_gen.py Генерировать sample_multipage_blob.csv sample.bin 0x4000 - версия 2
 

Примечание

Минимальный необходимый размер раздела NVS составляет 0x3000 байт.

Примечание

При прошивке двоичного файла на устройство убедитесь, что он соответствует приложению sdkconfig.

практических IoT криптография на Espressif ESP8266

Чипсет Espressif ESP8266 превращает трехдолларовую платформу «Интернета вещей» в экономическую реальность. Согласно популярному узлу автоматической сборки прошивки MCU-builds, за последние 60 дней было 13,341 пользовательских сборок прошивки для этой платформы. Из них только 19% имеют поддержку SSL, а 10% включают модуль криптографии.

Мы часто критикуем отсутствие безопасности в IoT-секторе и часто покрываем бот-сети и другие атаки, но будем ли мы придерживаться наших проектов в соответствии с теми же стандартами, которые мы требуем? Остановимся ли мы на выявлении проблемы или можем быть частью решения?

В этой статье основное внимание будет уделено применению функций шифрования AES и авторизации хэшей к протоколу MQTT с использованием популярного чипа ESP8266 с микропрограммой NodeMCU.Нашей целью является не предоставление панацеи от копирования / вставки, а пошаговое прохождение процесса, выявление проблем и решений на этом пути. В результате получается система, которая полностью зашифрована и аутентифицирована, предотвращая подслушивание и подделку действительных данных, не полагаясь на SSL.

Мы знаем, что есть и более мощные платформы, которые могут легко поддерживать SSL (например, Raspberry Pi, Orange Pi, FriendlyARM), но давайте начнем с самого дешевого оборудования, которое есть у большинства из нас, и протокола, подходящего для многих наших проекты.AES - это то, что вы можете реализовать на AVR, если вам нужно.

Теория

MQTT - это легкий протокол обмена сообщениями, который работает поверх TCP / IP и часто используется для проектов IoT. Клиентские устройства подписываются или публикуются по темам (например, датчики / температура / кухня), и эти сообщения передаются брокером MQTT. Более подробную информацию о MQTT можно найти на их веб-странице или в нашей собственной серии статей для начинающих.

Протокол MQTT не имеет каких-либо встроенных функций безопасности, кроме аутентификации по имени пользователя и паролю, поэтому для шифрования и аутентификации в сети обычно используется SSL.Однако SSL может быть довольно требовательным для ESP8266, и когда он включен, у вас остается гораздо меньше памяти для вашего приложения. В качестве упрощенной альтернативы вы можете зашифровать только отправляемую полезную нагрузку данных и использовать идентификатор сессии и хэш-функцию для аутентификации.

Простой способ сделать это - использовать Lua и криптографический модуль NodeMCU, который включает поддержку алгоритма AES в режиме CBC, а также хеш-функцию HMAC. Для правильного использования шифрования AES требуется три вещи для создания зашифрованного текста: сообщение, ключ и вектор инициализации (IV).Сообщения и ключи являются простыми понятиями, но вектор инициализации заслуживает некоторого обсуждения.

Когда вы кодируете сообщение в AES статическим ключом, оно всегда будет выдавать один и тот же результат. Например, сообщение «usernamepassword», зашифрованное ключом «1234567890ABCDEF», может привести к такому результату, как «E40D86C04D723AFF». Если вы снова запустите шифрование с тем же ключом и сообщением, вы получите тот же результат. Это открывает вам несколько распространенных типов атак, особенно анализ паттернов и повторных атак.

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

IV делают анализ паттернов более сложным. IV - это часть данных, отправляемая вместе с ключом, который изменяет конечный результат зашифрованного текста. Как следует из названия, оно инициализирует состояние алгоритма шифрования до ввода данных. IV должен быть разным для каждого отправляемого сообщения, чтобы повторяющиеся данные шифровались в другой зашифрованный текст, а некоторые шифры (например, AES-CBC) требуют, чтобы он был непредсказуемым - практический способ сделать это - просто каждый раз рандомизировать его. ИВ не нужно хранить в секрете, но обычно их запутывают каким-то образом.

Хотя это защищает от анализа паттернов, оно не помогает при атаках воспроизведения. Например, повторная передача заданного набора зашифрованных данных все равно будет дублировать результат. Чтобы предотвратить это, нам нужно аутентифицировать отправителя. Мы будем использовать общедоступный псевдослучайно сгенерированный идентификатор сессии для каждого сообщения. Этот идентификатор сеанса может быть сгенерирован принимающим устройством путем публикации в теме MQTT.

Предотвращение подобных атак важно в нескольких случаях. Существуют контролируемые Интернетом печки, за исключением сомнительной утилиты, было бы неплохо, если бы они не использовали небезопасные команды.Во-вторых, если я регистрирую данные с сотен датчиков, я не хочу, чтобы кто-нибудь заполнил мою базу данных мусором.

Практическое шифрование

Реализация вышеупомянутого на NodeMCU требует некоторых усилий. Вам потребуется скомпилированная прошивка для включения модуля «crypto» в дополнение к любым другим, которые вам требуются для вашего приложения. Поддержка SSL не требуется.

Во-первых, давайте предположим, что вы подключены к брокеру MQTT с чем-то вроде следующего. Вы можете реализовать это как отдельную функцию от криптографии, чтобы сохранить вещи в чистоте.Клиент подписывается на sessionID канал, который публикует подходящие длинные псевдослучайные идентификаторы сеанса. Вы можете зашифровать их, но это не обязательно.

m = mqtt.Client ("clientid", 120)

m: connect (& quot; myserver.com & quot ;, 1883, 0,
Функция (клиент)
печать (& Quot; соединен & Quot;)
клиент: подписаться ("mytopic / sessionID", 0,
функция (клиент) print (& quot; подписка успешно & quot;) end
)
конец,
функция (клиент, причина)
распечатать (& quot; причина сбоя: & quot;., причина)
конец
)

m: on (& quot; сообщение & quot ;, функция (клиент, тема, sessionID) end)
 

Далее, идентификатор узла - это удобный способ помочь идентифицировать источники данных. Вы можете использовать любую желаемую строку: nodeid = node.chipid () .

Затем мы устанавливаем статический вектор инициализации и ключ. Это используется только для запутывания случайного вектора инициализации, отправляемого с каждым сообщением, НЕ используется для каких-либо данных. Мы также выбираем отдельный ключ для данных.Эти ключи 16-битные шестнадцатеричные, просто замените их на свои.

Наконец, нам понадобится фраза-пароль для хэш-функции, которую мы будем использовать позже. Строка разумной длины в порядке.

staticiv = "abcdef2345678901"
ivkey = "2345678901abcdef"
datakey = "0123456789abcdef"
фраза-пароль = "фраза-пароль"
 

Мы также предполагаем, что у вас есть какой-то источник данных. Для этого примера это будет значение, считанное с АЦП.8 минус 1) и объединить их.

half1 = node.random (4294967295)
half2 = node.random (4294967295)
I = string.format ("% 8x", half1)
V = string.format ("% 8x", half2)
iv = I .. V
 

Теперь мы можем запустить фактическое шифрование. Здесь мы зашифровываем текущий вектор инициализации, идентификатор узла и один фрагмент данных датчика.

encrypted_iv = crypto.encrypt ("AES-CBC", ivkey, iv, staticiv)
encrypted_nodeid = crypto.зашифровать («AES-CBC», datakey, nodeid, iv)
encrypted_data = crypto.encrypt ("AES-CBC", datakey, data, iv)
 

Теперь мы применяем хеш-функцию для аутентификации. Сначала мы объединяем , , , , данные и идентификатор сеанса в одно сообщение, а затем вычисляем хэш HMAC SHA1, используя парольную фразу, которую мы определили ранее. Мы конвертируем его в шестнадцатеричный формат, чтобы сделать его более читабельным для любой отладки.

fullmessage = nodeid., iv .. data .. sessionID
hmac = crypto.toHex (crypto.hmac ("sha1", полное сообщение, фраза-пароль))
 

Теперь, когда и проверки шифрования, и проверки подлинности выполнены, мы можем поместить всю эту информацию в некоторую структуру и отправить ее. Здесь мы будем использовать значения через запятую, как это удобно:

payload = table.concat ({encrypted_iv, eid, data1, hmac}, & quot;, & quot;)
m: publish ("yourMQTTtopic", полезная нагрузка, 2, 1, функция (клиент), p = "Sent", print (p) end)
 

Когда мы запустим приведенный выше код на реальном NodeMCU, мы получим что-то вроде этого:

 1d54dd1af0f75a91a00d4dcd8f4ad28d,
d1a0b14d187c5adfc948dfd77c2b2ee5,
564633a4a053153bcbd6ed25370346d5,
c66697df7e7d467112757c841bfb6bce051d6289
 

Все вместе, программа шифрования выглядит следующим образом (разделы MQTT исключены для ясности):

nodeid = узел.chipid ()
staticiv = "abcdef2345678901"
ivkey = "2345678901abcdef"
datakey = "0123456789abcdef"
фраза-пароль = "фраза-пароль"

data = adc.read (0)
half1 = node.random (4294967295)
half2 = node.random (4294967295)
I = string.format ("% 8x", half1)
V = string.format ("% 8x", half2)
iv = I .. V

encrypted_iv = crypto.encrypt ("AES-CBC", ivkey, iv, staticiv)
encrypted_nodeid = crypto.зашифровать («AES-CBC», datakey, nodeid, iv)
encrypted_data = crypto.encrypt ("AES-CBC", datakey, data, iv)
fullmessage = nodeid .. iv .. data .. sessionID
hmac = crypto.toHex (crypto.hmac ("sha1", полное сообщение, фраза-пароль))
payload = table.concat ({encrypted_iv, encrypted_nodeid, encrypted_data, hmac}, & quot;)
 

Расшифровка

Теперь ваш MQTT-брокер не знает и не заботится о том, что данные зашифрованы, он просто передает их.Таким образом, ваши другие клиенты MQTT, подписавшиеся на эту тему, должны будут знать, как расшифровать данные. На NodeMCU это довольно просто. Просто разделите полученные данные на строки через запятую и сделайте что-то вроде ниже. Обратите внимание, что этот конец сгенерирует идентификатор сеанса, поэтому он уже знает это.

staticiv = "abcdef2345678901"
ivkey = "2345678901abcdef"
datakey = "0123456789abcdef"
фраза-пароль = "фраза-пароль"

iv = крипторасшифровать («AES-CBC», ivkey, encrypted_iv, staticiv)
nodeid = crypto.decrypt (& quot; AES-CBC & quot ;, ключ данных, encrypted_nodeid, iv)
data = crypto.decrypt ("AES-CBC", datakey, encrypted_data, iv)
fullmessage = nodeid .. iv .. data .. sessionID
hmac = crypto.toHex (crypto.hmac ("sha1", полное сообщение, фраза-пароль))
 

Затем сравните полученный и вычисленный HMAC и, независимо от результата, аннулируйте этот идентификатор сеанса, создав новый.

Еще раз, в Python

Для небольшого разнообразия рассмотрим, как мы будем обрабатывать расшифровку в Python, если бы у нас был клиент MQTT на той же виртуальной машине, что и брокер, который анализировал данные или сохранял их в базе данных. Предположим, вы получили данные в виде строки «полезной нагрузки» от чего-то вроде превосходного клиента Paho MQTT для Python.

В этом случае перед передачей удобно закодировать зашифрованные данные в NodeMCU в шестнадцатеричном формате. Поэтому в NodeMCU мы конвертируем все зашифрованные данные в шестнадцатеричные, например: encrypted_iv = crypto.toHex (crypto.encrypt ("AES-CBC", ivkey, iv, staticiv))

Публикация рандомизированного sessionID не обсуждается ниже, но достаточно проста с помощью os.urandom () и Paho MQTT Client. Расшифровка обрабатывается следующим образом:

от Crypto. Шифрование импорта AES
импорт бинасксии
из Crypto. Хэш-импорт SHA, HMAC

# определить все ключи
ivkey = '2345678901abcdef'
datakey = '0123456789abcdef'
staticiv = 'abcdef2345678901'
passphrase = 'mypassphrase'

# Конвертировать полученную строку в список
данные = полезная нагрузкасплит (& Quot;, & Quot;)

# извлечь элементы списка
encrypted_iv = binascii.unhexlify (data [0])
encrypted_nodeid = binascii.unhexlify (data [1])
encrypted_data = binascii.unhexlify (data [2])
receive_hash = binascii.unhexlify (data [3])

# расшифровать вектор инициализации
iv_decryption_suite = AES.new (ivkey, AES.MODE_CBC, staticiv)
iv = iv_decryption_suite.decrypt (encrypted_iv)

# расшифровать данные с помощью вектора инициализации
id_decryption_suite = AES.новый (datakey, AES.MODE_CBC, iv)
nodeid = id_decryption_suite.decrypt (encrypted_nodeid)
data_decryption_suite = AES.new (ключ данных, AES.MODE_CBC, iv)
sensordata = data_decryption_suite.decrypt (encrypted_data)

# вычислить хеш-функцию для сравнения с receive_hash
fullmessage = s.join ([nodeid, iv, sensordata, sessionID])
hmac = HMAC.new (фраза-пароль, полное сообщение, SHA)
computed_hash = hmac.hexdigest ()

# см. docs.python.org/2/library/hmac.html, чтобы узнать, как безопасно сравнивать хэши
 

Конец, Начало

Теперь у нас есть система, которая отправляет зашифрованные, аутентифицированные сообщения через MQTT-сервер либо другому клиенту ESP8266, либо более крупной системе, на которой работает Python.Есть все еще важные слабые стороны для вас, чтобы связать, если вы реализуете это самостоятельно. Все ключи хранятся во флэш-памяти ESP8266, поэтому вам нужно будет контролировать доступ к этим устройствам, чтобы предотвратить реверс-инжиниринг. Ключи также хранятся в коде на компьютере, получающем данные, здесь работает Python. Кроме того, вы, вероятно, хотите, чтобы у каждого клиента был свой ключ и фраза. Это много секретных материалов, которые можно хранить в безопасности и, при необходимости, обновлять. Решение проблемы распределения ключей оставлено в качестве упражнения для мотивированного читателя.

И на заключительном замечании, одна из ужасных вещей при написании статьи, связанной с криптографией, - это вероятность того, что ошибочен в Интернете . Это довольно простое применение проверенного и действительного режима AES-CBC с HMAC, так что оно должно быть довольно надежным. Тем не менее, если вы обнаружите какие-либо интересные недостатки в вышеуказанном, пожалуйста, сообщите нам об этом в комментариях.