Skip to main content

vc_shared/
hashing.rs

1//! Hashing utilities using SHA256.
2
3use serde::{Deserialize, Deserializer, Serialize, Serializer};
4use sha2::{Digest, Sha256};
5use std::fmt;
6use std::str::FromStr;
7use thiserror::Error;
8
9/// A SHA256 digest (32 bytes).
10#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
11pub struct Sha256Digest([u8; 32]);
12
13/// Serialization helpers for `Sha256Digest` as hex string.
14mod hex_serde {
15    use super::*;
16
17    pub fn serialize<S>(bytes: &[u8; 32], serializer: S) -> Result<S::Ok, S::Error>
18    where
19        S: Serializer,
20    {
21        let hex = hex::encode(bytes);
22        serializer.serialize_str(&hex)
23    }
24
25    pub fn deserialize<'de, D>(deserializer: D) -> Result<[u8; 32], D::Error>
26    where
27        D: Deserializer<'de>,
28    {
29        let s = String::deserialize(deserializer)?;
30        let bytes = hex::decode(s).map_err(serde::de::Error::custom)?;
31        bytes.try_into().map_err(|_| serde::de::Error::custom("expected 32 bytes"))
32    }
33}
34
35impl Serialize for Sha256Digest {
36    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
37    where
38        S: Serializer,
39    {
40        hex_serde::serialize(&self.0, serializer)
41    }
42}
43
44impl<'de> Deserialize<'de> for Sha256Digest {
45    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
46    where
47        D: Deserializer<'de>,
48    {
49        let bytes = hex_serde::deserialize(deserializer)?;
50        Ok(Sha256Digest(bytes))
51    }
52}
53
54impl Sha256Digest {
55    #[must_use]
56    pub fn to_hex(&self) -> String {
57        hex::encode(self.0)
58    }
59
60    #[must_use]
61    pub fn as_bytes(&self) -> &[u8; 32] {
62        &self.0
63    }
64}
65
66impl AsRef<[u8]> for Sha256Digest {
67    fn as_ref(&self) -> &[u8] {
68        &self.0
69    }
70}
71
72impl From<[u8; 32]> for Sha256Digest {
73    fn from(bytes: [u8; 32]) -> Self {
74        Sha256Digest(bytes)
75    }
76}
77
78impl From<Sha256Digest> for [u8; 32] {
79    fn from(digest: Sha256Digest) -> Self {
80        digest.0
81    }
82}
83
84impl fmt::Display for Sha256Digest {
85    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
86        write!(f, "{}", self.to_hex())
87    }
88}
89
90#[derive(Debug, Clone, PartialEq, Eq, Error)]
91pub enum ParseDigestError {
92    #[error("expected exactly 64 hexadecimal characters, got {0}")]
93    InvalidLength(usize),
94    #[error("invalid hexadecimal character")]
95    InvalidHex,
96}
97
98impl FromStr for Sha256Digest {
99    type Err = ParseDigestError;
100
101    fn from_str(s: &str) -> Result<Self, Self::Err> {
102        let trimmed = s.trim();
103        if trimmed.len() != 64 {
104            return Err(ParseDigestError::InvalidLength(trimmed.len()));
105        }
106        let mut bytes = [0u8; 32];
107        for (i, chunk) in trimmed.as_bytes().chunks(2).enumerate() {
108            let byte = u8::from_str_radix(
109                std::str::from_utf8(chunk).map_err(|_| ParseDigestError::InvalidHex)?,
110                16,
111            )
112            .map_err(|_| ParseDigestError::InvalidHex)?;
113            bytes[i] = byte;
114        }
115        Ok(Sha256Digest(bytes))
116    }
117}
118
119/// Computes the SHA256 digest of the given bytes.
120#[must_use]
121pub fn sha256(data: &[u8]) -> Sha256Digest {
122    let mut hasher = Sha256::new();
123    hasher.update(data);
124    Sha256Digest(hasher.finalize().into())
125}
126
127#[cfg(test)]
128mod tests {
129    use super::*;
130
131    #[test]
132    fn sha256_empty() {
133        let digest = sha256(b"");
134        assert_eq!(
135            digest.to_hex(),
136            "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
137        );
138    }
139
140    #[test]
141    fn sha256_abc() {
142        let digest = sha256(b"abc");
143        assert_eq!(
144            digest.to_hex(),
145            "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
146        );
147    }
148
149    #[test]
150    fn sha256_quick_brown_fox() {
151        let data = b"The quick brown fox jumps over the lazy dog";
152        let digest = sha256(data);
153        assert_eq!(
154            digest.to_hex(),
155            "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592"
156        );
157    }
158
159    #[test]
160    fn sha256_quick_brown_fox_with_dot() {
161        let data = b"The quick brown fox jumps over the lazy dog.";
162        let digest = sha256(data);
163        assert_eq!(
164            digest.to_hex(),
165            "ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c"
166        );
167    }
168
169    #[test]
170    fn sha256_deterministic() {
171        let data = b"hello";
172        let d1 = sha256(data);
173        let d2 = sha256(data);
174        assert_eq!(d1, d2);
175    }
176
177    #[test]
178    fn parse_valid_digest() {
179        let hex = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
180        let digest: Sha256Digest = hex.parse().unwrap();
181        assert_eq!(digest.to_hex(), hex);
182    }
183
184    #[test]
185    fn parse_invalid_length() {
186        let result = "e3b0c4".parse::<Sha256Digest>();
187        assert!(matches!(result, Err(ParseDigestError::InvalidLength(6))));
188    }
189
190    #[test]
191    fn parse_invalid_hex() {
192        let result = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b85g"
193            .parse::<Sha256Digest>();
194        assert!(matches!(result, Err(ParseDigestError::InvalidHex)));
195    }
196
197    #[test]
198    fn from_str_roundtrip() {
199        let data = b"hello";
200        let digest = sha256(data);
201        let hex = digest.to_hex();
202        let parsed: Sha256Digest = hex.parse().unwrap();
203        assert_eq!(digest, parsed);
204    }
205}