Trait HashEngine

pub trait HashEngine: Clone + Default {
    type Digest: Copy + Clone + PartialEq + Eq + PartialOrd + Ord + Hash + AsRef<[u8]>;
    type Midstate;

    const BLOCK_SIZE: usize;

    // Required methods
    fn input(&mut self, data: &[u8]);
    fn n_bytes_hashed(&self) -> usize;
    fn finalize(self) -> Self::Digest;
    fn midstate(&self) -> Self::Midstate;
    fn from_midstate(midstate: Self::Midstate, length: usize) -> Self;

    // Provided methods
    fn new() -> Self { ... }
    fn hash(bytes: &[u8]) -> Self::Digest { ... }
    fn hash_byte_chunks<B, I>(byte_slices: I) -> Self::Digest
       where B: AsRef<[u8]>,
             I: IntoIterator<Item = B> { ... }
}

A hashing engine which bytes can be serialized into.

Required Associated Constants

const BLOCK_SIZE: usize

Length of the hash’s internal block size, in bytes.

Required Associated Types

type Digest: Copy + Clone + PartialEq + Eq + PartialOrd + Ord + Hash + AsRef<[u8]>

The digest returned by this hash engine.

This is expected to be an array.

type Midstate

Byte array representing the internal state of the hash engine.

Required Methods

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

Add data to the hash engine.

fn n_bytes_hashed(&self) -> usize

Return the number of bytes already n_bytes_hashed(inputted).

fn finalize(self) -> Self::Digest

Returns the final digest from the current state of the hash engine.

fn midstate(&self) -> Self::Midstate

Outputs the midstate of the hash engine. This function should not be used directly unless you really know what you’re doing.

fn from_midstate(midstate: Self::Midstate, length: usize) -> Self

Create a new HashEngine from a Self::Midstate.

Only use this function if you know what you are doing.

Provided Methods

fn new() -> Self

Creates a new hash engine.

fn hash(bytes: &[u8]) -> Self::Digest

Creates a default hash engine, adds bytes to it, then finalizes the engine.

Returns

The digest created by hashing bytes with engine’s hashing algorithm.

fn hash_byte_chunks<B, I>(byte_slices: I) -> Self::Digest

where B: AsRef<[u8]>, I: IntoIterator<Item = B>,

Hashes all the byte slices retrieved from the iterator together.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl HashEngine for chf::ripemd160::Engine

const BLOCK_SIZE: usize = 64usize

type Digest = [u8; 20]

type Midstate = [u8; 20]

impl HashEngine for chf::sha1::Engine

const BLOCK_SIZE: usize = 64usize

type Digest = [u8; 20]

type Midstate = [u8; 20]

impl HashEngine for chf::sha256::Engine

const BLOCK_SIZE: usize = 64usize

type Digest = [u8; 32]

type Midstate = Midstate

impl HashEngine for chf::sha384::Engine

const BLOCK_SIZE: usize = 128usize

type Digest = [u8; 48]

type Midstate = [u8; 64]

impl HashEngine for chf::sha512::Engine

const BLOCK_SIZE: usize = 128usize

type Digest = [u8; 64]

type Midstate = [u8; 64]

impl HashEngine for chf::sha512_256::Engine

const BLOCK_SIZE: usize = 128usize

type Digest = [u8; 32]

type Midstate = [u8; 64]

impl HashEngine for chf::siphash24::Engine

const BLOCK_SIZE: usize = 32usize

type Digest = [u8; 8]

type Midstate = State

impl<E: HashEngine> HashEngine for chf::hmac::Engine<E>

const BLOCK_SIZE: usize = E::BLOCK_SIZE

type Digest = <E as HashEngine>::Digest

type Midstate = Midstate<E>

impl<T: Tag> HashEngine for chf::sha256t::Engine<T>

const BLOCK_SIZE: usize = 64usize

type Digest = [u8; 32]

type Midstate = Midstate