1use crate::cesr::{dig_dex, mtr_dex, BaseMatter, Parsable};
2use crate::errors::MatterError;
3use crate::Matter;
4use blake2::{Blake2b512, Blake2s256, Digest as Blake2Digest};
5use blake3::Hasher as Blake3Hasher;
6use sha2::{Sha256, Sha512};
7use sha3::{Digest as Sha3Digest, Sha3_256, Sha3_512};
8use std::any::Any;
9
10#[derive(Debug, Clone)]
12pub struct Diger {
13 base: BaseMatter,
14}
15
16impl Diger {
17 pub fn new(
18 raw: Option<&[u8]>,
19 code: Option<&str>,
20 soft: Option<&str>,
21 rize: Option<usize>,
22 ) -> Result<Self, MatterError> {
23 let code = code.unwrap_or_else(|| mtr_dex::BLAKE3_256);
24 if !dig_dex::TUPLE.contains(&(code)) {
25 return Err(MatterError::UnsupportedCodeError(String::from(code)));
26 }
27
28 let base = BaseMatter::new(raw, Some(code), soft, rize)?;
29 Ok(Diger { base })
30 }
31
32 pub fn from_raw(raw: Option<&[u8]>) -> Result<Self, MatterError> {
33 let base = BaseMatter::new(raw, Some(mtr_dex::BLAKE3_256), None, None)?;
34
35 Ok(Diger { base })
36 }
37
38 pub fn from_qb64(qb64: &str) -> Result<Self, MatterError> {
39 let base = BaseMatter::from_qb64(qb64)?;
40 if !dig_dex::TUPLE.contains(&(base.code())) {
41 return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
42 }
43
44 Ok(Diger { base })
45 }
46
47 pub fn from_ser(ser: &[u8], code: Option<&str>) -> Result<Self, MatterError> {
48 let code = code.unwrap_or_else(|| mtr_dex::BLAKE3_256);
49 Diger::from_ser_and_code(ser, code)
50 }
51
52 pub fn from_ser_and_code(ser: &[u8], code: &str) -> Result<Self, MatterError> {
53 let raw = Diger::digest(ser, code)?;
54 let base = BaseMatter::new(Some(&raw), Some(code), None, None)?;
55 Ok(Diger { base })
56 }
57
58 pub fn digest(ser: &[u8], code: &str) -> Result<Vec<u8>, MatterError> {
59 match code {
60 code if code == dig_dex::BLAKE3_256 => {
61 let result = Diger::digest_blake3_256(ser)?;
62 Ok(result.to_vec())
63 }
64 code if code == dig_dex::BLAKE3_512 => {
65 let result = Diger::digest_blake3_512(ser)?;
66 Ok(result.to_vec())
67 }
68 code if code == dig_dex::SHA3_256 => {
69 let result = Diger::digest_sha3_256(ser)?;
70 Ok(result.to_vec())
71 }
72 code if code == dig_dex::SHA2_256 => {
73 let result = Diger::digest_sha2_256(ser)?;
74 Ok(result.to_vec())
75 }
76 code if code == dig_dex::SHA3_512 => {
77 let result = Diger::digest_sha3_512(ser)?;
78 Ok(result.to_vec())
79 }
80 code if code == dig_dex::SHA2_512 => {
81 let result = Diger::digest_sha2_512(ser)?;
82 Ok(result.to_vec())
83 }
84 code if code == dig_dex::BLAKE2S_256 => {
85 let result = Diger::digest_blake2s_256(ser)?;
86 Ok(result.to_vec())
87 }
88 code if code == dig_dex::BLAKE2B_512 => {
89 let result = Diger::digest_blake2b_512(ser)?;
90 Ok(result.to_vec())
91 }
92 code if code == dig_dex::BLAKE2B_256 => {
93 let result = Diger::digest_blake2b_256(ser)?;
94 Ok(result.to_vec())
95 }
96 _ => Err(MatterError::UnsupportedCodeError(String::from(code))),
98 }
99 }
100
101 fn digest_blake3_256(data: &[u8]) -> Result<[u8; 32], MatterError> {
103 let result = blake3::hash(data).into();
104 Ok(result)
105 }
106
107 fn digest_blake2b_512(data: &[u8]) -> Result<[u8; 64], MatterError> {
109 let mut hasher = Blake2b512::new();
110 hasher.update(data);
111 let result = hasher.finalize();
112 let mut digest = [0u8; 64];
113 digest.copy_from_slice(&result);
114 Ok(digest)
115 }
116
117 fn digest_blake2b_256(data: &[u8]) -> Result<[u8; 32], MatterError> {
119 use blake2::digest::{Update, VariableOutput};
120 use blake2::Blake2bVar;
121
122 let mut hasher = Blake2bVar::new(32).unwrap();
123 hasher.update(data);
124 let mut result = vec![0u8; 32];
125 hasher.finalize_variable(&mut result).unwrap();
126
127 let mut digest = [0u8; 32];
128 digest.copy_from_slice(&result);
129 Ok(digest)
130 }
131
132 fn digest_blake2s_256(data: &[u8]) -> Result<[u8; 32], MatterError> {
134 let mut hasher = Blake2s256::new();
135 hasher.update(data);
136 let result = hasher.finalize();
137 let mut digest = [0u8; 32];
138 digest.copy_from_slice(&result);
139 Ok(digest)
140 }
141
142 fn digest_blake3_512(data: &[u8]) -> Result<[u8; 64], MatterError> {
144 let mut hasher = Blake3Hasher::new();
145 hasher.update(data);
146 let mut digest = [0u8; 64];
147 hasher.finalize_xof().fill(&mut digest);
148 Ok(digest)
149 }
150 fn digest_sha3_256(data: &[u8]) -> Result<[u8; 32], MatterError> {
152 let mut hasher = Sha3_256::new();
153 hasher.update(data);
154 let result = hasher.finalize();
155 let mut digest = [0u8; 32];
156 digest.copy_from_slice(&result);
157 Ok(digest)
158 }
159
160 fn digest_sha2_256(data: &[u8]) -> Result<[u8; 32], MatterError> {
162 let mut hasher = Sha256::new();
163 hasher.update(data);
164 let result = hasher.finalize();
165 let mut digest = [0u8; 32];
166 digest.copy_from_slice(&result);
167 Ok(digest)
168 }
169
170 fn digest_sha3_512(data: &[u8]) -> Result<[u8; 64], MatterError> {
172 let mut hasher = Sha3_512::new();
173 hasher.update(data);
174 let result = hasher.finalize();
175 let mut digest = [0u8; 64];
176 digest.copy_from_slice(&result);
177 Ok(digest)
178 }
179
180 fn digest_sha2_512(data: &[u8]) -> Result<[u8; 64], MatterError> {
182 let mut hasher = Sha512::new();
183 hasher.update(data);
184 let result = hasher.finalize();
185 let mut digest = [0u8; 64];
186 digest.copy_from_slice(&result);
187 Ok(digest)
188 }
189
190 fn verify(&self, ser: &[u8]) -> bool {
191 match Diger::digest(ser, self.base.code()) {
192 Ok(raw) => self.base.raw() == raw.as_slice(),
193 Err(_) => false,
194 }
195 }
196
197 fn compare_with_diger(&self, ser: &[u8], other: &Self) -> bool {
198 if self.base.qb64() == other.base.qb64() {
199 return true;
200 }
201
202 if self.code() == other.code() {
203 return false;
204 }
205
206 other.verify(ser) && self.verify(ser)
207 }
208
209 fn compare_with_qb64(&self, ser: &[u8], other: &str) -> bool {
210 self.compare_with_diger(ser, &Diger::from_qb64(other).unwrap())
211 }
212
213 fn compare_with_qb64b(&self, ser: &[u8], other: &[u8]) -> bool {
214 self.compare_with_diger(ser, &Diger::from_qb64b(&mut other.to_vec(), None).unwrap())
215 }
216}
217
218impl Parsable for Diger {
219 fn from_qb64b(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
220 let base = BaseMatter::from_qb64b(data, strip)?;
221 if !dig_dex::TUPLE.contains(&(base.code())) {
222 return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
223 }
224
225 Ok(Diger { base })
226 }
227
228 fn from_qb2(data: &mut Vec<u8>, strip: Option<bool>) -> Result<Self, MatterError> {
229 let base = BaseMatter::from_qb2(data, strip)?;
230 if !dig_dex::TUPLE.contains(&(base.code())) {
231 return Err(MatterError::UnsupportedCodeError(String::from(base.code())));
232 }
233
234 Ok(Diger { base })
235 }
236}
237
238impl Matter for Diger {
239 fn code(&self) -> &str {
240 self.base.code()
241 }
242 fn raw(&self) -> &[u8] {
243 self.base.raw()
244 }
245 fn qb64(&self) -> String {
246 self.base.qb64()
247 }
248 fn qb64b(&self) -> Vec<u8> {
249 self.base.qb64b()
250 }
251 fn qb2(&self) -> Vec<u8> {
252 self.base.qb2()
253 }
254 fn soft(&self) -> &str {
255 self.base.soft()
256 }
257 fn full_size(&self) -> usize {
258 self.base.full_size()
259 }
260 fn size(&self) -> usize {
261 self.base.size()
262 }
263 fn is_transferable(&self) -> bool {
264 self.base.is_transferable()
265 }
266 fn is_digestive(&self) -> bool {
267 self.base.is_digestive()
268 }
269 fn is_prefixive(&self) -> bool {
270 self.base.is_prefixive()
271 }
272 fn is_special(&self) -> bool {
273 self.base.is_special()
274 }
275 fn as_any(&self) -> &dyn Any {
276 self
277 }
278}
279
280#[cfg(test)]
281mod tests {
282 use super::*;
283 use crate::cesr::raw_size;
284 use blake2::{Blake2b512, Blake2s256, Digest};
285 use blake3;
286 use sha2::Sha256;
287 use sha3::Sha3_256;
288
289 #[test]
290 fn test_diger() {
291 let result = Diger::new(None, None, None, None);
296 assert!(result.is_err());
297
298 let ser = b"abcdefghijklmnopqrstuvwxyz0123456789";
300
301 let hash = blake3::hash(ser);
303 let dig = hash.as_bytes();
304 let result = Diger::new(Some(&dig[..]), Some(mtr_dex::ED25519), None, None);
305 assert!(result.is_err());
306
307 let diger = Diger::new(Some(&dig[..]), None, None, None).unwrap();
309 assert_eq!(diger.code(), mtr_dex::BLAKE3_256);
310 assert_eq!(diger.raw().len(), raw_size(diger.code()).unwrap());
311 assert!(diger.verify(ser));
312 assert!(!diger.verify(&[ser.to_vec(), b"ABCDEF".to_vec()].concat()));
313
314 let diger = Diger::new(Some(&dig[..]), Some(mtr_dex::BLAKE3_256), None, None).unwrap();
316 assert_eq!(diger.code(), mtr_dex::BLAKE3_256);
317 assert_eq!(diger.raw().len(), raw_size(diger.code()).unwrap());
318 assert!(diger.verify(ser));
319
320 let diger = Diger::from_ser(ser, None).unwrap();
322 assert_eq!(diger.code(), mtr_dex::BLAKE3_256);
323 assert_eq!(diger.raw().len(), raw_size(diger.code()).unwrap());
324 assert!(diger.verify(ser));
325 assert_eq!(
326 diger.qb64b(),
327 b"ELC5L3iBVD77d_MYbYGGCUQgqQBju1o4x1Ud-z2sL-ux"
328 );
329
330 let digb = b"ELC5L3iBVD77d_MYbYGGCUQgqQBju1o4x1Ud-z2sL-ux";
332 let dig = "ELC5L3iBVD77d_MYbYGGCUQgqQBju1o4x1Ud-z2sL-ux";
333 let diger = Diger::from_qb64b(&mut digb.to_vec(), None).unwrap();
334 assert_eq!(diger.qb64b(), digb);
335 assert_eq!(diger.qb64(), dig);
336 assert_eq!(diger.code(), mtr_dex::BLAKE3_256);
337 let diger = Diger::from_qb64(dig).unwrap();
340 assert_eq!(diger.qb64(), dig);
341 assert_eq!(diger.qb64b(), digb);
342 assert_eq!(diger.code(), mtr_dex::BLAKE3_256);
343
344 let mut hasher = Blake2b512::new();
351 hasher.update(ser);
352 let dig = hasher.finalize()[..].to_vec();
353 let diger = Diger::new(Some(&dig[..]), Some(mtr_dex::BLAKE2B_512), None, None).unwrap();
354 assert_eq!(diger.code(), mtr_dex::BLAKE2B_512);
355 assert_eq!(diger.raw().len(), raw_size(diger.code()).unwrap());
356 assert!(diger.verify(ser));
357
358 let diger = Diger::from_ser(ser, Some(mtr_dex::BLAKE2B_512)).unwrap();
359 assert_eq!(diger.code(), mtr_dex::BLAKE2B_512);
360 assert_eq!(diger.raw().len(), raw_size(diger.code()).unwrap());
361 assert!(diger.verify(ser));
362 let mut hasher = Blake2s256::new();
365 hasher.update(ser);
366 let dig = hasher.finalize();
367 let diger = Diger::new(Some(&dig[..]), Some(mtr_dex::BLAKE2S_256), None, None).unwrap();
368 assert_eq!(diger.code(), mtr_dex::BLAKE2S_256);
369 assert_eq!(diger.raw().len(), raw_size(diger.code()).unwrap());
370 assert!(diger.verify(ser));
371 let diger = Diger::from_ser(ser, Some(mtr_dex::BLAKE2S_256)).unwrap();
373 assert_eq!(diger.code(), mtr_dex::BLAKE2S_256);
374 assert_eq!(diger.raw().len(), raw_size(diger.code()).unwrap());
375 assert!(diger.verify(ser));
376
377 let mut hasher = Sha3_256::new();
379 hasher.update(ser);
380 let dig = hasher.finalize();
381 let diger = Diger::new(Some(&dig), Some(mtr_dex::SHA3_256), None, None).unwrap();
382 assert_eq!(diger.code(), mtr_dex::SHA3_256);
383 assert_eq!(diger.raw().len(), raw_size(diger.code()).unwrap());
384 assert!(diger.verify(ser));
385
386 let diger = Diger::from_ser(ser, Some(mtr_dex::SHA3_256)).unwrap();
387 assert_eq!(diger.code(), mtr_dex::SHA3_256);
388 assert_eq!(diger.raw().len(), raw_size(diger.code()).unwrap());
389 assert!(diger.verify(ser));
390
391 let mut hasher = Sha256::new();
393 hasher.update(ser);
394 let dig = hasher.finalize();
395 let diger = Diger::new(Some(&dig), Some(mtr_dex::SHA2_256), None, None).unwrap();
396 assert_eq!(diger.code(), mtr_dex::SHA2_256);
397 assert_eq!(diger.raw().len(), raw_size(diger.code()).unwrap());
398 assert!(diger.verify(ser));
399
400 let diger = Diger::from_ser(ser, Some(mtr_dex::SHA2_256)).unwrap();
401 assert_eq!(diger.code(), mtr_dex::SHA2_256);
402 assert_eq!(diger.raw().len(), raw_size(diger.code()).unwrap());
403 assert!(diger.verify(ser));
404
405 let diger0 = Diger::from_ser(ser, None).unwrap(); let diger1 = Diger::from_ser(ser, Some(mtr_dex::SHA3_256)).unwrap();
408 let diger2 = Diger::from_ser(ser, Some(mtr_dex::BLAKE2B_512)).unwrap();
409 assert!(diger0.compare_with_diger(ser, &diger1));
411 assert!(diger0.compare_with_diger(ser, &diger2));
412 assert!(diger1.compare_with_diger(ser, &diger2));
413
414 assert!(diger0.compare_with_qb64(ser, &diger1.qb64()));
415 assert!(diger0.compare_with_qb64b(ser, &diger2.qb64b()));
416 assert!(diger1.compare_with_qb64(ser, &diger2.qb64()));
417
418 let ser1 = b"ABCDEFGHIJKLMNOPQSTUVWXYXZabcdefghijklmnopqrstuvwxyz0123456789";
419
420 let diger_ser1 = Diger::from_ser(ser1, None).unwrap();
422 assert!(!diger0.compare_with_diger(ser, &diger_ser1));
423 assert!(!diger0.compare_with_qb64(ser, &diger_ser1.qb64()));
424
425 let diger_ser1_sha3 = Diger::from_ser(ser1, Some(mtr_dex::SHA3_256)).unwrap();
427 assert!(!diger0.compare_with_diger(ser, &diger_ser1_sha3));
428 assert!(!diger0.compare_with_qb64b(ser, &diger_ser1_sha3.qb64b()));
429 }
430}