Wie für die Generierung von großen Zufallszahlen C

Ich bin auf der Suche nach einem Weg, um die Generierung von großen Zufallszahlen in der Größenordnung von 2^64 in C... (100000000 - 999999999), die in einem public-key-encryption-Algorithmus (p und q).

Will ich nicht erzeugen, eine Zahl kleiner als 2^64 (das heißt, kleiner als 100000000).

Gibt es irgendetwas, das mir helfen könnte, dies zu tun?

  • 2^64 ist viel größer als 999999999.
  • [100000000 - 999999999] ist 900,000,000 unterschiedliche Werte haben. Diese zahlen sind in der Größenordnung von 30 bit, nicht 64.
InformationsquelleAutor gfppaste | 2011-10-27
  1. 13

    random() gibt eine lange, die auf einem 64bit-system sollte 64 bit sein. Wenn Sie auf einem 32bit system können Sie Folgendes tun:

    #include <inttypes.h>

uint64_t num;

/* add code to seed random number generator */

num = rand();
num = (num << 32) | rand();

//enforce limits of value between 100000000 and 999999999
num = (num % (999999999 - 100000000)) + 100000000;

    Alternativ auf ein NIX-system, das Sie Lesen konnte /dev/random in Ihren Puffer:

    #include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <inttypes.h>   

int fd;
uint64_t num; 
if ((fd = open("/dev/random", O_RDONLY) == -1)
{
    /* handle error */
};
read(fd, &num, 8);
close(fd);

//enforce limits of value between 100000000 and 999999999
num = (num % (999999999 - 100000000)) + 100000000;

    Einen

    • rand() ist begrenzt durch RAND_MAX die nicht notwendig 2^32. Und, Sie noch etwas brauchen, um passieren zu srand(). /dev/random Funktionalität ist auch verfügbar auf andere Plattformen.
    • Dies stellt nicht sicher, dass die Anforderung "ich will nicht generieren Zahl kleiner als ... 100000000" erfüllt ist.
    • Fügen Sie die Zeile num = (num % (999999999 - 100000000)) + 100000000; zum generieren einer zufälligen Zahl an der unteren Grenze von 100000000 und die Obere Grenze von 999999999.
    • Besser, aber jetzt die zahlen oben 805933941 (2^64 -1 mod 899999999) sind etwas weniger wahrscheinlich als die zahlen unten 😉
    • Auf meinem pc RAND_MAX ist 2^31, nicht 2^32.
    • Unter der Annahme kleiner zahlen u32 gleichmäßig verteilt, ist eine solche kombinierte Anzahl u64 = (u32 << 32) | u32 auch?
    • num = (num << 32) | rand(); ist wahrscheinlich schwach gegeben, "Wenn Sie auf einem 32-bit", dann RAND_MAX wahrscheinlich ist 2^31-1 oder viel weniger. Dann num = (num << 32) | rand(); wird immer erzeugen eines raw - num mit einigen bits gelöscht, die in der gleichen position. num % (999999999 - 100000000) hilft verteilen das problem etwa noch auf Kosten der noch größere Mangel an einer einheitlichen Verteilung.

    InformationsquelleAutor David M. Syzdek
  2. 9

    Könnten Sie kombinieren zwei 4-byte zufällige Ganzzahlen zu erzeugen, eine 8-byte ein:

    #include <stdint.h>
...
uint64_t random = 
  (((uint64_t) rand() <<  0) & 0x00000000FFFFFFFFull) | 
  (((uint64_t) rand() << 32) & 0xFFFFFFFF00000000ull);

    Seit rand zurück int, und sizeof(int) >= 4 auf fast jeder modernen Plattform, sollte dieser code funktionieren. Ich habe die << 0 zu machen die Absicht deutlicher.

    Die Maskierung mit 0x00000000FFFFFFFF und 0xFFFFFFFF00000000 ist, um zu verhindern, dass die überlappung der bits in den beiden zahlen, die im Fall sizeof(int) > 4.

    BEARBEITEN

    Da @Banthar kommentierte, dass RAND_MAX ist nicht unbedingt 2 ^ 32, und ich denke, es ist garantiert mindestens 2 ^ 16 Sie kombinieren könnte vier 2-byte-zahlen nur um sicher zu sein:

    uint64_t random = 
  (((uint64_t) rand() <<  0) & 0x000000000000FFFFull) | 
  (((uint64_t) rand() << 16) & 0x00000000FFFF0000ull) | 
  (((uint64_t) rand() << 32) & 0x0000FFFF00000000ull) |
  (((uint64_t) rand() << 48) & 0xFFFF000000000000ull);
    • Wenn Sie ^ zu kombinieren, die zahlen anstelle von | Sie müssen sich keine Gedanken über die Maskierung.
    • Off-by-one: RAND_MAX ist sehr unwahrscheinlich, dass 2 ^ 32. Es könnte sein (2 ^ 32) - 1. Doch auch das ist ungewöhnlich. Wahrscheinlicher ist es dasselbe wie INT_MAX für die sich ein gemeinsamer Wert der (2 ^ 31) - 1 oder (2 ^ 15) - 1. C gibt an RAND_MAX mindestens (2^15) - 1, nicht 2 ^ 16.
    InformationsquelleAutor Blagovest Buyukliev
  3. 7

    Du suchst einen kryptografischen Stärke PRNG, wie openssl/rand: http://www.openssl.org/docs/crypto/rand.html

    InformationsquelleAutor wkl
  4. 3

    Ich weiß, ich werde wahrscheinlich erhalten, b____schlug durch OliCharlesworth, aber die Verwendung von rand() mit einer Skalierung und offset. Es ist in stdlib.h, um die ganze Reihe sollte man hinzufügen, dass ein kleiner rand() zum füllen der Lücken in der Zuordnung.

    InformationsquelleAutor MartyTPS
  5. 3

    Können Sie eine große Anzahl L aus kleineren zahlen (z.B. A & B). Zum Beispiel mit so etwas wie L = (2^ n)*A + B wo ^ bedeutet Potenzierung und n einige Konstante ganze Zahl (z.B. 32). Dann geben Sie den code 1<<n (Bitweises Links-shift) für die Stromversorgung-der Betrieb 2.

    So können Sie eine große zufällige Zahl von der kleineren Zufallszahlen.

    • was bedeuten die Buchstaben L, n, A, and b bedeuten? könnten Sie bitte erklären?
    • Unter der Annahme kleiner zahlen u32 gleichmäßig verteilt, ist eine solche kombinierte Anzahl u64 = (u32 << 32) | u32 auch?
    • Ich denke, dass ja, aber Sie sollten Fragen Sie einen Mathematiker.
    • L = (2^ n)*A + B ist ein problem, wenn der Bereich der B ist nicht [0...(2^ n)-1]. Besser L = (2^ n)*A ^ B wenn B range ist breiter (und noch ein power-of-2). Am besten ist L = (max_possible_value_of_B + (type_of_L)1) *A + B
    InformationsquelleAutor Basile Starynkevitch
  6. -1

    Oder könnten Sie zwei Zufallszahlengeneratoren mit UNABHÄNGIGEN Samen aus und setzen Sie Ihre output zahlen zusammen, wie vorgeschlagen. Das hängt davon ab, ob Sie eine 64 bit-Zahl der a RNG mit einer Periode im Bereich von 2^64. Einfach nicht mit dem Standard-Aufruf, die abhängig von der Zeit, denn Sie erhalten identische Samen für jeden generator. Der richtige Weg ist, ich weiß nur nicht ...

    InformationsquelleAutor jwoods486
Schreibe einen Kommentar