Math::Random::MT is a very well documented and tested PRNG with an extremely long periodicity. Unfortunately, the reference links within the modules POD are no longer valid, but google will find a zillion references including this one.

Of course, like any PRNG, it does generate a known sequence for a given seed, so the trick is to chose a seed at random. Time of day (in milliseconds), process number and various other things can be used, but they are at least to some extent inferable. A possibility would be to randomly pick a file from a directory and then a random offset within that file and then unpack 4 bytes at that location as a number and use that to seed MT.

#!perl -slw
use strict;
use Math::Random::MT qw[ rand srand ];;

my @files = glob '*';;
my $file = $files[ rand @files ];

open RND, '<', $file or die $!;
my $slurp = do{ local $/; <RND> };
close RND;

my $seed = unpack 'N', substr $slurp, rand( length $slurp - 4 ), 4;

srand $seed;

print rand for 1 .. 100;
[download]

With a suitable choice of directory that includes some binary images, especially if the contents of the directory change, the random choice of seed drawn this way should be pretty unpredictable. From then on, the sequence produced by MT is about as unpredicatable as PRNGs get.

ISAAC source

That page itself links to a perl version of the ISAAC code: http://burtleburtle.net/bob/rand/randperl.txt.

But the code is trivial enough that exposing the C code via an XS or Inline module should be a pretty straightforward path to retaining the speed of C if that's an issue.

Hugo

Aha! Thank you! I'm working producing a module for that code that can provide a drop-in replacement to the default rand(). I will probably publish it in the Monestary first, then work on submitting to CPAN (which will be a new experience for me, and so might take some time).

As I mention in my new update to the parent node, however, I also need a cross-platform (at least *NIX and Win) method to generate a seed. For ISAAC specifically, I would want at least one and no more than 256 32-bit values with which to seed the PRNG. Any thoughts?

Yoda would agree with Perl design: there is no try{}

Find variance in nature and bring it into your computer. Emulate the interface to /dev/random or EGD. Then, use the accepted (and already written) secure algorithms in CPAN that rightfully require this functionality.

- paul

"A fool and his freedom are soon parted"
-RMS

Mersenne Twister is a great PRNG, but not a Cryptographically Secure PRNG. See the Mersenne Twister homepage. There is, unfortunately, a big difference between PRNGs that are statistically random enough for mathematics purposes, and PRNGs that are random in the right ways for cryptography.

Yoda would agree with Perl design: there is no try{}

Ahem. From the homepage you linked (my emphasis):

Caution: Mersenne Twister is basically for Monte-Carlo simulations - it is not cryptographically secure "as is". Please read FAQ.

And from the FAQ:

Want to use for cryptography.

Mersenne Twister is not cryptographically secure. (MT is based on a linear recursion. Any pseudorandom number sequence generated by a linear recursion is insecure, since from sufficiently long subsequence of the outputs, one can predict the rest of the outputs.)

To make it secure, you need to use some Secure Hashing Algorithm with MT. For example, you may gather every eight words of outputs, and compress them into one word (thus the length of the output sequence is 1/8 of the original one).

It is meaningful to replace linear generators like LFSR with MT.

2002-version can receive an array of integer as a seed, and it fits to this usage.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

Lingua non convalesco, consenesco et abolesco. -- Rule 1 has a caveat! -- Who broke the cabal?

"Science is about questioning the status quo. Questioning authority".

The "good enough" maybe good enough for the now, and perfection maybe unobtainable, but that should not preclude us from striving for perfection, when time, circumstance or desire allow.

Your proof demonstrates only that no PRNG is truly random: we already know this, and that's why it's called a Psuedo-random number generator.

Cryptographically Secure means that the randomness has no easily discernable pattern, and has a very long period -- that is, you don't start demonstrating any pattern until a whole lot of numbers have been generated.

Gathering entropy from a random (or "random enough") source for seeding doesn't make for a better source of random numbers; gathering entropy is time-intensive, but if we only do it once and then use a CSPRNG to generate further PR values, you end up with reasonable performance. Besides, you use the seed and then throw it away; as long as no one can derive the seed (with ISAAC, it is 256 32-bit values, so it's tough to brute-force), it's fantasically hard to duplicate the string of random values.

I strongly suggest that you research CSPRNG tech -- yes, it isn't as good as using a hardware RNG (or a Lava Lamp) as a source of entropy, but it is a good enough simulation that the numbers generated are random enough for cryptography. Not every application can implement a true RNG.

Yoda would agree with Perl design: there is no try{}