client: key: Remove impl From<&key> for Value

These methods require allocating and taking a reference in a From is not
very idiomatic, instead we use the inner Vec and the implementation of
From<Vec<u8>> of zvariant::Array.

Note that since Key implements Drop, we cannot just use self.key and we
need to take the value out.

Author: A6GibKm

client/src/dbus/api/service.rs

@@ -88,7 +88,7 @@ impl<'a> Service<'a> {
     #[doc(alias = "OpenSession")]
     pub async fn open_session(
         &self,
-        client_public_key: Option<&Key>,
+        client_public_key: Option<Key>,
     ) -> Result<(Option<Key>, Session<'a>), Error> {
         let (algorithm, key): (_, Value<'_>) = match client_public_key {
             None => (Algorithm::Plain, zvariant::Str::default().into()),

client/src/dbus/service.rs

@@ -87,7 +87,7 @@ impl<'a> Service<'a> {
                 tracing::debug!("Starting an encrypted Secret Service session");
                 let private_key = Key::generate_private_key()?;
                 let public_key = Key::generate_public_key(&private_key)?;
-                let (service_key, session) = service.open_session(Some(&public_key)).await?;
+                let (service_key, session) = service.open_session(Some(public_key)).await?;
                 let aes_key = service_key
                     .map(|service_key| Key::generate_aes_key(&private_key, &service_key))
                     .transpose()?

client/src/key.rs

@@ -1,5 +1,4 @@
 use zeroize::{Zeroize, ZeroizeOnDrop};
-use zvariant::Type;
 
 use crate::{crypto, file};
 
@@ -57,20 +56,16 @@ impl Key {
     }
 }
 
-impl From<&Key> for zvariant::Value<'_> {
-    fn from(key: &Key) -> Self {
-        let mut array = zvariant::Array::new(u8::SIGNATURE);
-        for byte in key.as_ref() {
-            array
-                .append(zvariant::Value::U8(*byte))
-                .expect("Element of valid type");
-        }
-        array.into()
+impl From<Key> for zvariant::Value<'static> {
+    fn from(key: Key) -> Self {
+        let mut key = key;
+        let inner: Vec<u8> = std::mem::take(&mut key.key);
+        zvariant::Array::from(inner).into()
     }
 }
 
-impl From<&Key> for zvariant::OwnedValue {
-    fn from(key: &Key) -> Self {
+impl From<Key> for zvariant::OwnedValue {
+    fn from(key: Key) -> Self {
         zvariant::Value::from(key).try_to_owned().unwrap()
     }
 }

server/src/service.rs

@@ -97,7 +97,7 @@ impl Service {
         object_server.at(&path, session).await?;
 
         let service_key = public_key
-            .map(|k| OwnedValue::from(&k))
+            .map(OwnedValue::from)
             .unwrap_or_else(|| Value::new::<Vec<u8>>(vec![]).try_to_owned().unwrap());
 
         Ok((service_key, path))