Struct SHAKE 

pub struct SHAKE<PARAMS: SHAKEParams> { /* private fields */ }

Note: FIPS 202 section 7 states:

“SHAKE128 and SHAKE256 are approved XOFs, whose approved uses will be specified in NIST Special Publications. Although some of those uses may overlap with the uses of approved hash functions, the XOFs are not approved as hash functions, due to the property that is discussed in Sec. A.2.”

Section A.2 describes how SHAKE does not internally diversify its output based on the requested length. For example, the first 32 bytes of SHAKE128(“message”, 64) and SHAKE128(“message”, 128), will be identical and equal to SHAKE128(“message”, 32). Proper hash functions don’t do this, and NIST is concerned that this could lead to application vulnerabilities.

As such, even though SHAKE is physically capable of acting as a hash function, and in fact is secure as such if the provided message includes the requested length, SHAKE does not implement the Hash trait.

Implementations

impl<PARAMS: SHAKEParams> SHAKE<PARAMS>

pub fn new() -> Self

Trait Implementations

impl<PARAMS: SHAKEParams> Algorithm for SHAKE<PARAMS>

const ALG_NAME: &'static str = PARAMS::ALG_NAME

const MAX_SECURITY_STRENGTH: SecurityStrength = PARAMS::MAX_SECURITY_STRENGTH

impl<PARAMS: Clone + SHAKEParams> Clone for SHAKE<PARAMS>

fn clone(&self) -> SHAKE<PARAMS>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<PARAMS: SHAKEParams> Default for SHAKE<PARAMS>

fn default() -> Self

Returns the “default value” for a type.

impl<PARAMS: SHAKEParams> KDF for SHAKE<PARAMS>

fn derive_key( self, key: &impl KeyMaterial, additional_input: &[u8], ) -> Result<Box<dyn KeyMaterial>, KDFError>

Returns a KeyMaterialInternal. For the KDF to be considered “fully-seeded” and be capable of outputting full-entropy KeyMaterials, it requires full-entropy input that is at least 2x the bit size (ie 256 bits for SHAKE128, and 512 bits for SHAKE256). Returns a 32 byte key for SHAKE128 and a 64 byte key for SHAKE256. To produce longer keys, use KDF::derive_key_out. To produce shorter keys, either use KDF::derive_key_out or truncate this result down with KeyMaterialInternal::truncate.

fn derive_key_from_multiple( self, keys: &[&impl KeyMaterial], additional_input: &[u8], ) -> Result<Box<dyn KeyMaterial>, KDFError>

Always returns a full KeyMaterialInternal; ie that fills the internal buffer of the appropriately-sized key material for the underlying cryptographic hash function. This can be truncated down with KeyMaterialInternal::truncate. Returns a 32 byte key for SHAKE128 and a 64 byte key for SHAKE256. To produce longer keys, use KDF::derive_key_out. To produce shorter keys, either use KDF::derive_key_out or truncate this result down with KeyMaterialInternal::truncate.

fn derive_key_out( self, key: &impl KeyMaterial, additional_input: &[u8], output_key: &mut impl KeyMaterial, ) -> Result<usize, KDFError>

Same as KDF::derive_key, but fills the provided output KeyMaterialInternal.

fn derive_key_from_multiple_out( self, keys: &[&impl KeyMaterial], additional_input: &[u8], output_key: &mut impl KeyMaterial, ) -> Result<usize, KDFError>

Same as KDF::derive_key, but fills the provided output KeyMaterialInternal.

fn max_security_strength(&self) -> SecurityStrength

Returns the maximum security strength that this KDF is capable of supporting, based on the underlying primitives.

impl<PARAMS: SHAKEParams> XOF for SHAKE<PARAMS>

fn absorb_last_partial_byte( &mut self, partial_byte: u8, num_partial_bits: usize, ) -> Result<(), HashError>

Switches to squeezing.

fn squeeze(&mut self, num_bytes: usize) -> Result<Vec<u8>, HashError>

Is infallible.

fn squeeze_out(&mut self, output: &mut [u8]) -> Result<usize, HashError>

Is infallible.

fn squeeze_partial_byte_final_out( self, num_bits: usize, output: &mut u8, ) -> Result<(), HashError>

Result is the number of bits squezed into output.

fn hash_xof(self, data: &[u8], result_len: usize) -> Vec<u8>

A static one-shot API that digests the input data and produces result_len bytes of output.

fn hash_xof_out(self, data: &[u8], output: &mut [u8]) -> usize

A static one-shot API that digests the input data and produces result_len bytes of output. Fills the provided output slice.

fn absorb(&mut self, data: &[u8]) -> Result<(), HashError>

fn squeeze_partial_byte_final(self, num_bits: usize) -> Result<u8, HashError>

Squeezes a partial byte from the XOF. Output will be in the top num_bits bits of the returned u8 (ie Big Endian). This is a final call and consumes self.

fn max_security_strength(&self) -> SecurityStrength

Returns the maximum security strength that this KDF is capable of supporting, based on the underlying primitives.