libsumatracrypt_rs/
digest.rs

1use blake3;
2use blake2_rfc;
3use sha2::{Sha224, Sha256, Sha384, Sha512, Digest};
4use tiny_keccak::{Shake, *};
5use sha1::{Sha1};
6use hex::*;
7
8use serde::{Serialize,Deserialize};
9
10use zeroize::{Zeroize,ZeroizeOnDrop,Zeroizing};
11
12pub struct SumatraBlake3;
13pub struct SumatraBlake2b;
14pub struct SumatraSha2;
15pub struct SumatraSha3;
16pub struct SumatraShake256;
17
18pub struct SumatraSha1;
19
20#[derive(Zeroize,ZeroizeOnDrop,Clone,Serialize,Deserialize)]
21pub struct SumatraDigest(String);
22
23impl SumatraDigest {
24    pub fn to_string(&self) -> Zeroizing<String> {
25        let zeroizer = Zeroizing::new(self.0.to_string());
26        return zeroizer
27    }
28}
29
30impl SumatraBlake3 {
31    pub fn new<T: AsRef<[u8]>>(bytes: T) -> SumatraDigest {
32        let digest = blake3::hash(bytes.as_ref());
33        return SumatraDigest(hex::encode_upper(digest.as_bytes()));
34    }
35}
36
37impl SumatraBlake2b {
38    pub fn new<T: AsRef<[u8]>>(bytes: T, key: T, digest_size: usize) -> SumatraDigest {
39        if digest_size > 0usize && digest_size <= 64usize {
40            let hash = blake2_rfc::blake2b::blake2b(digest_size, key.as_ref(), bytes.as_ref());
41
42            return SumatraDigest(hex::encode_upper(hash.as_bytes()));
43        }
44        else {
45            panic!("Digest size is too high or too low")
46        }
47    }
48}
49
50impl SumatraSha1 {
51    pub fn new<T: AsRef<[u8]>>(bytes: T) -> SumatraDigest {
52        use sha1::Digest;
53        let mut hasher = Sha1::new();
54
55        hasher.update(bytes.as_ref());
56
57        let output = hasher.finalize();
58
59        return SumatraDigest(hex::encode_upper(output))
60    }
61}
62
63impl SumatraSha2 {
64    pub fn new<T: AsRef<[u8]>>(bytes: T) -> SumatraDigest {
65        return Self::sha256(bytes)
66    }
67    pub fn sha224<T: AsRef<[u8]>>(bytes: T) -> SumatraDigest {
68        let mut hasher = Sha224::new();
69        hasher.update(bytes.as_ref());
70        let digest = hasher.finalize();
71        return SumatraDigest(hex::encode_upper(digest));
72    }
73    pub fn sha256<T: AsRef<[u8]>>(bytes: T) -> SumatraDigest {
74        let mut hasher = Sha256::new();
75        hasher.update(bytes.as_ref());
76        let digest = hasher.finalize();
77        return SumatraDigest(hex::encode_upper(digest));
78    }
79    pub fn sha384<T: AsRef<[u8]>>(bytes: T) -> SumatraDigest {
80        let mut hasher = Sha384::new();
81        hasher.update(bytes.as_ref());
82        let digest = hasher.finalize();
83        return SumatraDigest(hex::encode_upper(digest));
84    }
85    pub fn sha512<T: AsRef<[u8]>>(bytes: T) -> SumatraDigest {
86        let mut hasher = Sha512::new();
87        hasher.update(bytes.as_ref());
88        let digest = hasher.finalize();
89        return SumatraDigest(hex::encode_upper(digest));
90    }
91}
92
93impl SumatraSha3 {
94    pub fn sha3_224<T: AsRef<[u8]>>(data: T) -> SumatraDigest {
95        let mut output = [0u8;28];
96
97        let mut sha3 = Sha3::v224();
98        sha3.update(data.as_ref());
99        sha3.finalize(&mut output);
100
101        return SumatraDigest(hex::encode_upper(output))
102    }
103    pub fn sha3_256<T: AsRef<[u8]>>(data: T) -> SumatraDigest {
104        let mut output = [0u8;32];
105
106        let mut sha3 = Sha3::v256();
107        sha3.update(data.as_ref());
108        sha3.finalize(&mut output);
109
110        return SumatraDigest(hex::encode_upper(output))
111    }
112    pub fn sha3_384<T: AsRef<[u8]>>(data: T) -> SumatraDigest {
113        let mut output = [0u8;48];
114
115        let mut sha3 = Sha3::v384();
116        sha3.update(data.as_ref());
117        sha3.finalize(&mut output);
118
119        return SumatraDigest(hex::encode_upper(output))
120    }
121    pub fn sha3_512<T: AsRef<[u8]>>(data: T) -> SumatraDigest {
122        let mut output = [0u8;64];
123
124        let mut sha3 = Sha3::v512();
125        sha3.update(data.as_ref());
126        sha3.finalize(&mut output);
127
128        return SumatraDigest(hex::encode_upper(output))
129    }
130}
131
132impl SumatraShake256 {
133    pub fn new<T: AsRef<[u8]>>(data: T) -> SumatraDigest {
134        let mut output = [0u8;64];
135
136        let mut shake = Shake::v256();
137        shake.update(data.as_ref());
138        shake.finalize(&mut output);
139
140        return SumatraDigest(hex::encode_upper(output))
141    }
142}
libsumatracrypt_rs/digest.rs

libsumatracrypt_rs/
digest.rs
