Struct NBitKeccakState

pub struct NBitKeccakState<T, const RATE: usize, const OUTPUT_SIZE: usize>
where
    T: Copy + Default,
{ /* private fields */ }

NBitKeccakState represents the state of a Keccak-nBits hashing process.

It holds intermediate hash calculations. However, it’s important to note that starting a hashing process from an arbitrary NBitKeccakState 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 NBitKeccakState extracted from a KeccakNBitsHasher should not be used with the expectation of continuing the hashing operation from where it left off in the original KeccakNBitsHasher. 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 Keccak-nBits hash operation:

let hello = b"hello";
let world = b" world";

const RATE: usize = 6;
const OUTPUT_SIZE: usize = 24;
let mut default_keccakhasher = NBitKeccakState::<u8, RATE, OUTPUT_SIZE>::default().build_hasher();

default_keccakhasher.write(hello);

let intermediate_state: NBitKeccakState<u8, RATE, OUTPUT_SIZE> = default_keccakhasher.clone().into();

default_keccakhasher.write(world);
let mut from_keccakstate: NBitKeccakHasher<u8, RATE, OUTPUT_SIZE> = intermediate_state.into();
from_keccakstate.write(world);

let default_hello_world_result = default_keccakhasher.finish();
let from_arbitrary_state_result = from_keccakstate.finish();
assert_ne!(default_hello_world_result, from_arbitrary_state_result);

Note

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

Trait Implementations

impl<T, const RATE: usize, const OUTPUT_SIZE: usize> BuildHasher for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: BitAnd + BitAndAssign + BitOr<NBitWord<T>, Output = NBitWord<T>> + BitXor<Output = T> + BitXorAssign + Copy + Default + Not<Output = T>, NBitWord<T>: From<u64> + LittleEndianBytes + Not<Output = NBitWord<T>> + Rotate + TSize<T>, u32: Sub<NBitWord<T>, Output = NBitWord<T>>,

type Hasher = NBitKeccakHasher<T, RATE, OUTPUT_SIZE>

Type of the hasher that will be created.

fn build_hasher(&self) -> Self::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<T, const RATE: usize, const OUTPUT_SIZE: usize> BytesLen for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: Copy + Default,

fn len() -> usize

impl<T, const RATE: usize, const OUTPUT_SIZE: usize> Clone for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: Copy + Default + Clone,

fn clone(&self) -> NBitKeccakState<T, RATE, OUTPUT_SIZE>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, const RATE: usize, const OUTPUT_SIZE: usize> Debug for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: Copy + Default + Debug,

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

Formats the value using the given formatter.

impl<T, const RATE: usize, const OUTPUT_SIZE: usize> Default for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: Copy + Default + Default,

fn default() -> NBitKeccakState<T, RATE, OUTPUT_SIZE>

Returns the “default value” for a type.

impl<T, const RATE: usize, const OUTPUT_SIZE: usize> ExtendedOutputFunction<OUTPUT_SIZE> for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: BitAnd + BitAndAssign + BitOr<NBitWord<T>, Output = NBitWord<T>> + BitXor<Output = T> + BitXorAssign + Copy + Default + Not<Output = T>, NBitWord<T>: From<u64> + LittleEndianBytes + Rotate + TSize<T>, u32: Sub<NBitWord<T>, Output = NBitWord<T>>,

fn squeeze_u64(&self) -> u64

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

Squeezes the output data from the sponge

impl<T, const RATE: usize, const OUTPUT_SIZE: usize> From<NBitKeccakHasher<T, RATE, OUTPUT_SIZE>> for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: Copy + Default + BitAnd + BitAndAssign + BitOr<NBitWord<T>, Output = NBitWord<T>> + BitXor<Output = T> + BitXorAssign + Not<Output = T>, NBitWord<T>: From<u64> + LittleEndianBytes + Not<Output = NBitWord<T>> + Rotate + TSize<T>, u32: Sub<NBitWord<T>, Output = NBitWord<T>>,

fn from(value: NBitKeccakHasher<T, RATE, OUTPUT_SIZE>) -> Self

Converts to this type from the input type.

impl<T, const RATE: usize, const OUTPUT_SIZE: usize> From<NBitKeccakState<T, RATE, OUTPUT_SIZE>> for ByteArrayWrapper<OUTPUT_SIZE>

where T: BitAnd + BitAndAssign + BitOr<NBitWord<T>, Output = NBitWord<T>> + BitXor<Output = T> + BitXorAssign + Copy + Default + Not<Output = T>, NBitWord<T>: From<u64> + LittleEndianBytes + Not + Rotate + TSize<T>, u32: Sub<NBitWord<T>, Output = NBitWord<T>>,

fn from(value: NBitKeccakState<T, RATE, OUTPUT_SIZE>) -> Self

Converts to this type from the input type.

impl<T, const RATE: usize, const OUTPUT_SIZE: usize> From<NBitKeccakState<T, RATE, OUTPUT_SIZE>> for NBitKeccakHasher<T, RATE, OUTPUT_SIZE>

where T: Copy + Default + BitAnd + BitAndAssign + BitOr<NBitWord<T>, Output = NBitWord<T>> + BitXor<Output = T> + BitXorAssign + Not<Output = T>, NBitWord<T>: From<u64> + LittleEndianBytes + Not<Output = NBitWord<T>> + Rotate + TSize<T>, u32: Sub<NBitWord<T>, Output = NBitWord<T>>,

fn from(value: NBitKeccakState<T, RATE, OUTPUT_SIZE>) -> Self

Converts to this type from the input type.

impl<T, const RATE: usize, const OUTPUT_SIZE: usize> Hash for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: Copy + Default + Hash,

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

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<T, const RATE: usize, const OUTPUT_SIZE: usize> HashAlgorithm for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: BitAnd + BitAndAssign + BitOr<NBitWord<T>, Output = NBitWord<T>> + BitXor<Output = T> + BitXorAssign + Copy + Default + Not<Output = T>, NBitWord<T>: From<u64> + LittleEndianBytes + Not<Output = NBitWord<T>> + Rotate + TSize<T>, u32: Sub<NBitWord<T>, Output = NBitWord<T>>,

type Padding = GenericPad<KeccakU128Size, RATE, 31>

type Output = ByteArrayWrapper<OUTPUT_SIZE>

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

fn state_to_u64(&self) -> u64

impl<T, const RATE: usize, const OUTPUT_SIZE: usize> PartialEq for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: Copy + Default + PartialEq,

fn eq(&self, other: &NBitKeccakState<T, RATE, OUTPUT_SIZE>) -> bool

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

const 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<T, const RATE: usize, const OUTPUT_SIZE: usize> Eq for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: Copy + Default + Eq,

impl<T, const RATE: usize, const OUTPUT_SIZE: usize> StructuralPartialEq for NBitKeccakState<T, RATE, OUTPUT_SIZE>

where T: Copy + Default,