Port to zgvariant

Cargo.toml

@@ -53,7 +53,8 @@ tempfile = "3.26"
 tokio = { version = "1.52", default-features = false }
 tracing = "0.1"
 tracing-subscriber = "0.3"
-zbus = { version = "5.14.0", default-features = false }
-zbus_macros = { version = "5.11", features = ["gvariant"] }
+zbus = { version = "5.19", default-features = false }
+zgvariant = { version = "1.0", features = ["serde_bytes"] }
+zbus_macros = { version = "5.19", features = ["gvariant"] }
 zeroize = { version = "1", features = ["zeroize_derive"] }
-zvariant = { version = "5.8", default-features = false, features = ["gvariant", "serde_bytes"] }
+zvariant = { version = "5.14", default-features = false, features = ["gvariant", "serde_bytes"] }

client/Cargo.toml

@@ -41,6 +41,7 @@ tokio = { workspace = true, features = [
     "io-util",
 ], optional = true, default-features = false }
 tracing = { workspace = true, optional = true }
+zgvariant.workspace = true
 zbus.workspace = true
 zbus_macros.workspace = true
 zvariant.workspace = true

client/src/file/api/encrypted_item.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
-use zbus::zvariant::Type;
 use zeroize::{Zeroize, ZeroizeOnDrop};
+use zgvariant::Type;
 
 use super::{Error, UnlockedItem};
 use crate::{AsAttributes, Key, Mac, crypto};

client/src/file/api/mod.rs

@@ -21,7 +21,7 @@ use futures_lite::AsyncWriteExt;
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "tokio")]
 use tokio::{fs, io, io::AsyncWriteExt};
-use zbus::zvariant::{Endian, Type, serialized::Context};
+use zgvariant::{Type, serialized::Context};
 
 /// Used for newly created [`Keyring`]s
 const DEFAULT_ITERATION_COUNT: u32 = 100000;
@@ -65,7 +65,7 @@ pub(crate) fn data_dir() -> Option<PathBuf> {
 }
 
 pub(crate) static GVARIANT_ENCODING: LazyLock<Context> =
-    LazyLock::new(|| Context::new_gvariant(Endian::Little, 0));
+    LazyLock::new(|| Context::new(zgvariant::LE, 0));
 
 /// Logical contents of a keyring file
 #[derive(Deserialize, Serialize, Type, Debug, Zeroize, ZeroizeOnDrop)]
@@ -257,7 +257,7 @@ impl Keyring {
 
         blob.push(MAJOR_VERSION);
         blob.push(MINOR_VERSION);
-        blob.append(&mut zvariant::to_bytes(*GVARIANT_ENCODING, &self)?.to_vec());
+        blob.append(&mut zgvariant::to_bytes(*GVARIANT_ENCODING, &self)?.to_vec());
 
         Ok(blob)
     }
@@ -373,7 +373,7 @@ impl TryFrom<&[u8]> for Keyring {
         }
 
         if let Some(data) = value.get((FILE_HEADER_LEN + 2)..) {
-            let keyring: Self = zvariant::serialized::Data::new(data, *GVARIANT_ENCODING)
+            let keyring: Self = zgvariant::serialized::Data::new(data, *GVARIANT_ENCODING)
                 .deserialize()?
                 .0;
 

client/src/file/error.rs

@@ -10,7 +10,7 @@ pub enum Error {
     /// No Parent directory.
     NoParentDir(String),
     /// Bytes don't have the expected GVariant format.
-    GVariantDeserialization(zvariant::Error),
+    GVariantDeserialization(zgvariant::Error),
     /// Mismatch between array length and length explicitly stored in keyring
     SaltSizeMismatch(usize, u32),
     /// Key for some reason too weak to trust it for writing
@@ -51,8 +51,8 @@ pub enum Error {
     Schema(crate::SchemaError),
 }
 
-impl From<zvariant::Error> for Error {
-    fn from(value: zvariant::Error) -> Self {
+impl From<zgvariant::Error> for Error {
+    fn from(value: zgvariant::Error) -> Self {
         Self::GVariantDeserialization(value)
     }
 }

client/src/file/unlocked_item.rs

@@ -11,7 +11,7 @@ use crate::{AsAttributes, CONTENT_TYPE_ATTRIBUTE, Key, Mac, Secret, crypto, secr
 
 /// An item stored in the file backend.
 #[derive(
-    Deserialize, Serialize, zvariant::Type, Clone, Debug, Zeroize, ZeroizeOnDrop, PartialEq,
+    Deserialize, Serialize, zgvariant::Type, Clone, Debug, Zeroize, ZeroizeOnDrop, PartialEq,
 )]
 pub struct UnlockedItem {
     #[zeroize(skip)]
@@ -182,7 +182,7 @@ impl UnlockedItem {
     }
 
     fn encrypt_plaintext(&self) -> Result<EncryptedItem, Error> {
-        let blob = zvariant::to_bytes(*GVARIANT_ENCODING, &self)?.to_vec();
+        let blob = zgvariant::to_bytes(*GVARIANT_ENCODING, &self)?.to_vec();
         Ok(EncryptedItem {
             hashed_attributes: self
                 .attributes
@@ -194,7 +194,7 @@ impl UnlockedItem {
     }
 
     fn encrypt_encrypted(&self, key: &Key, iv: &[u8]) -> Result<EncryptedItem, Error> {
-        let decrypted = Zeroizing::new(zvariant::to_bytes(*GVARIANT_ENCODING, &self)?.to_vec());
+        let decrypted = Zeroizing::new(zgvariant::to_bytes(*GVARIANT_ENCODING, &self)?.to_vec());
 
         let mut blob = crypto::encrypt(&*decrypted, key, iv)?;
 
@@ -219,7 +219,7 @@ impl TryFrom<&[u8]> for UnlockedItem {
     type Error = Error;
 
     fn try_from(value: &[u8]) -> Result<Self, Error> {
-        let mut item: UnlockedItem = zvariant::serialized::Data::new(value, *GVARIANT_ENCODING)
+        let mut item: UnlockedItem = zgvariant::serialized::Data::new(value, *GVARIANT_ENCODING)
             .deserialize()?
             .0;
 

client/src/mac.rs

@@ -1,8 +1,8 @@
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "native_crypto")]
 use subtle::ConstantTimeEq;
-use zbus::zvariant::Type;
 use zeroize::{Zeroize, ZeroizeOnDrop};
+use zgvariant::Type;
 
 // There is no constructor to avoid performing sanity checks, e.g. length.
 /// A message authentication code. It provides constant-time comparison when