Как кратко, портативно и тщательно засеять ГПСЧ mt19937?

Кажется, я вижу много ответов, в которых кто-то предлагает использовать <random>для генерации случайных чисел, обычно вместе с таким кодом:

std::random_device rd;  
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, 5);
dis(gen);

Обычно это заменяет какую-то «нечестивую мерзость» типа:

srand(time(NULL));
rand()%6;

Мы могли бы критиковать старый способ, утверждая, что он time(NULL)обеспечивает низкую энтропию, time(NULL)предсказуемость и конечный результат неоднороден.

Но все это верно в отношении нового способа: у него просто более блестящий внешний вид.

• rd()возвращает сингл unsigned int. Он имеет как минимум 16 бит, а возможно, 32. Этого недостаточно для заполнения 19937 бит состояния MT.

• Использование std::mt19937 gen(rd());gen()(заполнение 32 битами и просмотр первого вывода) не дает хорошего распределения вывода. 7 и 13 никогда не могут быть первым выходом. Два семени дают 0. Двенадцать семян дают 1226181350. ( Ссылка )

• std::random_deviceможет быть, а иногда и реализуется как простой ГПСЧ с фиксированным начальным значением. Следовательно, при каждом запуске может производиться одна и та же последовательность. ( Ссылка ) Это даже хуже чем time(NULL).

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

В свете этого, мой вопрос: как можно кратко, портативно и тщательно засеять mt19937 PRNG в C ++?

Учитывая вышеперечисленные проблемы, хороший ответ:

• Необходимо полностью засеять mt19937 / mt19937_64.
• Нельзя полагаться только на источник энтропии std::random_deviceили time(NULL)как на ее источник.
• Не следует полагаться на Boost или другие библиотеки.
• Должен уместиться в небольшом количестве строк, чтобы он выглядел хорошо вставленным в ответ.

мысли

• Моя текущая мысль заключается в том, что выходные данные std::random_deviceможно объединить (возможно, с помощью XOR) со time(NULL)значениями, полученными в результате рандомизации адресного пространства , и жестко запрограммированной константой (которая может быть установлена ​​во время распределения), чтобы получить максимальную отдачу от энтропии.

• std::random_device::entropy() не дает четкого представления о том, что std::random_deviceможет или не может сделать.

Я бы сказал, что самый большой недостаток std::random_deviceзаключается в том, что разрешен детерминированный откат, если CSPRNG недоступен. Уже одно это является хорошей причиной не заполнять ГПСЧ с помощью std::random_device, поскольку производимые байты могут быть детерминированными. К сожалению, он не предоставляет API, чтобы узнать, когда это происходит, или запросить сбой вместо случайных чисел низкого качества.

То есть полностью переносимого решения нет: зато есть достойный, минималистичный подход. Вы можете использовать минимальную оболочку вокруг CSPRNG (определенного sysrandomниже) для заполнения PRNG.

Windows

Вы можете положиться на CryptGenRandomCSPRNG. Например, вы можете использовать следующий код:

bool acquire_context(HCRYPTPROV *ctx)
{
    if (!CryptAcquireContext(ctx, nullptr, nullptr, PROV_RSA_FULL, 0)) {
        return CryptAcquireContext(ctx, nullptr, nullptr, PROV_RSA_FULL, CRYPT_NEWKEYSET);
    }
    return true;
}


size_t sysrandom(void* dst, size_t dstlen)
{
    HCRYPTPROV ctx;
    if (!acquire_context(&ctx)) {
        throw std::runtime_error("Unable to initialize Win32 crypt library.");
    }

    BYTE* buffer = reinterpret_cast<BYTE*>(dst);
    if(!CryptGenRandom(ctx, dstlen, buffer)) {
        throw std::runtime_error("Unable to generate random bytes.");
    }

    if (!CryptReleaseContext(ctx, 0)) {
        throw std::runtime_error("Unable to release Win32 crypt library.");
    }

    return dstlen;
}

