Як швидко, переносно та ретельно висіяти PRNG 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 біт.

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

• std::random_deviceможе бути, а іноді і реалізується як звичайний PRNG з фіксованим насінням. Таким чином, він може створювати однакову послідовність на кожному запуску. ( Посилання ) Це навіть гірше , ніж 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. Це одне є вагомою причиною не засівати PRNG, використовуючи 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-Like

У багатьох системах, схожих на 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) реалізують це як PRNG (насправді, щоразу створюючи ту саму послідовність, щоб попереджати людей про те, що це не належним чином випадково).

Висівання насіння

Тепер, коли у нас є шматки з мінімальними накладними витратами, ми можемо генерувати бажані біти випадкової ентропії для насіння нашого PRNG. У прикладі використовується (очевидно недостатньо) 32-біт для виведення PRNG, і ви повинні збільшити це значення (яке залежить від вашого CSPRNG).

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

Порівняння для підвищення

Ми можемо побачити паралелі для підвищення :: 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. Натомість слід використовувати гетентропію .

#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 на розблоковане відкрите / читання / закриття 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 ++ (скажімо, тренажер, який керує машинним годинником детерміновано, та з "визначеним" введенням-виведенням), в якому немає джерела випадковості висаджувати PRNG.

Ви можете використовувати 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. Поки щонайменше один раз джерело є "хорошим", результат буде принаймні таким "добрим".

Ця відповідь не є такою короткою, як це було б кращим, і може містити одну або кілька помилок логіки. Тому я вважаю це незавершеною роботою. Будь ласка, коментуйте, якщо у вас є відгуки.

• Використовуйте гетентропію () для посіву генератора псевдовипадкових чисел (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() )щоб отримати більше біт ентропії для додатків, які не є критичними для безпеки.