package rand

Import Path
	crypto/rand (on go.dev)

Dependency Relation
	imports 14 packages, and imported by 3 packages

Involved Source Files

	      eagain.go
	   #d rand.go
		Package rand implements a cryptographically secure
		random number generator.

	      rand_unix.go
	      util.go
Code Examples

	Read
		package main
		
		import (
			"bytes"
			"crypto/rand"
			"fmt"
		)
		
		func main() {
			c := 10
			b := make([]byte, c)
			_, err := rand.Read(b)
			if err != nil {
				fmt.Println("error:", err)
				return
			}
			// The slice should now contain random bytes instead of only zeroes.
			fmt.Println(bytes.Equal(b, make([]byte, c)))
		
		}


Package-Level Type Names (total 3, none are exported)

	/* sort exporteds by: alphabet | popularity */
	/* 3 unexporteds ... *//* 3 unexporteds: */
	 type devReader (struct)
		A devReader satisfies reads by reading the file named name.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			f io.Reader
			mu sync.Mutex
			name string
			used int32
				// atomic; whether this devReader has been used

		Methods (only one, which is exported)
			(*T) Read(b []byte) (n int, err error)
		Implements (at least one exported)
			*T : io.Reader

	 type hideAgainReader (struct)
		hideAgainReader masks EAGAIN reads from /dev/urandom.
		See golang.org/issue/9205

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			r io.Reader
		Methods (only one, which is exported)
			( T) Read(p []byte) (n int, err error)
		Implements (at least one exported)
			 T : io.Reader

	 type reader (struct)

		Fields (total 8, none are exported)
			/* 8 unexporteds ... *//* 8 unexporteds: */
			budget int
				// number of bytes that can be generated

			cipher cipher.Block
			dst [16]byte
			entropy io.Reader
			key [16]byte
			mu sync.Mutex
			seed [16]byte
			time [16]byte
		Methods (only one, which is exported)
			(*T) Read(b []byte) (n int, err error)
		Implements (at least one exported)
			*T : io.Reader


Package-Level Functions (total 8, in which 3 are exported)

	 func Int(rand io.Reader, max *big.Int) (n *big.Int, err error)
		Int returns a uniform random value in [0, max). It panics if max <= 0.

	 func Prime(rand io.Reader, bits int) (p *big.Int, err error)
		Prime returns a number, p, of the given size, such that p is prime
		with high probability.
		Prime will return error for any error returned by rand.Read or if bits < 2.

	 func Read(b []byte) (n int, err error)
		Read is a helper function that calls Reader.Read using io.ReadFull.
		On return, n == len(b) if and only if err == nil.

	/* 5 unexporteds ... *//* 5 unexporteds: */
	 func init()
	 func init()
	 func newReader(entropy io.Reader) io.Reader
		newReader returns a new pseudorandom generator that
		seeds itself by reading from entropy. If entropy == nil,
		the generator seeds itself by reading from the system's
		random number generator, typically /dev/random.
		The Read method on the returned reader always returns
		the full amount asked for, or else it returns an error.

		The generator uses the X9.31 algorithm with AES-128,
		reseeding after every 1 MB of generated data.

	 func unixIsEAGAIN(err error) bool
		unixIsEAGAIN reports whether err is a syscall.EAGAIN wrapped in a PathError.
		See golang.org/issue/9205

	 func warnBlocked()
Package-Level Variables (total 5, in which 1 are exported)

	  var Reader io.Reader
		Reader is a global, shared instance of a cryptographically
		secure random number generator.

		On Linux and FreeBSD, Reader uses getrandom(2) if available, /dev/urandom otherwise.
		On OpenBSD, Reader uses getentropy(2).
		On other Unix-like systems, Reader reads from /dev/urandom.
		On Windows systems, Reader uses the RtlGenRandom API.
		On Wasm, Reader uses the Web Crypto API.

	/* 4 unexporteds ... *//* 4 unexporteds: */
	  var altGetRandom ([]byte) (ok bool)
		altGetRandom if non-nil specifies an OS-specific function to get
		urandom-style randomness.

	  var isEAGAIN (error) bool // set by eagain.go on unix systems
	  var smallPrimes []uint8
		smallPrimes is a list of small, prime numbers that allows us to rapidly
		exclude some fraction of composite candidates when searching for a random
		prime. This list is truncated at the point where smallPrimesProduct exceeds
		a uint64. It does not include two because we ensure that the candidates are
		odd by construction.

	  var smallPrimesProduct *big.Int
		smallPrimesProduct is the product of the values in smallPrimes and allows us
		to reduce a candidate prime by this number and then determine whether it's
		coprime to all the elements of smallPrimes without further big.Int
		operations.


Package-Level Constants (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	const urandomDevice = "/dev/urandom"

The pages are generated with Golds v0.4.2. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.