Unix-подобный

Во многих Unix-подобных системах по возможности следует использовать / dev / urandom (хотя это не гарантируется в POSIX-совместимых системах).

size_t sysrandom(void* dst, size_t dstlen)
{
    char* buffer = reinterpret_cast<char*>(dst);
    std::ifstream stream("/dev/urandom", std::ios_base::binary | std::ios_base::in);
    stream.read(buffer, dstlen);

    return dstlen;
}

Другой

Если CSPRNG недоступен, вы можете полагаться на него std::random_device. Однако я бы по возможности избегал этого, поскольку различные компиляторы (в первую очередь, MinGW) реализуют его как ГПСЧ (фактически, каждый раз создавая одну и ту же последовательность, чтобы предупредить людей о том, что она не является должным образом случайной).

Посев

Теперь, когда у нас есть части с минимальными накладными расходами, мы можем сгенерировать желаемые биты случайной энтропии для заполнения нашего ГПСЧ. В примере используются (явно недостаточные) 32 бита для заполнения PRNG, и вам следует увеличить это значение (которое зависит от вашего CSPRNG).

std::uint_least32_t seed;    
sysrandom(&seed, sizeof(seed));
std::mt19937 gen(seed);

Сравнение с Boost

Мы можем увидеть параллели с boost :: random_device (настоящий CSPRNG) после беглого просмотра исходного кода . Boost используется MS_DEF_PROVв Windows, это тип поставщика для PROV_RSA_FULL. Единственное, чего не хватает, - это проверки криптографического контекста, что можно сделать с помощью CRYPT_VERIFYCONTEXT. На * Nix Boost использует /dev/urandom. IE, это решение портативно, хорошо протестировано и простое в использовании.

Специализация Linux

Если вы готовы пожертвовать краткостью ради безопасности, getrandomэто отличный выбор для Linux 3.17 и новее, а также для недавней версии Solaris. getrandomведет себя идентично /dev/urandom, за исключением того, что блокируется, если ядро ​​еще не инициализировало свой CSPRNG после загрузки. Следующий фрагмент кода определяет getrandom, доступен ли Linux , и, если нет, возвращается к /dev/urandom.

#if defined(__linux__) || defined(linux) || defined(__linux)
#   // Check the kernel version. `getrandom` is only Linux 3.17 and above.
#   include <linux/version.h>
#   if LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
#       define HAVE_GETRANDOM
#   endif
#endif

// also requires glibc 2.25 for the libc wrapper
#if defined(HAVE_GETRANDOM)
#   include <sys/syscall.h>
#   include <linux/random.h>

size_t sysrandom(void* dst, size_t dstlen)
{
    int bytes = syscall(SYS_getrandom, dst, dstlen, 0);
    if (bytes != dstlen) {
        throw std::runtime_error("Unable to read N bytes from CSPRNG.");
    }

    return dstlen;
}

#elif defined(_WIN32)

// Windows sysrandom here.

#else

// POSIX sysrandom here.

#endif

OpenBSD

Есть еще одно последнее предостережение: в современной OpenBSD его нет /dev/urandom. Вместо этого вы должны использовать getentropy .

#if defined(__OpenBSD__)
#   define HAVE_GETENTROPY
#endif

#if defined(HAVE_GETENTROPY)
#   include <unistd.h>

size_t sysrandom(void* dst, size_t dstlen)
{
    int bytes = getentropy(dst, dstlen);
    if (bytes != dstlen) {
        throw std::runtime_error("Unable to read N bytes from CSPRNG.");
    }

    return dstlen;
}

#endif

другие мысли

Если вам нужны криптографически безопасные случайные байты, вам, вероятно, следует заменить fstream на небуферизованные open / read / close POSIX. Это потому , что , как basic_filebufи FILEсодержит внутренний буфер, который будет выделен с помощью стандартного распределителя (и , следовательно , не стер из памяти).

