Add decryptable/encryptable tests

Author: dani-garcia

crates/bitwarden-crypto/src/traits/decryptable.rs

@@ -74,3 +74,75 @@ impl<Ids: KeyIds, Key: KeyId, T: Decryptable<Ids, Key, Output>, Output>
         self.iter().map(|value| value.decrypt(ctx, key)).collect()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{traits::tests::*, Decryptable, EncString, KeyStore, SymmetricCryptoKey};
+
+    fn test_store() -> KeyStore<TestIds> {
+        let store = KeyStore::<TestIds>::default();
+
+        let key = SymmetricCryptoKey::try_from("sJnO8rVi0dTwND43n0T9x7665s8mVUYNAaJ4nm7gx1iia1I7947URL60nwfIHaf9QJePO4VkNN0oT9jh4iC6aA==".to_string()).unwrap();
+
+        #[allow(deprecated)]
+        store
+            .context_mut()
+            .set_symmetric_key(TestSymmKey::A(0), key.clone())
+            .unwrap();
+
+        store
+    }
+
+    #[test]
+    fn test_decryptable_bytes() {
+        let store = test_store();
+        let mut ctx = store.context();
+        let key = TestSymmKey::A(0);
+
+        let data_encrypted: EncString = "2.kTtIypq9OLzd5iMMbU11pQ==|J4i3hTtGVdg7EZ+AQv/ujg==|QJpSpotQVpIW8j8dR/8l015WJzAIxBaOmrz4Uj/V1JA=".parse().unwrap();
+
+        let data_decrypted: Vec<u8> = data_encrypted.decrypt(&mut ctx, key).unwrap();
+        assert_eq!(data_decrypted, &[1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn test_decryptable_string() {
+        let store = test_store();
+        let mut ctx = store.context();
+        let key = TestSymmKey::A(0);
+
+        let data_encrypted: EncString = "2.fkvl0+sL1lwtiOn1eewsvQ==|dT0TynLl8YERZ8x7dxC+DQ==|cWhiRSYHOi/AA2LiV/JBJWbO9C7pbUpOM6TMAcV47hE=".parse().unwrap();
+
+        let data_decrypted: String = data_encrypted.decrypt(&mut ctx, key).unwrap();
+        assert_eq!(data_decrypted, "Hello, World!");
+    }
+
+    #[test]
+    fn test_decryptable_option_some() {
+        let store = test_store();
+        let mut ctx = store.context();
+        let key = TestSymmKey::A(0);
+
+        let data_encrypted: EncString = "2.fkvl0+sL1lwtiOn1eewsvQ==|dT0TynLl8YERZ8x7dxC+DQ==|cWhiRSYHOi/AA2LiV/JBJWbO9C7pbUpOM6TMAcV47hE=".parse().unwrap();
+        let data_encrypted_some = Some(data_encrypted);
+
+        let string_decrypted: Option<String> = data_encrypted_some.decrypt(&mut ctx, key).unwrap();
+        assert_eq!(string_decrypted, Some("Hello, World!".to_string()));
+    }
+
+    #[test]
+    fn test_decryptable_option_none() {
+        let store = test_store();
+        let mut ctx = store.context();
+
+        let key = TestSymmKey::A(0);
+        let none_data: Option<EncString> = None;
+        let string_decrypted: Option<String> = none_data.decrypt(&mut ctx, key).unwrap();
+        assert_eq!(string_decrypted, None);
+
+        // The None implementation will not do any decrypt operations, so it won't fail even if the key doesn't exist
+        let bad_key = TestSymmKey::B((0, 1));
+        let string_decrypted_bad: Option<String> = none_data.decrypt(&mut ctx, bad_key).unwrap();
+        assert_eq!(string_decrypted_bad, None);
+    }
+}

crates/bitwarden-crypto/src/traits/encryptable.rs

@@ -27,6 +27,26 @@ impl<Ids: KeyIds> Encryptable<Ids, Ids::Asymmetric, AsymmetricEncString> for &[u
     }
 }
 
+impl<Ids: KeyIds> Encryptable<Ids, Ids::Symmetric, EncString> for Vec<u8> {
+    fn encrypt(
+        &self,
+        ctx: &mut KeyStoreContext<Ids>,
+        key: Ids::Symmetric,
+    ) -> Result<EncString, CryptoError> {
+        ctx.encrypt_data_with_symmetric_key(key, self)
+    }
+}
+
+impl<Ids: KeyIds> Encryptable<Ids, Ids::Asymmetric, AsymmetricEncString> for Vec<u8> {
+    fn encrypt(
+        &self,
+        ctx: &mut KeyStoreContext<Ids>,
+        key: Ids::Asymmetric,
+    ) -> Result<AsymmetricEncString, CryptoError> {
+        ctx.encrypt_data_with_asymmetric_key(key, self)
+    }
+}
+
 impl<Ids: KeyIds> Encryptable<Ids, Ids::Symmetric, EncString> for &str {
     fn encrypt(
         &self,
@@ -92,3 +112,138 @@ impl<Ids: KeyIds, Key: KeyId, T: Encryptable<Ids, Key, Output>, Output>
         self.iter().map(|value| value.encrypt(ctx, key)).collect()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        traits::tests::*, AsymmetricCryptoKey, Decryptable, Encryptable, KeyStore,
+        SymmetricCryptoKey,
+    };
+
+    fn test_store() -> KeyStore<TestIds> {
+        let store = KeyStore::<TestIds>::default();
+
+        let symm_key = SymmetricCryptoKey::generate(rand::thread_rng());
+        let asymm_key = AsymmetricCryptoKey::generate(&mut rand::thread_rng());
+
+        #[allow(deprecated)]
+        store
+            .context_mut()
+            .set_symmetric_key(TestSymmKey::A(0), symm_key.clone())
+            .unwrap();
+        #[allow(deprecated)]
+        store
+            .context_mut()
+            .set_asymmetric_key(TestAsymmKey::A(0), asymm_key.clone())
+            .unwrap();
+
+        store
+    }
+
+    #[test]
+    fn test_encryptable_bytes() {
+        let store = test_store();
+        let mut ctx = store.context();
+        let key = TestSymmKey::A(0);
+
+        let vec_data = vec![1, 2, 3, 4, 5];
+        let slice_data: &[u8] = &vec_data;
+
+        let vec_encrypted = vec_data.encrypt(&mut ctx, key).unwrap();
+        let slice_encrypted = slice_data.encrypt(&mut ctx, key).unwrap();
+
+        let vec_decrypted: Vec<u8> = vec_encrypted.decrypt(&mut ctx, key).unwrap();
+        let slice_decrypted: Vec<u8> = slice_encrypted.decrypt(&mut ctx, key).unwrap();
+
+        assert_eq!(vec_data, vec_decrypted);
+        assert_eq!(slice_data, slice_decrypted);
+    }
+
+    #[test]
+    fn test_encryptable_string() {
+        let store = test_store();
+        let mut ctx = store.context();
+        let key = TestSymmKey::A(0);
+
+        let string_data = "Hello, World!".to_string();
+        let str_data: &str = string_data.as_str();
+
+        let string_encrypted = string_data.encrypt(&mut ctx, key).unwrap();
+        let str_encrypted = str_data.encrypt(&mut ctx, key).unwrap();
+
+        let string_decrypted: String = string_encrypted.decrypt(&mut ctx, key).unwrap();
+        let str_decrypted: String = str_encrypted.decrypt(&mut ctx, key).unwrap();
+
+        assert_eq!(string_data, string_decrypted);
+        assert_eq!(str_data, str_decrypted);
+    }
+
+    #[test]
+    fn test_encryptable_bytes_asymmetric() {
+        let store = test_store();
+        let mut ctx = store.context();
+        let key = TestAsymmKey::A(0);
+
+        let vec_data = vec![1, 2, 3, 4, 5];
+        let slice_data: &[u8] = &vec_data;
+
+        let vec_encrypted = vec_data.encrypt(&mut ctx, key).unwrap();
+        let slice_encrypted = slice_data.encrypt(&mut ctx, key).unwrap();
+
+        let vec_decrypted: Vec<u8> = vec_encrypted.decrypt(&mut ctx, key).unwrap();
+        let slice_decrypted: Vec<u8> = slice_encrypted.decrypt(&mut ctx, key).unwrap();
+
+        assert_eq!(vec_data, vec_decrypted);
+        assert_eq!(slice_data, slice_decrypted);
+    }
+
+    #[test]
+    fn test_encryptable_string_asymmetric() {
+        let store = test_store();
+        let mut ctx = store.context();
+        let key = TestAsymmKey::A(0);
+
+        let string_data = "Hello, World!".to_string();
+        let str_data: &str = string_data.as_str();
+
+        let string_encrypted = string_data.encrypt(&mut ctx, key).unwrap();
+        let str_encrypted = str_data.encrypt(&mut ctx, key).unwrap();
+
+        let string_decrypted: String = string_encrypted.decrypt(&mut ctx, key).unwrap();
+        let str_decrypted: String = str_encrypted.decrypt(&mut ctx, key).unwrap();
+
+        assert_eq!(string_data, string_decrypted);
+        assert_eq!(str_data, str_decrypted);
+    }
+
+    #[test]
+    fn test_encryptable_option_some() {
+        let store = test_store();
+        let mut ctx = store.context();
+        let key = TestSymmKey::A(0);
+
+        let string_data = Some("Hello, World!".to_string());
+
+        let string_encrypted = string_data.encrypt(&mut ctx, key).unwrap();
+
+        let string_decrypted: Option<String> = string_encrypted.decrypt(&mut ctx, key).unwrap();
+
+        assert_eq!(string_data, string_decrypted);
+    }
+
+    #[test]
+    fn test_encryptable_option_none() {
+        let store = test_store();
+        let mut ctx = store.context();
+
+        let key = TestSymmKey::A(0);
+        let none_data: Option<String> = None;
+        let string_encrypted = none_data.encrypt(&mut ctx, key).unwrap();
+        assert_eq!(string_encrypted, None);
+
+        // The None implementation will not do any decrypt operations, so it won't fail even if the key doesn't exist
+        let bad_key = TestSymmKey::B((0, 1));
+        let string_encrypted_bad = none_data.encrypt(&mut ctx, bad_key).unwrap();
+        assert_eq!(string_encrypted_bad, None);
+    }
+}