ssh-key: DSA PublicKey encoder support

ssh-key/src/mpint.rs

@@ -1,7 +1,7 @@
 //! Multiple precision integer
 
 use crate::{
-    base64::{self, Decode},
+    base64::{self, Decode, Encode},
     Error, Result,
 };
 use alloc::vec::Vec;
@@ -89,6 +89,16 @@ impl Decode for MPInt {
     }
 }
 
+impl Encode for MPInt {
+    fn encoded_len(&self) -> Result<usize> {
+        Ok(4 + self.as_bytes().len())
+    }
+
+    fn encode(&self, encoder: &mut base64::Encoder<'_>) -> Result<()> {
+        encoder.encode_byte_slice(self.as_bytes())
+    }
+}
+
 impl TryFrom<&[u8]> for MPInt {
     type Error = Error;
 

ssh-key/src/public.rs

@@ -244,6 +244,8 @@ impl Encode for KeyData {
     fn encoded_len(&self) -> Result<usize> {
         let alg_len = self.algorithm().encoded_len()?;
         let key_len = match self {
+            #[cfg(feature = "alloc")]
+            Self::Dsa(key) => key.encoded_len()?,
             #[cfg(feature = "ecdsa")]
             Self::Ecdsa(key) => key.encoded_len()?,
             Self::Ed25519(key) => key.encoded_len()?,
@@ -257,6 +259,8 @@ impl Encode for KeyData {
     fn encode(&self, encoder: &mut base64::Encoder<'_>) -> Result<()> {
         self.algorithm().encode(encoder)?;
         match self {
+            #[cfg(feature = "alloc")]
+            Self::Dsa(key) => key.encode(encoder),
             #[cfg(feature = "ecdsa")]
             Self::Ecdsa(key) => key.encode(encoder),
             Self::Ed25519(key) => key.encode(encoder),

ssh-key/src/public/dsa.rs

@@ -1,7 +1,7 @@
 //! Digital Signature Algorithm (DSA) public keys.
 
 use crate::{
-    base64::{self, Decode},
+    base64::{self, Decode, Encode},
     MPInt, Result,
 };
 
@@ -34,3 +34,19 @@ impl Decode for DsaPublicKey {
         Ok(Self { p, q, g, y })
     }
 }
+
+impl Encode for DsaPublicKey {
+    fn encoded_len(&self) -> Result<usize> {
+        Ok(self.p.encoded_len()?
+            + self.q.encoded_len()?
+            + self.g.encoded_len()?
+            + self.y.encoded_len()?)
+    }
+
+    fn encode(&self, encoder: &mut base64::Encoder<'_>) -> Result<()> {
+        self.p.encode(encoder)?;
+        self.q.encode(encoder)?;
+        self.g.encode(encoder)?;
+        self.y.encode(encoder)
+    }
+}

ssh-key/tests/public_key.rs

@@ -213,30 +213,37 @@ fn decode_rsa_4096_openssh() {
     assert_eq!("[email protected]", ossh_key.comment);
 }
 
+#[cfg(feature = "alloc")]
+#[test]
+fn encode_dsa_openssh() {
+    let ossh_key = PublicKey::from_openssh(OSSH_DSA_EXAMPLE).unwrap();
+    assert_eq!(OSSH_DSA_EXAMPLE.trim_end(), &ossh_key.to_string());
+}
+
 #[cfg(all(feature = "alloc", feature = "ecdsa"))]
 #[test]
 fn encode_ecdsa_p256_openssh() {
     let ossh_key = PublicKey::from_openssh(OSSH_ECDSA_P256_EXAMPLE).unwrap();
-    assert_eq!(OSSH_ECDSA_P256_EXAMPLE.trim_end(), &ossh_key.to_string())
+    assert_eq!(OSSH_ECDSA_P256_EXAMPLE.trim_end(), &ossh_key.to_string());
 }
 
 #[cfg(all(feature = "alloc", feature = "ecdsa"))]
 #[test]
 fn encode_ecdsa_p384_openssh() {
     let ossh_key = PublicKey::from_openssh(OSSH_ECDSA_P384_EXAMPLE).unwrap();
-    assert_eq!(OSSH_ECDSA_P384_EXAMPLE.trim_end(), &ossh_key.to_string())
+    assert_eq!(OSSH_ECDSA_P384_EXAMPLE.trim_end(), &ossh_key.to_string());
 }
 
 #[cfg(all(feature = "alloc", feature = "ecdsa"))]
 #[test]
 fn encode_ecdsa_p521_openssh() {
     let ossh_key = PublicKey::from_openssh(OSSH_ECDSA_P521_EXAMPLE).unwrap();
-    assert_eq!(OSSH_ECDSA_P521_EXAMPLE.trim_end(), &ossh_key.to_string())
+    assert_eq!(OSSH_ECDSA_P521_EXAMPLE.trim_end(), &ossh_key.to_string());
 }
 
 #[cfg(feature = "alloc")]
 #[test]
 fn encode_ed25519_openssh() {
     let ossh_key = PublicKey::from_openssh(OSSH_ED25519_EXAMPLE).unwrap();
-    assert_eq!(OSSH_ED25519_EXAMPLE.trim_end(), &ossh_key.to_string())
+    assert_eq!(OSSH_ED25519_EXAMPLE.trim_end(), &ossh_key.to_string());
 }