Это легко сделать, изменив sysrandomна:

size_t sysrandom(void* dst, size_t dstlen)
{
    int fd = open("/dev/urandom", O_RDONLY);
    if (fd == -1) {
        throw std::runtime_error("Unable to open /dev/urandom.");
    }
    if (read(fd, dst, dstlen) != dstlen) {
        close(fd);
        throw std::runtime_error("Unable to read N bytes from CSPRNG.");
    }

    close(fd);
    return dstlen;
}

Спасибо

Особая благодарность Бену Фойгту за указание на FILEиспользование буферизованного чтения, поэтому его не следует использовать.

Я также хотел бы поблагодарить Питера Кордеса за упоминание getrandomи отсутствие в OpenBSD /dev/urandom.

В некотором смысле это невозможно сделать портативно. Таким образом, можно представить себе действительную полностью детерминированную платформу, работающую на C ++ (скажем, симулятор, который детерминированно изменяет синхронизацию машинных часов и с «детерминированным» вводом-выводом), в которой нет источника случайности для заполнения ГПСЧ.

Вы можете использовать a std::seed_seqи заполнить его, по крайней мере, до требуемого размера состояния для генератора, используя метод Александра Хусзага для получения энтропии:

size_t sysrandom(void* dst, size_t dstlen); //from Alexander Huszagh answer above

void foo(){

    std::array<std::mt19937::UIntType, std::mt19937::state_size> state;
    sysrandom(state.begin(), state.length*sizeof(std::mt19937::UIntType));
    std::seed_seq s(state.begin(), state.end());

    std::mt19937 g;
    g.seed(s);
}

Если бы существовал правильный способ заполнения или создания SeedSequence из UniformRandomBitGenerator в стандартной библиотеке, использование std::random_deviceдля правильного заполнения было бы намного проще.

Реализация, над которой я работаю, использует state_sizeсвойство mt19937PRNG, чтобы решить, сколько семян предоставить при инициализации:

using Generator = std::mt19937;

inline
auto const& random_data()
{
    thread_local static std::array<typename Generator::result_type, Generator::state_size> data;
    thread_local static std::random_device rd;

    std::generate(std::begin(data), std::end(data), std::ref(rd));

    return data;
}

inline
Generator& random_generator()
{
    auto const& data = random_data();

    thread_local static std::seed_seq seeds(std::begin(data), std::end(data));
    thread_local static Generator gen{seeds};

    return gen;
}

template<typename Number>
Number random_number(Number from, Number to)
{
    using Distribution = typename std::conditional
    <
        std::is_integral<Number>::value,
        std::uniform_int_distribution<Number>,
        std::uniform_real_distribution<Number>
    >::type;

    thread_local static Distribution dist;

    return dist(random_generator(), typename Distribution::param_type{from, to});
}

Я думаю, что есть возможности для улучшения, потому что они std::random_device::result_typeмогут отличаться std::mt19937::result_typeпо размеру и диапазону, поэтому это действительно следует учитывать.

Замечание о std :: random_device .

Согласно C++11(/14/17)стандарту (-ам):

26.5.6 Класс random_device [ rand.device ]

2 Если ограничения реализации не позволяют генерировать недетерминированные случайные числа, реализация может использовать механизм случайных чисел.

Это означает, что реализация может генерировать детерминированные значения только в том случае, если ей не позволяют генерировать недетерминированные значения из - за некоторых ограничений.

MinGWКомпилятор на Windowsлихе не обеспечивает недетерминированное значение своего std::random_device, несмотря на их быть легко доступны из операционной системы. Поэтому я считаю это ошибкой, которая вряд ли часто встречается в разных реализациях и на разных платформах.

Нет ничего плохого в раздаче с использованием времени, если это вам не нужно для обеспечения безопасности (и вы не говорили, что это было необходимо). Понимание состоит в том, что вы можете использовать хеширование, чтобы исправить неслучайность. Я обнаружил, что это работает адекватно во всех случаях, включая, в частности, тяжелое моделирование методом Монте-Карло.

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

