wip

Author: jasonish

rust/Cargo.lock.in

@@ -15,20 +15,19 @@
  * 02110-1301, USA.
  */
 
-use aes::cipher::generic_array::GenericArray;
+use aes::cipher::{Block, BlockEncrypt, NewBlockCipher};
 use aes::Aes128;
-use aes::BlockEncrypt;
-use aes::NewBlockCipher;
-use aes_gcm::AeadInPlace;
-use aes_gcm::Aes128Gcm;
-use aes_gcm::NewAead;
+use aes_gcm::aead::{AeadCore, AeadInPlace, NewAead};
+use aes_gcm::{Aes128Gcm, Nonce, Tag};
 use hkdf::Hkdf;
 use sha2::Sha256;
 
 pub const AES128_KEY_LEN: usize = 16;
 pub const AES128_TAG_LEN: usize = 16;
 pub const AES128_IV_LEN: usize = 12;
 
+type PacketNonce = Nonce<<Aes128Gcm as AeadCore>::NonceSize>;
+
 pub struct HeaderProtectionKey(Aes128);
 
 impl HeaderProtectionKey {
@@ -41,16 +40,19 @@ impl HeaderProtectionKey {
             b"quic hp" as &[u8]
         };
         hkdf_expand_label(&hk, quichp, &mut secret, AES128_KEY_LEN as u16);
-        return Self(Aes128::new(GenericArray::from_slice(&secret)));
+        return Self(
+            Aes128::new_from_slice(&secret).expect("invalid AES-128 key length"),
+        );
     }
 
     pub fn decrypt_in_place(
         &self, sample: &[u8], first: &mut u8, packet_number: &mut [u8],
     ) -> Result<(), ()> {
-        let mut mask = GenericArray::clone_from_slice(sample);
+        let mut mask = Block::<Aes128>::default();
+        mask.copy_from_slice(sample);
         self.0.encrypt_block(&mut mask);
-
-        let (first_mask, pn_mask) = mask.split_first().unwrap();
+        let mask_slice: &[u8] = &mask;
+        let (first_mask, pn_mask) = mask_slice.split_first().unwrap();
 
         let bits = if (*first & 0x80) != 0 {
             0x0f // Long header: 4 bits masked
@@ -84,7 +86,8 @@ impl PacketKey {
             b"quic key" as &[u8]
         };
         hkdf_expand_label(&hk, quickey, &mut secret, AES128_KEY_LEN as u16);
-        let key = Aes128Gcm::new(GenericArray::from_slice(&secret));
+        let key =
+            Aes128Gcm::new_from_slice(&secret).expect("invalid AES-GCM key length");
 
         let mut r = PacketKey {
             key,
@@ -112,9 +115,17 @@ impl PacketKey {
         }
         let tag_pos = payload.len() - AES128_TAG_LEN;
         let (buffer, tag) = payload.split_at_mut(tag_pos);
-        let taga = GenericArray::from_slice(tag);
+        let mut taga = Tag::default();
+        taga.copy_from_slice(tag);
+        let mut nonce_block = PacketNonce::default();
+        nonce_block.copy_from_slice(&nonce);
         self.key
-            .decrypt_in_place_detached(GenericArray::from_slice(&nonce), header, buffer, taga)
+            .decrypt_in_place_detached(
+                &nonce_block,
+                header,
+                buffer,
+                &taga,
+            )
             .map_err(|_| ())?;
         Ok(&payload[..tag_pos])
     }