Struct Sha224Hasher

pub struct Sha224Hasher(/* private fields */);

Sha224Hasher is a type that provides the SHA-224 hashing algorithm in RustyShield.

A “Hasher” in the context of cryptographic hashing refers to the object that manages the process of converting input data into a fixed-size sequence of bytes. The Hasher is responsible for maintaining the internal state of the hashing process and providing methods to add more data and retrieve the resulting hash.

The Sha224Hasher struct adheres to Rust’s Hasher trait, enabling you to use it interchangeably with other hashers in Rust. It can be used anywhere a type implementing Hasher is required.

Examples

The following examples demonstrate using Sha1Hasher with both Hash and Hasher, and from where the difference comes from:

 let data = b"hello";

 // Using Hash
 let mut sha224hasher = Sha224Hasher::default();
 data.hash(&mut sha224hasher);
 let result_via_hash = sha224hasher.finish();

 // Using Hasher
 let mut sha224hasher = Sha224Hasher::default();
 sha224hasher.write(data);
 let result_via_hasher = sha224hasher.finish();

 // Simulating the Hash inners
 let mut sha224hasher = Sha224Hasher::default();
 sha224hasher.write_usize(data.len());
 sha224hasher.write(data);
 let simulated_hash_result = sha224hasher.finish();

 assert_ne!(result_via_hash, result_via_hasher);
 assert_eq!(result_via_hash, simulated_hash_result);

Trait Implementations

impl Clone for Sha224Hasher

fn clone(&self) -> Sha224Hasher

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Sha224Hasher

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

Formats the value using the given formatter.

impl Default for Sha224Hasher

fn default() -> Sha224Hasher

Returns the “default value” for a type.

impl From<Sha224Hasher> for Sha224State

fn from(value: Sha224Hasher) -> Sha224State

Converts to this type from the input type.

impl From<Sha224State> for Sha224Hasher

fn from(value: Sha224State) -> Sha224Hasher

Converts to this type from the input type.

impl Hash for Sha224Hasher

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Hasher for Sha224Hasher

fn finish(&self) -> u64

Finish the hash and return the hash value as a u64.

fn write(&mut self, bytes: &[u8])

Write a byte array to the hasher. This hasher can digest up to u64::MAX bytes. If more bytes are written, the hasher will panic.

fn write_u8(&mut self, i: u8)

Writes a single u8 into this hasher.

fn write_u16(&mut self, i: u16)

Writes a single u16 into this hasher.

fn write_u32(&mut self, i: u32)

Writes a single u32 into this hasher.

fn write_u64(&mut self, i: u64)

Writes a single u64 into this hasher.

fn write_u128(&mut self, i: u128)

Writes a single u128 into this hasher.

fn write_usize(&mut self, i: usize)

Writes a single usize into this hasher.

fn write_i8(&mut self, i: i8)

Writes a single i8 into this hasher.

fn write_i16(&mut self, i: i16)

Writes a single i16 into this hasher.

fn write_i32(&mut self, i: i32)

Writes a single i32 into this hasher.

fn write_i64(&mut self, i: i64)

Writes a single i64 into this hasher.

fn write_i128(&mut self, i: i128)

Writes a single i128 into this hasher.

fn write_isize(&mut self, i: isize)

Writes a single isize into this hasher.

fn write_length_prefix(&mut self, len: usize)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras)

Writes a length prefix into this hasher, as part of being prefix-free.

fn write_str(&mut self, s: &str)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras)

Writes a single str into this hasher.

impl HasherContext<rs_sha224::::sha224hasher::{impl#3}::{constant#0}> for Sha224Hasher

type Output = ByteArrayWrapper<rs_sha224::::sha224hasher::{impl#3}::Output::{constant#0}>

fn finish( &mut self, ) -> <Sha224Hasher as HasherContext<rs_sha224::::sha224hasher::{impl#3}::{constant#0}>>::Output

impl PartialEq for Sha224Hasher

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Sha224Hasher

impl StructuralPartialEq for Sha224Hasher