Make sure RSA and ECDSA have KeyPair instances.

src/ecdsa/mod.rs

@@ -13,6 +13,7 @@ use self::point::{ECCPoint,Point};
 pub use self::private::ECCPrivateKey;
 pub use self::public::{ECDSAPublic,ECCPublicKey};
 pub use self::public::{ECDSADecodeErr,ECDSAEncodeErr};
+use super::KeyPair;
 
 pub struct ECDSAKeyPair<Curve: EllipticCurve> {
     pub public: ECCPublicKey<Curve>,
@@ -21,6 +22,15 @@ pub struct ECDSAKeyPair<Curve: EllipticCurve> {
 
 macro_rules! generate_impl {
     ($curve: ident, $un: ident, $si: ident) => {
+        impl KeyPair for ECDSAKeyPair<$curve> {
+            type Public = ECCPublicKey<$curve>;
+            type Private = ECCPrivateKey<$curve>;
+
+            fn new(public: ECCPublicKey<$curve>, private: ECCPrivateKey<$curve>) -> ECDSAKeyPair<$curve>
+            {
+                ECDSAKeyPair{ public, private }
+            }
+        }
         impl ECDSAKeyPair<$curve> {
             pub fn generate<G: Rng>(rng: &mut G) -> ECDSAKeyPair<$curve>
             {

src/rsa/mod.rs

@@ -41,6 +41,7 @@ use cryptonum::unsigned::{CryptoNum,PrimeGen};
 use cryptonum::unsigned::{U256,U512,U1024,U1536,U2048,U3072,U4096,U7680,U8192,U15360};
 use rand::RngCore;
 use std::ops::Sub;
+use super::KeyPair;
 
 fn diff<T>(a: &T, b: &T) -> T
  where
@@ -62,14 +63,19 @@ pub struct RSAKeyPair<R: RSAMode> {
 macro_rules! generate_rsa_pair
 {
     ($uint: ident, $half: ident, $iterations: expr) => {
-        impl RSAKeyPair<$uint> {
+        impl KeyPair for RSAKeyPair<$uint> {
-            pub fn new(pu: RSAPublicKey<$uint>, pr: RSAPrivateKey<$uint>) -> RSAKeyPair<$uint> {
+            type Public = RSAPublicKey<$uint>;
+            type Private = RSAPrivateKey<$uint>;
+
+            fn new(pu: RSAPublicKey<$uint>, pr: RSAPrivateKey<$uint>) -> RSAKeyPair<$uint> {
                 RSAKeyPair {
                     public: pu,
                     private: pr
                 }
             }
+        }
 
+        impl RSAKeyPair<$uint> {
             pub fn generate<G>(rng: &mut G) -> RSAKeyPair<$uint>
              where G: RngCore
             {

src/ssh/frame.rs

@@ -94,7 +94,6 @@ pub fn render_openssh_u32<O: Write>(output: &mut O, val: u32) -> Result<(),SSHKe
 pub fn parse_openssh_string<I: Read>(input: &mut I) -> Result<String,SSHKeyParseError>
 {
     let length = parse_openssh_u32(input)?;
-    println!("len: {:X}", length);
     let mut limited_input = input.take(length as u64);
     let mut result = String::new();
     limited_input.read_to_string(&mut result)?;