如何简洁，可移植和彻底播种mt19937 PRNG？

我似乎看到了许多答案，有人建议使用这些答案<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位。这不足以使MT的19937位状态成为种子。

• 使用std::mt19937 gen(rd());gen()（用32位播种并查看第一个输出）不能提供良好的输出分布。7和13永远不会是第一个输出。两颗种子产生0。十二颗种子产生1226181350。（链接）

• std::random_device可以并且有时被实现为带有固定种子的简单PRNG。因此，每次运行可能会产生相同的序列。（链接）甚至比time(NULL)。

更糟糕的是，尽管存在上述问题，但复制并粘贴上述代码片段非常容易。为此，一些解决方案需要获取可能并不适合每个人的大型 库。

有鉴于此，我的问题是，如何能以C ++简洁，可移植，彻底地植入mt19937 PRNG？

鉴于上述问题，一个好的答案是：

• 必须完全植入mt19937 / mt19937_64。
• 不能完全依赖std::random_device或time(NULL)作为熵的来源。
• 不应该依赖Boost或其他库。
• 应该放在少量的行中，这样看起来很不错，可以粘贴到答案中。

思想

• 我目前的想法是，std::random_device可以使用time(NULL)，从地址空间随机化派生的值和硬编码的常数（可以在分发期间设置）将的输出（可以通过XOR）进行混搭，以尽力而为。

• std::random_device::entropy() 不能很好地说明std::random_device可能做什么或可能不会做什么。

我认为最大的缺点std::random_device是，如果没有CSPRNG，则允许确定性回退。仅此一个很好的理由，不要使用来播种PRNG std::random_device，因为产生的字节可能是确定的。不幸的是，它没有提供API来找出发生这种情况的时间，也没有提供请求失败的API，而不是低质量的随机数。

也就是说，没有完全可移植的解决方案：但是，有一种体面的最小方法。您可以在CSPRNG（定义sysrandom如下）周围使用最小包装，以播种PRNG。

视窗

您可以依靠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）都将其作为PRNG来实现（实际上，每次都会产生相同的序列以警告人们它不是适当的随机性）。

播种

现在我们有了最少的开销的块，我们可以生成所需的随机熵位来播种PRNG。该示例使用（显然不足）32位来播种PRNG，并且您应该增加此值（取决于CSPRNG）。

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

比较提升

在快速查看源代码之后，我们可以看到与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，则会阻塞。以下代码段检测Linux getrandom是否可用，如果不可用，则退回到/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替换为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;
}

谢谢

特别感谢Ben Voigt指出FILE使用缓冲读取，因此不应使用。

我还要感谢Peter Cordes的提及getrandom以及OpenBSD缺乏/dev/urandom。

从某种意义上说，这是无法移植的。也就是说，可以构想一个运行C ++的有效的完全确定性平台（例如，一个确定性地步进机器时钟并使用“确定性” I / O的模拟器），在该平台中，没有随机来源来植入PRNG。

您可以使用a，std::seed_seq然后使用Alexander Huszagh的获取熵的方法将其填充到至少生成器所需的状态大小：

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播种正确就会简单得多。

我正在研究的实现利用PRNG 的state_size属性mt19937来决定要在初始化时提供多少种子：

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（出于线程安全性考虑），则可以仅基于哈希线程ID进行初始化。

以下是从我的代码库中提炼出来的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）。
• 如果您想要随机值（而不是说/dev/urandom或/dev/random），请使用getrandom（）。

这些可在类似Linux的现代UNIX系统上使用，例如Linux，Solaris和OpenBSD。

给定的平台可能具有熵的来源，例如/dev/random。自大纪元以来的十亿分之一秒std::chrono::high_resolution_clock::now()可能是标准库中最好的种子。

以前，我曾使用过类似的方法(uint64_t)( time(NULL)*CLOCKS_PER_SEC + clock() )来获取对安全性要求不高的应用程序更多的熵。