NAME

       arc4rand, arc4random, random, read_random, read_random_uio, srandom — supply pseudo-random numbers

SYNOPSIS

       #include <sys/libkern.h>

       void
       srandom(u_long seed);

       u_long
       random(void);

       void
       arc4rand(void *ptr, u_int length, int reseed);

       uint32_t
       arc4random(void);

       #include <sys/random.h>

       int
       read_random(void *buffer, int count);

       int
       read_random_uio(struct uio *uio, bool nonblock);

DESCRIPTION

       The  random()  function  will  by default produce a sequence of numbers that can be duplicated by calling
       srandom() with some constant as the seed.  The srandom() function may be called with any  arbitrary  seed
       value to get slightly more unpredictable numbers.  It is important to remember that the random() function
       is entirely predictable, and is therefore not of use where knowledge of the sequence of numbers may be of
       benefit to an attacker.

       The  arc4rand() function will return very good quality random numbers, better suited for security-related
       purposes.  The random numbers from arc4rand() are seeded from the entropy  device  if  it  is  available.
       Automatic  reseeds  happen  after  a  certain  timeinterval and after a certain number of bytes have been
       delivered.  A forced reseed can be forced by passing a non-zero value in the reseed argument.

       The read_random() function is used to return entropy directly from the entropy  device  if  it  has  been
       loaded.   If  the  entropy  device  is  not loaded, then the buffer is ignored and zero is returned.  The
       buffer is filled with no more than count bytes.  It is strongly advised that read_random() is  not  used;
       instead use arc4rand() unless it is necessary to know that no entropy has been returned.

       The read_random_uio() function behaves identically to read(2) on /dev/random.  The uio argument points to
       a  buffer  where  random  data should be stored.  This function only returns data if the random device is
       seeded.  It blocks if unseeded, except when the nonblock argument is true.

       All the bits returned by random(), arc4rand(), read_random(),  and  read_random_uio()  are  usable.   For
       example, ‘random()&01’ will produce a random binary value.

       The  arc4random()  is  a  convenience  function  which  calls arc4rand() to return a 32 bit pseudo-random
       integer.

RETURN VALUES

       The random() function uses a non-linear additive feedback random number  generator  employing  a  default
       table  of size 31 containing long integers to return successive pseudo-random numbers in the range from 0
       to (2**31)−1.  The period of this random number generator is very large, approximately 16*((2**31)−1).

       The arc4rand() function  uses  the  RC4  algorithm  to  generate  successive  pseudo-random  bytes.   The
       arc4random() function uses arc4rand() to generate pseudo-random numbers in the range from 0 to (2**32)−1.

       The read_random() function returns the number of bytes placed in buffer.

       read_random_uio() returns zero when successful, otherwise an error code is returned.

ERRORS

       read_random_uio() may fail if:

       [EFAULT]           uio points to an invalid memory region.

       [EWOULDBLOCK]      The random device is unseeded and nonblock is true.

AUTHORS

       Dan Moschuk wrote arc4random().
       Mark R V Murray wrote read_random().

Debian                                            July 16, 2015                                        RANDOM(9)