Replace non type aliased Bytes references with type aliases

Author: quexten

crates/bitwarden-core/src/auth/auth_request.rs

@@ -171,7 +171,7 @@ mod tests {
 
         // Verify fingerprint
         let pubkey = STANDARD.decode(public_key).unwrap();
-        let pubkey = Bytes::<SpkiPublicKeyDerContentFormat>::from(pubkey.clone());
+        let pubkey = SpkiPublicKeyBytes::from(pubkey.clone());
         let fingerprint = fingerprint("[email protected]", &pubkey).unwrap();
         assert_eq!(fingerprint, "childless-unfair-prowler-dropbox-designate");
 

crates/bitwarden-core/src/platform/generate_fingerprint.rs

@@ -3,7 +3,7 @@
 //! This module contains the logic for generating fingerprints.
 
 use base64::{engine::general_purpose::STANDARD, Engine};
-use bitwarden_crypto::{fingerprint, Bytes, SpkiPublicKeyDerContentFormat};
+use bitwarden_crypto::{fingerprint, SpkiPublicKeyBytes};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
@@ -42,7 +42,7 @@ pub enum FingerprintError {
 
 pub(crate) fn generate_fingerprint(input: &FingerprintRequest) -> Result<String, FingerprintError> {
     let key = STANDARD.decode(&input.public_key)?;
-    let key = Bytes::<SpkiPublicKeyDerContentFormat>::from(key);
+    let key = SpkiPublicKeyBytes::from(key);
     Ok(fingerprint(&input.fingerprint_material, &key)?)
 }
 

crates/bitwarden-crypto/examples/signature.rs

@@ -42,14 +42,13 @@ fn main() {
     mock_server.upload("serialized_message", serialized_message.as_bytes().to_vec());
 
     // Bob retrieves the signed object from the server
-    let retrieved_signature =
-        bitwarden_crypto::Signature::from_cose(&Bytes::<CoseSign1ContentFormat>::from(
-            mock_server
-                .download("signature")
-                .expect("Failed to download signature")
-                .clone(),
-        ))
-        .expect("Failed to deserialize signature");
+    let retrieved_signature = bitwarden_crypto::Signature::from_cose(&CoseSign1Bytes::from(
+        mock_server
+            .download("signature")
+            .expect("Failed to download signature")
+            .clone(),
+    ))
+    .expect("Failed to deserialize signature");
     let retrieved_serialized_message = bitwarden_crypto::SerializedMessage::from_bytes(
         mock_server
             .download("serialized_message")
@@ -90,22 +89,20 @@ fn main() {
             .content_type()
             .expect("Failed to get content type from signature"),
     );
-    let retrieved_alice_signature =
-        bitwarden_crypto::Signature::from_cose(&Bytes::<CoseSign1ContentFormat>::from(
-            mock_server
-                .download("signature")
-                .expect("Failed to download Alice's signature")
-                .clone(),
-        ))
-        .expect("Failed to deserialize Alice's signature");
-    let retrieved_bobs_signature =
-        bitwarden_crypto::Signature::from_cose(&Bytes::<CoseSign1ContentFormat>::from(
-            mock_server
-                .download("bobs_signature")
-                .expect("Failed to download Bob's signature")
-                .clone(),
-        ))
-        .expect("Failed to deserialize Bob's signature");
+    let retrieved_alice_signature = bitwarden_crypto::Signature::from_cose(&CoseSign1Bytes::from(
+        mock_server
+            .download("signature")
+            .expect("Failed to download Alice's signature")
+            .clone(),
+    ))
+    .expect("Failed to deserialize Alice's signature");
+    let retrieved_bobs_signature = bitwarden_crypto::Signature::from_cose(&CoseSign1Bytes::from(
+        mock_server
+            .download("bobs_signature")
+            .expect("Failed to download Bob's signature")
+            .clone(),
+    ))
+    .expect("Failed to deserialize Bob's signature");
 
     // Charlie verifies Alice's signature
     if !retrieved_alice_signature.verify(

crates/bitwarden-crypto/examples/signed_object.rs

@@ -39,7 +39,7 @@ fn main() {
     mock_server.upload("signed_object", signed_object.to_cose().to_vec());
 
     // Bob retrieves the signed object from the server
-    let retrieved_signed_object = SignedObject::from_cose(&Bytes::<CoseSign1ContentFormat>::from(
+    let retrieved_signed_object = SignedObject::from_cose(&CoseSign1Bytes::from(
         mock_server
             .download("signed_object")
             .expect("Failed to download signed object")

crates/bitwarden-crypto/src/fingerprint.rs

@@ -8,20 +8,14 @@ use num_bigint::BigUint;
 use num_traits::cast::ToPrimitive;
 use thiserror::Error;
 
-use crate::{
-    content_format::SpkiPublicKeyDerContentFormat, error::Result, wordlist::EFF_LONG_WORD_LIST,
-    Bytes, CryptoError,
-};
+use crate::{error::Result, wordlist::EFF_LONG_WORD_LIST, CryptoError, SpkiPublicKeyBytes};
 
 /// Computes a fingerprint of the given `fingerprint_material` using the given `public_key`.
 ///
 /// This is commonly used for account fingerprints. With the following arguments:
 /// - `fingerprint_material`: user's id.
 /// - `public_key`: user's public key.
-pub fn fingerprint(
-    fingerprint_material: &str,
-    public_key: &Bytes<SpkiPublicKeyDerContentFormat>,
-) -> Result<String> {
+pub fn fingerprint(fingerprint_material: &str, public_key: &SpkiPublicKeyBytes) -> Result<String> {
     let hkdf = hkdf::Hkdf::<sha2::Sha256>::from_prk(public_key.as_ref())
         .map_err(|_| CryptoError::InvalidKeyLen)?;
 
@@ -93,7 +87,7 @@ mod tests {
             197, 3, 219, 56, 77, 109, 47, 72, 251, 131, 36, 240, 96, 169, 31, 82, 93, 166, 242, 3,
             33, 213, 2, 3, 1, 0, 1,
         ];
-        let key: Bytes<SpkiPublicKeyDerContentFormat> = Bytes::from(key.to_vec());
+        let key: SpkiPublicKeyBytes = Bytes::from(key.to_vec());
         assert_eq!(
             "turban-deftly-anime-chatroom-unselfish",
             fingerprint(user_id, &key).unwrap()

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

@@ -5,9 +5,8 @@ use serde_repr::{Deserialize_repr, Serialize_repr};
 
 use super::key_encryptable::CryptoKey;
 use crate::{
-    content_format::{Bytes, SpkiPublicKeyDerContentFormat},
     error::{CryptoError, Result},
-    Pkcs8PrivateKeyBytes,
+    Pkcs8PrivateKeyBytes, SpkiPublicKeyBytes,
 };
 
 /// Algorithm / public key encryption scheme used for encryption/decryption.
@@ -45,7 +44,7 @@ impl AsymmetricPublicCryptoKey {
     }
 
     /// Makes a SubjectPublicKeyInfo DER serialized version of the public key.
-    pub fn to_der(&self) -> Result<Bytes<SpkiPublicKeyDerContentFormat>> {
+    pub fn to_der(&self) -> Result<SpkiPublicKeyBytes> {
         use rsa::pkcs8::EncodePublicKey;
         match &self.inner {
             RawPublicKey::RsaOaepSha1(public_key) => Ok(public_key
@@ -167,7 +166,8 @@ mod tests {
 
     use crate::{
         content_format::{Bytes, Pkcs8PrivateKeyDerContentFormat},
-        AsymmetricCryptoKey, AsymmetricPublicCryptoKey, SymmetricCryptoKey, UnsignedSharedKey,
+        AsymmetricCryptoKey, AsymmetricPublicCryptoKey, Pkcs8PrivateKeyBytes, SymmetricCryptoKey,
+        UnsignedSharedKey,
     };
 
     #[test]
@@ -261,7 +261,7 @@ DnqOsltgPomWZ7xVfMkm9niL2OA=
             ))
             .unwrap();
 
-        let private_key = Bytes::<Pkcs8PrivateKeyDerContentFormat>::from(private_key);
+        let private_key = Pkcs8PrivateKeyBytes::from(private_key);
         let private_key = AsymmetricCryptoKey::from_der(&private_key).unwrap();
         let public_key = AsymmetricPublicCryptoKey::from_der(&public_key).unwrap();
 

crates/bitwarden-send/src/send.rs

@@ -8,8 +8,8 @@ use bitwarden_core::{
     require,
 };
 use bitwarden_crypto::{
-    generate_random_bytes, Bytes, CompositeEncryptable, CryptoError, Decryptable, EncString,
-    IdentifyKey, KeyStoreContext, OctetStreamContentFormat, PrimitiveEncryptable,
+    generate_random_bytes, CompositeEncryptable, CryptoError, Decryptable, EncString, IdentifyKey,
+    KeyStoreContext, OctetStreamBytes, PrimitiveEncryptable,
 };
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
@@ -331,7 +331,7 @@ impl CompositeEncryptable<KeyIds, SymmetricKeyId, Send> for SendView {
 
             name: self.name.encrypt(ctx, send_key)?,
             notes: self.notes.encrypt(ctx, send_key)?,
-            key: Bytes::<OctetStreamContentFormat>::from(k.clone()).encrypt(ctx, key)?,
+            key: OctetStreamBytes::from(k.clone()).encrypt(ctx, key)?,
             password: self.new_password.as_ref().map(|password| {
                 let password = bitwarden_crypto::pbkdf2(password.as_bytes(), &k, SEND_ITERATIONS);
                 STANDARD.encode(password)

crates/bitwarden-send/src/send_client.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 
 use bitwarden_core::Client;
 use bitwarden_crypto::{
-    Bytes, Decryptable, EncString, IdentifyKey, OctetStreamContentFormat, PrimitiveEncryptable,
+    Decryptable, EncString, IdentifyKey, OctetStreamBytes, PrimitiveEncryptable,
 };
 use thiserror::Error;
 
@@ -129,7 +129,7 @@ impl SendClient {
 
         let key = Send::get_key(&mut ctx, &send.key, send.key_identifier())?;
 
-        let encrypted = Bytes::<OctetStreamContentFormat>::from(buffer).encrypt(&mut ctx, key)?;
+        let encrypted = OctetStreamBytes::from(buffer).encrypt(&mut ctx, key)?;
         Ok(encrypted.to_buffer()?)
     }
 }

crates/bitwarden-vault/src/cipher/attachment.rs

@@ -1,7 +1,7 @@
 use bitwarden_core::key_management::{KeyIds, SymmetricKeyId};
 use bitwarden_crypto::{
-    Bytes, CompositeEncryptable, CryptoError, Decryptable, EncString, IdentifyKey, KeyStoreContext,
-    OctetStreamContentFormat, PrimitiveEncryptable,
+    CompositeEncryptable, CryptoError, Decryptable, EncString, IdentifyKey, KeyStoreContext,
+    OctetStreamBytes, PrimitiveEncryptable,
 };
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "wasm")]
@@ -95,7 +95,7 @@ impl CompositeEncryptable<KeyIds, SymmetricKeyId, AttachmentEncryptResult>
         // with it, and then encrypt the key with the cipher key
         let attachment_key = ctx.generate_symmetric_key(ATTACHMENT_KEY)?;
         let encrypted_contents =
-            Bytes::<OctetStreamContentFormat>::from(self.contents).encrypt(ctx, attachment_key)?;
+            OctetStreamBytes::from(self.contents).encrypt(ctx, attachment_key)?;
         attachment.key = Some(ctx.wrap_symmetric_key(ciphers_key, attachment_key)?);
 
         let contents = encrypted_contents.to_buffer()?;