Ниже приведен SSCCE , полученный из моей кодовой базы (для простоты; некоторые структуры поддержки OO опущены):

#include <cstdint> //`uint32_t`
#include <functional> //`std::hash`
#include <random> //`std::mt19937`
#include <iostream> //`std::cout`

static std::mt19937 rng;

static void seed(uint32_t seed) {
    rng.seed(static_cast<std::mt19937::result_type>(seed));
}
static void seed() {
    uint32_t t = static_cast<uint32_t>( time(nullptr) );
    std::hash<uint32_t> hasher; size_t hashed=hasher(t);
    seed( static_cast<uint32_t>(hashed) );
}

int main(int /*argc*/, char* /*argv*/[]) {
    seed();
    std::uniform_int_distribution<> dis(0, 5);
    std::cout << dis(rng);
}

Вот мой собственный ответ на вопрос:

#include <random>
#include <chrono>
#include <cstdint>
#include <algorithm>
#include <functional>
#include <iostream>

uint32_t LilEntropy(){
  //Gather many potential forms of entropy and XOR them
  const  uint32_t my_seed = 1273498732; //Change during distribution
  static uint32_t i = 0;        
  static std::random_device rd; 
  const auto hrclock = std::chrono::high_resolution_clock::now().time_since_epoch().count();
  const auto sclock  = std::chrono::system_clock::now().time_since_epoch().count();
  auto *heap         = malloc(1);
  const auto mash = my_seed + rd() + hrclock + sclock + (i++) +
    reinterpret_cast<intptr_t>(heap)    + reinterpret_cast<intptr_t>(&hrclock) +
    reinterpret_cast<intptr_t>(&i)      + reinterpret_cast<intptr_t>(&malloc)  +
    reinterpret_cast<intptr_t>(&LilEntropy);
  free(heap);
  return mash;
}

//Fully seed the mt19937 engine using as much entropy as we can get our
//hands on
void SeedGenerator(std::mt19937 &mt){
  std::uint_least32_t seed_data[std::mt19937::state_size];
  std::generate_n(seed_data, std::mt19937::state_size, std::ref(LilEntropy));
  std::seed_seq q(std::begin(seed_data), std::end(seed_data));
  mt.seed(q);
}

int main(){
  std::mt19937 mt;
  SeedGenerator(mt);

  for(int i=0;i<100;i++)
    std::cout<<mt()<<std::endl;
}

Идея здесь состоит в том, чтобы использовать XOR для объединения многих потенциальных источников энтропии (быстрое время, медленное время std::random-device, местоположения статических переменных, местоположения кучи, местоположения функций, местоположения библиотек, значения, специфичные для программы), чтобы предпринять максимальную попытку инициализировать mt19937. Если хотя бы один раз источник будет «хорошим», результат будет не менее «хорошим».

Этот ответ не такой короткий, как хотелось бы, и может содержать одну или несколько логических ошибок. Так что я считаю это незавершенным. Прокомментируйте, если у вас есть отзыв.

• Используйте getentropy () для заполнения генератора псевдослучайных чисел (PRNG).
• Используйте getrandom (), если вам нужны случайные значения (вместо, скажем, /dev/urandomили /dev/random).

Они доступны в современных UNIX-подобных системах, таких как Linux, Solaris и OpenBSD.

Данная платформа может иметь источник энтропии, например /dev/random. Наносекунды с начала эпохи, std::chrono::high_resolution_clock::now()вероятно, являются лучшим начальным значением в стандартной библиотеке.

Раньше я использовал что-то вроде того, (uint64_t)( time(NULL)*CLOCKS_PER_SEC + clock() )чтобы получить больше бит энтропии для приложений, которые не критичны с точки зрения безопасности.