Struct Pad10Sponge 

pub struct Pad10Sponge<T, P, D, const WIDTH: usize, const RATE: usize, const OUT: usize> { /* private fields */ }

An overwrite-mode sponge with 10-padding.

Absorbs input into the rate, permutes after each full block, and squeezes OUT elements. Two-case padding ensures collision resistance for inputs of variable length.

Padding Rule

Case 1 – partial block (input ends at position i < RATE):

    Sentinel at position i, zeros after, then permute.

    [a]    RATE=2:  [a, S, 0, ... | cap...]  -> P
    [a, 0] RATE=2:  [a, 0, S, ... | cap...]  -> P
                          ^
                          different position => no collision

Case 2 – full block (input length is a multiple of RATE):

    Add sentinel to first capacity element, then permute.

    [a, b] RATE=2:  [a, b | cap_0 + S, cap_1, ...]  -> P

Sentinel lands in rate (case 1) vs capacity (case 2), so no length-k input can collide with any length != k.

Role of the Derangement

The padding function is a derangement d: a permutation with no fixed points (d(x) != x for all x). This guarantees:

• Rate-domain: d(0) != 0, so the sentinel is always non-zero.
• Capacity-domain: d(state[RATE]) != state[RATE], so the capacity always changes.

    Partial:  state[i]    = d(0)           -- sentinel
    Full:     state[RATE] = d(state[RATE]) -- domain separator

Construction

The padding function is a derangement (permutation with no fixed points). The standard choice is Increment which computes d(x) = x + 1:

Pad10Sponge::new(permutation, Increment(BabyBear::ONE))  // field
Pad10Sponge::new(permutation, Increment(1u64))           // integer

The derangement must have no fixed points (d(x) != x for all x).

Parameters

• WIDTH – total state size (rate + capacity).
• RATE – positions overwritten per block.
• OUT – elements squeezed from the final state.

Security

Indifferentiable from a random oracle up to |F|^{c/2} queries (c = WIDTH - RATE).

Implies collision resistance, preimage resistance, etc. [BDPA08] + [LBM25, Section 3.1].

Implementations

impl<T, P, D, const WIDTH: usize, const RATE: usize, const OUT: usize> Pad10Sponge<T, P, D, WIDTH, RATE, OUT>

pub const fn new(permutation: P, padding_derangement: D) -> Self

Trait Implementations

impl<T, P: Clone, D: Clone, const WIDTH: usize, const RATE: usize, const OUT: usize> Clone for Pad10Sponge<T, P, D, WIDTH, RATE, OUT>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, P: Copy, D: Copy, const WIDTH: usize, const RATE: usize, const OUT: usize> Copy for Pad10Sponge<T, P, D, WIDTH, RATE, OUT>

impl<T, P, D, const WIDTH: usize, const RATE: usize, const OUT: usize> CryptographicHasher<T, [T; OUT]> for Pad10Sponge<T, P, D, WIDTH, RATE, OUT>

where T: Default + Copy, P: CryptographicPermutation<[T; WIDTH]>, D: Derangement<T>,

fn hash_iter<I>(&self, input: I) -> [T; OUT]

where I: IntoIterator<Item = T>,

Hash an iterator of input items.

fn hash_iter_slices<'a, I>(&self, input: I) -> Out

where I: IntoIterator<Item = &'a [Item]>, Item: 'a,

Hash an iterator of slices, by flattening it into a single stream of items.

fn hash_slice(&self, input: &[Item]) -> Out

Hash a single slice of items.

fn hash_item(&self, input: Item) -> Out

Hash a single item.

impl<T: Debug, P: Debug, D: Debug, const WIDTH: usize, const RATE: usize, const OUT: usize> Debug for Pad10Sponge<T, P, D, WIDTH, RATE, OUT>

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

Formats the value using the given formatter.