Apply cargo fmt

Author: quexten

bitwarden_license/bitwarden-sm/src/secrets/create.rs

@@ -40,17 +40,8 @@ pub(crate) async fn create_secret(
     let secret = {
         let mut ctx = key_store.context();
         Some(SecretCreateRequestModel {
-            key: input
-                .key
-                .clone()
-                .trim()
-                .encrypt(&mut ctx, key)?
-                .to_string(),
-            value: input
-                .value
-                .clone()
-                .encrypt(&mut ctx, key)?
-                .to_string(),
+            key: input.key.clone().trim().encrypt(&mut ctx, key)?.to_string(),
+            value: input.value.clone().encrypt(&mut ctx, key)?.to_string(),
             note: input
                 .note
                 .clone()

bitwarden_license/bitwarden-sm/src/secrets/update.rs

@@ -39,17 +39,8 @@ pub(crate) async fn update_secret(
     let secret = {
         let mut ctx = key_store.context();
         Some(SecretUpdateRequestModel {
-            key: input
-                .key
-                .clone()
-                .trim()
-                .encrypt(&mut ctx, key)?
-                .to_string(),
-            value: input
-                .value
-                .clone()
-                .encrypt(&mut ctx, key)?
-                .to_string(),
+            key: input.key.clone().trim().encrypt(&mut ctx, key)?.to_string(),
+            value: input.value.clone().encrypt(&mut ctx, key)?.to_string(),
             note: input
                 .note
                 .clone()

crates/bitwarden-core/src/mobile/crypto.rs

@@ -8,7 +8,8 @@ use std::collections::HashMap;
 
 use base64::{engine::general_purpose::STANDARD, Engine};
 use bitwarden_crypto::{
-    AsymmetricCryptoKey, ContentFormat, CryptoError, EncString, Kdf, KeyDecryptable, KeyEncryptable, MasterKey, SymmetricCryptoKey, UnsignedSharedKey, UserKey
+    AsymmetricCryptoKey, ContentFormat, CryptoError, EncString, Kdf, KeyDecryptable,
+    KeyEncryptable, MasterKey, SymmetricCryptoKey, UnsignedSharedKey, UserKey,
 };
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "wasm")]

crates/bitwarden-crypto/src/cose.rs

@@ -24,10 +24,12 @@ pub(crate) const XCHACHA20_POLY1305: i64 = -70000;
 const XCHACHA20_TEXT_PAD_BLOCK_SIZE: usize = 32;
 const CONTENT_TYPE_PADDED_UTF8: &str = "application/utf8-padded";
 
-/// The content format describes the format of the contained bytes. Message encryption always happens on the byte level, and this
-/// allows determining what format the contained data has. For instance, an `EncString` in most cases contains UTF-8 encoded
-/// text. In some cases it may contain a Pkcs8 private key, or a COSE key. Specifically, for COSE keys, this allows distinguishing between
-/// the old symmetric key format, represented as `ContentFormat::OctetStream`, and the new COSE key format, represented as `ContentFormat::CoseKey`.
+/// The content format describes the format of the contained bytes. Message encryption always
+/// happens on the byte level, and this allows determining what format the contained data has. For
+/// instance, an `EncString` in most cases contains UTF-8 encoded text. In some cases it may contain
+/// a Pkcs8 private key, or a COSE key. Specifically, for COSE keys, this allows distinguishing
+/// between the old symmetric key format, represented as `ContentFormat::OctetStream`, and the new
+/// COSE key format, represented as `ContentFormat::CoseKey`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[cfg_attr(feature = "wasm", derive(Tsify), tsify(into_wasm_abi, from_wasm_abi))]
 pub enum ContentFormat {

crates/bitwarden-crypto/src/keys/device_key.rs

@@ -1,5 +1,6 @@
 use crate::{
-    error::Result, AsymmetricCryptoKey, ContentFormat, CryptoError, EncString, KeyDecryptable, KeyEncryptable, SymmetricCryptoKey, UnsignedSharedKey
+    error::Result, AsymmetricCryptoKey, ContentFormat, CryptoError, EncString, KeyDecryptable,
+    KeyEncryptable, SymmetricCryptoKey, UnsignedSharedKey,
 };
 
 /// Device Key

crates/bitwarden-crypto/src/lib.rs

@@ -34,7 +34,9 @@ mod cose;
 mod traits;
 pub use cose::ContentFormat;
 mod xchacha20;
-pub use traits::{Decryptable, Encryptable, CompositeEncryptable, TypedEncryptable, IdentifyKey, KeyId, KeyIds};
+pub use traits::{
+    CompositeEncryptable, Decryptable, Encryptable, IdentifyKey, KeyId, KeyIds, TypedEncryptable,
+};
 pub use zeroizing_alloc::ZeroAlloc as ZeroizingAllocator;
 
 #[cfg(feature = "uniffi")]

crates/bitwarden-crypto/src/store/context.rs

@@ -385,7 +385,9 @@ mod tests {
         store::{
             tests::{Data, DataView},
             KeyStore,
-        }, traits::tests::{TestIds, TestSymmKey}, CompositeEncryptable, Decryptable, SymmetricCryptoKey
+        },
+        traits::tests::{TestIds, TestSymmKey},
+        CompositeEncryptable, Decryptable, SymmetricCryptoKey,
     };
 
     #[test]
@@ -445,9 +447,7 @@ mod tests {
         // with one and decrypt with the other
 
         let data = DataView("Hello, World!".to_string(), key_2_id);
-        let encrypted = data
-            .encrypt_composite(&mut ctx, key_2_id)
-            .unwrap();
+        let encrypted = data.encrypt_composite(&mut ctx, key_2_id).unwrap();
 
         let decrypted1 = encrypted.decrypt(&mut ctx, key_2_id).unwrap();
         let decrypted2 = encrypted.decrypt(&mut ctx, new_key_id).unwrap();

crates/bitwarden-crypto/src/store/mod.rs

@@ -209,7 +209,11 @@ impl<Ids: KeyIds> KeyStore<Ids> {
     /// already be present in the store, otherwise this will return an error.
     /// This method is not parallelized, and is meant for single item encryption.
     /// If you need to encrypt multiple items, use `encrypt_list` instead.
-    pub fn encrypt<Key: KeyId, Data: CompositeEncryptable<Ids, Key, Output> + IdentifyKey<Key>, Output>(
+    pub fn encrypt<
+        Key: KeyId,
+        Data: CompositeEncryptable<Ids, Key, Output> + IdentifyKey<Key>,
+        Output,
+    >(
         &self,
         data: Data,
     ) -> Result<Output, crate::CryptoError> {
@@ -304,7 +308,9 @@ fn batch_chunk_size(len: usize) -> usize {
 #[cfg(test)]
 pub(crate) mod tests {
     use crate::{
-        store::{KeyStore, KeyStoreContext}, traits::tests::{TestIds, TestSymmKey}, EncString, Encryptable, SymmetricCryptoKey, TypedEncryptable
+        store::{KeyStore, KeyStoreContext},
+        traits::tests::{TestIds, TestSymmKey},
+        EncString, Encryptable, SymmetricCryptoKey, TypedEncryptable,
     };
 
     pub struct DataView(pub String, pub TestSymmKey);

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

@@ -27,7 +27,7 @@ impl<Ids: KeyIds, Key: KeyId, T: CompositeEncryptable<Ids, Key, Output>, Output>
     }
 }
 
-impl <Ids: KeyIds, Key: KeyId, T: CompositeEncryptable<Ids, Key, Output>, Output>
+impl<Ids: KeyIds, Key: KeyId, T: CompositeEncryptable<Ids, Key, Output>, Output>
     CompositeEncryptable<Ids, Key, Vec<Output>> for Vec<T>
 {
     fn encrypt_composite(
@@ -41,14 +41,10 @@ impl <Ids: KeyIds, Key: KeyId, T: CompositeEncryptable<Ids, Key, Output>, Output
     }
 }
 
-/// An encryption operation that takes the input value - a primitive such as `String` and encrypts it into the output value.
-/// The implementation decides the content format.
+/// An encryption operation that takes the input value - a primitive such as `String` and encrypts
+/// it into the output value. The implementation decides the content format.
 pub trait TypedEncryptable<Ids: KeyIds, Key: KeyId, Output> {
-    fn encrypt(
-        &self,
-        ctx: &mut KeyStoreContext<Ids>,
-        key: Key,
-    ) -> Result<Output, CryptoError>;
+    fn encrypt(&self, ctx: &mut KeyStoreContext<Ids>, key: Key) -> Result<Output, CryptoError>;
 }
 
 impl<Ids: KeyIds, Key: KeyId, T: TypedEncryptable<Ids, Key, Output>, Output>
@@ -65,8 +61,7 @@ impl<Ids: KeyIds, Key: KeyId, T: TypedEncryptable<Ids, Key, Output>, Output>
     }
 }
 
-impl<Ids: KeyIds> TypedEncryptable<Ids, Ids::Symmetric, EncString> for &str
-{
+impl<Ids: KeyIds> TypedEncryptable<Ids, Ids::Symmetric, EncString> for &str {
     fn encrypt(
         &self,
         ctx: &mut KeyStoreContext<Ids>,
@@ -76,8 +71,7 @@ impl<Ids: KeyIds> TypedEncryptable<Ids, Ids::Symmetric, EncString> for &str
     }
 }
 
-impl<Ids: KeyIds> TypedEncryptable<Ids, Ids::Symmetric, EncString> for String
-{
+impl<Ids: KeyIds> TypedEncryptable<Ids, Ids::Symmetric, EncString> for String {
     fn encrypt(
         &self,
         ctx: &mut KeyStoreContext<Ids>,
@@ -87,7 +81,8 @@ impl<Ids: KeyIds> TypedEncryptable<Ids, Ids::Symmetric, EncString> for String
     }
 }
 
-/// An encryption operation that takes the input value - a primitive such as `Vec<u8>` - and encrypts it into the output value.
+/// An encryption operation that takes the input value - a primitive such as `Vec<u8>` - and
+/// encrypts it into the output value.
 pub trait Encryptable<Ids: KeyIds, Key: KeyId, Output> {
     fn encrypt(
         &self,
@@ -152,7 +147,8 @@ impl<Ids: KeyIds, Key: KeyId, T: Encryptable<Ids, Key, Output>, Output>
 #[cfg(test)]
 mod tests {
     use crate::{
-        cose::ContentFormat, traits::tests::*, AsymmetricCryptoKey, Decryptable, Encryptable, KeyStore, SymmetricCryptoKey, TypedEncryptable
+        cose::ContentFormat, traits::tests::*, AsymmetricCryptoKey, Decryptable, Encryptable,
+        KeyStore, SymmetricCryptoKey, TypedEncryptable,
     };
 
     fn test_store() -> KeyStore<TestIds> {
@@ -207,12 +203,8 @@ mod tests {
         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_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();
@@ -229,9 +221,7 @@ mod tests {
 
         let string_data = Some("Hello, World!".to_string());
 
-        let string_encrypted = string_data
-            .encrypt(&mut ctx, key)
-            .unwrap();
+        let string_encrypted = string_data.encrypt(&mut ctx, key).unwrap();
 
         let string_decrypted: Option<String> = string_encrypted.decrypt(&mut ctx, key).unwrap();
 
@@ -245,17 +235,13 @@ mod tests {
 
         let key = TestSymmKey::A(0);
         let none_data: Option<String> = None;
-        let string_encrypted = none_data
-            .encrypt(&mut ctx, key)
-            .unwrap();
+        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();
+        let string_encrypted_bad = none_data.encrypt(&mut ctx, bad_key).unwrap();
         assert_eq!(string_encrypted_bad, None);
     }
 }

crates/bitwarden-exporters/src/export.rs

@@ -80,10 +80,7 @@ fn encrypt_import(
         view.set_new_fido2_credentials(ctx, passkeys)?;
     }
 
-    let new_cipher = view.encrypt_composite(
-        ctx,
-        view.key_identifier(),
-    )?;
+    let new_cipher = view.encrypt_composite(ctx, view.key_identifier())?;
 
     Ok(new_cipher)
 }