use aes::{Aes128, Aes192, Aes256};
use cbc::cipher::block_padding::NoPadding;
use cipher::{
Array, BlockCipherDecrypt, BlockCipherEncrypt, BlockModeDecrypt, BlockModeEncrypt, KeyInit,
KeyIvInit,
};
use cmac::Cmac;
use digest::Mac;
use thiserror::Error;
pub const AES_BLOCK_SIZE: usize = 16;
pub const AES_CMAC_OUTPUT_LEN: usize = 8;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KeyLength {
S128,
S192,
S256,
}
impl KeyLength {
pub fn byte_size(&self) -> usize {
match self {
KeyLength::S128 => 16,
KeyLength::S192 => 24,
KeyLength::S256 => 32,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CipherAlgorithm {
DeSede,
Aes,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum BlockCipherMode {
#[default]
Cbc,
Ecb,
}
#[derive(Debug, Error)]
pub enum AesCipherError {
#[error("AES{bits} key length must be {bytes} bytes, got {got}", bits = size * 8, bytes = size)]
InvalidKeyLength { size: usize, got: usize },
#[error("AES IV length must be {AES_BLOCK_SIZE} bytes, got {0}")]
InvalidIvLength(usize),
#[error("AES CBC mode requires an explicit IV")]
MissingIv,
#[error("AES data length must be a multiple of {AES_BLOCK_SIZE} bytes, got {0}")]
InvalidDataLength(usize),
#[error("CMAC key is invalid: {0}")]
CmacKeyError(String),
#[error("AES block size must be greater than zero")]
InvalidBlockSize,
}
#[derive(Clone)]
pub struct AesCipher {
key_size: usize,
}
impl AesCipher {
pub fn new(key_length: KeyLength) -> Self {
Self {
key_size: key_length.byte_size(),
}
}
pub fn key_size(&self) -> usize {
self.key_size
}
pub fn encrypt(
&self,
data: &[u8],
key: &[u8],
iv: Option<&[u8]>,
mode: BlockCipherMode,
padding: bool,
) -> Result<Vec<u8>, AesCipherError> {
self.validate_key(key)?;
let input = if padding {
self.zero_pad(data, AES_BLOCK_SIZE)?
} else {
data.to_vec()
};
if input.len() % AES_BLOCK_SIZE != 0 {
return Err(AesCipherError::InvalidDataLength(input.len()));
}
match mode {
BlockCipherMode::Cbc => {
let iv_bytes = self.resolve_iv(iv)?;
Ok(aes_cbc_encrypt(key, &iv_bytes, &input))
}
BlockCipherMode::Ecb => Ok(aes_ecb_encrypt(key, &input)),
}
}
pub fn decrypt(
&self,
data: &[u8],
key: &[u8],
iv: Option<&[u8]>,
mode: BlockCipherMode,
) -> Result<Vec<u8>, AesCipherError> {
self.validate_key(key)?;
if !data.len().is_multiple_of(AES_BLOCK_SIZE) {
return Err(AesCipherError::InvalidDataLength(data.len()));
}
match mode {
BlockCipherMode::Cbc => {
let iv_bytes = self.resolve_iv(iv)?;
Ok(aes_cbc_decrypt(key, &iv_bytes, data))
}
BlockCipherMode::Ecb => Ok(aes_ecb_decrypt(key, data)),
}
}
pub fn calculate_cmac(&self, data: &[u8], key: &[u8]) -> Result<Vec<u8>, AesCipherError> {
self.validate_key(key)?;
compute_cmac_truncated(key, data).map_err(|e| AesCipherError::CmacKeyError(e.to_string()))
}
pub fn zero_pad(&self, data: &[u8], block_size: usize) -> Result<Vec<u8>, AesCipherError> {
if block_size == 0 {
return Err(AesCipherError::InvalidBlockSize);
}
let remainder = data.len() % block_size;
if remainder == 0 {
return Ok(data.to_vec());
}
let pad_len = block_size - remainder;
let mut padded = data.to_vec();
padded.resize(padded.len() + pad_len, 0);
Ok(padded)
}
fn validate_key(&self, key: &[u8]) -> Result<(), AesCipherError> {
if key.len() != self.key_size {
return Err(AesCipherError::InvalidKeyLength {
size: self.key_size,
got: key.len(),
});
}
Ok(())
}
fn resolve_iv(&self, iv: Option<&[u8]>) -> Result<[u8; AES_BLOCK_SIZE], AesCipherError> {
match iv {
Some(v) => {
if v.len() != AES_BLOCK_SIZE {
return Err(AesCipherError::InvalidIvLength(v.len()));
}
let mut arr = [0u8; AES_BLOCK_SIZE];
arr.copy_from_slice(v);
Ok(arr)
}
None => Err(AesCipherError::MissingIv),
}
}
}
pub fn get_cipher(key_length: KeyLength) -> AesCipher {
AesCipher::new(key_length)
}
fn aes_cbc_encrypt(key: &[u8], iv: &[u8; AES_BLOCK_SIZE], data: &[u8]) -> Vec<u8> {
match key.len() {
16 => cbc::Encryptor::<Aes128>::new_from_slices(key, iv)
.expect("valid AES-128 key/iv")
.encrypt_padded_vec::<NoPadding>(data),
24 => cbc::Encryptor::<Aes192>::new_from_slices(key, iv)
.expect("valid AES-192 key/iv")
.encrypt_padded_vec::<NoPadding>(data),
32 => cbc::Encryptor::<Aes256>::new_from_slices(key, iv)
.expect("valid AES-256 key/iv")
.encrypt_padded_vec::<NoPadding>(data),
n => panic!("Invalid AES key length: {n}"),
}
}
fn aes_cbc_decrypt(key: &[u8], iv: &[u8; AES_BLOCK_SIZE], data: &[u8]) -> Vec<u8> {
match key.len() {
16 => cbc::Decryptor::<Aes128>::new_from_slices(key, iv)
.expect("valid AES-128 key/iv")
.decrypt_padded_vec::<NoPadding>(data),
24 => cbc::Decryptor::<Aes192>::new_from_slices(key, iv)
.expect("valid AES-192 key/iv")
.decrypt_padded_vec::<NoPadding>(data),
32 => cbc::Decryptor::<Aes256>::new_from_slices(key, iv)
.expect("valid AES-256 key/iv")
.decrypt_padded_vec::<NoPadding>(data),
n => panic!("Invalid AES key length: {n}"),
}
.expect("CBC NoPadding decrypt of block-aligned data is infallible")
}
fn aes_ecb_encrypt(key: &[u8], data: &[u8]) -> Vec<u8> {
let schedule = AesKeySchedule::new(key);
let mut output = data.to_vec();
for block in output.chunks_exact_mut(AES_BLOCK_SIZE) {
let mut arr: [u8; AES_BLOCK_SIZE] = block.try_into().unwrap();
schedule.encrypt_block_inplace(&mut arr);
block.copy_from_slice(&arr);
}
output
}
fn aes_ecb_decrypt(key: &[u8], data: &[u8]) -> Vec<u8> {
let schedule = AesKeySchedule::new(key);
let mut output = data.to_vec();
for block in output.chunks_exact_mut(AES_BLOCK_SIZE) {
let mut arr: [u8; AES_BLOCK_SIZE] = block.try_into().unwrap();
schedule.decrypt_block_inplace(&mut arr);
block.copy_from_slice(&arr);
}
output
}
enum AesKeySchedule {
A128(Aes128),
A192(Aes192),
A256(Aes256),
}
impl AesKeySchedule {
fn new(key: &[u8]) -> Self {
match key.len() {
16 => Self::A128(Aes128::new_from_slice(key).expect("valid AES-128 key")),
24 => Self::A192(Aes192::new_from_slice(key).expect("valid AES-192 key")),
32 => Self::A256(Aes256::new_from_slice(key).expect("valid AES-256 key")),
n => panic!("Invalid AES key length: {n}"),
}
}
fn encrypt_block_inplace(&self, block: &mut [u8; AES_BLOCK_SIZE]) {
let ga: &mut Array<u8, _> = block.into();
match self {
Self::A128(c) => c.encrypt_block(ga),
Self::A192(c) => c.encrypt_block(ga),
Self::A256(c) => c.encrypt_block(ga),
}
}
fn decrypt_block_inplace(&self, block: &mut [u8; AES_BLOCK_SIZE]) {
let ga: &mut Array<u8, _> = block.into();
match self {
Self::A128(c) => c.decrypt_block(ga),
Self::A192(c) => c.decrypt_block(ga),
Self::A256(c) => c.decrypt_block(ga),
}
}
}
fn compute_cmac_truncated(key: &[u8], data: &[u8]) -> Result<Vec<u8>, digest::InvalidLength> {
let full: Vec<u8> = match key.len() {
16 => {
let mut mac = <Cmac<Aes128> as digest::KeyInit>::new_from_slice(key)?;
Mac::update(&mut mac, data);
mac.finalize().into_bytes().to_vec()
}
24 => {
let mut mac = <Cmac<Aes192> as digest::KeyInit>::new_from_slice(key)?;
Mac::update(&mut mac, data);
mac.finalize().into_bytes().to_vec()
}
32 => {
let mut mac = <Cmac<Aes256> as digest::KeyInit>::new_from_slice(key)?;
Mac::update(&mut mac, data);
mac.finalize().into_bytes().to_vec()
}
n => panic!("Invalid AES key length for CMAC: {n}"),
};
Ok(full[..AES_CMAC_OUTPUT_LEN].to_vec())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn key_length_byte_sizes() {
assert_eq!(KeyLength::S128.byte_size(), 16);
assert_eq!(KeyLength::S192.byte_size(), 24);
assert_eq!(KeyLength::S256.byte_size(), 32);
}
#[test]
fn aes128_cbc_roundtrip() {
let cipher = AesCipher::new(KeyLength::S128);
let key = [0x01u8; 16];
let iv = [0x00u8; 16];
let pt = [0xABu8; 32];
let ct = cipher
.encrypt(&pt, &key, Some(&iv), BlockCipherMode::Cbc, false)
.unwrap();
assert_eq!(ct.len(), 32);
let dec = cipher
.decrypt(&ct, &key, Some(&iv), BlockCipherMode::Cbc)
.unwrap();
assert_eq!(dec, pt);
}
#[test]
fn aes192_cbc_roundtrip() {
let cipher = AesCipher::new(KeyLength::S192);
let key = [0x02u8; 24];
let iv = [0x01u8; 16];
let pt = [0xCDu8; 16];
let ct = cipher
.encrypt(&pt, &key, Some(&iv), BlockCipherMode::Cbc, false)
.unwrap();
let dec = cipher
.decrypt(&ct, &key, Some(&iv), BlockCipherMode::Cbc)
.unwrap();
assert_eq!(dec, pt);
}
#[test]
fn aes256_cbc_roundtrip() {
let cipher = AesCipher::new(KeyLength::S256);
let key = [0x03u8; 32];
let iv = [0x00u8; 16];
let pt = [0xEFu8; 48];
let ct = cipher
.encrypt(&pt, &key, Some(&iv), BlockCipherMode::Cbc, false)
.unwrap();
let dec = cipher
.decrypt(&ct, &key, Some(&iv), BlockCipherMode::Cbc)
.unwrap();
assert_eq!(dec, pt);
}
#[test]
fn aes128_ecb_roundtrip() {
let cipher = AesCipher::new(KeyLength::S128);
let key = [0xAAu8; 16];
let pt = [0x55u8; 16];
let ct = cipher
.encrypt(&pt, &key, None, BlockCipherMode::Ecb, false)
.unwrap();
let dec = cipher
.decrypt(&ct, &key, None, BlockCipherMode::Ecb)
.unwrap();
assert_eq!(dec, pt);
}
#[test]
fn ecb_ignores_iv_even_if_wrong_length() {
let cipher = AesCipher::new(KeyLength::S128);
let key = [0xAAu8; 16];
let pt = [0x55u8; 16];
let bad_iv = [0u8; 3];
let ct = cipher
.encrypt(&pt, &key, Some(&bad_iv), BlockCipherMode::Ecb, false)
.unwrap();
let dec = cipher
.decrypt(&ct, &key, Some(&bad_iv), BlockCipherMode::Ecb)
.unwrap();
assert_eq!(dec, pt);
let ct_none = cipher
.encrypt(&pt, &key, None, BlockCipherMode::Ecb, false)
.unwrap();
assert_eq!(ct, ct_none);
}
#[test]
fn aes256_ecb_roundtrip() {
let cipher = AesCipher::new(KeyLength::S256);
let key = [0xBBu8; 32];
let pt = [0x11u8; 32];
let ct = cipher
.encrypt(&pt, &key, None, BlockCipherMode::Ecb, false)
.unwrap();
let dec = cipher
.decrypt(&ct, &key, None, BlockCipherMode::Ecb)
.unwrap();
assert_eq!(dec, pt);
}
#[test]
fn zero_pad_three_bytes() {
let cipher = AesCipher::new(KeyLength::S128);
let padded = cipher
.zero_pad(&[0x01, 0x02, 0x03], AES_BLOCK_SIZE)
.unwrap();
assert_eq!(padded.len(), AES_BLOCK_SIZE);
assert_eq!(&padded[..3], &[0x01u8, 0x02, 0x03]);
assert!(padded[3..].iter().all(|&b| b == 0));
}
#[test]
fn zero_pad_exact_block_is_unchanged() {
let cipher = AesCipher::new(KeyLength::S128);
let data = [0xAAu8; AES_BLOCK_SIZE];
let padded = cipher.zero_pad(&data, AES_BLOCK_SIZE).unwrap();
assert_eq!(padded, data);
}
#[test]
fn zero_pad_zero_block_size_errors() {
let cipher = AesCipher::new(KeyLength::S128);
assert!(matches!(
cipher.zero_pad(&[0x01], 0),
Err(AesCipherError::InvalidBlockSize)
));
}
#[test]
fn encrypt_with_padding_roundtrip() {
let cipher = AesCipher::new(KeyLength::S128);
let key = [0x01u8; 16];
let iv = [0u8; 16];
let pt = b"Hello".as_ref();
let ct = cipher
.encrypt(pt, &key, Some(&iv), BlockCipherMode::Cbc, true)
.unwrap();
assert_eq!(ct.len(), AES_BLOCK_SIZE);
let dec = cipher
.decrypt(&ct, &key, Some(&iv), BlockCipherMode::Cbc)
.unwrap();
assert_eq!(&dec[..5], pt);
assert!(dec[5..].iter().all(|&b| b == 0));
}
#[test]
fn cbc_without_iv_returns_missing_iv_error() {
let cipher = AesCipher::new(KeyLength::S128);
let key = [0x01u8; 16];
let pt = [0xFFu8; 16];
assert!(matches!(
cipher.encrypt(&pt, &key, None, BlockCipherMode::Cbc, false),
Err(AesCipherError::MissingIv)
));
assert!(matches!(
cipher.decrypt(&pt, &key, None, BlockCipherMode::Cbc),
Err(AesCipherError::MissingIv)
));
let zero_iv = [0u8; 16];
let ct = cipher
.encrypt(&pt, &key, Some(&zero_iv), BlockCipherMode::Cbc, false)
.unwrap();
let dec = cipher
.decrypt(&ct, &key, Some(&zero_iv), BlockCipherMode::Cbc)
.unwrap();
assert_eq!(dec, pt);
}
#[test]
fn cmac128_returns_8_bytes() {
let cipher = AesCipher::new(KeyLength::S128);
let key = [0x01u8; 16];
let data = [0x00u8; 16];
let mac = cipher.calculate_cmac(&data, &key).unwrap();
assert_eq!(mac.len(), AES_CMAC_OUTPUT_LEN);
}
#[test]
fn cmac256_returns_8_bytes() {
let cipher = AesCipher::new(KeyLength::S256);
let key = [0x01u8; 32];
let data = [0xFFu8; 32];
let mac = cipher.calculate_cmac(&data, &key).unwrap();
assert_eq!(mac.len(), AES_CMAC_OUTPUT_LEN);
}
#[test]
fn cmac_empty_data() {
let cipher = AesCipher::new(KeyLength::S128);
let key = [0x02u8; 16];
let mac = cipher.calculate_cmac(&[], &key).unwrap();
assert_eq!(mac.len(), AES_CMAC_OUTPUT_LEN);
}
#[test]
fn cmac_different_data_gives_different_mac() {
let cipher = AesCipher::new(KeyLength::S128);
let key = [0x01u8; 16];
let mac1 = cipher.calculate_cmac(&[0x00u8; 16], &key).unwrap();
let mac2 = cipher.calculate_cmac(&[0xFFu8; 16], &key).unwrap();
assert_ne!(mac1, mac2);
}
#[test]
fn pace_aes256_encrypt_decrypt_nonce() {
let kpi = hex::decode("00112233445566778899AABBCCDDEEFF00112233445566778899AABBCCDDEEFF")
.unwrap();
let nonce = hex::decode("A1A2A3A4A5A6A7A8A9AAABACADAEAFB0").unwrap();
let cipher = AesCipher::new(KeyLength::S256);
let zero_iv = [0u8; AES_BLOCK_SIZE];
let encrypted = cipher
.encrypt(&nonce, &kpi, Some(&zero_iv), BlockCipherMode::Cbc, false)
.unwrap();
assert_eq!(encrypted.len(), AES_BLOCK_SIZE);
let decrypted = cipher
.decrypt(&encrypted, &kpi, Some(&zero_iv), BlockCipherMode::Cbc)
.unwrap();
assert_eq!(decrypted, nonce);
}
#[test]
fn wrong_key_length_returns_error() {
let cipher = AesCipher::new(KeyLength::S128);
let bad_key = [0u8; 24]; assert!(cipher
.encrypt(&[0u8; 16], &bad_key, None, BlockCipherMode::Cbc, false)
.is_err());
}
#[test]
fn bad_iv_length_returns_error() {
let cipher = AesCipher::new(KeyLength::S128);
let key = [0u8; 16];
let bad_iv = [0u8; 8]; assert!(cipher
.encrypt(&[0u8; 16], &key, Some(&bad_iv), BlockCipherMode::Cbc, false)
.is_err());
}
#[test]
fn non_block_aligned_data_without_padding_returns_error() {
let cipher = AesCipher::new(KeyLength::S128);
let key = [0u8; 16];
assert!(cipher
.encrypt(&[0u8; 5], &key, None, BlockCipherMode::Cbc, false)
.is_err());
}
#[test]
fn get_cipher_s256_returns_correct_size() {
let c = get_cipher(KeyLength::S256);
assert_eq!(c.key_size(), 32);
}
}