forge_hasher 0.1.3

The rust language implementation of forge_hasher
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use super::HashLen;
use super::Result;

use crypto::digest::Digest;
use crypto::sha2;

/// len enum {224, 256, 384, 512}, default 256
/// round enum {1, 2, 3 ... 100}, default 2
/// input is hashed round times by sha2, return [u8]
pub fn hash(input: &[u8], len: HashLen, round: u8) -> Result<Vec<u8>> {
    // FIXME: redesign this code future, ugly!!!
    match len {
        HashLen::Len224 => {
            let mut ret = [0; 28];
            let mut hasher = sha2::Sha224::new();
            hasher.input(input);
            hasher.result(&mut ret);
            for _ in 0..round - 1 {
                let mut hasher = sha2::Sha224::new();
                hasher.input(&ret);
                hasher.result(&mut ret);
            }
            return Ok(ret.to_vec());
        }
        HashLen::Len256 => {
            let mut ret = [0; 32];
            let mut hasher = sha2::Sha256::new();
            hasher.input(input);
            hasher.result(&mut ret);
            for _ in 0..round - 1 {
                let mut hasher = sha2::Sha256::new();
                hasher.input(&ret);
                hasher.result(&mut ret);
            }
            return Ok(ret.to_vec());
        }
        HashLen::Len384 => {
            let mut ret = [0; 48];
            let mut hasher = sha2::Sha384::new();
            hasher.input(input);
            hasher.result(&mut ret);
            for _ in 0..round - 1 {
                let mut hasher = sha2::Sha384::new();
                hasher.input(&ret);
                hasher.result(&mut ret);
            }
            return Ok(ret.to_vec());
        }
        HashLen::Len512 => {
            let mut ret = [0; 64];
            let mut hasher = sha2::Sha512::new();
            hasher.input(input);
            hasher.result(&mut ret);
            for _ in 0..round - 1 {
                let mut hasher = sha2::Sha512::new();
                hasher.input(&ret);
                hasher.result(&mut ret);
            }
            return Ok(ret.to_vec());
        }
        _ => bail!("sha2 not support hash algo {:?}", len),
    }
}

#[test]
fn test_sha2() -> Result<()> {
    let input = &"hello".as_bytes();

    let expect_256_1 = vec![
        44, 242, 77, 186, 95, 176, 163, 14, 38, 232, 59, 42, 197, 185, 226, 158, 27, 22, 30, 92,
        31, 167, 66, 94, 115, 4, 51, 98, 147, 139, 152, 36,
    ];
    assert_eq!(hash(input, HashLen::Len256, 1)?, expect_256_1);

    let expect_256_2 = vec![
        149, 149, 201, 223, 144, 7, 81, 72, 235, 6, 134, 3, 101, 223, 51, 88, 75, 117, 191, 247,
        130, 165, 16, 198, 205, 72, 131, 164, 25, 131, 61, 80,
    ];
    assert_eq!(hash(input, HashLen::Len256, 2)?, expect_256_2);

    let expect_384_2 = vec![
        212, 125, 137, 255, 213, 7, 30, 130, 96, 205, 111, 202, 26, 70, 104, 96, 88, 113, 175, 95,
        190, 219, 237, 115, 117, 161, 17, 124, 140, 20, 200, 45, 60, 234, 194, 52, 77, 209, 224,
        48, 53, 174, 28, 94, 117, 92, 245, 242,
    ];
    assert_eq!(hash(input, HashLen::Len384, 2)?, expect_384_2);

    Ok(())
}