Use Traits (#378)

* Added From + TryFrom Traits
* Added Support for AsRef<Path> + Read + Write
* PublicKey Changes + Formatting Fixes
* io Traits for PublicKey + PrivateKey

Author: tcyrus

ssh-key/src/dot_ssh.rs

@@ -72,12 +72,12 @@ impl DotSsh {
 
     /// Write a private key into `~/.ssh`.
     pub fn write_private_key(&self, filename: impl AsRef<Path>, key: &PrivateKey) -> Result<()> {
-        key.write_openssh_file(&self.path.join(filename), Default::default())
+        key.write_openssh_file(self.path.join(filename), Default::default())
     }
 
     /// Write a public key into `~/.ssh`.
     pub fn write_public_key(&self, filename: impl AsRef<Path>, key: &PublicKey) -> Result<()> {
-        key.write_openssh_file(&self.path.join(filename))
+        key.write_openssh_file(self.path.join(filename))
     }
 }
 
@@ -100,7 +100,7 @@ impl Iterator for PrivateKeysIter {
         loop {
             let entry = self.read_dir.next()?.ok()?;
 
-            if let Ok(key) = PrivateKey::read_openssh_file(&entry.path()) {
+            if let Ok(key) = PrivateKey::read_openssh_file(entry.path()) {
                 return Some(key);
             }
         }
@@ -119,7 +119,7 @@ impl Iterator for PublicKeysIter {
         loop {
             let entry = self.read_dir.next()?.ok()?;
 
-            if let Ok(key) = PublicKey::read_openssh_file(&entry.path()) {
+            if let Ok(key) = PublicKey::read_openssh_file(entry.path()) {
                 return Some(key);
             }
         }

ssh-key/src/private.rs

@@ -163,8 +163,11 @@ use rand_core::CryptoRng;
 #[cfg(feature = "std")]
 use std::{fs, path::Path};
 
+#[cfg(feature = "std")]
+use std::io::{self, Read, Write};
+
 #[cfg(all(unix, feature = "std"))]
-use std::{io::Write, os::unix::fs::OpenOptionsExt};
+use std::os::unix::fs::OpenOptionsExt;
 
 /// Error message for infallible conversions (used by `expect`)
 const CONVERSION_ERROR_MSG: &str = "SSH private key conversion error";
@@ -343,15 +346,34 @@ impl PrivateKey {
 
     /// Read private key from an OpenSSH-formatted PEM file.
     #[cfg(feature = "std")]
-    pub fn read_openssh_file(path: &Path) -> Result<Self> {
+    pub fn read_openssh<R: Read>(reader: &mut R) -> Result<Self> {
+        let pem = Zeroizing::new(io::read_to_string(reader)?);
+        Self::from_openssh(&*pem)
+    }
+
+    /// Read private key from an OpenSSH-formatted PEM file.
+    #[cfg(feature = "std")]
+    pub fn read_openssh_file<P: AsRef<Path>>(path: P) -> Result<Self> {
         // TODO(tarcieri): verify file permissions match `UNIX_FILE_PERMISSIONS`
         let pem = Zeroizing::new(fs::read_to_string(path)?);
         Self::from_openssh(&*pem)
     }
 
     /// Write private key as an OpenSSH-formatted PEM file.
     #[cfg(feature = "std")]
-    pub fn write_openssh_file(&self, path: &Path, line_ending: LineEnding) -> Result<()> {
+    pub fn write_openssh<W: Write>(&self, writer: &mut W, line_ending: LineEnding) -> Result<()> {
+        let pem = self.to_openssh(line_ending)?;
+        writer.write_all(pem.as_bytes())?;
+        Ok(())
+    }
+
+    /// Write private key as an OpenSSH-formatted PEM file.
+    #[cfg(feature = "std")]
+    pub fn write_openssh_file<P: AsRef<Path>>(
+        &self,
+        path: P,
+        line_ending: LineEnding,
+    ) -> Result<()> {
         let pem = self.to_openssh(line_ending)?;
 
         #[cfg(not(unix))]

ssh-key/src/private/dsa.rs

@@ -65,6 +65,14 @@ impl PartialEq for DsaPrivateKey {
     }
 }
 
+impl TryFrom<Mpint> for DsaPrivateKey {
+    type Error = Error;
+
+    fn try_from(x: Mpint) -> Result<Self> {
+        Self::new(x)
+    }
+}
+
 impl Decode for DsaPrivateKey {
     type Error = Error;
 

ssh-key/src/private/ecdsa.rs

@@ -88,6 +88,12 @@ impl<const SIZE: usize> Encode for EcdsaPrivateKey<SIZE> {
     }
 }
 
+impl<const SIZE: usize> From<[u8; SIZE]> for EcdsaPrivateKey<SIZE> {
+    fn from(bytes: [u8; SIZE]) -> Self {
+        Self { bytes }
+    }
+}
+
 impl<const SIZE: usize> AsRef<[u8; SIZE]> for EcdsaPrivateKey<SIZE> {
     fn as_ref(&self) -> &[u8; SIZE] {
         &self.bytes

ssh-key/src/private/opaque.rs

@@ -77,6 +77,12 @@ impl OpaqueKeypair {
     }
 }
 
+impl From<Vec<u8>> for OpaquePrivateKeyBytes {
+    fn from(bytes: Vec<u8>) -> Self {
+        Self(bytes)
+    }
+}
+
 impl Decode for OpaquePrivateKeyBytes {
     type Error = Error;
 

ssh-key/src/public.rs

@@ -50,6 +50,9 @@ use serde::{Deserialize, Serialize, de, ser};
 #[cfg(feature = "std")]
 use std::{fs, path::Path};
 
+#[cfg(feature = "std")]
+use std::io::{self, Read, Write};
+
 #[cfg(doc)]
 use crate::PrivateKey;
 
@@ -237,14 +240,31 @@ impl PublicKey {
 
     /// Read public key from an OpenSSH-formatted file.
     #[cfg(feature = "std")]
-    pub fn read_openssh_file(path: &Path) -> Result<Self> {
+    pub fn read_openssh<R: Read>(reader: &mut R) -> Result<Self> {
+        let input = io::read_to_string(reader)?;
+        Self::from_openssh(&input)
+    }
+
+    /// Read public key from an OpenSSH-formatted file.
+    #[cfg(feature = "std")]
+    pub fn read_openssh_file<P: AsRef<Path>>(path: P) -> Result<Self> {
         let input = fs::read_to_string(path)?;
         Self::from_openssh(&input)
     }
 
     /// Write public key as an OpenSSH-formatted file.
     #[cfg(feature = "std")]
-    pub fn write_openssh_file(&self, path: &Path) -> Result<()> {
+    pub fn write_openssh<W: Write>(&self, writer: &mut W) -> Result<()> {
+        let mut encoded = self.to_openssh()?;
+        encoded.push('\n'); // TODO(tarcieri): OS-specific line endings?
+
+        writer.write_all(encoded.as_bytes())?;
+        Ok(())
+    }
+
+    /// Write public key as an OpenSSH-formatted file.
+    #[cfg(feature = "std")]
+    pub fn write_openssh_file<P: AsRef<Path>>(&self, path: P) -> Result<()> {
         let mut encoded = self.to_openssh()?;
         encoded.push('\n'); // TODO(tarcieri): OS-specific line endings?