Struct Hash

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

An output of the default size, 32 bytes, which provides constant-time equality checking.

Hash implements From and Into for [u8; 32], and it provides from_bytes and as_bytes for explicit conversions between itself and [u8; 32]. However, byte arrays and slices don’t provide constant-time equality checking, which is often a security requirement in software that handles private data. Hash doesn’t implement Deref or AsRef, to avoid situations where a type conversion happens implicitly and the constant-time property is accidentally lost.

Hash provides the to_hex and from_hex methods for converting to and from hexadecimal. It also implements Display and FromStr.

Implementations

impl Hash

pub const fn as_bytes(&self) -> &[u8; 32]

The raw bytes of the Hash. Note that byte arrays don’t provide constant-time equality checking, so if you need to compare hashes, prefer the Hash type.

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

Create a Hash from its raw bytes representation.

pub fn to_hex(&self) -> ArrayString<{ _ }>

Encode a Hash in lowercase hexadecimal.

The returned ArrayString is a fixed size and doesn’t allocate memory on the heap. Note that ArrayString doesn’t provide constant-time equality checking, so if you need to compare hashes, prefer the Hash type.

pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Self, HexError>

Decode a Hash from hexadecimal. Both uppercase and lowercase ASCII bytes are supported.

Any byte outside the ranges '0'...'9', 'a'...'f', and 'A'...'F' results in an error. An input length other than 64 also results in an error.

Note that Hash also implements FromStr, so Hash::from_hex("...") is equivalent to "...".parse().

Trait Implementations

impl Clone for Hash

fn clone(&self) -> Hash

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Hash

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

Formats the value using the given formatter.

impl Display for Hash

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

Formats the value using the given formatter.

impl From<[u8; 32]> for Hash

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

Converts to this type from the input type.

impl From<Hash> for [u8; 32]

fn from(hash: Hash) -> Self

Converts to this type from the input type.

impl FromStr for Hash

type Err = HexError

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 Hash

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 PartialEq<[u8]> for Hash

This implementation is constant-time if the target is 32 bytes long.

fn eq(&self, other: &[u8]) -> 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 PartialEq<[u8; 32]> for Hash

This implementation is constant-time.

fn eq(&self, other: &[u8; 32]) -> 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 PartialEq for Hash

This implementation is constant-time.

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

impl Eq for Hash