Получение действительно случайного числа в Arduino

randomSeed(analogRead(x)) создаст только 255 последовательностей чисел, что делает тривиальной проверку всех комбинаций и создание оракула, который может соединиться с вашим выходным потоком, предсказывая все выходные данные 100 %. Однако вы на правильном пути, это всего лишь игра с числами, и вам нужно их НАМНОГО больше. Например, взять 100 аналоговых чтений из 4 АЦП, суммировать их все и передать в randomSeed, было бы намного лучше. Для максимальной безопасности вам нужен как непредсказуемый ввод, так и недетерминированное смешивание.

Я не криптограф, но я потратил тысячи часов на исследование и создание аппаратных и программных генераторов случайных чисел, поэтому позвольте мне поделиться некоторыми из того, что я узнал:

Непредсказуемый ввод:

• analogRead() (для плавающих контактов)
• ПолучитьВремя()

Потенциально непредсказуемый ввод:

• micros() (с недетерминированным периодом выборки)
• дрожание часов (низкая пропускная способность, но пригодная для использования)
• readVCC() (если не работает от батареи)

Внешний непредсказуемый ввод:

• датчики температуры, влажности и давления
• микрофоны
• Делители напряжения LDR
• шум транзистора с обратным смещением
• дрожание компаса/ускорения
• сканирование точки доступа Wi-Fi esp8266 (ssid, db и т. д.)
• время esp8266 (фоновые задачи Wi-Fi делают запланированные выборки micros() неопределенными)
• esp8266 HWRNG – RANDOM_REG32 – чрезвычайно быстрый и непредсказуемый, 1-ступенчатый

собирать Последнее, что вы хотите сделать, это выплевывать энтропию по мере ее поступления. Легче угадать бросок монеты, чем ведро монет. Суммирование хорошее. unsigned long bank; затем позже bank+= thisSample; хорошо; он перевернется. bank[32] еще лучше, читайте дальше. Вы хотите собрать как минимум 8 выборок входных данных для каждого фрагмента выходных данных, в идеале гораздо больше.

Защита от отравления Если нагрев платы вызывает определенное максимальное дрожание тактовой частоты, это вектор атаки. То же самое с радиопомехами, направленными на вход AnalogRead(). Еще одна распространенная атака — простое отключение устройства от сети и сброс всей накопленной энтропии. Вы не должны выводить числа, пока не убедитесь, что это безопасно, даже ценой скорости.

Вот почему вы хотите сохранить некоторую энтропию в долгосрочной перспективе, используя EEPROM, SD и т. д. Посмотрите Fortuna PRNG использует 32 банка, каждый из которых обновляется в два раза реже, чем предыдущий. Это затрудняет атаку всех 32 банков за разумное время.

Обработка После того, как вы соберете «энтропию», вы должны очистить ее и отделить от ввода труднообратимым способом. SHA/1/256 подходит для этого. Вы можете использовать SHA1 (или даже MD5) для скорости, поскольку у вас нет уязвимости открытого текста. Чтобы собрать урожай, никогда не используйте полный банк энтопии и ВСЕГДА ВСЕГДА добавляйте «соль» к выходным данным, которая каждый раз разная, чтобы предотвратить идентичные выходные данные при отсутствии изменений в банке энтропии: output = sha1( String(micros()) + String (bank[0]) + [...] ); Функция sha одновременно скрывает входные данные и отбеливает выходные данные, защищая от слабых семян, низкого накопления ent и других распространенных проблем.

Чтобы использовать входные данные таймера, необходимо сделать их недетерминированными. Это просто как delayMicroseconds(lastSample % 255); который делает паузу на непредсказуемое количество времени, делая «последовательные» показания часов неравномерными по различию. Делайте это полурегулярно, например if(analogRead(A1)>200){...}, при условии, что A1 зашумлен или подключен к динамическому вводу. Усложнение определения каждой вилки вашего потока предотвратит криптоанализ декомпилированного/скопированного вывода.

Настоящая безопасность — это когда злоумышленник знает всю вашу систему и все еще беспомощен в ее преодолении.

