1use serde::{Deserialize, Deserializer, Serialize, Serializer};
4use sha2::{Digest, Sha256};
5use std::fmt;
6use std::str::FromStr;
7use thiserror::Error;
8
9#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
11pub struct Sha256Digest([u8; 32]);
12
13mod 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#[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}