rename expanded key

expanded key is not really a good name; since the key expansion actually
outputs a vector of `Word`s, where each 4-word chunk is used as a round key.

src/encryption/symmetric/aes/README.md

@@ -98,8 +98,7 @@ the key and the ciphertext as part of the *confusion* property.
 During substitution, a byte is interpreted as a polynomial and
 mapped to its multiplicative inverse in [Rijndael's finite field][Rijndael ff]: GF(2^8) = GF(2)[x]/(x^8 + x^4 + x^3 + x + 1).
 
-The inverse
-is then transformed using an affine transformation which is the sum of multiple rotations of the byte as a vector, where addition is the XOR operation. The result is an 8-bit output array which is used to substitute the original byte.
+The inverse is then transformed using an affine transformation which is the sum of multiple rotations of the byte as a vector, where addition is the XOR operation. The result is an 8-bit output array which is used to substitute the original byte.
 
 ## Security
 

src/encryption/symmetric/aes/mod.rs

@@ -118,9 +118,9 @@ where [(); N / 8]:
  assert!(!key.is_empty(), "Key is not instantiated");
 
  let key_len_words = N / 32;
- let mut expanded_key = Vec::with_capacity(key_len_words * (num_rounds + 1));
- Self::key_expansion(*key, &mut expanded_key, key_len_words, num_rounds);
- let mut expanded_key_chunks = expanded_key.chunks_exact(4);
+ let mut round_keys_words = Vec::with_capacity(key_len_words * (num_rounds + 1));
+ Self::key_expansion(*key, &mut round_keys_words, key_len_words, num_rounds);
+ let mut round_keys = round_keys_words.chunks_exact(4);
 
  let mut state = State(
  plaintext
@@ -133,24 +133,24 @@ where [(); N / 8]:
  assert!(state != State::default(), "State is not instantiated");
 
  // Round 0 - add round key
- Self::add_round_key(&mut state, expanded_key_chunks.next().unwrap());
+ Self::add_round_key(&mut state, round_keys.next().unwrap());
 
  // Rounds 1 to N - 1
  for _ in 1..num_rounds {
  Self::sub_bytes(&mut state);
  Self::shift_rows(&mut state);
  Self::mix_columns(&mut state);
- Self::add_round_key(&mut state, expanded_key_chunks.next().unwrap());
+ Self::add_round_key(&mut state, round_keys.next().unwrap());
  }
 
  // Last round - we do not mix columns here.
  Self::sub_bytes(&mut state);
  Self::shift_rows(&mut state);
- Self::add_round_key(&mut state, expanded_key_chunks.next().unwrap());
+ Self::add_round_key(&mut state, round_keys.next().unwrap());
 
  assert!(
- expanded_key_chunks.remainder().is_empty(),
- "Expanded key not fully consumed - perhaps check key expansion?"
+ round_keys.remainder().is_empty(),
+ "Round keys not fully consumed - perhaps check key expansion?"
  );
 
  state.0.into_iter().flatten().collect::<Vec<_>>().try_into().unwrap()
@@ -252,15 +252,20 @@ where [(); N / 8]:
  ///
  /// Key expansion ensures that each key used per round is different, introducing additional
  /// complexity and diffusion.
- fn key_expansion(key: Key<N>, expanded_key: &mut Vec<Word>, key_len: usize, num_rounds: usize) {
+ fn key_expansion(
+ key: Key<N>,
+ round_keys_words: &mut Vec<Word>,
+ key_len: usize,
+ num_rounds: usize,
+ ) {
  let block_num_words = 128 / 32;
 
  let out_len = block_num_words * (num_rounds + 1);
  let key_words: Vec<Word> = key.chunks(4).map(|c| c.try_into().unwrap()).collect();
- expanded_key.extend(key_words);
+ round_keys_words.extend(key_words);
 
  for i in key_len..(block_num_words * (num_rounds + 1)) {
- let mut last = *expanded_key.last().unwrap();
+ let mut last = *round_keys_words.last().unwrap();
 
  if i % key_len == 0 {
  Self::rotate_word(&mut last);
@@ -271,16 +276,20 @@ where [(); N / 8]:
  last = Self::sub_word(last)
  }
 
- let round_key = expanded_key[i - key_len]
+ let round_key = round_keys_words[i - key_len]
  .iter()
  .zip(last.iter())
  .map(|(w, l)| w ^ l)
  .collect_vec()
  .try_into()
  .unwrap();
- expanded_key.push(round_key);
+ round_keys_words.push(round_key);
  }
 
- assert_eq!(expanded_key.len(), out_len, "Wrong number of words output during key expansion");
+ assert_eq!(
+ round_keys_words.len(),
+ out_len,
+ "Wrong number of words output during key expansion"
+ );
  }
 }