Main index | Section 9 | Options |

#include <sys/libkern.h>

#include <sys/random.h>

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.

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.

[EFAULT]
| |

uio points to an invalid memory region. | |

[EWOULDBLOCK]
| |

The random device is unseeded and nonblock is true. | |

RANDOM (9) | July 16, 2015 |

Main index | Section 9 | Options |

Please direct any comments about this manual page service to Ben Bullock. Privacy policy.

“ | Not only is UNIX dead, it's starting to smell really bad. | ” |

— Rob Pike |