Struct ring::digest::Algorithm

pub struct Algorithm {
    output_len: usize,
    chaining_len: usize,
    block_len: usize,
    len_len: usize,
    block_data_order: unsafe extern "C" fn(state: &mut State, data: *const u8, num: usize),
    format_output: fn(input: State) -> Output,
    initial_state: State,
    id: AlgorithmID,
}

A digest algorithm.

Fields

output_len: usize

chaining_len: usize

block_len: usize

len_len: usize

The length of the length in the padding.

block_data_order: unsafe extern "C" fn(state: &mut State, data: *const u8, num: usize)

format_output: fn(input: State) -> Output

initial_state: State

id: AlgorithmID

Implementations

impl Algorithm

pub fn block_len(&self) -> usize

The internal block length.

pub fn chaining_len(&self) -> usize

The size of the chaining value of the digest function, in bytes.

For non-truncated algorithms (SHA-1, SHA-256, SHA-512), this is equal to Self::output_len(). For truncated algorithms (e.g. SHA-384, SHA-512/256), this is equal to the length before truncation. This is mostly helpful for determining the size of an HMAC key that is appropriate for the digest algorithm.

pub fn output_len(&self) -> usize

The length of a finalized digest.

Trait Implementations

impl Debug for Algorithm

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

Formats the value using the given formatter.

impl PartialEq<Algorithm> for Algorithm

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Algorithm