Làm thế nào để bắt nguồn từ mt19937 PRNG?

Tôi dường như thấy nhiều câu trả lời trong đó ai đó đề xuất sử dụng <random>để tạo các số ngẫu nhiên, thường cùng với mã như thế này:

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

Thông thường điều này thay thế một số loại "sự ghê tởm xấu xa" chẳng hạn như:

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

Chúng ta có thể chỉ trích cách làm cũ bằng cách lập luận rằng time(NULL)cung cấp entropy thấp, time(NULL)có thể dự đoán được và kết quả cuối cùng là không đồng nhất.

Nhưng tất cả những điều đó đều đúng với phương pháp mới: nó chỉ có một lớp veneer sáng bóng hơn.

• rd()trả về một đơn unsigned int. Điều này có ít nhất 16 bit và có lẽ là 32. Điều đó không đủ để tạo ra trạng thái 19937 bit của MT.

• Sử dụng std::mt19937 gen(rd());gen()(gieo hạt với 32 bit và xem xét đầu ra đầu tiên) không cung cấp phân phối đầu ra tốt. 7 và 13 không bao giờ có thể là đầu ra đầu tiên. Hai hạt tạo ra 0. Mười hai hạt tạo ra 1226181350. ( Link )

• std::random_devicecó thể, và đôi khi được thực hiện như một PRNG đơn giản với một hạt giống cố định. Do đó, nó có thể tạo ra cùng một trình tự trên mỗi lần chạy. ( Liên kết ) Điều này thậm chí còn tồi tệ hơn time(NULL).

Tệ hơn nữa, rất dễ dàng sao chép và dán các đoạn mã nói trên, bất chấp các vấn đề của chúng. Một số giải pháp cho này đòi hỏi phải mua largish thư viện mà có thể không phù hợp với tất cả mọi người.

Về vấn đề này, câu hỏi của tôi là Làm cách nào để có thể gieo mầm mt19937 PRNG trong C ++ một cách ngắn gọn, dễ hiểu và kỹ lưỡng?

Với những vấn đề trên, một câu trả lời hay:

• Phải gieo đầy đủ mt19937 / mt19937_64.
• Không thể chỉ dựa vào std::random_devicehoặc time(NULL)như một nguồn entropy.
• Không nên dựa vào Boost hoặc các quyền tự do khác.
• Nên vừa với một số dòng nhỏ để nó trông đẹp mắt khi được dán vào một câu trả lời.

Suy nghĩ

• Suy nghĩ hiện tại của tôi là kết quả đầu ra từ std::random_devicecó thể được trộn (có thể thông qua XOR) với time(NULL), các giá trị bắt nguồn từ ngẫu nhiên hóa không gian địa chỉ và một hằng số được mã hóa cứng (có thể được thiết lập trong quá trình phân phối) để có được một bức ảnh nỗ lực tốt nhất tại entropy.

• std::random_device::entropy() không đưa ra một dấu hiệu tốt về những gì std::random_devicecó thể hoặc không thể làm.

Tôi tranh luận rằng lỗ hổng lớn nhất std::random_devicelà nó được phép dự phòng xác định nếu không có CSPRNG. Đây là lý do chính đáng để không sử dụng PRNG std::random_device, vì các byte được tạo ra có thể mang tính xác định. Rất tiếc, nó không cung cấp một API để tìm hiểu khi nào điều này xảy ra hoặc yêu cầu thất bại thay vì các số ngẫu nhiên chất lượng thấp.

Đó là, không có giải pháp hoàn toàn di động : tuy nhiên, có một cách tiếp cận tối thiểu và phù hợp. Bạn có thể sử dụng một trình bao bọc tối thiểu xung quanh CSPRNG (được định nghĩa như sysrandombên dưới) để tạo PRNG.

các cửa sổ

Bạn có thể dựa vào CryptGenRandomCSPRNG. Ví dụ: bạn có thể sử dụng mã sau:

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

