Struct Sponge 

pub struct Sponge<S, T, const W: usize>
where
    S: Safe<T, W>,
    T: Default + Copy + Zeroize,
{ /* private fields */ }

Struct that implements the Sponge API over field elements.

The capacity is fixed to one field element and the rate are W - 1 field elements.

Implementations

impl<S, T, const W: usize> Sponge<S, T, W>

where S: Safe<T, W>, T: Default + Copy + Zeroize,

pub fn start( safe: S, iopattern: impl Into<Vec<Call>>, domain_sep: u64, ) -> Result<Self, Error>

This initializes the sponge, setting the first element of the state to the Safe::tag() and the other elements to the default value of T. It’s done once in the lifetime of a sponge.

Parameters

• safe: The sponge safe implementation.
• iopattern: The IO-pattern for the sponge.
• domain_sep: The domain separator to be used.

Returns

A result containing the initialized Sponge on success, or an Error if the IO-pattern is invalid.

pub fn finish(self) -> Result<Vec<T>, Error>

This marks the end of the sponge life, preventing any further operation. In particular, the state is erased from memory.

Returns

A result containing the output vector on success, or an Error if the IO-pattern wasn’t followed.

pub fn absorb( &mut self, len: usize, input: impl AsRef<[T]>, ) -> Result<(), Error>

This absorbs len field elements from the input into the state with interleaving calls to the permutation function. It also checks if the call matches the IO-pattern.

Parameters

• len: The number of field elements to absorb.
• input: The input slice of field elements.

Returns

A result indicating success if the operation completes, or an Error if the IO-pattern wasn’t followed.

pub fn squeeze(&mut self, len: usize) -> Result<(), Error>

This extracts len field elements from the state with interleaving calls to the permutation function. It also checks if the call matches the IO-pattern.

Parameters

• len: The number of field elements to squeeze.

Returns

A result indicating success if the operation completes, or an Error if the IO-pattern wasn’t followed.

Trait Implementations

impl<S, T, const W: usize> Clone for Sponge<S, T, W>

where S: Safe<T, W> + Clone, T: Default + Copy + Zeroize + Clone,

fn clone(&self) -> Sponge<S, T, W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S, T, const W: usize> Debug for Sponge<S, T, W>

where S: Safe<T, W> + Debug, T: Default + Copy + Zeroize + Debug,

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

Formats the value using the given formatter.

impl<S, T, const W: usize> Drop for Sponge<S, T, W>

where S: Safe<T, W>, T: Default + Copy + Zeroize,

fn drop(&mut self)

Executes the destructor for this type.

impl<S, T, const W: usize> PartialEq for Sponge<S, T, W>

where S: Safe<T, W> + PartialEq, T: Default + Copy + Zeroize + PartialEq,

fn eq(&self, other: &Sponge<S, T, W>) -> 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<S, T, const W: usize> Zeroize for Sponge<S, T, W>

where S: Safe<T, W>, T: Default + Copy + Zeroize,

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl<S, T, const W: usize> StructuralPartialEq for Sponge<S, T, W>

where S: Safe<T, W>, T: Default + Copy + Zeroize,