easy_hasher/
lib.rs

1
2/// Easy Hasher module
3pub mod easy_hasher {
4    type _Byte = u8;
5    type _Data = Vec<_Byte>;
6    type _Input<'a> = &'a String;
7    use sha3::Digest;
8    use sha1::Sha1;
9    use std::borrow::Borrow;
10
11    mod filedata {
12        use std::fs;
13        use std::io::Read;
14        use crate::easy_hasher::_Data;
15
16        pub(crate) struct FileData {
17            fp: fs::File,
18            fm: fs::Metadata,
19        }
20
21        impl FileData {
22            pub fn open<P: AsRef<std::path::Path>>(p: P) -> Result<FileData, String> {
23                let _fp = fs::File::open(p);
24                let _file: fs::File;
25                match _fp {
26                    Ok(f) => _file = f,
27                    Err(e) => return Err(e.to_string())
28                };
29
30                let _fm = _file.metadata();
31                let _meta: fs::Metadata;
32                match _fm {
33                    Ok(m) => _meta = m,
34                    Err(e) => return Err(e.to_string())
35                }
36
37                Ok(
38                    FileData {
39                        fp: _file,
40                        fm: _meta,
41                    }
42                )
43            }
44
45            pub fn to_vec(mut self) -> Result<_Data, String> {
46                let mut vec = vec![0; self.fm.len() as usize];
47                let _res = self.fp.read(&mut vec);
48                match _res {
49                    Ok(r) => if vec.len() == r {
50                        Ok(vec)
51                    } else {
52                        Err("error reading from file".to_string())
53                    },
54                    Err(e) => Err(e.to_string()),
55                }
56            }
57
58            #[allow(dead_code)]
59            pub fn file(self) -> fs::File {
60                self.fp
61            }
62
63            #[allow(dead_code)]
64            pub fn metadata(self) -> fs::Metadata {
65                self.fm
66            }
67        }
68    }
69
70    pub struct Hash {
71        hash: _Data,
72        length: usize
73    }
74
75    impl Hash {
76        /// Performs the conversion from `Vec<u8>` to `String`
77        pub fn hex_string(data: &_Data) -> String {
78            data
79                .iter()
80                .map(|byte| format!("{:02x}", byte))
81                .collect()
82        }
83
84        pub fn from_vec(data: &_Data) -> Hash {
85            Hash {
86                hash: data.clone(),
87                length: data.len()
88            }
89        }
90
91        /// Express hash as hex string
92        pub fn to_hex_string(&self) -> String {
93            Hash::hex_string(&self.hash)
94        }
95
96        /// Get hash as `Vec<u8>`
97        pub fn to_vec(&self) -> _Data {
98            self.hash.clone()
99        }
100
101        pub fn len(&self) -> usize {
102            self.length
103        }
104    }
105
106    /// Generic hashing function
107    fn sha3<T>(mut hasher: T, data: _Data) -> Hash where T: Digest {
108        hasher.input(data.as_slice());
109        let result = hasher
110            .result()
111            .to_vec();
112        Hash::from_vec(&result)
113    }
114
115    fn sha(data: _Data) -> Hash {
116        let mut hasher = Sha1::new();
117        hasher.update(data.as_slice());
118        let result = hasher
119            .digest()
120            .bytes()
121            .to_vec();
122        Hash::from_vec(&result)
123    }
124
125    fn md2n<T>(mut hasher: T, data: _Data) -> Hash where T: Digest {
126        hasher.input(data.as_slice());
127        let result = hasher
128            .result()
129            .to_vec();
130        Hash::from_vec(&result)
131    }
132
133    /// CRC8 raw data hashing function, based on polynomial and initial value
134    pub fn param_crc8(data: _Data, poly: u8, init: u8) -> Hash {
135        let mut crc8 = crc8::Crc8::create_msb(poly);
136        let result = vec![crc8.calc(data.as_slice(), data.len() as i32, init)];
137        Hash::from_vec(&result)
138    }
139
140    /// Generic-algorithm file hasher
141    pub fn file_hash(hasher: fn(_Data) -> Hash, filename: _Input) -> Result<Hash, String> {
142        use filedata::*;
143        let rfd = FileData::open(filename);
144        let fd: FileData;
145
146        match rfd {
147            Ok(data) => {
148                fd = data
149            },
150            Err(e) => {
151                println!("{}", e);
152                return Err(e)
153            },
154        }
155
156        let rcont = fd.to_vec();
157        let cont: _Data;
158
159        match rcont {
160            Ok(bytes) => cont = bytes,
161            Err(e) => return Err(e),
162        }
163
164        Ok(hasher(cont))
165    }
166
167    // FILE
168
169    /// CRC8 file hashing function\
170    /// poly = 0x07, init = 0x00
171    pub fn file_crc8(filename: _Input) -> Result<Hash, String> {
172        file_hash(raw_crc8, filename)
173    }
174
175    /// CRC16/ARC file hashing function
176    pub fn file_crc16(filename: _Input) -> Result<Hash, String> {
177        file_hash(raw_crc16, filename)
178    }
179
180    /// CRC32/IEEE file hashing function
181    pub fn file_crc32(filename: _Input) -> Result<Hash, String> {
182        file_hash(raw_crc32, filename)
183    }
184
185    /// CRC64/ECMA file hashing function
186    pub fn file_crc64(filename: _Input) -> Result<Hash, String> {
187        file_hash(raw_crc64, filename)
188    }
189
190    /// MD5 file hashing function
191    pub fn file_md5(filename: _Input) -> Result<Hash, String> {
192        file_hash(raw_md5, filename)
193    }
194
195    /// SHA-1 file hashing function
196    pub fn file_sha1(filename: _Input) -> Result<Hash, String> {
197        file_hash(raw_sha1, filename)
198    }
199
200    /// SHA-224 file hashing function
201    pub fn file_sha224(filename: _Input) -> Result<Hash, String> {
202        file_hash(raw_sha224, filename)
203    }
204
205    /// SHA-256 file hashing function
206    pub fn file_sha256(filename: String) -> Result<Hash, String> {
207        file_hash(raw_sha256, filename.borrow())
208    }
209
210    /// SHA-384 file hashing function
211    pub fn file_sha384(filename: _Input) -> Result<Hash, String> {
212        file_hash(raw_sha384, filename)
213    }
214
215    /// SHA-512 file hashing function
216    pub fn file_sha512(filename: _Input) -> Result<Hash, String> {
217        file_hash(raw_sha512, filename)
218    }
219
220    /// SHA-512/224 file hashing function
221    pub fn file_sha512_224(filename: _Input) -> Result<Hash, String> {
222        file_hash(raw_sha512_224, filename)
223    }
224
225    /// SHA-512/256 file hashing function
226    pub fn file_sha512_256(filename: _Input) -> Result<Hash, String> {
227        file_hash(raw_sha512_256, filename)
228    }
229
230    /// SHA3-224 file hashing function
231    pub fn file_sha3_224(filename: _Input) -> Result<Hash, String> {
232        file_hash(raw_sha3_224, filename)
233    }
234
235    /// SHA3-256 file hashing function
236    pub fn file_sha3_256(filename: _Input) -> Result<Hash, String> {
237        file_hash(raw_sha3_256, filename)
238    }
239
240    /// SHA3-384 file hashing function
241    pub fn file_sha3_384(filename: _Input) -> Result<Hash, String> {
242        file_hash(raw_sha3_384, filename)
243    }
244
245    /// SHA3-512 file hashing function
246    pub fn file_sha3_512(filename: _Input) -> Result<Hash, String> {
247        file_hash(raw_sha3_512, filename)
248    }
249
250    /// Keccak-224 file hashing function
251    pub fn file_keccak_224(filename: _Input) -> Result<Hash, String> {
252        file_hash(raw_keccak224, filename)
253    }
254
255    /// Keccak-256 file hashing function
256    pub fn file_keccak_256(filename: _Input) -> Result<Hash, String> {
257        file_hash(raw_keccak256, filename)
258    }
259
260    /// Keccak-384 file hashing function
261    pub fn file_keccak_384(filename: _Input) -> Result<Hash, String> {
262        file_hash(raw_keccak384, filename)
263    }
264
265    /// Keccak-512 file hashing function
266    pub fn file_keccak_512(filename: _Input) -> Result<Hash, String> {
267        file_hash(raw_keccak512, filename)
268    }
269
270
271    // BINARY DATA
272
273    /// CRC8 raw data hashing function\
274    /// poly = 0x07, init = 0x00
275    pub fn raw_crc8(d: _Data) -> Hash {
276        param_crc8(d, 0x7, 0x0)
277    }
278
279    /// CRC16/ARC raw data hashing function
280    pub fn raw_crc16(d: _Data) -> Hash {
281        let result = crc16::State::<crc16::ARC>::calculate(d.as_slice())
282            .to_be_bytes()
283            .to_vec()
284            .clone();
285        Hash::from_vec(&result)
286    }
287
288    /// CRC32 raw data hashing function
289    pub fn raw_crc32(d: _Data) -> Hash {
290        let result = crc::crc32::checksum_ieee(d.as_slice())
291            .to_be_bytes()
292            .to_vec()
293            .clone();
294        Hash::from_vec(&result)
295    }
296
297    /// CRC64 raw data hashing function
298    pub fn raw_crc64(d: _Data) -> Hash {
299        let result = crc::crc64::checksum_ecma(d.as_slice())
300            .to_be_bytes()
301            .to_vec()
302            .clone();
303        Hash::from_vec(&result)
304    }
305
306    /// MD2 raw data hashing function
307    pub fn raw_md2(d: _Data) -> Hash {
308        use md2::Md2;
309        md2n(Md2::new(), d)
310    }
311
312    /// MD4 raw data hashing function
313    pub fn raw_md4(d: _Data) -> Hash {
314        use md4::Md4;
315        md2n(Md4::new(), d)
316    }
317
318    /// MD5 raw data hashing function
319    pub fn raw_md5(d: _Data) -> Hash {
320        let result = md5::compute(d)
321            .0
322            .to_vec();
323        Hash::from_vec(&result)
324    }
325
326    /// SHA-1 raw data hashing function
327    pub fn raw_sha1(d: _Data) -> Hash {
328        sha(d)
329    }
330
331    /// SHA-224 raw data hashing function
332    pub fn raw_sha224(d: _Data) -> Hash {
333        sha3(sha2::Sha224::new(), d)
334    }
335
336    /// SHA-256 raw data hashing function
337    pub fn raw_sha256(d: _Data) -> Hash {
338        sha3(sha2::Sha256::new(), d)
339    }
340
341    /// SHA-384 raw data hashing function
342    pub fn raw_sha384(d: _Data) -> Hash {
343        sha3(sha2::Sha384::new(), d)
344    }
345
346    /// SHA-512 raw data hashing function
347    pub fn raw_sha512(d: _Data) -> Hash {
348        sha3(sha2::Sha512::new(), d)
349    }
350
351    /// SHA-512/224 raw data hashing function
352    pub fn raw_sha512_224(d: _Data) -> Hash {
353        sha3(sha2::Sha512Trunc224::new(), d)
354    }
355
356    /// SHA-512/256 raw data hashing function
357    pub fn raw_sha512_256(d: _Data) -> Hash {
358        sha3(sha2::Sha512Trunc256::new(), d)
359    }
360
361    /// SHA3-224 raw data hashing function
362    pub fn raw_sha3_224(d: _Data) -> Hash {
363        sha3(sha3::Sha3_224::new(), d)
364    }
365
366    /// SHA3-256 raw data hashing function
367    pub fn raw_sha3_256(d: _Data) -> Hash {
368        sha3(sha3::Sha3_256::new(), d)
369    }
370
371    /// SHA3-384 raw data hashing function
372    pub fn raw_sha3_384(d: _Data) -> Hash {
373        sha3(sha3::Sha3_384::new(), d)
374    }
375
376    /// SHA3-512 raw data hashing function
377    pub fn raw_sha3_512(d: _Data) -> Hash {
378        sha3(sha3::Sha3_512::new(), d)
379    }
380
381    /// Keccak-224 raw data hashing function
382    pub fn raw_keccak224(d: _Data) -> Hash {
383        sha3(sha3::Keccak224::new(), d)
384    }
385
386    /// Keccak-256 raw data hashing function
387    pub fn raw_keccak256(d: _Data) -> Hash {
388        sha3(sha3::Keccak256::new(), d)
389    }
390
391    /// Keccak-384 raw data hashing function
392    pub fn raw_keccak384(d: _Data) -> Hash {
393        sha3(sha3::Keccak384::new(), d)
394    }
395
396    /// Keccak-512 raw data hashing function
397    pub fn raw_keccak512(d: _Data) -> Hash {
398        sha3(sha3::Keccak512::new(), d)
399    }
400
401    // STRING
402
403    /// CRC8 string hashing function\
404    /// poly = 0x07, init = 0x00
405    pub fn crc8(s: _Input) -> Hash {
406        raw_crc8(s.clone().into_bytes())
407    }
408
409    /// CRC16/ARC string hashing function
410    pub fn crc16(s: _Input) -> Hash {
411        raw_crc16(s.clone().into_bytes())
412    }
413
414    /// CRC32 string hashing function
415    pub fn crc32(s: _Input) -> Hash {
416        raw_crc32(s.clone().into_bytes())
417    }
418
419    /// CRC64 string hashing function
420    pub fn crc64(s: _Input) -> Hash {
421        raw_crc64(s.clone().into_bytes())
422    }
423
424    /// MD5 string hashing function
425    pub fn md2(s: _Input) -> Hash {
426        raw_md2(s.clone().into_bytes())
427    }
428
429    /// MD5 string hashing function
430    pub fn md4(s: _Input) -> Hash {
431        raw_md4(s.clone().into_bytes())
432    }
433
434    /// MD5 string hashing function
435    pub fn md5(s: _Input) -> Hash {
436        raw_md5(s.clone().into_bytes())
437    }
438
439    /// SHA-1 string hashing function
440    pub fn sha1(s: _Input) -> Hash {
441        raw_sha1(s.clone().into_bytes())
442    }
443
444    /// SHA-224 string hashing function
445    pub fn sha224(s: _Input) -> Hash {
446        raw_sha224(s.clone().into_bytes())
447    }
448
449    /// SHA-256 string hashing function
450    pub fn sha256(s: _Input) -> Hash {
451        raw_sha256(s.clone().into_bytes())
452    }
453
454    /// SHA-384 string hashing function
455    pub fn sha384(s: _Input) -> Hash {
456        raw_sha384(s.clone().into_bytes())
457    }
458
459    /// SHA-512 string hashing function
460    pub fn sha512(s: _Input) -> Hash {
461        raw_sha512(s.clone().into_bytes())
462    }
463
464    /// SHA-512/224 string hashing function
465    pub fn sha512_224(s: _Input) -> Hash {
466        raw_sha512_224(s.clone().into_bytes())
467    }
468
469    /// SHA-512/256 string hashing function
470    pub fn sha512_256(s: _Input) -> Hash {
471        raw_sha512_256(s.clone().into_bytes())
472    }
473
474    /// SHA3-224 string hashing function
475    pub fn sha3_224(s: _Input) -> Hash {
476        raw_sha3_224(s.clone().into_bytes())
477    }
478
479    /// SHA3-256 string hashing function
480    pub fn sha3_256(s: _Input) -> Hash {
481        raw_sha3_256(s.clone().into_bytes())
482    }
483
484    /// SHA3-384 string hashing function
485    pub fn sha3_384(s: _Input) -> Hash {
486        raw_sha3_384(s.clone().into_bytes())
487    }
488
489    /// SHA3-512 string hashing function
490    pub fn sha3_512(s: _Input) -> Hash {
491        raw_sha3_512(s.clone().into_bytes())
492    }
493
494    /// Keccak-224 string hashing function
495    pub fn keccak224(s: _Input) -> Hash {
496        raw_keccak224(s.clone().into_bytes())
497    }
498
499    /// Keccak-256 string hashing function
500    pub fn keccak256(s: _Input) -> Hash {
501        raw_keccak256(s.clone().into_bytes())
502    }
503
504    /// Keccak-384 string hashing function
505    pub fn keccak384(s: _Input) -> Hash {
506        raw_keccak384(s.clone().into_bytes())
507    }
508
509    /// Keccak-512 string hashing function
510    pub fn keccak512(s: _Input) -> Hash {
511        raw_keccak512(s.clone().into_bytes())
512    }
513}
easy_hasher/lib.rs

easy_hasher/
lib.rs
