Struct HalftimeHash16 

pub struct HalftimeHash16 { /* private fields */ }

Almost-universal hash with a 16-byte tag (HalftimeHash16, Section 4).

Implementations

impl HalftimeHash16

pub const TAG_BYTES: usize = hh16::TAG_BYTES

Tag width in bytes.

pub fn digest(key: &Key<Self>, data: &[u8]) -> Block<Self>

Hash data in one shot with a 32-byte RustCrypto key (NH KDF entropy).

pub fn from_master_key(key: &impl MasterKey) -> Self

Construct from any supported master key ([Key32], [Key64], [Key128]).

A 32-byte key is expanded into input entropy with NH on demand (convenient KDF). Longer keys are folded to 32 bytes with NH before expansion.

pub fn digest_master_key(key: &impl MasterKey, data: &[u8]) -> Block<Self>

One-shot hash with a master key of any supported length.

pub fn with_entropy(entropy: &[u64]) -> Result<Self, EntropyTooShort>

Construct with caller-supplied input entropy (C++ reference style).

The buffer must hold at least Self::entropy_words_needed words for the maximum message length you will hash (defaults to 1 MiB).

pub fn with_entropy_for( entropy: &[u64], max_input_bytes: usize, ) -> Result<Self, EntropyTooShort>

Like Self::with_entropy, but validate for a specific maximum message size.

pub fn digest_with_entropy( entropy: &[u64], data: &[u8], ) -> Result<Block<Self>, EntropyTooShort>

One-shot hash with external entropy sized for data.len().

pub fn entropy_words_needed(input_bytes: usize) -> usize

Number of u64 entropy words required to hash up to input_bytes of message data.

Trait Implementations

impl BlockSizeUser for HalftimeHash16

type BlockSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>

Size of the block in bytes.

fn block_size() -> usize

Return block size in bytes.

impl Debug for HalftimeHash16

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

Formats the value using the given formatter.

impl KeyInit for HalftimeHash16

fn new(key: &Key<Self>) -> Self

32-byte key; entropy is expanded on demand via NH (see Self::from_master_key).

fn new_from_slice(key: &[u8]) -> Result<Self, InvalidLength>

Create new value from variable size key.

impl KeySizeUser for HalftimeHash16

type KeySize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>

Key size in bytes.

fn key_size() -> usize

Return key size in bytes.

impl UniversalHash for HalftimeHash16

fn update_with_backend( &mut self, f: impl UhfClosure<BlockSize = Self::BlockSize>, )

Update hash function state using the provided rank-2 closure.

fn update_padded(&mut self, data: &[u8])

Input data into the universal hash function. If the length of the data is not a multiple of the block size, the remaining data is padded with zeroes up to the BlockSize.

fn finalize(self) -> Block<Self>

Retrieve result and consume hasher instance.

fn update(&mut self, blocks: &[Array<u8, Self::BlockSize>])

Update hash function state with the provided block.

fn verify(self, expected: &Array<u8, Self::BlockSize>) -> Result<(), Error>

Verify the UniversalHash of the processed input matches a given expected value.