Trên nhiều hệ thống giống Unix, bạn nên sử dụng / dev / urandom khi có thể (mặc dù điều này không được đảm bảo tồn tại trên các hệ thống tuân thủ 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;
}

Khác

Nếu không có CSPRNG, bạn có thể chọn dựa vào std::random_device. Tuy nhiên, tôi sẽ tránh điều này nếu có thể, vì nhiều trình biên dịch khác nhau (đáng chú ý nhất là MinGW) triển khai nó dưới dạng PRNG (trên thực tế, tạo ra cùng một trình tự mọi lúc để cảnh báo con người rằng nó không phải là ngẫu nhiên).

Gieo hạt

Bây giờ chúng ta đã có các mảnh của mình với chi phí tối thiểu, chúng ta có thể tạo ra các bit entropy ngẫu nhiên mong muốn để gieo PRNG của chúng ta. Ví dụ sử dụng (rõ ràng là không đủ) 32 bit để tạo PRNG và bạn nên tăng giá trị này (phụ thuộc vào CSPRNG của bạn).

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

So sánh để tăng

Chúng ta có thể thấy các điểm tương đồng để boost :: random_device (một CSPRNG thực sự) sau khi xem nhanh mã nguồn . Tăng cường sử dụng MS_DEF_PROVtrên Windows, là loại nhà cung cấp cho PROV_RSA_FULL. Điều duy nhất còn thiếu sẽ là xác minh bối cảnh mật mã, có thể được thực hiện với CRYPT_VERIFYCONTEXT. Trên * Nix, Boost sử dụng /dev/urandom. IE, giải pháp này có tính di động, được thử nghiệm tốt và dễ sử dụng.

Chuyên môn Linux

Nếu bạn sẵn sàng hy sinh tính ngắn gọn cho bảo mật, đây getrandomlà một lựa chọn tuyệt vời trên Linux 3.17 trở lên và trên Solaris gần đây. getrandomhoạt động giống hệt nhau /dev/urandom, ngoại trừ nó chặn nếu hạt nhân chưa khởi tạo CSPRNG sau khi khởi động. Đoạn mã sau sẽ phát hiện xem Linux getrandomcó khả dụng hay không và nếu không có /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

Có một cảnh báo cuối cùng: OpenBSD hiện đại không có /dev/urandom. Bạn nên sử dụng getentropy để thay thế.

#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

Suy nghĩ khác

Nếu bạn cần các byte ngẫu nhiên an toàn bằng mật mã, bạn có thể nên thay thế fstream bằng mở / đọc / đóng không có bộ đệm của POSIX. Điều này là do cả hai basic_filebufvà FILEđều chứa bộ đệm bên trong, bộ đệm này sẽ được cấp phát qua bộ cấp phát tiêu chuẩn (và do đó không bị xóa khỏi bộ nhớ).

Điều này có thể dễ dàng được thực hiện bằng cách thay đổi sysrandomthành:

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;
}

Cảm ơn

Đặc biệt cảm ơn Ben Voigt vì đã chỉ ra cách FILEsử dụng các lần đọc được đệm và do đó không nên sử dụng.

Tôi cũng muốn cảm ơn Peter Cordes đã đề cập getrandom, và sự thiếu sót của OpenBSD /dev/urandom.

Theo một nghĩa nào đó, điều này không thể được thực hiện một cách di động. Có nghĩa là, người ta có thể hình dung một nền tảng xác định đầy đủ hợp lệ chạy C ++ (giả sử, một trình mô phỏng điều khiển đồng hồ máy một cách xác định và với I / O "xác định") trong đó không có nguồn ngẫu nhiên nào để tạo ra một PRNG.

Bạn có thể sử dụng a std::seed_seqvà điền nó đến ít nhất là kích thước trạng thái yêu cầu cho bộ tạo bằng phương pháp lấy entropy của 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);
}

Nếu có một cách thích hợp để điền hoặc tạo SeedSequence từ UniformRandomBitGenerator trong thư viện tiêu chuẩn, sử dụng std::random_deviceđể gieo hạt đúng cách sẽ đơn giản hơn nhiều.

