hacl-star 0.1.0

HACL*, a formally verified cryptographic library for Rust (binding to hacl-c).
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use hacl_star_sys as ffi;


macro_rules! sha2 {
    (
        pub struct $name:ident {
            state: [ $s:ty; $size:expr ],
            block: [ u8; $block:expr ]
        }

        const HASH_LENGTH = $outlen:expr;

        impl $hash:path;
        impl $init:path;
        impl $update:path;
        impl $update_multi:path;
        impl $update_last:path;
        impl $finish:path;
    ) => {
        #[derive(Clone)]
        pub struct $name {
            state: [$s; $size],
            block: [u8; $block],
            pos: usize
        }

        impl $name {
            pub const BLOCK_LENGTH: usize = $block;
            pub const HASH_LENGTH: usize = $outlen;

            pub fn hash(output: &mut [u8; $outlen], input: &[u8]) {
                unsafe { $hash(output.as_mut_ptr(), input.as_ptr() as _, input.len() as _) };
            }
        }

        impl Default for $name {
            fn default() -> Self {
                let mut state = [0; $size];
                unsafe { $init(state.as_mut_ptr()) };
                $name { state, block: [0; $block], pos: 0 }
            }
        }

        impl $name {
            pub fn update(&mut self, buf: &[u8]) {
                let len = buf.len();
                let br = $block - self.pos;

                if len >= br {
                    self.block[self.pos..][..br].copy_from_slice(&buf[..br]);
                    unsafe { $update(self.state.as_mut_ptr(), self.block.as_ptr() as _) };
                    self.pos = 0;
                } else {
                    self.block[self.pos..][..len].copy_from_slice(buf);
                    self.pos += len;
                    return;
                }

                let buf = &buf[br..];
                let len = buf.len();
                let n = len / $block;
                let r = len % $block;

                unsafe { $update_multi(self.state.as_mut_ptr(), buf.as_ptr() as _, n as _) };

                self.block[..r].copy_from_slice(&buf[n * $block..][..r]);
                self.pos = r;
            }

            pub fn finish(mut self, buf: &mut [u8; $outlen]) {
                unsafe {
                    $update_last(self.state.as_mut_ptr(), self.block.as_ptr() as _, self.pos as _);
                    $finish(self.state.as_ptr() as _, buf.as_mut_ptr());
                }
            }
        }
    }
}

sha2!{
    pub struct Sha256 {
        state: [u32; 137],
        block: [u8; 64]
    }

    const HASH_LENGTH = 32;

    impl ffi::sha2_256::Hacl_SHA2_256_hash;
    impl ffi::sha2_256::Hacl_SHA2_256_init;
    impl ffi::sha2_256::Hacl_SHA2_256_update;
    impl ffi::sha2_256::Hacl_SHA2_256_update_multi;
    impl ffi::sha2_256::Hacl_SHA2_256_update_last;
    impl ffi::sha2_256::Hacl_SHA2_256_finish;
}

sha2!{
    pub struct Sha384 {
        state: [u64; 169],
        block: [u8; 128]
    }

    const HASH_LENGTH = 48;

    impl ffi::sha2_384::Hacl_SHA2_384_hash;
    impl ffi::sha2_384::Hacl_SHA2_384_init;
    impl ffi::sha2_384::Hacl_SHA2_384_update;
    impl ffi::sha2_384::Hacl_SHA2_384_update_multi;
    impl ffi::sha2_384::Hacl_SHA2_384_update_last;
    impl ffi::sha2_384::Hacl_SHA2_384_finish;
}

sha2!{
    pub struct Sha512 {
        state: [u64; 169],
        block: [u8; 128]
    }

    const HASH_LENGTH = 64;

    impl ffi::sha2_512::Hacl_SHA2_512_hash;
    impl ffi::sha2_512::Hacl_SHA2_512_init;
    impl ffi::sha2_512::Hacl_SHA2_512_update;
    impl ffi::sha2_512::Hacl_SHA2_512_update_multi;
    impl ffi::sha2_512::Hacl_SHA2_512_update_last;
    impl ffi::sha2_512::Hacl_SHA2_512_finish;
}