fuchsia_hash/
lib.rs

1// Copyright 2020 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use hex::{FromHex, FromHexError};
6use serde::{Deserialize, Deserializer, Serialize, Serializer};
7use std::fmt;
8use thiserror::Error;
9
10mod iter;
11pub use iter::*;
12
13/// The size of a hash in bytes.
14pub const HASH_SIZE: usize = 32;
15
16#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
17pub struct FuchsiaMerkleMarker;
18/// A digest created by the Fuchsia Merkle Tree hashing algorithm.
19/// https://fuchsia.dev/fuchsia-src/concepts/packages/merkleroot
20pub type Hash = GenericDigest<FuchsiaMerkleMarker>;
21
22#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
23pub struct Sha256Marker;
24/// A digest created by the Sha256 hashing algorithm.
25pub type Sha256 = GenericDigest<Sha256Marker>;
26
27/// The 32 byte digest of a hash function. The type parameter indicates the hash algorithm that was
28/// used to compute the digest.
29#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
30pub struct GenericDigest<T> {
31    digest: [u8; HASH_SIZE],
32    type_: std::marker::PhantomData<T>,
33}
34
35impl<T> GenericDigest<T> {
36    /// Obtain a slice of the bytes representing the hash.
37    pub fn as_bytes(&self) -> &[u8] {
38        &self.digest[..]
39    }
40
41    pub const fn from_array(arr: [u8; HASH_SIZE]) -> Self {
42        Self { digest: arr, type_: std::marker::PhantomData::<T> }
43    }
44}
45
46impl<T> std::str::FromStr for GenericDigest<T> {
47    type Err = ParseHashError;
48
49    fn from_str(s: &str) -> Result<Self, Self::Err> {
50        Ok(Self { digest: FromHex::from_hex(s)?, type_: std::marker::PhantomData::<T> })
51    }
52}
53
54impl<'de, T> Deserialize<'de> for GenericDigest<T> {
55    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
56    where
57        D: Deserializer<'de>,
58    {
59        let s = String::deserialize(deserializer)?;
60        std::str::FromStr::from_str(&s).map_err(serde::de::Error::custom)
61    }
62}
63
64impl<T> From<[u8; HASH_SIZE]> for GenericDigest<T> {
65    fn from(bytes: [u8; HASH_SIZE]) -> Self {
66        GenericDigest { digest: bytes, type_: std::marker::PhantomData::<T> }
67    }
68}
69
70impl<T> From<GenericDigest<T>> for [u8; HASH_SIZE] {
71    fn from(hash: GenericDigest<T>) -> Self {
72        hash.digest
73    }
74}
75
76impl<T> TryFrom<&[u8]> for GenericDigest<T> {
77    type Error = std::array::TryFromSliceError;
78
79    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
80        Ok(Self { digest: bytes.try_into()?, type_: std::marker::PhantomData::<T> })
81    }
82}
83
84impl<T> TryFrom<&str> for GenericDigest<T> {
85    type Error = ParseHashError;
86
87    fn try_from(s: &str) -> Result<Self, Self::Error> {
88        Ok(Self { digest: FromHex::from_hex(s)?, type_: std::marker::PhantomData::<T> })
89    }
90}
91
92impl<T> TryFrom<String> for GenericDigest<T> {
93    type Error = ParseHashError;
94
95    fn try_from(s: String) -> Result<Self, Self::Error> {
96        Self::try_from(s.as_str())
97    }
98}
99
100impl<T> From<GenericDigest<T>> for String {
101    fn from(h: GenericDigest<T>) -> Self {
102        hex::encode(h.digest)
103    }
104}
105
106impl<T> fmt::Display for GenericDigest<T> {
107    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
108        hex::encode(self.digest).fmt(f)
109    }
110}
111
112impl<T> Serialize for GenericDigest<T> {
113    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
114    where
115        S: Serializer,
116    {
117        serializer.serialize_str(&self.to_string())
118    }
119}
120
121impl<T> fmt::Debug for GenericDigest<T> {
122    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
123        f.debug_tuple("Hash").field(&self.to_string()).finish()
124    }
125}
126
127impl<T> std::ops::Deref for GenericDigest<T> {
128    type Target = [u8; HASH_SIZE];
129
130    fn deref(&self) -> &Self::Target {
131        &self.digest
132    }
133}
134
135/// An error encountered while parsing a [`Hash`].
136#[derive(Copy, Clone, Debug, Error, PartialEq)]
137pub struct ParseHashError(FromHexError);
138
139impl fmt::Display for ParseHashError {
140    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
141        match self.0 {
142            FromHexError::InvalidStringLength => {
143                write!(f, "{}, expected {} hex encoded bytes", self.0, HASH_SIZE)
144            }
145            _ => write!(f, "{}", self.0),
146        }
147    }
148}
149
150impl From<FromHexError> for ParseHashError {
151    fn from(e: FromHexError) -> Self {
152        ParseHashError(e)
153    }
154}
155
156#[cfg(test)]
157mod tests {
158    use super::*;
159    use proptest::prelude::*;
160    use std::str::FromStr;
161
162    proptest! {
163        #[test]
164        fn test_from_str_display(ref s in "[[:xdigit:]]{64}") {
165            let hash = Hash::from_str(s).unwrap();
166            let display = format!("{hash}");
167            prop_assert_eq!(s.to_ascii_lowercase(), display);
168        }
169
170        #[test]
171        fn test_rejects_odd_length_strings(ref s in "[[:xdigit:]][[:xdigit:]]{2}{0,128}") {
172            prop_assert_eq!(Err(FromHexError::OddLength.into()), Hash::from_str(s));
173        }
174
175        #[test]
176        fn test_rejects_incorrect_byte_count(ref s in "[[:xdigit:]]{2}{0,128}") {
177            prop_assume!(s.len() != HASH_SIZE * 2);
178            prop_assert_eq!(Err(FromHexError::InvalidStringLength.into()), Hash::from_str(s));
179        }
180    }
181}
fuchsia_hash/lib.rs

fuchsia_hash/
lib.rs
