Struct ParallelHash128 

pub struct ParallelHash128;

SP 800-185 ParallelHash128: hashes fixed-size blocks independently, then hashes their digests.

The structure is designed so the per-block work can be spread across cores. This implementation does them in order — the workspace has no threading and no_std targets have no threads to spread onto — so what it buys here is interoperability with implementations that do, not speed. The output is identical either way.

Implementations

impl ParallelHash128

pub const CHAINING_LEN: usize = 32

Width of each block’s inner digest, in bytes.

pub fn hash(custom: &[u8], block_size: usize, data: &[u8], out: &mut [u8])

Hash data in blocks of block_size bytes.

block_size must be at least one. SP 800-185 places no upper bound on it, and neither does this.

pub fn hash_xof(custom: &[u8], block_size: usize, data: &[u8], out: &mut [u8])

As Self::hash, in XOF mode.

Trait Implementations

impl Algorithm for ParallelHash128

const ID: &'static str = "parallelhash128"

Stable ontology identifier for this algorithm.

const NAME: &'static str = "ParallelHash128"

Human-facing display name (for example "SHA-256").

impl SelfTest for ParallelHash128

fn self_test() -> Result<()>

The block size is bound into the result, and the whole thing is deterministic. A build that dropped left_encode(B) would give the same answer for every block size, which is what this catches.