Struct HMAC 

pub struct HMAC<HASH: Hash + Default, const KEY_BUF_LEN: usize = LARGEST_HASHER_BLOCK_LEN> { /* private fields */ }

Internal struct for HKDF. HMAC implements RFC 2104. Can, in theory, be instantiated with hash functions other than the ones provided by this crate (even custom ones).

Implementations

impl HMAC<SHA224, 64>

pub fn keygen() -> Result<KeyMaterial<28>, RNGError>

Generate a key of the appropriate length for the given HMAC

impl HMAC<SHA256, 64>

pub fn keygen() -> Result<KeyMaterial<32>, RNGError>

Generate a key of the appropriate length for the given HMAC

impl HMAC<SHA384, 128>

pub fn keygen() -> Result<KeyMaterial<48>, RNGError>

Generate a key of the appropriate length for the given HMAC

impl HMAC<SHA512, 128>

pub fn keygen() -> Result<KeyMaterial<64>, RNGError>

Generate a key of the appropriate length for the given HMAC

impl HMAC<SHA3_224, 144>

pub fn keygen() -> Result<KeyMaterial<28>, RNGError>

Generate a key of the appropriate length for the given HMAC

impl HMAC<SHA3_256, 136>

pub fn keygen() -> Result<KeyMaterial<32>, RNGError>

Generate a key of the appropriate length for the given HMAC

impl HMAC<SHA3_384, 104>

pub fn keygen() -> Result<KeyMaterial<48>, RNGError>

Generate a key of the appropriate length for the given HMAC

impl HMAC<SHA3_512, 72>

pub fn keygen() -> Result<KeyMaterial<64>, RNGError>

Generate a key of the appropriate length for the given HMAC

Trait Implementations

impl<HASH: Clone + Hash + Default, const KEY_BUF_LEN: usize> Clone for HMAC<HASH, KEY_BUF_LEN>

fn clone(&self) -> HMAC<HASH, KEY_BUF_LEN>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<HASH: Hash + Default, const KEY_BUF_LEN: usize> Debug for HMAC<HASH, KEY_BUF_LEN>

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

Formats the value using the given formatter.

impl<HASH: Hash + Default, const KEY_BUF_LEN: usize> Display for HMAC<HASH, KEY_BUF_LEN>

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

Formats the value using the given formatter.

impl<HASH: Hash + Default, const KEY_BUF_LEN: usize> MAC for HMAC<HASH, KEY_BUF_LEN>

fn new(key: &impl KeyMaterialTrait) -> Result<Self, MACError>

Create a new MAC instance with the given key.

fn new_allow_weak_key(key: &impl KeyMaterialTrait) -> Result<Self, MACError>

Create a new HMAC instance with the given key.

fn output_len(&self) -> usize

The size of the output in bytes.

fn mac(self, data: &[u8]) -> Vec<u8>

One-shot API that computes a MAC for the provided data. data can be of any length, including zero bytes.

fn mac_out(self, data: &[u8], out: &mut [u8]) -> Result<usize, MACError>

One-shot API that computes a MAC for the provided data and writes it into the provided output slice. data can be of any length, including zero bytes.

fn verify(self, data: &[u8], mac: &[u8]) -> bool

One-shot API that verifies a MAC for the provided data. data can be of any length, including zero bytes.

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

Provide a chunk of data to be absorbed into the MAC. data can be of any length, including zero bytes. do_update() is intended to be used as part of a streaming interface, and so may by called multiple times.

fn do_final(self) -> Vec<u8>

Finish absorbing input and produce the MAC value.

fn do_final_out(self, out: &mut [u8]) -> Result<usize, MACError>

Depending on the underlying MAC implementation, NIST may require that the library enforce a minimum length on the mac output value. See documentation for the underlying implementation to see conditions under which it throws MACError::InvalidLength.

fn do_verify_final(self, mac: &[u8]) -> bool

Internally, this will re-compute the MAC value and then compare it to the provided mac value using constant-time comparison. It is highly encouraged to use this utility function instead of comparing mac values for equality yourself.

fn max_security_strength(&self) -> SecurityStrength

Returns the maximum security strength that this KDF is capable of supporting, based on the underlying primitives.

impl<const HASH_STATE_LEN: usize, const KEY_BUF_LEN: usize, HASH: Hash + Default + Suspendable<HASH_STATE_LEN>> SuspendableKeyed<HASH_STATE_LEN> for HMAC<HASH, KEY_BUF_LEN>

HMAC is a keyed algorithm, so it implements SuspendableKeyed (rather than Suspendable) for suspending and resuming in-progress operations. The key is deliberately NOT written into the serialized bytes and must be re-supplied at deserialization.

The serialized state is exactly the inner hasher’s state (which has already absorbed K ⊕ ipad and any message chunks provided so far) — so this is a straight passthrough to the underlying hash’s Suspendable impl. The re-supplied key is needed to reconstruct the material for the outer (K ⊕ opad) step at finalization.

There is no way to detect a mismatched key on resume: the caller MUST supply the same key the HMAC was created with, otherwise the resumed operation will silently produce an incorrect MAC.

type Key = dyn KeyMaterialTrait

The type of key that must be re-supplied to resume this object.

fn suspend(self) -> [u8; HASH_STATE_LEN]

Suspend operation by serializing out the state of the object.

fn from_suspended( state: [u8; HASH_STATE_LEN], key: &Self::Key, ) -> Result<Self, SuspendableError>

Resume operation from a serialized state and the key.