paysec_crypto_soft_aes/
lib.rs1use 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}