Skip to main content

paysec_crypto_soft_aes/
lib.rs

1use std::error::Error;
2use std::fmt::{Display, Formatter};
3
4use paysec_crypto::{AesBlockCipher, AesCbc, AesCmac, AesCmacKeyDerivation, CryptoProvider};
5use soft_aes::aes::{aes_cmac, aes_dec_block, aes_dec_cbc, aes_enc_block, aes_enc_cbc};
6
7#[derive(Debug, Default, Clone, Copy)]
8pub struct SoftAesProvider;
9
10impl SoftAesProvider {
11    pub const fn new() -> Self {
12        Self
13    }
14}
15
16#[derive(Debug)]
17pub struct SoftAesError {
18    message: String,
19}
20
21impl SoftAesError {
22    fn new(message: impl Into<String>) -> Self {
23        Self {
24            message: message.into(),
25        }
26    }
27}
28
29impl Display for SoftAesError {
30    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
31        f.write_str(&self.message)
32    }
33}
34
35impl Error for SoftAesError {}
36
37impl From<Box<dyn Error>> for SoftAesError {
38    fn from(error: Box<dyn Error>) -> Self {
39        Self {
40            message: error.to_string(),
41        }
42    }
43}
44
45impl CryptoProvider for SoftAesProvider {
46    type Error = SoftAesError;
47}
48
49impl AesBlockCipher<[u8]> for SoftAesProvider {
50    fn encrypt_block(&self, key: &[u8], block: &[u8; 16]) -> Result<[u8; 16], Self::Error> {
51        aes_enc_block(block, key).map_err(SoftAesError::from)
52    }
53
54    fn decrypt_block(&self, key: &[u8], block: &[u8; 16]) -> Result<[u8; 16], Self::Error> {
55        aes_dec_block(block, key).map_err(SoftAesError::from)
56    }
57}
58
59impl AesCbc<[u8]> for SoftAesProvider {
60    fn encrypt_cbc(
61        &self,
62        key: &[u8],
63        iv: &[u8; 16],
64        plaintext: &[u8],
65    ) -> Result<Vec<u8>, Self::Error> {
66        aes_enc_cbc(plaintext, key, iv, None).map_err(SoftAesError::from)
67    }
68
69    fn decrypt_cbc(
70        &self,
71        key: &[u8],
72        iv: &[u8; 16],
73        ciphertext: &[u8],
74    ) -> Result<Vec<u8>, Self::Error> {
75        aes_dec_cbc(ciphertext, key, iv, None).map_err(SoftAesError::from)
76    }
77}
78
79impl AesCmac<[u8]> for SoftAesProvider {
80    fn calculate_cmac(&self, key: &[u8], message: &[u8]) -> Result<[u8; 16], Self::Error> {
81        aes_cmac(message, key).map_err(SoftAesError::from)
82    }
83}
84
85impl AesCmacKeyDerivation<[u8]> for SoftAesProvider {
86    type DerivedKey = Vec<u8>;
87
88    fn derive_key_cmac(
89        &self,
90        key: &[u8],
91        derivation_inputs: &[&[u8]],
92        output_len: usize,
93    ) -> Result<Self::DerivedKey, Self::Error> {
94        let available_len = derivation_inputs.len() * 16;
95
96        if output_len > available_len {
97            return Err(SoftAesError::new(
98                "insufficient CMAC output for requested derived key length",
99            ));
100        }
101
102        let mut derived_key = Vec::with_capacity(available_len);
103
104        for input in derivation_inputs {
105            let block = aes_cmac(input, key).map_err(SoftAesError::from)?;
106
107            derived_key.extend_from_slice(&block);
108        }
109
110        derived_key.truncate(output_len);
111
112        Ok(derived_key)
113    }
114}
115
116#[cfg(test)]
117mod tests {
118    use super::*;
119
120    #[test]
121    fn aes_128_block_cipher_matches_known_vector() {
122        let provider = SoftAesProvider::new();
123
124        let key = hex::decode("000102030405060708090A0B0C0D0E0F").unwrap();
125
126        let plaintext: [u8; 16] = hex::decode("00112233445566778899AABBCCDDEEFF")
127            .unwrap()
128            .try_into()
129            .unwrap();
130
131        let expected: [u8; 16] = hex::decode("69C4E0D86A7B0430D8CDB78070B4C55A")
132            .unwrap()
133            .try_into()
134            .unwrap();
135
136        let encrypted = provider.encrypt_block(&key, &plaintext).unwrap();
137
138        assert_eq!(encrypted, expected);
139
140        let decrypted = provider.decrypt_block(&key, &encrypted).unwrap();
141
142        assert_eq!(decrypted, plaintext);
143    }
144
145    #[test]
146    fn aes_128_cmac_matches_known_vector() {
147        let provider = SoftAesProvider::new();
148
149        let key = hex::decode("2B7E151628AED2A6ABF7158809CF4F3C").unwrap();
150
151        let message = hex::decode("6BC1BEE22E409F96E93D7E117393172A").unwrap();
152
153        let expected: [u8; 16] = hex::decode("070A16B46B4D4144F79BDD9DD04A287C")
154            .unwrap()
155            .try_into()
156            .unwrap();
157
158        let mac = provider.calculate_cmac(&key, &message).unwrap();
159
160        assert_eq!(mac, expected);
161    }
162}
163
164impl AesCbc<Vec<u8>> for SoftAesProvider {
165    fn encrypt_cbc(
166        &self,
167        key: &Vec<u8>,
168        iv: &[u8; 16],
169        plaintext: &[u8],
170    ) -> Result<Vec<u8>, Self::Error> {
171        aes_enc_cbc(plaintext, key.as_slice(), iv, None).map_err(SoftAesError::from)
172    }
173
174    fn decrypt_cbc(
175        &self,
176        key: &Vec<u8>,
177        iv: &[u8; 16],
178        ciphertext: &[u8],
179    ) -> Result<Vec<u8>, Self::Error> {
180        aes_dec_cbc(ciphertext, key.as_slice(), iv, None).map_err(SoftAesError::from)
181    }
182}
183
184impl AesCmac<Vec<u8>> for SoftAesProvider {
185    fn calculate_cmac(&self, key: &Vec<u8>, message: &[u8]) -> Result<[u8; 16], Self::Error> {
186        aes_cmac(message, key.as_slice()).map_err(SoftAesError::from)
187    }
188}