Struct Sha1State 

pub struct Sha1State(pub NBitWord<u32>, pub NBitWord<u32>, pub NBitWord<u32>, pub NBitWord<u32>, pub NBitWord<u32>);

Sha1State represents the state of a SHA-1 hashing process.

It holds intermediate hash calculations. However, it’s important to note that starting a hashing process from an arbitrary Sha1State is not equivalent to resuming the original process that produced that state. Instead, it begins a new hashing process with a different set of initial values.

Therefore, a Sha1State extracted from a Sha1Hasher should not be used with the expectation of continuing the hashing operation from where it left off in the original Sha1Hasher. It is a snapshot of a particular point in the process, not a means to resume the process.

Example

This example demonstrates how to persist the state of a SHA-1 hash operation:

let hello = b"hello";
let world = b" world";

let mut default_sha1hasher = Sha1State::default().build_hasher();
default_sha1hasher.write(hello);

let intermediate_state: Sha1State = default_sha1hasher.clone().into();

default_sha1hasher.write(world);

let mut from_sha1state: Sha1Hasher = intermediate_state.into();
from_sha1state.write(world);

let default_hello_world_result = default_sha1hasher.finish();
let from_arbitrary_state_result = from_sha1state.finish();
assert_ne!(default_hello_world_result, from_arbitrary_state_result);

Note

In this example, even though the internal state are the same between default_sha1hasher and from_sha1state before the Hasher::finish call, the results are different due to from_sha1state be instantiated with an empty pad while the default_sha1hasher’s pad already is populated with b"hello".

Tuple Fields

0: NBitWord<u32>

1: NBitWord<u32>

2: NBitWord<u32>

3: NBitWord<u32>

4: NBitWord<u32>

Trait Implementations

impl AddAssign<Sha160BitsState> for Sha1State

fn add_assign(&mut self, rhs: Sha160BitsState)

Performs the += operation.

impl BuildHasher for Sha1State

type Hasher = Sha1Hasher

Type of the hasher that will be created.

fn build_hasher(&self) -> Self::Hasher

Creates a new hasher.

fn hash_one<T>(&self, x: T) -> u64

where T: Hash, Self: Sized, Self::Hasher: Hasher,

Calculates the hash of a single value.

impl BytesLen for Sha1State

fn len() -> usize

impl Clone for Sha1State

fn clone(&self) -> Sha1State

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Sha1State

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

Formats the value using the given formatter.

impl Default for Sha1State

fn default() -> Self

Returns the “default value” for a type.

impl From<[u32; 5]> for Sha1State

fn from(v: [u32; 5]) -> Self

Converts to this type from the input type.

impl From<[u8; 20]> for Sha1State

fn from(v: [u8; 20]) -> Self

Converts to this type from the input type.

impl From<Sha1Hasher> for Sha1State

fn from(value: Sha1Hasher) -> Self

Converts to this type from the input type.

impl From<Sha1State> for ByteArrayWrapper<BYTES_LEN>

fn from(value: Sha1State) -> Self

Converts to this type from the input type.

impl From<Sha1State> for Sha1Hasher

fn from(value: Sha1State) -> Self

Converts to this type from the input type.

impl Hash for Sha1State

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

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 HashAlgorithm for Sha1State

type Padding = GenericPad<U64Size, 64, 128>

type Output = ByteArrayWrapper<BYTES_LEN>

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

fn state_to_u64(&self) -> u64

impl PartialEq for Sha1State

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

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

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 Sha1State

impl StructuralPartialEq for Sha1State