package blake2b

Import Path
	golang.org/x/crypto/blake2b (on go.dev)

Dependency Relation
	imports 7 packages, and imported by one package

Involved Source Files

	   #d blake2b.go
		Package blake2b implements the BLAKE2b hash algorithm defined by RFC 7693
		and the extendable output function (XOF) BLAKE2Xb.

		BLAKE2b is optimized for 64-bit platforms—including NEON-enabled ARMs—and
		produces digests of any size between 1 and 64 bytes.
		For a detailed specification of BLAKE2b see https://blake2.net/blake2.pdf
		and for BLAKE2Xb see https://blake2.net/blake2x.pdf

		If you aren't sure which function you need, use BLAKE2b (Sum512 or New512).
		If you need a secret-key MAC (message authentication code), use the New512
		function with a non-nil key.

		BLAKE2X is a construction to compute hash values larger than 64 bytes. It
		can produce hash values between 0 and 4 GiB.

	      blake2bAVX2_amd64.go
	      blake2b_generic.go
	      blake2x.go
	      register.go
	      blake2bAVX2_amd64.s
	      blake2b_amd64.s
Package-Level Type Names (total 3, in which 1 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type XOF (interface)
		XOF defines the interface to hash functions that
		support arbitrary-length output.

		Methods (total 4, all are exported)
			( XOF) Clone() XOF
				Clone returns a copy of the XOF in its current state.

			( XOF) Read(p []byte) (n int, err error)
			( XOF) Reset()
				Reset resets the XOF to its initial state.

			( XOF) Write(p []byte) (n int, err error)
		Implemented By (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			*xof
		Implements (at least 3, all are exported)
			 XOF : io.Reader
			 XOF : io.ReadWriter
			 XOF : io.Writer
		As Outputs Of (at least 2, both are exported)
			func NewXOF(size uint32, key []byte) (XOF, error)
			func XOF.Clone() XOF

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 type digest (struct)

		Fields (total 7, none are exported)
			/* 7 unexporteds ... *//* 7 unexporteds: */
			block [128]byte
			c [2]uint64
			h [8]uint64
			key [128]byte
			keyLen int
			offset int
			size int
		Methods (total 9, in which 7 are exported)
			(*digest) BlockSize() int
			(*digest) MarshalBinary() ([]byte, error)
			(*digest) Reset()
			(*digest) Size() int
			(*digest) Sum(sum []byte) []byte
			(*digest) UnmarshalBinary(b []byte) error
			(*digest) Write(p []byte) (n int, err error)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*digest) finalize(hash *[64]byte)
			(*digest) initConfig(cfg *[64]byte)
		Implements (at least 5, in which 4 are exported)
			*digest : encoding.BinaryMarshaler
			*digest : encoding.BinaryUnmarshaler
			*digest : hash.Hash
			*digest : io.Writer
			/* at least one unexported ... *//* at least one unexported: */
			*digest : crypto/hmac.marshalable
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newDigest(hashSize int, key []byte) (*digest, error)

	 type xof (struct)

		Fields (total 9, none are exported)
			/* 9 unexporteds ... *//* 9 unexporteds: */
			block [64]byte
			cfg [64]byte
			d digest
			length uint32
			nodeOffset uint32
			offset int
			readMode bool
			remaining uint64
			root [64]byte
		Methods (total 4, all are exported)
			(*xof) Clone() XOF
			(*xof) Read(p []byte) (n int, err error)
			(*xof) Reset()
			(*xof) Write(p []byte) (n int, err error)
		Implements (at least 4, all are exported)
			*xof : XOF
			*xof : io.Reader
			*xof : io.ReadWriter
			*xof : io.Writer


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

	 func New(size int, key []byte) (hash.Hash, error)
		New returns a new hash.Hash computing the BLAKE2b checksum with a custom length.
		A non-nil key turns the hash into a MAC. The key must be between zero and 64 bytes long.
		The hash size can be a value between 1 and 64 but it is highly recommended to use
		values equal or greater than:
		- 32 if BLAKE2b is used as a hash function (The key is zero bytes long).
		- 16 if BLAKE2b is used as a MAC function (The key is at least 16 bytes long).
		When the key is nil, the returned hash.Hash implements BinaryMarshaler
		and BinaryUnmarshaler for state (de)serialization as documented by hash.Hash.

	 func New256(key []byte) (hash.Hash, error)
		New256 returns a new hash.Hash computing the BLAKE2b-256 checksum. A non-nil
		key turns the hash into a MAC. The key must be between zero and 64 bytes long.

	 func New384(key []byte) (hash.Hash, error)
		New384 returns a new hash.Hash computing the BLAKE2b-384 checksum. A non-nil
		key turns the hash into a MAC. The key must be between zero and 64 bytes long.

	 func New512(key []byte) (hash.Hash, error)
		New512 returns a new hash.Hash computing the BLAKE2b-512 checksum. A non-nil
		key turns the hash into a MAC. The key must be between zero and 64 bytes long.

	 func NewXOF(size uint32, key []byte) (XOF, error)
		NewXOF creates a new variable-output-length hash. The hash either produce a
		known number of bytes (1 <= size < 2**32-1), or an unknown number of bytes
		(size == OutputLengthUnknown). In the latter case, an absolute limit of
		256GiB applies.

		A non-nil key turns the hash into a MAC. The key must between
		zero and 32 bytes long.

	 func Sum256(data []byte) [32]byte
		Sum256 returns the BLAKE2b-256 checksum of the data.

	 func Sum384(data []byte) [48]byte
		Sum384 returns the BLAKE2b-384 checksum of the data.

	 func Sum512(data []byte) [64]byte
		Sum512 returns the BLAKE2b-512 checksum of the data.

	/* 13 unexporteds ... *//* 13 unexporteds: */
	 func appendUint32(b []byte, x uint32) []byte
	 func appendUint64(b []byte, x uint64) []byte
	 func checkSum(sum *[64]byte, hashSize int, data []byte)
	 func consumeUint32(b []byte) ([]byte, uint32)
	 func consumeUint64(b []byte) ([]byte, uint64)
	 func hashBlocks(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)
	 func hashBlocksAVX(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)
	 func hashBlocksAVX2(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)
	 func hashBlocksGeneric(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)
	 func hashBlocksSSE4(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)
	 func init()
	 func init()
	 func newDigest(hashSize int, key []byte) (*digest, error)
Package-Level Variables (total 7, none are exported)

	/* 7 unexporteds ... *//* 7 unexporteds: */
	  var errHashSize error
	  var errKeySize error
	  var iv [8]uint64
	  var precomputed [12][16]byte
		the precomputed values for BLAKE2b
		there are 12 16-byte arrays - one for each round
		the entries are calculated from the sigma constants.

	  var useAVX bool
	  var useAVX2 bool
	  var useSSE4 bool
Package-Level Constants (total 9, in which 5 are exported)

	const BlockSize = 128
		The blocksize of BLAKE2b in bytes.

	const OutputLengthUnknown = 0
		OutputLengthUnknown can be used as the size argument to NewXOF to indicate
		the length of the output is not known in advance.

	const Size = 64
		The hash size of BLAKE2b-512 in bytes.

	const Size256 = 32
		The hash size of BLAKE2b-256 in bytes.

	const Size384 = 48
		The hash size of BLAKE2b-384 in bytes.

	/* 4 unexporteds ... *//* 4 unexporteds: */
	const magic = "b2b"
	const magicUnknownOutputLength = 4294967295
		magicUnknownOutputLength is a magic value for the output size that indicates
		an unknown number of output bytes.

	const marshaledSize int = 213
	const maxOutputLength = 274877906944
		maxOutputLength is the absolute maximum number of bytes to produce when the
		number of output bytes is unknown.

The pages are generated with Golds v0.4.9. (GOOS=linux GOARCH=amd64)