David Cantrell > Net-Random-2.2 > Net::Random



Annotate this POD


Open  0
View/Report Bugs
Module Version: 2.2   Source   Latest Release: Net-Random-2.31


Net::Random - get random data from online sources


  my $rand = Net::Random->new( # use fourmilab.ch's randomness source,
    src => 'fourmilab.ch',   # and return results from 1 to 2000
    min => 1,
    max => 2000
  @numbers = $rand->get(5);  # get 5 numbers

  my $rand = Net::Random->new( # use qrng.anu.edu.au's randomness source,
    src => 'qrng.anu.edu.au',   # with no explicit range - so values will
  );               # be in the default range from 0 to 255

  my $rand = Net::Random->new( # use random.org's randomness source,
    src => 'random.org',   # with no explicit range - so values will
  );               # be in the default range from 0 to 255

  $number = $rand->get();    # get 1 random number


The three sources of randomness above correspond to https://www.fourmilab.ch/cgi-bin/uncgi/Hotbits?nbytes=1024&fmt=hex and https://random.org/cgi-bin/randbyte?nbytes=1024&format=hex and https://qrng.anu.edu.au/RawHex.php. We always get chunks of 1024 bytes at a time, storing it in a pool which is used up as and when needed. The pool is shared between all objects using the same randomness source. When we run out of randomness we go back to the source for more juicy random goodness.

If you have set a http_proxy variable in your environment, this will be honoured.

While we always fetch 1024 bytes, data can be used up one, two, three or four bytes at a time, depending on the range between the minimum and maximum desired values. There may be a noticeable delay while more random data is fetched.

The maintainers of both randomness sources claim that their data is *truly* random. A some simple tests show that they are certainly more random than the rand() function on this 'ere machine.



The constructor returns a Net::Random object. It takes named parameters, of which one - 'src' - is compulsory, telling the module where to get its random data from. The 'min' and 'max' parameters are optional, and default to 0 and 255 respectively. Both must be integers, and 'max' must be at least min+1. The maximum value of 'max' is 2^32-1, the largest value that can be stored in a 32-bit int, or 0xFFFFFFFF. The range between min and max can not be greater than 0xFFFFFFFF either.

You may also set 'ssl' to 0 if you wish to retrieve data using plaintext (or outbound SSL is prohibited in your network environment for some reason)

Currently, the only valid values of 'src' are 'qrng.anu.edu.au', 'fourmilab.ch' and 'random.org'.


Takes a single optional parameter, which must be a positive integer. This determines how many random numbers are to be returned and, if not specified, defaults to 1.

If it fails to retrieve data, we return undef. Note that both sources ration their random data. If you hit your quota, we spit out a warning. See the section on ERROR HANDLING below.


Doesn't handle really BIGNUMs. Patches are welcome to make it use Math::BigInt internally. Note that you'll need to calculate how many random bytes to use per result. I strongly suggest only using BigInts when absolutely necessary, because they are slooooooow.

Tests are a bit lame. Really needs to test the results to make sure they're as random as the input (to make sure I haven't introduced any bias).


True randomness is very useful for cryptographic applications. Unfortunately, I can not recommend using this module to produce such random data. While some simple testing shows that we can be fairly confident that it is random, and the published methodologies on both sites used looks sane, you can not, unfortunately, trust that you are getting unique data (ie, someone else might get the same bytes as you) or that they don't log who gets what data.

Be aware that if you use an http_proxy - or if your upstream uses a transparent proxy like some of the more shoddy consumer ISPs do - then that is another place that your randomness could be compromised.

I should stress that I *do* trust both site maintainers to give me data that is sufficiently random and unique for my own uses, but I can not recommend that you do too. As in any security situation, you need to perform your own risk analysis.


There are two types of error that this module can emit which aren't your fault. Those are network errors, in which case it emits a warning:

  Net::Random: Error talking to [your source]

and errors generated by the randomness sources, which look like:

  Net::Random: [your source] [message]

Once you hit either of these errors, it means that either you have run out of randomness and can't get any more, or you are very close to running out of randomness. Because this module's raison d'être is to provide a source of truly random data when you don't have your own one available, it does not provide any pseudo-random fallback.

If you want to implement your own fallback, you can catch those warnings by using $SIG{__WARN__}. See perldoc perlvar for details.


I welcome feedback about my code, especially constructive criticism.


Copyright 2003 - 2012 David Cantrell <david@cantrell.org.uk>

This software is free-as-in-speech software, and may be used, distributed, and modified under the terms of either the GNU General Public Licence version 2 or the Artistic Licence. It's up to you which one you use. The full text of the licences can be found in the files GPL2.txt and ARTISTIC.txt, respectively.


Thanks are also due to the maintainers of the randomness sources. See their web sites for details on how to praise them.

Suggestions from the following people have been included:

Rich Rauenzahn, for using an http_proxy;
Wiggins d Anconia suggested I mutter in the docs about security concerns

And patches from:

Mark Allen, who supplied the code for using SSL;
Steve Wills, who supplied the code for talking to qrng.anu.edu.au;


This module is also free-as-in-mason software.

syntax highlighting: