Struct blake3::Hasher

pub struct Hasher { /* fields omitted */ }

An incremental hash state that can accept any number of writes.

In addition to its inherent methods, this type implements several commonly used traits from the digest and crypto_mac crates.

Methods

impl Hasher

pub fn new() -> Self

Construct a new Hasher for the regular hash function.

pub fn new_keyed(key: &[u8; 32]) -> Self

Construct a new Hasher for the keyed hash function. See keyed_hash.

pub fn new_derive_key(context: &str) -> Self

Construct a new Hasher for the key derivation function. See derive_key. The context string should be hardcoded, globally unique, and application-specific.

pub fn reset(&mut self) -> &mut Self

Reset the Hasher to its initial state.

This is functionally the same as overwriting the Hasher with a new one, using the same key or context string if any. However, depending on how much inlining the optimizer does, moving a Hasher might copy its entire CV stack, most of which is useless uninitialized bytes. This methods avoids that copy.

pub fn update(&mut self, input: &[u8]) -> &mut Self

Add input bytes to the hash state. You can call this any number of times.

Note that the degree of SIMD and multi-threading parallelism that Hasher can use is limited by the size of this input buffer. The 8 KiB buffer currently used by std::io::copy is enough to leverage AVX2, for example, but not enough to leverage AVX-512. If multi-threading is enabled (the rayon feature), the optimal input buffer size will vary considerably across different CPUs, and it may be several mebibytes.

pub fn finalize(&self) -> Hash

Finalize the hash state and return the Hash of the input.

This method is idempotent. Calling it twice will give the same result. You can also add more input and finalize again.

Important traits for OutputReader

impl Read for OutputReader

pub fn finalize_xof(&self) -> OutputReader

Finalize the hash state and return an OutputReader, which can supply any number of output bytes.

This method is idempotent. Calling it twice will give the same result. You can also add more input and finalize again.

Trait Implementations

impl BlockInput for Hasher

type BlockSize = U64

impl Clone for Hasher

Important traits for Hasher

impl Write for Hasher

fn clone(&self) -> Hasher

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Hasher

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

Formats the value using the given formatter.

impl Default for Hasher

fn default() -> Self

Returns the "default value" for a type.

impl ExtendableOutput for Hasher

type Reader = OutputReader

fn xof_result(self) -> Self::Reader

Retrieve XOF reader and consume hasher instance.

fn vec_result(self, n: usize) -> Vec<u8>

Retrieve result into vector of specified length.

impl FixedOutput for Hasher

type OutputSize = U32

fn fixed_result(self) -> GenericArray<u8, Self::OutputSize>

Retrieve result and consume hasher instance.

impl Input for Hasher

fn input<B: AsRef<[u8]>>(&mut self, data: B)

Digest input data.

fn chain<B>(self, data: B) -> Self where
    B: AsRef<[u8]>, 

Digest input data in a chained manner.

impl Mac for Hasher

type OutputSize = U32

type KeySize = U32

fn new(key: &GenericArray<u8, Self::KeySize>) -> Self

Create new MAC instance from key with fixed size.

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

Process input data.

fn reset(&mut self)

Reset Mac instance.

fn result(self) -> MacResult<Self::OutputSize>

Obtain the result of a Mac computation as a MacResult and consume Mac instance.

fn new_varkey(key: &[u8]) -> Result<Self, InvalidKeyLength>

Create new MAC instance from key with variable size.

fn result_reset(&mut self) -> MacResult<Self::OutputSize>

Obtain the result of a Mac computation as a MacResult and reset Mac instance.

fn verify(self, code: &[u8]) -> Result<(), MacError>

Check if code is correct for the processed input.

impl Reset for Hasher

fn reset(&mut self)

Reset hasher instance to its initial state and return current state.

impl Write for Hasher

fn write(&mut self, input: &[u8]) -> Result<usize>

This is equivalent to update.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.