cc2538-hal 0.3.0

Hardware abstraction layer for the CC2538 System-On-Chip
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
127
128
129
130
131
132
133
134

use cc2538_pac::aes;

use super::super::CtrWidth;
use super::AesEngine;
use super::Crypto;

pub struct AesCcm {}

#[derive(Debug, Clone, Copy)]
pub struct AesCcmInfo<'a> {
    key_index: u32,
    len_field_size: u8,
    auth_field_size: u8,
    adata: Option<&'a [u8]>,
}

impl<'a> AesCcmInfo<'a> {
    pub fn new(key_index: u32, len_field_size: u8, auth_field_size: u8) -> Self {
        Self {
            key_index,
            len_field_size,
            auth_field_size,
            adata: None,
        }
    }

    pub fn with_added_auth_data(self, adata: &'a [u8]) -> Self {
        Self {
            adata: Some(adata),
            ..self
        }
    }
}

impl Crypto<'_> {
    const CCM_NONCE_LEN: usize = 15;

    fn ccm_crypt(
        &mut self,
        ctrl: impl FnOnce(&aes::RegisterBlock),
        ccm_info: &AesCcmInfo,
        nonce: &[u8],
        data_in: &[u8],
        data_out: &mut [u8],
    ) {
        if Self::is_aes_in_use() {
            return;
        }

        // Prepare the IV
        // The first part is the length of the data minus 1.
        // The following part is the nonce.
        // And the rest is the counter.
        let mut iv = [0u8; 16];
        iv[0] = ccm_info.len_field_size - 1;
        iv[1..][..Self::CCM_NONCE_LEN - ccm_info.len_field_size as usize].copy_from_slice(nonce);
        iv[16 - ccm_info.len_field_size as usize..].fill_with(|| 0);

        self.auth_crypt(
            ctrl,
            ccm_info.key_index,
            Some(&iv),
            ccm_info.adata,
            data_in,
            data_out,
        );
    }

    pub fn ccm_encrypt(
        &mut self,
        ccm_info: &AesCcmInfo,
        nonce: &[u8],
        data_in: &[u8],
        data_out: &mut [u8],
        tag: &mut [u8],
    ) {
        let m = (ccm_info.auth_field_size.max(2) - 2) >> 1;
        let l = ccm_info.len_field_size - 1;

        let ctrl = |aes: &aes::RegisterBlock| unsafe {
            aes.aes_ctrl().modify(|_, w| {
                w.save_context()
                    .set_bit()
                    .ccm_m()
                    .bits(m)
                    .ccm_l()
                    .bits(l)
                    .ccm()
                    .set_bit()
                    .ctr_width()
                    .bits(CtrWidth::Width128 as u8)
                    .ctr()
                    .set_bit()
                    .direction()
                    .set_bit()
            });
        };

        self.ccm_crypt(ctrl, ccm_info, nonce, data_in, data_out);
        self.read_tag(tag);
    }

    pub fn ccm_decrypt(
        &mut self,
        ccm_info: &AesCcmInfo,
        nonce: &[u8],
        data_in: &[u8],
        data_out: &mut [u8],
    ) {
        let m = (ccm_info.auth_field_size.max(2) - 2) >> 1;
        let l = ccm_info.len_field_size - 1;

        let ctrl = |aes: &aes::RegisterBlock| unsafe {
            aes.aes_ctrl().modify(|_, w| {
                w.save_context()
                    .set_bit()
                    .ccm_m()
                    .bits(m)
                    .ccm_l()
                    .bits(l)
                    .ccm()
                    .set_bit()
                    .ctr_width()
                    .bits(CtrWidth::Width128 as u8)
                    .ctr()
                    .set_bit()
                    .direction()
                    .clear_bit()
            });
        };

        self.ccm_crypt(ctrl, ccm_info, nonce, data_in, data_out);
    }
}