Việc triển khai mà tôi đang thực hiện tận dụng state_sizetài sản của mt19937PRNG để quyết định số lượng hạt giống cần cung cấp khi khởi tạo:

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});
}

Tôi nghĩ rằng có chỗ để cải thiện vì std::random_device::result_typecó thể khác nhau std::mt19937::result_typevề kích thước và phạm vi nên điều đó thực sự cần được tính đến.

Lưu ý về std :: random_device .

Theo C++11(/14/17)(các) tiêu chuẩn:

26.5.6 Lớp random_device [ rand.device ]

2 Nếu các giới hạn triển khai ngăn cản việc tạo ra các số ngẫu nhiên không xác định, thì việc triển khai có thể sử dụng một công cụ số ngẫu nhiên.

Điều này có nghĩa là việc triển khai chỉ có thể tạo ra các giá trị xác định nếu nó bị ngăn cản việc tạo ra các giá trị không xác định bởi một số giới hạn.

Trình MinGWbiên dịch trên Windowsnổi tiếng không cung cấp các giá trị không xác định từ nó std::random_device, mặc dù chúng có sẵn dễ dàng từ Hệ điều hành. Vì vậy, tôi coi đây là một lỗi và không có khả năng xảy ra phổ biến trên các triển khai và nền tảng.

Không có gì sai khi gieo hạt theo thời gian, giả sử bạn không cần nó được bảo mật (và bạn đã không nói điều này là cần thiết). Sự hiểu biết sâu sắc là bạn có thể sử dụng hàm băm để khắc phục tính không ngẫu nhiên. Tôi thấy điều này hoạt động đầy đủ trong mọi trường hợp, bao gồm và đặc biệt đối với các mô phỏng Monte Carlo nặng.

Một tính năng hay của cách tiếp cận này là nó tổng quát hóa để khởi tạo từ các tập hợp hạt giống không thực sự ngẫu nhiên khác. Ví dụ: nếu bạn muốn mỗi luồng có RNG riêng (để an toàn cho luồng), bạn chỉ có thể khởi tạo dựa trên ID luồng đã băm.

Sau đây là một SSCCE , được chắt lọc từ codebase của tôi (để đơn giản hơn; một số cấu trúc hỗ trợ OO được giải thích):

#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);
}

Đây là câu hỏi của riêng tôi:

#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;
}

Ý tưởng ở đây là sử dụng XOR để kết hợp nhiều nguồn entropy tiềm năng (thời gian nhanh, thời gian chậm, std::random-device vị trí biến tĩnh, vị trí đống, vị trí hàm, vị trí thư viện, giá trị theo chương trình cụ thể) để nỗ lực tối đa trong việc khởi tạo mt19937. Miễn là ít nhất một lần nguồn là "tốt", kết quả sẽ ít nhất là "tốt".

Câu trả lời này không ngắn gọn như mong muốn và có thể chứa một hoặc nhiều sai lầm về logic. Vì vậy, tôi đang coi nó là một công việc đang được tiến hành. Hãy bình luận nếu bạn có phản hồi.

• Sử dụng getentropy () để gieo một trình tạo số giả ngẫu nhiên (PRNG).
• Sử dụng getrandom () nếu bạn muốn các giá trị ngẫu nhiên (thay vì, giả sử /dev/urandomhoặc /dev/random).

Chúng có sẵn trên các hệ thống giống UNIX hiện đại, chẳng hạn như Linux, Solaris và OpenBSD.

Một nền tảng nhất định có thể có một nguồn entropy, chẳng hạn như /dev/random. Nanoseconds kể từ Epoch với std::chrono::high_resolution_clock::now()có lẽ là hạt giống tốt nhất trong Thư viện chuẩn.

Trước đây tôi đã sử dụng một cái gì đó như (uint64_t)( time(NULL)*CLOCKS_PER_SEC + clock() )để lấy thêm bit entropy cho các ứng dụng không quan trọng về bảo mật.