Skip to main content

libkeri/cesr/
diger.rs

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///  Diger is Matter subclass with method to verify digest of serialization
11#[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            // This should never happen because we validate in the constructor
97            _ => Err(MatterError::UnsupportedCodeError(String::from(code))),
98        }
99    }
100
101    /// Calculate Blake3 256-bit hash (default output size of Blake3)
102    fn digest_blake3_256(data: &[u8]) -> Result<[u8; 32], MatterError> {
103        let result = blake3::hash(data).into();
104        Ok(result)
105    }
106
107    /// Calculate Blake2b 512-bit hash
108    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    // /// Calculate Blake2b 256-bit hash
118    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    /// Calculate Blake2s 256-bit hash
133    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    /// Calculate Blake3 512-bit hash
143    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    /// Calculate SHA3-256 hash
151    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    /// Calculate SHA2-256 hash
161    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    /// Calculate SHA3-512 hash
171    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    /// Calculate SHA2-512 hash
181    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        // Test that the keyspace of Diger.Digests is the same as codes in DigDex
292        // (this would need to be adapted to your specific Rust implementation)
293        // assert_eq!(DigDex.keys().collect::<HashSet<_>>(), Diger::DIGESTS.keys().collect::<HashSet<_>>());
294        // Test EmptyMaterialError
295        let result = Diger::new(None, None, None, None);
296        assert!(result.is_err());
297
298        // Create something to digest and verify
299        let ser = b"abcdefghijklmnopqrstuvwxyz0123456789";
300
301        // Test invalid code error
302        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        // Test default constructor with raw digest
308        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        // Test with explicit code
315        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        // Test constructor with serialization
321        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        // Test constructor with qb64b
331        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        //
338        // Test constructor with qb64
339        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        // Test base64 encoding/decoding
345        // let pig = b"sLkveIFUPvt38xhtgYYJRCCpAGO7WjjHVR37Pawv67E=";
346        // let raw = decode_b64(str::from_utf8(pig).unwrap()).unwrap();
347        // assert_eq!(str::from_utf8(pig).unwrap(), &encode_b64(&raw));
348
349        // Test Blake2b_512
350        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        //
363        // Test Blake2s_256
364        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        //
372        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        // Test SHA3_256
378        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        // Test SHA2_256
392        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        // Test comparison functionality
406        let diger0 = Diger::from_ser(ser, None).unwrap(); // default code
407        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        //
410        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        // Codes match but content different
421        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        // Codes don't match and content different
426        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}