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

use std::marker::PhantomData;

use digest::KeyInit;
use generic_array::{ArrayLength, GenericArray};

use super::crypto::{CryptoMac, CryptoMacAlgorithm};
use super::{Mac, MacAlgorithm};

pub struct CryptoEtmMacAlgorithm<
    M: digest::Mac + KeyInit + Send + 'static,
    KL: ArrayLength<u8> + 'static,
>(pub PhantomData<M>, pub PhantomData<KL>);

impl<M: digest::Mac + KeyInit + Send + 'static, KL: ArrayLength<u8> + 'static> MacAlgorithm
    for CryptoEtmMacAlgorithm<M, KL>
{
    fn key_len(&self) -> usize {
        CryptoMacAlgorithm::<M, KL>(self.0, self.1).key_len()
    }

    fn make_mac(&self, mac_key: &[u8]) -> Box<dyn Mac + Send> {
        let mut key = GenericArray::<u8, KL>::default();
        key.clone_from_slice(mac_key);
        Box::new(CryptoEtmMac::<M, KL>(CryptoMac::<M, KL> {
            key,
            p: PhantomData,
        })) as Box<dyn Mac + Send>
    }
}

pub struct CryptoEtmMac<M: digest::Mac + KeyInit + Send + 'static, KL: ArrayLength<u8> + 'static>(
    CryptoMac<M, KL>,
);

impl<M: digest::Mac + KeyInit + Send + 'static, KL: ArrayLength<u8> + 'static> Mac
    for CryptoEtmMac<M, KL>
{
    fn is_etm(&self) -> bool {
        true
    }

    fn mac_len(&self) -> usize {
        self.0.mac_len()
    }

    fn compute(&self, sequence_number: u32, payload: &[u8], output: &mut [u8]) {
        self.0.compute(sequence_number, payload, output)
    }

    fn verify(&self, sequence_number: u32, payload: &[u8], mac: &[u8]) -> bool {
        self.0.verify(sequence_number, payload, mac)
    }
}