Fix build by removing code that does not compile

Signed-off-by: Wiktor Kwapisiewicz <wiktor@metacode.biz>

Author: wiktor-k

.justfile

@@ -83,7 +83,7 @@ fix:
     # try to fix rustc issues
     cargo fix --allow-staged
     # try to fix clippy issues
-    cargo clippy --fix --allow-staged
+    cargo clippy --fix --allow-staged --allow-dirty
 
     # fmt must be last as clippy's changes may break formatting
     cargo +nightly fmt --all

examples/agent-socket-info.rs

@@ -27,7 +27,7 @@ impl Session for AgentSocketInfo {
     async fn request_identities(&mut self) -> Result<Vec<Identity>, AgentError> {
         Ok(vec![Identity {
             // this is just a dummy key, the comment is important
-            pubkey: KeyData::Ed25519(ssh_key::public::Ed25519PublicKey([0; 32])),
+            pubkey: KeyData::Ed25519(ssh_key::public::Ed25519PublicKey([0; 32])).into(),
             comment: self.comment.clone(),
         }])
     }

examples/key-storage.rs

@@ -74,7 +74,7 @@ impl KeyStorage {
 #[crate::async_trait]
 impl Session for KeyStorage {
     async fn sign(&mut self, sign_request: SignRequest) -> Result<Signature, AgentError> {
-        let pubkey: PublicKey = sign_request.pubkey.clone().into();
+        let pubkey: PublicKey = sign_request.pubkey.key_data().clone().into();
 
         if let Some(identity) = self.identity_from_pubkey(&pubkey) {
             match identity.privkey.key_data() {
@@ -113,7 +113,7 @@ impl Session for KeyStorage {
         let mut identities = vec![];
         for identity in self.identities.lock().unwrap().iter() {
             identities.push(message::Identity {
-                pubkey: identity.pubkey.key_data().clone(),
+                pubkey: identity.pubkey.key_data().clone().into(),
                 comment: identity.comment.clone(),
             })
         }

examples/openpgp-card-agent.rs

@@ -71,7 +71,7 @@ impl CardSession {
                 if let AlgorithmAttributes::Ecc(ecc) = e.algo() {
                     if ecc.ecc_type() == EccType::EdDSA {
                         let pubkey = KeyData::Ed25519(Ed25519PublicKey(e.data().try_into()?));
-                        if pubkey == request.pubkey {
+                        if pubkey == *request.pubkey.key_data() {
                             let pin = self.pwds.get(&ident).await;
                             return if let Some(pin) = pin {
                                 let str = pin.expose_secret().as_bytes().to_vec();

examples/pgp-wrapper.rs

@@ -295,7 +295,7 @@ impl SecretKeyTrait for WrappedKey {
             .block_on(async {
                 let mut client = self.client.lock().await;
                 let result = client.sign(SignRequest {
-                    pubkey: self.pubkey.clone(),
+                    pubkey: self.pubkey.clone().into(),
                     data: data.to_vec(),
                     flags: 0,
                 });
@@ -454,9 +454,7 @@ fn main() -> testresult::TestResult {
             pgp::packet::write_packet(&mut std::io::stdout(), &signature)?;
         }
         Args::Decrypt => {
-            let CertKeyData::Key(pubkey) = decrypt_ids[0].pubkey else {
-                panic!("Only pubkeys are supported");
-            };
+            let pubkey = decrypt_ids[0].pubkey.key_data();
             let decryptor = WrappedKey::new(pubkey.clone(), client, KeyRole::Decryption);
             let message = Message::from_bytes(std::io::stdin())?;
 

src/proto/message/cert_key_data.rs

@@ -1,31 +1,33 @@
-use std::str::FromStr as _;
+use ssh_encoding::{Decode, Encode, Reader};
+use ssh_key::{public::KeyData, Certificate};
 
-use ssh_encoding::{CheckedSum as _, Decode, Encode, Reader};
-use ssh_key::{public::KeyData, Algorithm, Certificate, PublicKey};
-
-use crate::proto::{Error, Result};
+use crate::proto::Error;
 
 #[derive(Debug, PartialEq, Eq, Clone)]
+/// Represents a public credential.
 pub enum CertKeyData {
+    /// Plain public key.
     Key(KeyData),
+    /// Signed public key.
     Cert(Certificate),
 }
 
+impl CertKeyData {
+    /// Returns a reference to the [KeyData].
+    pub fn key_data(&self) -> &KeyData {
+        match self {
+            Self::Key(key) => key,
+            Self::Cert(cert) => cert.public_key(),
+        }
+    }
+}
+
 impl Decode for CertKeyData {
     type Error = Error;
 
     fn decode(reader: &mut impl Reader) -> core::result::Result<Self, Self::Error> {
-        let alg = String::decode(reader)?;
-        let cert_alg = Algorithm::new_certificate(&alg);
-
-        if let Ok(algorithm) = cert_alg {
-            let certificate = Certificate::decode_as(algorithm.clone(), reader)?;
-            Ok(Self::Cert(certificate))
-        } else {
-            let algorithm = Algorithm::from_str(&alg).map_err(ssh_encoding::Error::from)?;
-            let pubkey = KeyData::decode_as(reader, algorithm)?;
-            Ok(Self::Key(pubkey))
-        }
+        // TODO: implement parsing certificates
+        Ok(Self::Key(KeyData::decode(reader)?))
     }
 }
 

src/proto/message/identity.rs

@@ -1,7 +1,6 @@
 //! Data returned to the client when listing keys.
 
 use ssh_encoding::{self, CheckedSum, Decode, Encode, Reader, Writer};
-use ssh_key::public::KeyData;
 
 use super::cert_key_data::CertKeyData;
 use crate::proto::{Error, Result};

src/proto/message/sign.rs

@@ -1,7 +1,6 @@
 //! Signature request with data to be signed with a key in an agent.
 
 use ssh_encoding::{self, CheckedSum, Decode, Encode, Reader, Writer};
-use ssh_key::public::KeyData;
 
 use super::cert_key_data::CertKeyData;
 use crate::proto::{Error, Result};