|
|
@@ -0,0 +1,599 @@
|
|
|
+// Reference:
|
|
|
+// - https://blog.0x7d0.dev/education/how-aes-is-implemented/
|
|
|
+// - https://github.com/boppreh/aes/
|
|
|
+
|
|
|
+// TODO: Salt and stuff
|
|
|
+
|
|
|
+use crate::hash::Hashable;
|
|
|
+
|
|
|
+pub type Key = [u8; 128 / 8];
|
|
|
+
|
|
|
+type Word = [u8; 4];
|
|
|
+type Block = [Word; 4];
|
|
|
+type Array16 = [u8; 16];
|
|
|
+
|
|
|
+pub type Result<T> = std::result::Result<T, AesError>;
|
|
|
+#[derive(Debug)]
|
|
|
+pub enum AesError {
|
|
|
+ MissingCiphertext,
|
|
|
+ InvalidPadding,
|
|
|
+ InvalidRoundKeys,
|
|
|
+}
|
|
|
+
|
|
|
+const SUBSTITUTION_BOX: [u8; 256] = [
|
|
|
+ 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
|
|
|
+ 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
|
|
|
+ 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
|
|
|
+ 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
|
|
|
+ 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
|
|
|
+ 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
|
|
|
+ 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
|
|
|
+ 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
|
|
|
+ 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
|
|
|
+ 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
|
|
|
+ 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
|
|
|
+ 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
|
|
|
+ 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
|
|
|
+ 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
|
|
|
+ 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
|
|
|
+ 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16,
|
|
|
+];
|
|
|
+
|
|
|
+const INVERSE_SUBSTITUTION_BOX: [u8; 256] = [
|
|
|
+ 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
|
|
|
+ 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
|
|
|
+ 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
|
|
|
+ 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
|
|
|
+ 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
|
|
|
+ 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
|
|
|
+ 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
|
|
|
+ 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
|
|
|
+ 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
|
|
|
+ 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
|
|
|
+ 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
|
|
|
+ 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
|
|
|
+ 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
|
|
|
+ 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
|
|
|
+ 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
|
|
|
+ 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D,
|
|
|
+];
|
|
|
+
|
|
|
+const ROUNDS: usize = 10;
|
|
|
+
|
|
|
+// const ROUND_CONSTANT: [u8; 16] = [
|
|
|
+// 0x7d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36,
|
|
|
+// ];
|
|
|
+
|
|
|
+const ROUND_CONSTANT: [u8; 32] = [
|
|
|
+ 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36, 0x6C, 0xD8, 0xAB, 0x4D, 0x9A,
|
|
|
+ 0x2F, 0x5E, 0xBC, 0x63, 0xC6, 0x97, 0x35, 0x6A, 0xD4, 0xB3, 0x7D, 0xFA, 0xEF, 0xC5, 0x91, 0x39,
|
|
|
+];
|
|
|
+
|
|
|
+pub fn encrypt_cbc<H>(plaintext: &mut Vec<u8>, key: &H)
|
|
|
+where
|
|
|
+ H: Hashable,
|
|
|
+{
|
|
|
+ let key = key.hash().as_bytes_capped::<16>();
|
|
|
+ let round_keys = expand_key(&key);
|
|
|
+
|
|
|
+ pad(plaintext);
|
|
|
+
|
|
|
+ // TODO: Derive this properly
|
|
|
+ let mut previous_block = empty_block();
|
|
|
+
|
|
|
+ for ch in plaintext.chunks_mut(16) {
|
|
|
+ let mut buf = empty_array_16();
|
|
|
+ buf.copy_from_slice(ch);
|
|
|
+ let mut block = array_to_block(&buf);
|
|
|
+
|
|
|
+ xor_blocks(&mut block, &previous_block);
|
|
|
+ encrypt_block(&mut block, &round_keys)
|
|
|
+ .expect("expand_key() should always return the correct amount of round keys");
|
|
|
+ previous_block = block.clone();
|
|
|
+
|
|
|
+ let mut chunk_ciphertext = block_to_array(&block);
|
|
|
+ ch.swap_with_slice(&mut chunk_ciphertext);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+pub fn decrypt_cbc<H>(ciphertext: &mut Vec<u8>, key: &H) -> Result<()>
|
|
|
+where
|
|
|
+ H: Hashable,
|
|
|
+{
|
|
|
+ if ciphertext.is_empty() {
|
|
|
+ return Err(AesError::MissingCiphertext);
|
|
|
+ }
|
|
|
+
|
|
|
+ let key = key.hash().as_bytes_capped::<16>();
|
|
|
+ let round_keys = expand_key(&key);
|
|
|
+
|
|
|
+ let mut previous_block = empty_block();
|
|
|
+
|
|
|
+ for ch in ciphertext.chunks_mut(16) {
|
|
|
+ let mut buf = empty_array_16();
|
|
|
+ buf.copy_from_slice(ch);
|
|
|
+ let mut block = array_to_block(&buf);
|
|
|
+
|
|
|
+ let prev_temp = block.clone();
|
|
|
+ decrypt_block(&mut block, &round_keys)
|
|
|
+ .expect("expand_key() should always return the correct amount of round keys");
|
|
|
+ xor_blocks(&mut block, &previous_block);
|
|
|
+ previous_block = prev_temp;
|
|
|
+
|
|
|
+ let mut chunk_plaintext = block_to_array(&block);
|
|
|
+ ch.swap_with_slice(&mut chunk_plaintext);
|
|
|
+ }
|
|
|
+
|
|
|
+ unpad(ciphertext)?;
|
|
|
+
|
|
|
+ Ok(())
|
|
|
+}
|
|
|
+
|
|
|
+fn encrypt_block(block: &mut Block, round_keys: &[Block]) -> Result<()> {
|
|
|
+ // NOTE: Only works for 128 bit keys.
|
|
|
+ if round_keys.len() != ROUNDS + 1 {
|
|
|
+ return Err(AesError::InvalidRoundKeys);
|
|
|
+ }
|
|
|
+
|
|
|
+ add_round_key(block, &round_keys[0]);
|
|
|
+ for round in 1..ROUNDS {
|
|
|
+ substitute_block(block);
|
|
|
+ shift_rows_left(block);
|
|
|
+ mix_words(block);
|
|
|
+ add_round_key(block, &round_keys[round]);
|
|
|
+ }
|
|
|
+
|
|
|
+ substitute_block(block);
|
|
|
+ shift_rows_left(block);
|
|
|
+ add_round_key(block, &round_keys[round_keys.len() - 1]);
|
|
|
+
|
|
|
+ Ok(())
|
|
|
+}
|
|
|
+
|
|
|
+fn decrypt_block(block: &mut Block, round_keys: &[Block]) -> Result<()> {
|
|
|
+ // NOTE: Only works for 128 bit keys.
|
|
|
+ if round_keys.len() != ROUNDS + 1 {
|
|
|
+ return Err(AesError::InvalidRoundKeys);
|
|
|
+ }
|
|
|
+
|
|
|
+ add_round_key(block, &round_keys[round_keys.len() - 1]);
|
|
|
+ shift_rows_right(block);
|
|
|
+ inverse_substitute_block(block);
|
|
|
+
|
|
|
+ for round in (1..ROUNDS).rev() {
|
|
|
+ add_round_key(block, &round_keys[round]);
|
|
|
+ inverse_mix_words(block);
|
|
|
+ shift_rows_right(block);
|
|
|
+ inverse_substitute_block(block);
|
|
|
+ }
|
|
|
+
|
|
|
+ add_round_key(block, &round_keys[0]);
|
|
|
+
|
|
|
+ Ok(())
|
|
|
+}
|
|
|
+
|
|
|
+fn pad(plaintext: &mut Vec<u8>) {
|
|
|
+ let padding_len = 16 - (plaintext.len() % 16) as u8;
|
|
|
+ let padding = [padding_len].repeat(padding_len as usize);
|
|
|
+ plaintext.extend(padding);
|
|
|
+}
|
|
|
+
|
|
|
+fn unpad(ciphertext: &mut Vec<u8>) -> Result<()> {
|
|
|
+ const E: AesError = AesError::InvalidPadding;
|
|
|
+
|
|
|
+ let m1 = ciphertext.len().checked_sub(1).ok_or(E)?;
|
|
|
+ let padding_len = *ciphertext.get(m1).ok_or(E)?;
|
|
|
+
|
|
|
+ let start = ciphertext
|
|
|
+ .len()
|
|
|
+ .checked_sub(padding_len as usize)
|
|
|
+ .ok_or(E)?;
|
|
|
+ let padding = ciphertext.get(start..).ok_or(E)?.to_vec();
|
|
|
+
|
|
|
+ if !padding.iter().all(|x| x == &padding_len) {
|
|
|
+ return Err(E);
|
|
|
+ }
|
|
|
+
|
|
|
+ ciphertext.resize(start, 0);
|
|
|
+
|
|
|
+ Ok(())
|
|
|
+}
|
|
|
+
|
|
|
+#[inline]
|
|
|
+fn empty_array_16() -> Array16 {
|
|
|
+ [0; 16]
|
|
|
+}
|
|
|
+
|
|
|
+#[inline]
|
|
|
+fn empty_word() -> Word {
|
|
|
+ [0; 4]
|
|
|
+}
|
|
|
+
|
|
|
+#[inline]
|
|
|
+fn empty_block() -> Block {
|
|
|
+ [empty_word(); 4]
|
|
|
+}
|
|
|
+
|
|
|
+fn array_to_block(array: &[u8; 16]) -> Block {
|
|
|
+ let mut block: Block = empty_block();
|
|
|
+
|
|
|
+ for (idx, value) in array.iter().enumerate() {
|
|
|
+ let idx_b = idx % 4;
|
|
|
+ let idx_a = (idx - idx_b) / 4;
|
|
|
+
|
|
|
+ block[idx_a][idx_b] = *value;
|
|
|
+ }
|
|
|
+
|
|
|
+ block
|
|
|
+}
|
|
|
+
|
|
|
+fn block_to_array(block: &Block) -> [u8; 16] {
|
|
|
+ let mut array = empty_array_16();
|
|
|
+
|
|
|
+ let mut ida = 0;
|
|
|
+ for idx in 0..4 {
|
|
|
+ for idy in 0..4 {
|
|
|
+ array[ida] = block[idx][idy];
|
|
|
+ ida += 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ array
|
|
|
+}
|
|
|
+
|
|
|
+fn substitute_block(block: &mut Block) {
|
|
|
+ for idx in 0..4 {
|
|
|
+ substitute_word(&mut block[idx]);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn substitute_word(word: &mut Word) {
|
|
|
+ for idx in 0..4 {
|
|
|
+ word[idx] = SUBSTITUTION_BOX[word[idx] as usize];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn inverse_substitute_block(block: &mut Block) {
|
|
|
+ for idx in 0..4 {
|
|
|
+ inverse_substitute_word(&mut block[idx]);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn inverse_substitute_word(word: &mut Word) {
|
|
|
+ for idx in 0..4 {
|
|
|
+ word[idx] = INVERSE_SUBSTITUTION_BOX[word[idx] as usize];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn shift_rows_left(block: &mut Block) {
|
|
|
+ for idx in 1..4 {
|
|
|
+ let temp = block[idx];
|
|
|
+ for idy in 0..4 {
|
|
|
+ let shifted_idy = (idy + idx) % 4;
|
|
|
+ block[idx][idy] = temp[shifted_idy];
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn shift_rows_right(block: &mut Block) {
|
|
|
+ for idx in 1..4 {
|
|
|
+ let temp = block[idx];
|
|
|
+ for idy in 0..4 {
|
|
|
+ let shifted_idy = (idy + idx) % 4;
|
|
|
+ block[idx][shifted_idy] = temp[idy];
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn xtime(byte: u8) -> u8 {
|
|
|
+ if byte & 0x80 > 0 {
|
|
|
+ return (byte << 1) ^ 0x1B;
|
|
|
+ } else {
|
|
|
+ return byte << 1;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn mix_words(block: &mut Block) {
|
|
|
+ for idx in 0..4 {
|
|
|
+ let xor = block[idx][0] ^ block[idx][1] ^ block[idx][2] ^ block[idx][3];
|
|
|
+ let first = block[idx][0];
|
|
|
+
|
|
|
+ block[idx][0] ^= xtime(block[idx][0] ^ block[idx][1]) ^ xor;
|
|
|
+ block[idx][1] ^= xtime(block[idx][1] ^ block[idx][2]) ^ xor;
|
|
|
+ block[idx][2] ^= xtime(block[idx][2] ^ block[idx][3]) ^ xor;
|
|
|
+ block[idx][3] ^= xtime(block[idx][3] ^ first) ^ xor;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn inverse_mix_words(block: &mut Block) {
|
|
|
+ for idx in 0..4 {
|
|
|
+ let a = xtime(xtime(block[idx][0] ^ block[idx][2]));
|
|
|
+ let b = xtime(xtime(block[idx][1] ^ block[idx][3]));
|
|
|
+
|
|
|
+ block[idx][0] ^= a;
|
|
|
+ block[idx][1] ^= b;
|
|
|
+ block[idx][2] ^= a;
|
|
|
+ block[idx][3] ^= b;
|
|
|
+ }
|
|
|
+
|
|
|
+ mix_words(block);
|
|
|
+}
|
|
|
+
|
|
|
+fn add_round_key(block: &mut Block, round_key: &Block) {
|
|
|
+ for idx in 0..4 {
|
|
|
+ for idy in 0..4 {
|
|
|
+ block[idx][idy] ^= round_key[idx][idy];
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn xor_words(target: &mut Word, modifier: &Word) {
|
|
|
+ for idx in 0..4 {
|
|
|
+ target[idx] ^= modifier[idx];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn xor_blocks(target: &mut Block, modifier: &Block) {
|
|
|
+ for idx in 0..4 {
|
|
|
+ xor_words(&mut target[idx], &modifier[idx]);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+fn expand_key(key: &Key) -> Vec<Block> {
|
|
|
+ let mut key_words = array_to_block(key).to_vec();
|
|
|
+ let key_initial_word_count = key_words.len();
|
|
|
+
|
|
|
+ let mut idx = 1;
|
|
|
+ while key_words.len() < (ROUNDS + 1) * 4 {
|
|
|
+ let mut word = key_words[key_words.len() - 1];
|
|
|
+
|
|
|
+ if key_words.len() % key_initial_word_count == 0 {
|
|
|
+ let first = word[0];
|
|
|
+ word[0] = word[1];
|
|
|
+ word[1] = word[2];
|
|
|
+ word[2] = word[3];
|
|
|
+ word[3] = first;
|
|
|
+
|
|
|
+ substitute_word(&mut word);
|
|
|
+ word[0] ^= ROUND_CONSTANT[idx];
|
|
|
+ idx += 1;
|
|
|
+ } // TODO: >128 bit keys
|
|
|
+
|
|
|
+ xor_words(
|
|
|
+ &mut word,
|
|
|
+ &key_words[key_words.len() - key_initial_word_count],
|
|
|
+ );
|
|
|
+ key_words.push(word);
|
|
|
+ }
|
|
|
+
|
|
|
+ let mut expanded_keys = Vec::new();
|
|
|
+
|
|
|
+ let full_key_count = (key_words.len() - (key_words.len() % 4)) / 4;
|
|
|
+ for idx in 0..full_key_count {
|
|
|
+ let mut block = empty_block();
|
|
|
+ block.copy_from_slice(&key_words[idx * 4..(idx + 1) * 4]);
|
|
|
+ expanded_keys.push(block);
|
|
|
+ }
|
|
|
+
|
|
|
+ expanded_keys
|
|
|
+}
|
|
|
+
|
|
|
+#[cfg(test)]
|
|
|
+mod test {
|
|
|
+ use super::*;
|
|
|
+
|
|
|
+ const TEST_KEY: Key = [
|
|
|
+ 130, 191, 5, 162, 175, 104, 200, 14, 32, 0, 97, 170, 10, 83, 159, 90,
|
|
|
+ ];
|
|
|
+
|
|
|
+ const TEST_ARRAY_16: [u8; 16] = [
|
|
|
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
|
|
|
+ 0x0F,
|
|
|
+ ];
|
|
|
+
|
|
|
+ const TEST_BLOCK: Block = [
|
|
|
+ [0x00, 0x01, 0x02, 0x03],
|
|
|
+ [0x04, 0x05, 0x06, 0x07],
|
|
|
+ [0x08, 0x09, 0x0A, 0x0B],
|
|
|
+ [0x0C, 0x0D, 0x0E, 0x0F],
|
|
|
+ ];
|
|
|
+
|
|
|
+ const TEST_SUBSTITUTED_BLOCK: Block = [
|
|
|
+ [0x63, 0x7c, 0x77, 0x7b],
|
|
|
+ [0xf2, 0x6b, 0x6f, 0xc5],
|
|
|
+ [0x30, 0x01, 0x67, 0x2b],
|
|
|
+ [0xfe, 0xd7, 0xab, 0x76],
|
|
|
+ ];
|
|
|
+
|
|
|
+ const TEST_SHIFTED_BLOCK: Block = [
|
|
|
+ [0x00, 0x01, 0x02, 0x03],
|
|
|
+ [0x05, 0x06, 0x07, 0x04],
|
|
|
+ [0x0A, 0x0B, 0x08, 0x09],
|
|
|
+ [0x0F, 0x0C, 0x0D, 0x0E],
|
|
|
+ ];
|
|
|
+
|
|
|
+ #[test]
|
|
|
+ fn test_array_to_block() {
|
|
|
+ let block = array_to_block(&TEST_ARRAY_16);
|
|
|
+ assert_eq!(block, TEST_BLOCK);
|
|
|
+ let array = block_to_array(&block);
|
|
|
+ assert_eq!(array, TEST_ARRAY_16);
|
|
|
+ }
|
|
|
+
|
|
|
+ #[test]
|
|
|
+ fn test_substitute() {
|
|
|
+ let mut input = TEST_BLOCK.clone();
|
|
|
+ substitute_block(&mut input);
|
|
|
+ assert_eq!(input, TEST_SUBSTITUTED_BLOCK);
|
|
|
+ inverse_substitute_block(&mut input);
|
|
|
+ assert_eq!(input, TEST_BLOCK);
|
|
|
+ }
|
|
|
+
|
|
|
+ #[test]
|
|
|
+ fn test_shift_rows() {
|
|
|
+ let mut input = TEST_BLOCK.clone();
|
|
|
+ shift_rows_left(&mut input);
|
|
|
+ assert_eq!(input, TEST_SHIFTED_BLOCK);
|
|
|
+ shift_rows_right(&mut input);
|
|
|
+ assert_eq!(input, TEST_BLOCK);
|
|
|
+ }
|
|
|
+
|
|
|
+ fn _test_pad(input: Vec<u8>, expected: Vec<u8>) {
|
|
|
+ let mut buf = input.clone();
|
|
|
+
|
|
|
+ pad(&mut buf);
|
|
|
+ assert_eq!(buf, expected);
|
|
|
+ unpad(&mut buf).unwrap();
|
|
|
+ assert_eq!(buf, input);
|
|
|
+ }
|
|
|
+
|
|
|
+ #[test]
|
|
|
+ fn test_pad() {
|
|
|
+ let input = vec![1, 2, 3, 4, 5, 6, 7];
|
|
|
+ let expected = vec![1, 2, 3, 4, 5, 6, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9];
|
|
|
+ _test_pad(input, expected);
|
|
|
+
|
|
|
+ let input = vec![10].repeat(100);
|
|
|
+ let mut expected = input.clone();
|
|
|
+ expected.resize(112, 12);
|
|
|
+ _test_pad(input, expected);
|
|
|
+ }
|
|
|
+
|
|
|
+ #[test]
|
|
|
+ fn test_xtime() {
|
|
|
+ let tests = &[(84, 168), (255, 229), (0, 0), (240, 251)];
|
|
|
+
|
|
|
+ for (a, b) in tests {
|
|
|
+ assert_eq!(xtime(*a), *b);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ #[test]
|
|
|
+ fn test_mix_words() {
|
|
|
+ let mut input = TEST_BLOCK;
|
|
|
+ mix_words(&mut input);
|
|
|
+ inverse_mix_words(&mut input);
|
|
|
+ assert_eq!(input, TEST_BLOCK);
|
|
|
+ }
|
|
|
+
|
|
|
+ #[test]
|
|
|
+ fn test_xor() {
|
|
|
+ let mut input = TEST_BLOCK;
|
|
|
+ let modifier = TEST_SHIFTED_BLOCK;
|
|
|
+ xor_blocks(&mut input, &modifier);
|
|
|
+ xor_blocks(&mut input, &modifier);
|
|
|
+ assert_eq!(input, TEST_BLOCK);
|
|
|
+ }
|
|
|
+
|
|
|
+ #[test]
|
|
|
+ fn test_expand_key() {
|
|
|
+ let round_keys = expand_key(&TEST_KEY);
|
|
|
+ let expected: &[Block] = &[
|
|
|
+ [
|
|
|
+ [0b10000010, 0b10111111, 0b101, 0b10100010],
|
|
|
+ [0b10101111, 0b1101000, 0b11001000, 0b1110],
|
|
|
+ [0b100000, 0b0, 0b1100001, 0b10101010],
|
|
|
+ [0b1010, 0b1010011, 0b10011111, 0b1011010],
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ [0b1101110, 0b1100100, 0b10111011, 0b11000101],
|
|
|
+ [0b11000001, 0b1100, 0b1110011, 0b11001011],
|
|
|
+ [0b11100001, 0b1100, 0b10010, 0b1100001],
|
|
|
+ [0b11101011, 0b1011111, 0b10001101, 0b111011],
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ [0b10100011, 0b111001, 0b1011001, 0b101100],
|
|
|
+ [0b1100010, 0b110101, 0b101010, 0b11100111],
|
|
|
+ [0b10000011, 0b111001, 0b111000, 0b10000110],
|
|
|
+ [0b1101000, 0b1100110, 0b10110101, 0b10111101],
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ [0b10010100, 0b11101100, 0b100011, 0b1101001],
|
|
|
+ [0b11110110, 0b11011001, 0b1001, 0b10001110],
|
|
|
+ [0b1110101, 0b11100000, 0b110001, 0b1000],
|
|
|
+ [0b11101, 0b10000110, 0b10000100, 0b10110101],
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ [0b11011000, 0b10110011, 0b11110110, 0b11001101],
|
|
|
+ [0b101110, 0b1101010, 0b11111111, 0b1000011],
|
|
|
+ [0b1011011, 0b10001010, 0b11001110, 0b1001011],
|
|
|
+ [0b1000110, 0b1100, 0b1001010, 0b11111110],
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ [0b110110, 0b1100101, 0b1001101, 0b10010111],
|
|
|
+ [0b11000, 0b1111, 0b10110010, 0b11010100],
|
|
|
+ [0b1000011, 0b10000101, 0b1111100, 0b10011111],
|
|
|
+ [0b101, 0b10001001, 0b110110, 0b1100001],
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ [0b10110001, 0b1100000, 0b10100010, 0b11111100],
|
|
|
+ [0b10101001, 0b1101111, 0b10000, 0b101000],
|
|
|
+ [0b11101010, 0b11101010, 0b1101100, 0b10110111],
|
|
|
+ [0b11101111, 0b1100011, 0b1011010, 0b11010110],
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ [0b1010, 0b11011110, 0b1010100, 0b100011],
|
|
|
+ [0b10100011, 0b10110001, 0b1000100, 0b1011],
|
|
|
+ [0b1001001, 0b1011011, 0b101000, 0b10111100],
|
|
|
+ [0b10100110, 0b111000, 0b1110010, 0b1101010],
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ [0b10001101, 0b10011110, 0b1010110, 0b111],
|
|
|
+ [0b101110, 0b101111, 0b10010, 0b1100],
|
|
|
+ [0b1100111, 0b1110100, 0b111010, 0b10110000],
|
|
|
+ [0b11000001, 0b1001100, 0b1001000, 0b11011010],
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ [0b10111111, 0b11001100, 0b1, 0b1111111],
|
|
|
+ [0b10010001, 0b11100011, 0b10011, 0b1110011],
|
|
|
+ [0b11110110, 0b10010111, 0b101001, 0b11000011],
|
|
|
+ [0b110111, 0b11011011, 0b1100001, 0b11001],
|
|
|
+ ],
|
|
|
+ [
|
|
|
+ [0b110000, 0b100011, 0b11010101, 0b11100101],
|
|
|
+ [0b10100001, 0b11000000, 0b11000110, 0b10010110],
|
|
|
+ [0b1010111, 0b1010111, 0b11101111, 0b1010101],
|
|
|
+ [0b1100000, 0b10001100, 0b10001110, 0b1001100],
|
|
|
+ ],
|
|
|
+ ];
|
|
|
+ assert_eq!(round_keys, expected);
|
|
|
+ }
|
|
|
+
|
|
|
+ #[test]
|
|
|
+ fn test_encrypt_block() {
|
|
|
+ let round_keys = expand_key(&TEST_KEY);
|
|
|
+
|
|
|
+ let mut input = empty_block();
|
|
|
+ input[2][2] = 10;
|
|
|
+
|
|
|
+ let mut buf = input.clone();
|
|
|
+ let _ = encrypt_block(&mut buf, &round_keys);
|
|
|
+ let _ = decrypt_block(&mut buf, &round_keys);
|
|
|
+ assert_eq!(buf, input);
|
|
|
+ }
|
|
|
+
|
|
|
+ #[test]
|
|
|
+ fn test_aes() {
|
|
|
+ let input = vec![1, 2, 3, 4, 5];
|
|
|
+ let mut buf = input.clone();
|
|
|
+ encrypt_cbc(&mut buf, &"password".to_string());
|
|
|
+ decrypt_cbc(&mut buf, &"password").unwrap();
|
|
|
+ assert_eq!(buf, input);
|
|
|
+
|
|
|
+ let input = vec![10].repeat(100);
|
|
|
+ let mut buf = input.clone();
|
|
|
+ encrypt_cbc(&mut buf, &"password".to_string());
|
|
|
+ decrypt_cbc(&mut buf, &"password").unwrap();
|
|
|
+ assert_eq!(buf, input);
|
|
|
+ }
|
|
|
+
|
|
|
+ #[test]
|
|
|
+ fn test_empty() {
|
|
|
+ encrypt_cbc(&mut vec![], &"");
|
|
|
+ let _ = decrypt_cbc(&mut vec![], &"");
|
|
|
+ let _ = encrypt_block(&mut empty_block(), &[]);
|
|
|
+ let _ = decrypt_block(&mut empty_block(), &[]);
|
|
|
+ pad(&mut vec![]);
|
|
|
+ let _ = unpad(&mut vec![]);
|
|
|
+ }
|
|
|
+}
|
