Struct wolf_crypto::hash::Sha256

pub struct Sha256 { /* private fields */ }

The Sha256 hasher.

Example

use wolf_crypto::hash::Sha256;

let mut hasher = Sha256::new().unwrap();

let input = b"hello world";
assert!(hasher.try_update(input.as_slice()).is_ok());

let finalized = hasher.try_finalize().unwrap();
assert_ne!(finalized.as_slice(), input.as_slice());
assert_eq!(finalized.len(), 32);

Implementations

impl Sha256

pub fn new() -> Result<Self, ()>

Create a new Sha256 instance.

Errors

If the underlying initialization function fails (wc_InitSha256)

Example

use wolf_crypto::hash::Sha256;

let mut hasher = Sha256::new().unwrap();

let input = b"hello world";
assert!(hasher.try_update(input.as_slice()).is_ok());

let finalized = hasher.try_finalize().unwrap();
assert_ne!(finalized.as_slice(), input.as_slice());
assert_eq!(finalized.len(), 32);

pub unsafe fn update_unchecked(&mut self, data: &[u8]) -> Res

Update the underlying wc_Sha256 instance, without performing any safety checks.

Safety

The length of data is casted to a 32 bit unsigned integer without checking for overflows. While it is incredibly unlikely that this overflow will ever take place, it is not impossible. Thus this function is marked unsafe.

Arguments

• data - The slice to update the underlying hasher state with.

Returns

This function returns the result of the operation.

Example

use wolf_crypto::hash::Sha256;

let mut hasher = Sha256::new().unwrap();

let input = b"hello world";
// SAFETY: The length of `hello world` is 11, which
// cannot overflow even an 8 bit integer.
let res = unsafe {
    hasher.update_unchecked(input.as_slice())
};
assert!(res.is_ok());

let finalized = hasher.try_finalize().unwrap();
assert_ne!(finalized.as_slice(), input.as_slice());
assert_eq!(finalized.len(), 32);

pub fn try_update(&mut self, data: &[u8]) -> Res

Update the underlying wc_Sha256 instance.

Arguments

• data - The slice to update the underlying hasher state with.

Returns

This function returns the result of the operation.

Errors

• If the length of data cannot be safely casted to a u32.
• If the underlying wc_Sha256Update function fails.

Example

use wolf_crypto::hash::Sha256;

let mut hasher = Sha256::new().unwrap();

let input = b"hello world";
assert!(hasher.try_update(input.as_slice()).is_ok());

let finalized = hasher.try_finalize().unwrap();
assert_ne!(finalized.as_slice(), input.as_slice());
assert_eq!(finalized.len(), 32);

Note: if the size of the data is known at compile time, see update_sized for a slight optimization as the safety checks are done at compilation time.

pub fn update_sized<const C: usize>(&mut self, data: &[u8; C]) -> Res

Update the underlying wc_Sha256 instance, with the safety checks performed at compilation time.

Arguments

• data - The slice to update the underlying hasher state with.

Returns

This function returns the result of the operation.

Errors

• If the length of data cannot be safely casted to a u32.
• If the underlying wc_Sha256Update function fails.

Example

use wolf_crypto::hash::Sha256;

let mut hasher = Sha256::new().unwrap();

let input = b"hello world";
assert!(hasher.update_sized(input).is_ok());

let finalized = hasher.try_finalize().unwrap();
assert_ne!(finalized.as_slice(), input.as_slice());
assert_eq!(finalized.len(), 32);

Note: if the size of the data is not known at compile time, see try_update for more flexibility.

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

Update the underlying wc_Sha256, panicking under any failure.

Arguments

• data - The slice to update the underlying hasher state with.

Panics

• If the length of data cannot be safely casted to a u32.
• If the underlying wc_Sha256Update function fails.

If a panic under any failure is not acceptable for your use case, which generally is true, please consider using try_update.

Example

use wolf_crypto::hash::Sha256;

let mut hasher = Sha256::new().unwrap();

let input = b"hello world";
hasher.update(input.as_slice());

let finalized = hasher.try_finalize().unwrap();
assert_ne!(finalized.as_slice(), input.as_slice());
assert_eq!(finalized.len(), 32);

pub unsafe fn finalize_unchecked(&mut self, output: &mut [u8]) -> Res

