## table of contents

RANDOM(9) | Kernel Developer's Manual | RANDOM(9) |

# NAME¶

`arc4rand`

, `arc4random`

,
`random`

, `read_random`

,
`read_random_uio`

, `srandom`

—
# 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`

().
July 16, 2015 | Linux 4.9.0-9-amd64 |