Wie kurz und bündig, tragbar und gründlich Saatgut der mt19937 PRNG?

Ich würde behaupten der größte Fehler mit std::random_device ist die, dass es erlaubt ist eine deterministische fallback, wenn keine CSPRNG verfügbar ist. Dies allein ist ein guter Grund, nicht zu Saatgut ein PRNG mit std::random_device, da der bytes erzeugt werden kann deterministisch. Es ist leider nicht eine API bereitstellen, um herauszufinden, Wann dies geschieht, oder zu verlangen, Versagen anstelle von low-Qualität von Zufallszahlen.

Ist, es gibt keine komplett portable Lösung: allerdings, es ist ein anständiger, minimalistischen Ansatz. Sie können einen minimalen wrapper um eine CSPRNG (definiert als sysrandom unten), der Samen der PRNG.

Windows

Können Sie sich auf CryptGenRandom ein CSPRNG. Sie können beispielsweise den folgenden code verwenden:

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-Wie

Auf vielen Unix-artigen Systemen, die Sie verwenden sollten /dev/urandom, wenn möglich (obwohl dies nicht garantiert ist, gibt es auf POSIX-kompatiblen Systemen).

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

Anderen

Wenn keine CSPRNG verfügbar ist, können Sie wählen, auf die Sie sich verlassen std::random_device. Allerdings würde ich vermeiden, wenn möglich, da verschiedene Compiler (vor allem, MinGW) implementieren Sie es mit als PRNG (in der Tat produzieren die gleiche Reihenfolge jedes mal warnen, die Menschen, dass es nicht richtig random).

Seeding

Nun, wir haben unsere Stücke mit minimalem Aufwand können wir erzeugen die gewünschten bits von random entropy Seeding unsere PRNG. Das Beispiel verwendet (offensichtlich unzureichend) 32-bits, um die Samen der PRNG, und Sie sollten diesen Wert erhöhen (das ist abhängig von Ihrer CSPRNG).

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

Vergleich Zum Boost

Sehen wir parallelen zu boost::random_device (eine wahre CSPRNG) nach einem kurzen Blick auf die source code. Boost verwendet MS_DEF_PROV auf Windows, die die Anbieter geben für PROV_RSA_FULL. Das einzige, was fehlt, wäre die überprüfung der kryptographischen Kontext, die getan werden kann, mit CRYPT_VERIFYCONTEXT. Auf *Nix-Boost verwendet /dev/urandom. DH, diese Lösung ist transportabel, gut getestet und einfach zu verwenden.

Linux Spezialisierung

Wenn Sie zu opfern bereit sind lapidare für Sicherheit, getrandom ist eine ausgezeichnete Wahl auf Linux 3.17 und oben, und auf den letzten Solaris. getrandom verhält sich identisch zu /dev/urandom, außer es blockiert wird, wenn der kernel nicht initialisiert seine CSPRNG noch nach dem Booten. Der folgende Code erkennt, ob Linux getrandom verfügbar ist, und wenn nicht fällt zurück auf /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

Es ist eine Letzte Warnung: moderne OpenBSD nicht /dev/urandom. Sie verwenden sollten, getentropy statt.

#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

Andere Gedanken

Wenn Sie brauchen, kryptografisch sichere zufällige bytes, sollten Sie wahrscheinlich ersetzen die fstream sind mit POSIX ist Ungepuffert öffnen/Lesen/schließen. Dies ist, weil beide basic_filebuf und FILE enthalten einen internen Puffer, die zugeteilt werden, der über eine standard-Zuweisung (und deshalb nicht ausgelöscht aus dem Gedächtnis).

Dies kann leicht getan werden, indem Sie ändern sysrandom zu:

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

Dank

Besonderen Dank an Ben Voigt für den Hinweis FILE verwendet gepuffert liest, und sollte daher nicht verwendet werden.

Ich möchte auch meinen Dank an Peter Cordes für die Erwähnung getrandom ist, und OpenBSD ist der Mangel an /dev/urandom.

InformationsquelleAutor Alexander Huszagh

Können Sie eine std::seed_seq und füllen Sie mindestens die erfordert Zustand Größe für den generator mit Alexander Huszagh ' s Methode, die Entropie:

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

void foo(){

    std::uint_fast32_t[std::mt19937::state_size] state;
    sysrandom(state, sizeof(state));
    std::seed_seq s(std::begin(state), std::end(state));

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

Wenn es eine richtige Art und Weise zu füllen oder erstellen Sie eine SeedSequence von einem UniformRandomBitGenerator in der standard-Bibliothek, die mit std::random_device für das seeding richtig wäre doch viel einfacher.

InformationsquelleAutor ratchet freak

Es ist nichts falsch mit Aussaat von mit der Zeit, vorausgesetzt, Sie brauchen es nicht, um sicher zu sein (und Sie nicht sagen, das war nötig). Die Erkenntnis ist, dass Sie verwenden können, hashing zu beheben, die nicht-Zufälligkeit. Ich habe festgestellt, dass dies funktioniert, angemessen, in allen Fällen, einschließlich Fällen, und insbesondere bei schweren Monte-Carlo-Simulationen.

Ein nettes feature von diesem Ansatz ist, dass er verallgemeinert auf die Initialisierung von anderen nicht-wirklich-zufällige Mengen von Samen. Zum Beispiel, wenn Sie wollen, dass jeder thread seinen eigenen RNG (für threadsafety), Sie kann nur initialisiert werden, basierend auf Hash-thread-ID.

Folgende ist eine SSCCE, destilliert aus meine codebase (für Einfachheit, einige OO-support-Strukturen erstellte):

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

InformationsquelleAutor imallett

Eine bestimmte Plattform möglicherweise eine Quelle der Entropie, wie /dev/random. Nanosekunden, die seit der Epoche mit std::chrono::high_resolution_clock::now() ist wahrscheinlich der beste Samen in der Standard-Bibliothek.

Ich zuvor verwendet haben, so etwas wie (uint64_t)( time(NULL)*CLOCKS_PER_SEC + clock() ) um mehr bits der Entropie für Anwendungen, die nicht Sicherheits-kritische.

InformationsquelleAutor Davislor