package sha3

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

Dependency Relation
	imports 7 packages, and imported by 2 packages


Involved Source Files

	
		Package sha3 implements the SHA-3 fixed-output-length hash functions and
		the SHAKE variable-output-length hash functions defined by FIPS-202.
		
		Both types of hash function use the "sponge" construction and the Keccak
		permutation. For a detailed specification see http://keccak.noekeon.org/
		
		# Guidance
		
		If you aren't sure what function you need, use SHAKE256 with at least 64
		bytes of output. The SHAKE instances are faster than the SHA3 instances;
		the latter have to allocate memory to conform to the hash.Hash interface.
		
		If you need a secret-key MAC (message authentication code), prepend the
		secret key to the input, hash with SHAKE256 and read at least 32 bytes of
		output.
		
		# Security strengths
		
		The SHA3-x (x equals 224, 256, 384, or 512) functions have a security
		strength against preimage attacks of x bits. Since they only produce "x"
		bits of output, their collision-resistance is only "x/2" bits.
		
		The SHAKE-256 and -128 functions have a generic security strength of 256 and
		128 bits against all attacks, provided that at least 2x bits of their output
		is used.  Requesting more than 64 or 32 bytes of output, respectively, does
		not increase the collision-resistance of the SHAKE functions.
		
		# The sponge construction
		
		A sponge builds a pseudo-random function from a public pseudo-random
		permutation, by applying the permutation to a state of "rate + capacity"
		bytes, but hiding "capacity" of the bytes.
		
		A sponge starts out with a zero state. To hash an input using a sponge, up
		to "rate" bytes of the input are XORed into the sponge's state. The sponge
		is then "full" and the permutation is applied to "empty" it. This process is
		repeated until all the input has been "absorbed". The input is then padded.
		The digest is "squeezed" from the sponge in the same way, except that output
		is copied out instead of input being XORed in.
		
		A sponge is parameterized by its generic security strength, which is equal
		to half its capacity; capacity + rate is equal to the permutation's width.
		Since the KeccakF-1600 permutation is 1600 bits (200 bytes) wide, this means
		that the security strength of a sponge instance is equal to (1600 - bitrate) / 2.
		
		# Recommendations
		
		The SHAKE functions are recommended for most new uses. They can produce
		output of arbitrary length. SHAKE256, with an output length of at least
		64 bytes, provides 256-bit security against all attacks.  The Keccak team
		recommends it for most applications upgrading from SHA2-512. (NIST chose a
		much stronger, but much slower, sponge instance for SHA3-512.)
		
		The SHA-3 functions are "drop-in" replacements for the SHA-2 functions.
		They produce output of the same length, with the same security strengths
		against all attacks. This means, in particular, that SHA3-256 only has
		128-bit collision resistance, because its output length is 32 bytes.

	    hashes.go
	    hashes_noasm.go
	    keccakf_amd64.go
	    register.go
	    sha3.go
	    shake.go
	    shake_noasm.go
	    xor.go
	    keccakf_amd64.s


Package-Level Type Names (only one)


	/* sort by:  |  */
	
		ShakeHash defines the interface to hash functions that support
		arbitrary-length output. When used as a plain [hash.Hash], it
		produces minimum-length outputs that provide full-strength generic
		security.

		
			
				BlockSize returns the hash's underlying block size.
				The Write method must be able to accept any amount
				of data, but it may operate more efficiently if all writes
				are a multiple of the block size.

			
				Clone returns a copy of the ShakeHash in its current state.

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

			
				Size returns the number of bytes Sum will return.

			
				Sum appends the current hash to b and returns the resulting slice.
				It does not change the underlying hash state.

			( ShakeHash) Write([]byte) (int, error)
		
			 ShakeHash : hash.Hash
			 ShakeHash : internal/bisect.Writer
			 ShakeHash : io.Reader
			 ShakeHash : io.ReadWriter
			 ShakeHash : io.Writer
		
			func NewCShake128(N, S []byte) ShakeHash
			func NewCShake256(N, S []byte) ShakeHash
			func NewShake128() ShakeHash
			func NewShake256() ShakeHash
			func ShakeHash.Clone() ShakeHash




Package-Level Functions (total 16)


	
		New224 creates a new SHA3-224 hash.
		Its generic security strength is 224 bits against preimage attacks,
		and 112 bits against collision attacks.


	
		New256 creates a new SHA3-256 hash.
		Its generic security strength is 256 bits against preimage attacks,
		and 128 bits against collision attacks.


	
		New384 creates a new SHA3-384 hash.
		Its generic security strength is 384 bits against preimage attacks,
		and 192 bits against collision attacks.


	
		New512 creates a new SHA3-512 hash.
		Its generic security strength is 512 bits against preimage attacks,
		and 256 bits against collision attacks.


	
		NewCShake128 creates a new instance of cSHAKE128 variable-output-length ShakeHash,
		a customizable variant of SHAKE128.
		N is used to define functions based on cSHAKE, it can be empty when plain cSHAKE is
		desired. S is a customization byte string used for domain separation - two cSHAKE
		computations on same input with different S yield unrelated outputs.
		When N and S are both empty, this is equivalent to NewShake128.


	
		NewCShake256 creates a new instance of cSHAKE256 variable-output-length ShakeHash,
		a customizable variant of SHAKE256.
		N is used to define functions based on cSHAKE, it can be empty when plain cSHAKE is
		desired. S is a customization byte string used for domain separation - two cSHAKE
		computations on same input with different S yield unrelated outputs.
		When N and S are both empty, this is equivalent to NewShake256.


	
		NewLegacyKeccak256 creates a new Keccak-256 hash.
		
		Only use this function if you require compatibility with an existing cryptosystem
		that uses non-standard padding. All other users should use New256 instead.


	
		NewLegacyKeccak512 creates a new Keccak-512 hash.
		
		Only use this function if you require compatibility with an existing cryptosystem
		that uses non-standard padding. All other users should use New512 instead.


	
		NewShake128 creates a new SHAKE128 variable-output-length ShakeHash.
		Its generic security strength is 128 bits against all attacks if at
		least 32 bytes of its output are used.


	
		NewShake256 creates a new SHAKE256 variable-output-length ShakeHash.
		Its generic security strength is 256 bits against all attacks if
		at least 64 bytes of its output are used.


	
		ShakeSum128 writes an arbitrary-length digest of data into hash.


	
		ShakeSum256 writes an arbitrary-length digest of data into hash.


	
		Sum224 returns the SHA3-224 digest of the data.


	
		Sum256 returns the SHA3-256 digest of the data.


	
		Sum384 returns the SHA3-384 digest of the data.


	
		Sum512 returns the SHA3-512 digest of the data.