Struct Sha256Digest 

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

Represents a SHA-256 digest, which is a fixed-size array of 32 bytes.

For example, you can obtain the certificate digest with Certificate::hash.

Implementations

impl Sha256Digest

pub fn new(bytes: [u8; 32]) -> Self

Creates a new instance from a given array of 32 bytes.

Examples

use wtransport::tls::Sha256Digest;

// Create a new SHA-256 digest instance.
let digest = Sha256Digest::new([97; 32]);

pub fn from_str_fmt<S>( s: S, fmt: Sha256DigestFmt, ) -> Result<Self, InvalidDigest>

where S: AsRef<str>,

Attempts to create a new instance from a string representation.

This method parses the string representation of the digest according to the provided format (fmt) and constructs a new Sha256Digest instance if the parsing is successful.

Examples

use wtransport::tls::Sha256Digest;
use wtransport::tls::Sha256DigestFmt;

const HASH_ARRAY: &str = "[234, 204, 110, 153, 82, 177, 87, 232, 180, 125, \
                          234, 158, 66, 129, 212, 250, 217, 48, 47, 32, 83, \
                          133, 23, 44, 79, 198, 70, 118, 25, 153, 146, 142]";

let digest_bytes_array = Sha256Digest::from_str_fmt(HASH_ARRAY, Sha256DigestFmt::BytesArray);
assert!(digest_bytes_array.is_ok());

const HASH_HEX: &str = "e3:4e:c7:de:b8:da:2d:b8:3c:86:a0:11:76:40:75:b3:\
                        b9:ba:9d:00:e0:04:b3:38:72:cd:a1:af:4e:e3:11:26";

let digest_dotted_hex = Sha256Digest::from_str_fmt(HASH_HEX, Sha256DigestFmt::DottedHex);
assert!(digest_dotted_hex.is_ok());

let invalid_digest = Sha256Digest::from_str_fmt("invalid_digest", Sha256DigestFmt::BytesArray);
assert!(invalid_digest.is_err());

pub fn fmt(&self, fmt: Sha256DigestFmt) -> String

Formats the digest into a human-readable representation based on the specified format.

Examples

use wtransport::tls::Sha256Digest;
use wtransport::tls::Sha256DigestFmt;

let digest = Sha256Digest::new([
    97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
    116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 64,
]);

// Represent the digest as a byte array string.
let bytes_array_fmt = digest.fmt(Sha256DigestFmt::BytesArray);
assert_eq!(
    bytes_array_fmt,
    "[97, 98, 99, 100, 101, 102, 103, 104, 105, 106, \
      107, 108, 109, 110, 111, 112, 113, 114, 115, 116, \
      117, 118, 119, 120, 121, 122, 123, 124, 125, 126, \
      127, 64]"
);

// Represent the digest as a dotted hexadecimal string.
let dotted_hex_fmt = digest.fmt(Sha256DigestFmt::DottedHex);
assert_eq!(
    dotted_hex_fmt,
    "61:62:63:64:65:66:67:68:69:6a:6b:6c:6d:6e:6f:70:\
     71:72:73:74:75:76:77:78:79:7a:7b:7c:7d:7e:7f:40"
);

Trait Implementations

impl AsRef<[u8; 32]> for Sha256Digest

fn as_ref(&self) -> &[u8; 32]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Sha256Digest

fn clone(&self) -> Sha256Digest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Sha256Digest

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

Formats the value using the given formatter.

impl Display for Sha256Digest

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

Formats the value using the given formatter.

impl From<[u8; 32]> for Sha256Digest

fn from(value: [u8; 32]) -> Self

Converts to this type from the input type.

impl FromIterator<Sha256Digest> for ServerHashVerification

fn from_iter<T: IntoIterator<Item = Sha256Digest>>(iter: T) -> Self

Creates a value from an iterator.

impl FromStr for Sha256Digest

type Err = InvalidDigest

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Sha256Digest

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 Ord for Sha256Digest

fn cmp(&self, other: &Sha256Digest) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Sha256Digest

fn eq(&self, other: &Sha256Digest) -> 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 PartialOrd for Sha256Digest

fn partial_cmp(&self, other: &Sha256Digest) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Sha256Digest

impl StructuralPartialEq for Sha256Digest