Calls the wc_Sha256Final function, finalizing the hashing of data and resetting the underlying wc_Sha256 instance’s state, without performing any safety checks.

Safety

The size of the output argument must have a size of at least 32 (the size of the digest).

Arguments

• output - The buffer to store the output digest in.

Returns

This function returns the result of the operation.

Example

use wolf_crypto::hash::Sha256;
let mut hasher = Sha256::new().unwrap();

// Use the hasher ...

let mut output = [0u8; 32];
// SAFETY: The size of the output is exactly 
// the size of the digest.
let res = unsafe {
    hasher.finalize_unchecked(output.as_mut_slice())
};
assert!(res.is_ok());

pub fn finalize_into(&mut self, output: &mut [u8]) -> Res

Calls the wc_Sha256Final function, finalizing the hashing of data and resetting the underlying wc_Sha256 instance’s state.

Arguments

• output - The buffer to store the output digest in.

Errors

• If the size of output is less than the digest size (32).
• If the underlying finalize function fails.

Example

use wolf_crypto::hash::Sha256;
let mut hasher = Sha256::new().unwrap();

// Use the hasher ...

let mut output = [0u8; 32];
let res = hasher.finalize_into(output.as_mut_slice());
assert!(res.is_ok());

Note: if the size of the output slice is known at compile time, see finalize_into_sized for a slight optimization as the safety checks are done at compilation time. There is also finalize_into_exact if this size is exactly 32 bytes, moving all checks to the type system.

pub fn finalize_into_sized<const C: usize>( &mut self, output: &mut [u8; C], ) -> Res

Calls the wc_Sha256Final function, finalizing the hashing of data and resetting the underlying wc_Sha256 instance’s state, with the safety checks performed at compilation time.

Arguments

• output - The buffer to store the output digest in.

Errors

• If the size of output is less than the digest size (32).
• If the underlying finalize function fails.

Example

use wolf_crypto::hash::Sha256;
let mut hasher = Sha256::new().unwrap();

// Use the hasher ...

let mut output = [0u8; 32];
let res = hasher.finalize_into_sized(&mut output);
assert!(res.is_ok());

Note: If the size of the output buffer is not known at compilation time see finalize_into for greater flexibility. There is also finalize_into_exact if this size is exactly 32 bytes, moving all checks to the type system.

pub fn finalize_into_exact(&mut self, output: &mut [u8; 32]) -> Res

Calls the wc_Sha256Final function, finalizing the hashing of data and resetting the underlying wc_Sha256 instance’s state, with the safety checks moved to the type system.

Arguments

• output - The buffer to store the output digest in.

Errors

If the underlying finalize function fails.

Example

use wolf_crypto::hash::Sha256;
let mut hasher = Sha256::new().unwrap();

// Use the hasher ...

let mut output = [0u8; 32];
let res = hasher.finalize_into_exact(&mut output);
assert!(res.is_ok());

Note: If the size of the output buffer is not known at compilation time see finalize_into for greater flexibility. If the size is known at compilation time, but not exactly 32 bytes, see finalize_into_sized.

pub fn try_finalize(&mut self) -> Result<[u8; 32], ()>

Calls the wc_Sha256Final function, finalizing the hashing of data and resetting the underlying wc_Sha256 instance’s state.

Returns

On success, this returns the output digest.

Errors

If the underlying finalize function fails.

Example

use wolf_crypto::hash::Sha256;
let mut hasher = Sha256::new().unwrap();

// Use the hasher ...

let res = hasher.try_finalize().unwrap();
assert_ne!(res.as_slice(), input.as_slice());

pub fn finalize(&mut self) -> [u8; 32]

Calls the wc_Sha256Final function, finalizing the hashing of data and resetting the underlying wc_Sha256 instance’s state.

Returns

On success, this returns the output digest.

Panics

If the underlying finalize function fails. If panicking is not acceptable for your use case, which generally is true, see try_finalize.

Example

use wolf_crypto::hash::Sha256;
let mut hasher = Sha256::new().unwrap();

// Use the hasher ...

let res = hasher.try_finalize().unwrap();
assert_ne!(res.as_slice(), input.as_slice());

Trait Implementations

impl Drop for Sha256

fn drop(&mut self)

Calls the wc_Sha256Free function, cleaning up after itself.

impl Send for Sha256

impl Sync for Sha256