Наконец, проверьте свою работу. Пропустите свой вывод через ENT.EXE (также доступен для nix/mac) и посмотрите, подходит ли он. Наиболее важным является распределение хи-квадрат, которое обычно должно составлять от 33% до 66%. Если вы получаете 1,43% или 99,999% или что-то в этом роде, более одного теста подряд, ваш рандом — дерьмо. Вы также хотите, чтобы энтропия ENT сообщала как можно ближе к 8 битам на байт, > 7,9 наверняка.

TLDR: Самый простой надежный способ — использовать HWRNG ESP8266. Это быстро, равномерно и непредсказуемо. Запустите что-то подобное на ESP8266 с ядром Ardunio и используйте последовательный порт для связи с AVR:

// Код ядра ESP8266 Arduino:
void setup(){
 Serial.begin(9600); // или как там
}

void loop() {
  // Serial.write((char)(RANDOM_REG32 % 256)); // "бункер"
  Serial.print( String(RANDOM_REG32, HEX).substring(1)); // "шестнадцатеричный"
}

** изменить

вот скетч HWRNG на голой плате, который я написал некоторое время назад, работающий не только как сборщик, но и как целый CSPRNG, выплевывающий из последовательного порта. Он создан для про-мини, но должен быть легко адаптирован к другим платам. Можно использовать просто плавающие аналоговые пины, но лучше добавить к ним что-нибудь, желательно разное. Например, микрофоны, фоторезисторы, термисторы (урезанные до максимальной температуры в помещении) и даже длинные провода. Он довольно хорошо работает в ЛОР, если у вас есть даже умеренный шум.

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

// AVR (ardunio) HWRNG от dandavis. выпущен в общественное достояние автором.
#include <Hash.h> 

unsigned long read[8] = {0, 0, 0, 0, 0, 0, 0, 0};
const int pincount = 9; // уменьшаем для плат не pro-mini
int pins[9] = {A0, A1, A2, A3, A4, A5, A6, A7, A0}; // настройка для платы, имя аналоговых входов для выборки
unsigned int ticks = 0;
String buff = ""; // содержит один раунд токенов деривации для хеширования.
String cache; // последний прочитанный хэш



void harvest() { // String() замедляет обработку, что затрудняет воссоздание вызовов micros()
  unsigned long tot = 0; // сумма всех аналоговых операций чтения
  buff = String(random(2147483647)) + String(millis() % 999);
  int seed =  random(256) + (micros() % 32);
  int offset =  random(2147483647) % 256;

  for (int i = 0; i < 8; i++) {
    buff += String( seed + read[i] + i + (ticks % 65), HEX );
    buff += String(random(2147483647), HEX);
    tot += read[i];
  }//следующее я

  buff += String( (micros() + ticks + offset) % 99999, HEX);
  if (random(10) < 3) randomSeed(tot + random(2147483647) + micros()); 
  buff = sha1( String(random(2147483647)) + buff + (micros()%64) + cache); // используется хэш для унифицированного вывода и пустой траты времени
  Serial.print( buff ); // выводим хэш
  cache = buff;
  spin();
}//конец сбора()


void spin() { // добавляем энтропию и перемешиваем
  ticks++;
  int sample = 128;
  for (int i = 0; i < 8; i++) { // обновляем ~6/8 банков 8 раз
    read[ read[i] % 8] += (micros() % 128);
    sample = analogRead(  pins[i] ); // чтение с каждого аналогового вывода
    read[ micros() % 8] += ( read[i] % 64 ); // смешать синхронизацию и 6LSB из чтения
    read[i] += sample; // смешать весь необработанный образец
    read[(i + 1) % 8] += random(2147483647) % 1024; // смешиваем прнг
    read[ticks % 8] += sample % 16; // смешиваем лучшую часть прочитанного
    read[sample % 8] += read[ticks % 8] % 2147483647; // внутримиксовые банки
  }

}//конец вращения()



void setup() {
  Serial.begin(9600);
  delay(222);
  int mx = 2028 + ((analogRead(A0)  + analogRead(A1) + analogRead(A2)  + analogRead(A3)) % 256);  
  while (ticks < mx) {
    spin();
    delay(1);
    randomSeed(read[2] + read[1] + read[0] + micros() + random(4096) + ticks);
  }// идем
}// конец настройки()



void loop() {
  spin();
  delayMicroseconds((read[ micros() % 8] %  2048) + 333  );
  delay(random(10));
  //если (millis() < 500) return;
  if ((ticks % 16) == (millis() % 16) ) harvest();
}// конец цикла()