flatline-umac 0.1.0

Rust bindings for UMAC (Universal Message Authentication Code)
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

#[allow(non_camel_case_types)]
mod ffi {
    include!(concat!(env!("OUT_DIR"), "/umac.rs"));
}

pub trait UMac<const KEY: usize, const TAG: usize> {
    const KEY_LEN: usize = KEY;
    const TAG_LEN: usize = TAG;
    fn new(key: [u8; KEY]) -> Self;
    fn update(&mut self, data: &[u8]);
    fn finalize(&mut self, nonce: [u8; 8]) -> [u8; TAG];
}

pub struct UMac64 {
    ctx: *mut ffi::umac_ctx,
}
impl Drop for UMac64 {
    fn drop(&mut self) {
        unsafe {
            let ret = ffi::umac_delete(self.ctx);
            assert_eq!(ret, 1);
        }
    }
}
unsafe impl Send for UMac64 {}
unsafe impl Sync for UMac64 {}

impl UMac<16, 8> for UMac64 {
    const KEY_LEN: usize = 16;
    const TAG_LEN: usize = 8;
    fn new(mut key: [u8; Self::KEY_LEN]) -> Self {
        unsafe {
            let ctx = ffi::umac_new(key.as_mut_ptr() as _);
            Self { ctx }
        }
    }

    fn update(&mut self, data: &[u8]) {
        unsafe {
            let ret =
                ffi::umac_update(self.ctx, data.as_ptr() as _, data.len().try_into().unwrap());
            assert_eq!(ret, 1);
        }
    }

    fn finalize(&mut self, nonce: [u8; 8]) -> [u8; Self::TAG_LEN] {
        unsafe {
            let mut tag = [0u8; Self::TAG_LEN];
            let ret = ffi::umac_final(self.ctx, tag.as_mut_ptr() as _, nonce.as_ptr() as _);
            assert_eq!(ret, 1);
            tag
        }
    }
}

pub struct UMac128 {
    ctx: *mut ffi::umac_ctx,
}

unsafe impl Send for UMac128 {}
unsafe impl Sync for UMac128 {}

impl Drop for UMac128 {
    fn drop(&mut self) {
        unsafe {
            let ret = ffi::umac128_delete(self.ctx);
            assert_eq!(ret, 1);
        }
    }
}
impl UMac<16, 16> for UMac128 {
    fn new(mut key: [u8; Self::KEY_LEN]) -> Self {
        unsafe {
            let ctx = ffi::umac128_new(key.as_mut_ptr() as _);
            Self { ctx }
        }
    }

    fn update(&mut self, data: &[u8]) {
        unsafe {
            let ret =
                ffi::umac128_update(self.ctx, data.as_ptr() as _, data.len().try_into().unwrap());
            assert_eq!(ret, 1);
        }
    }

    fn finalize(&mut self, nonce: [u8; 8]) -> [u8; Self::TAG_LEN] {
        unsafe {
            let mut tag = [0u8; Self::TAG_LEN];
            let ret = ffi::umac128_final(self.ctx, tag.as_mut_ptr() as _, nonce.as_ptr() as _);
            assert_eq!(ret, 1);
            tag
        }
    }
}