client: Use serde_bytes

As otherwise serde would serialize every byte individually, it has a huge impact particularly on large keyrings.

Author: bilelmoussaoui

Cargo.lock

@@ -24,7 +24,7 @@ rust-version = "1.85"
 exclude = ["org.freedesktop.Secrets.xml"]
 
 [workspace.dependencies]
-zvariant = { version = "5.8", default-features = false, features = ["gvariant"]}
+zvariant = { version = "5.8", default-features = false, features = ["gvariant", "serde_bytes"]}
 ashpd = {version = "0.12", default-features = false}
 endi = "1.1"
 clap = { version = "4.5", features = [ "cargo", "derive" ] }

Cargo.toml

@@ -38,6 +38,7 @@ openssl = { version = "0.10", optional = true }
 pbkdf2 = { version = "0.12", optional = true }
 rand = { version = "0.9", default-features = false, features = ["thread_rng"] }
 serde.workspace = true
+serde_bytes = "0.11"
 sha2 = { version = "0.10", optional = true }
 subtle = { version = "2.5", optional = true }
 tokio = { workspace = true, features = [

client/Cargo.toml

@@ -12,7 +12,9 @@ use crate::{Key, Secret, crypto, dbus::Error, secret::ContentType};
 /// Same as [`DBusSecret`] without tying the session path to a [`Session`] type.
 pub struct DBusSecretInner(
     pub OwnedObjectPath,
+    #[serde(with = "serde_bytes")]
     pub Vec<u8>,
+    #[serde(with = "serde_bytes")]
     pub Vec<u8>,
     pub ContentType,
 );
@@ -104,8 +106,8 @@ impl Serialize for DBusSecret {
     {
         let mut tuple_serializer = serializer.serialize_tuple(4)?;
         tuple_serializer.serialize_element(self.session().inner().path())?;
-        tuple_serializer.serialize_element(self.parameters())?;
-        tuple_serializer.serialize_element(self.value())?;
+        tuple_serializer.serialize_element(&serde_bytes::Bytes::new(self.parameters()))?;
+        tuple_serializer.serialize_element(&serde_bytes::Bytes::new(self.value()))?;
         tuple_serializer.serialize_element(self.content_type().as_str())?;
         tuple_serializer.end()
     }

client/src/dbus/api/secret.rs

@@ -9,6 +9,7 @@ use crate::{Key, Mac, crypto};
 #[derive(Deserialize, Serialize, Type, Debug, Clone)]
 pub(crate) struct EncryptedItem {
     pub(crate) hashed_attributes: HashMap<String, Mac>,
+    #[serde(with = "serde_bytes")]
     pub(crate) blob: Vec<u8>,
 }
 

client/src/file/api/encrypted_item.rs

@@ -73,6 +73,7 @@ pub(crate) static GVARIANT_ENCODING: LazyLock<Context> =
 #[derive(Deserialize, Serialize, Type, Debug)]
 pub struct Keyring {
     salt_size: u32,
+    #[serde(with = "serde_bytes")]
     salt: Vec<u8>,
     iteration_count: u32,
     modified_time: u64,

client/src/file/api/mod.rs

@@ -22,6 +22,7 @@ pub struct UnlockedItem {
     created: u64,
     #[zeroize(skip)]
     modified: u64,
+    #[serde(with = "serde_bytes")]
     secret: Vec<u8>,
 }
 

client/src/file/unlocked_item.rs

@@ -7,7 +7,7 @@ use zbus::zvariant::Type;
 /// A message authentication code. It provides constant-time comparison when
 /// compared against another mac or against a slice of bytes.
 #[derive(Deserialize, Serialize, Type, Clone)]
-pub struct Mac(Vec<u8>);
+pub struct Mac(#[serde(with = "serde_bytes")] Vec<u8>);
 
 impl std::fmt::Debug for Mac {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {