Struct Shake256State

pub struct Shake256State<const OUTPUT_SIZE: usize> { /* private fields */ }

Shake256State represents the state of a SHAKE256 hashing process.

It holds intermediate hash calculations. However, it’s important to note that starting a hashing process from an arbitrary Shake256State is not equivalent to resuming the original process that produced that state. Instead, it begins a new hashing process with a different set of initial values.

Therefore, a Shake256State extracted from a Shake256Hasher should not be used with the expectation of continuing the hashing operation from where it left off in the original Shake256Hasher. It is a snapshot of a particular point in the process, not a means to resume the process.

Example

This example demonstrates how to persist the state of a SHAKE256 hash operation:

let hello = b"hello";
let world = b" world";
let default_shake256state = Shake256State::<32>::default();

let mut default_shake256hasher = default_shake256state.build_hasher();
default_shake256hasher.write(hello);

let intermediate_state: Shake256State<32> = default_shake256hasher.clone().into();

default_shake256hasher.write(world);

let mut from_shake256state: Shake256Hasher<32> = intermediate_state.into();
from_shake256state.write(world);

let default_hello_world_result = default_shake256hasher.finish();
let from_arbitrary_state_result = from_shake256state.finish();
assert_ne!(default_hello_world_result, from_arbitrary_state_result);

Note

In this example, even though the internal states are the same between default_shake256hasher and from_shake256state before the Hasher::finish_xof call, the results are different due to from_shake256state being instantiated with an empty pad while the default_shake256hasher’s pad is already populated with b"hello".

Trait Implementations

impl<const OUTPUT_SIZE: usize> BuildHasher for Shake256State<OUTPUT_SIZE>

type Hasher = Shake256Hasher<OUTPUT_SIZE>

Type of the hasher that will be created.

fn build_hasher(&self) -> <Shake256State<OUTPUT_SIZE> as BuildHasher>::Hasher

Creates a new hasher.

fn hash_one<T>(&self, x: T) -> u64

where T: Hash, Self: Sized, Self::Hasher: Hasher,

Calculates the hash of a single value.

impl<const OUTPUT_SIZE: usize> BytesLen for Shake256State<OUTPUT_SIZE>

fn len() -> usize

impl<const OUTPUT_SIZE: usize> Clone for Shake256State<OUTPUT_SIZE>

fn clone(&self) -> Shake256State<OUTPUT_SIZE>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const OUTPUT_SIZE: usize> Debug for Shake256State<OUTPUT_SIZE>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<const OUTPUT_SIZE: usize> Default for Shake256State<OUTPUT_SIZE>

fn default() -> Shake256State<OUTPUT_SIZE>

Returns the “default value” for a type.

impl<const OUTPUT_SIZE: usize> ExtendedOutputFunction<OUTPUT_SIZE> for Shake256State<OUTPUT_SIZE>

fn squeeze_u64(&self) -> u64

fn squeeze(&mut self) -> [u8; OUTPUT_SIZE]

Squeezes the output data from the sponge

impl<const OUTPUT_SIZE: usize> From<Shake256Hasher<OUTPUT_SIZE>> for Shake256State<OUTPUT_SIZE>

fn from(value: Shake256Hasher<OUTPUT_SIZE>) -> Shake256State<OUTPUT_SIZE>

Converts to this type from the input type.

impl<const OUTPUT_SIZE: usize> From<Shake256State<OUTPUT_SIZE>> for Shake256Hasher<OUTPUT_SIZE>

fn from(value: Shake256State<OUTPUT_SIZE>) -> Shake256Hasher<OUTPUT_SIZE>

Converts to this type from the input type.

impl<const OUTPUT_SIZE: usize> Hash for Shake256State<OUTPUT_SIZE>

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const OUTPUT_SIZE: usize> HashAlgorithm for Shake256State<OUTPUT_SIZE>

type Padding = GenericPad<KeccakU128Size, rs_shake256::::shake256state::{impl#4}::Padding::{constant#1}, 31>

type Output = ByteArrayWrapper<OUTPUT_SIZE>

fn hash_block(&mut self, bytes: &[u8])

fn state_to_u64(&self) -> u64

impl<const OUTPUT_SIZE: usize> PartialEq for Shake256State<OUTPUT_SIZE>

fn eq(&self, other: &Shake256State<OUTPUT_SIZE>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const OUTPUT_SIZE: usize> Eq for Shake256State<OUTPUT_SIZE>

impl<const OUTPUT_SIZE: usize> StructuralPartialEq for Shake256State<OUTPUT_SIZE>