Start the infrastructure for ECDSA SSH keys.

src/ecdsa/mod.rs

@@ -10,7 +10,7 @@ use rand::Rng;
 use rand::distributions::Standard;
 use self::curve::{EllipticCurve,P192,P224,P256,P384,P521};
 use self::point::{ECCPoint,Point};
-pub use self::private::ECCPrivateKey;
+pub use self::private::{ECDSAPrivate,ECCPrivateKey};
 pub use self::public::{ECDSAPublic,ECCPublicKey};
 pub use self::public::{ECDSADecodeErr,ECDSAEncodeErr};
 use super::KeyPair;
@@ -20,6 +20,32 @@ pub struct ECDSAKeyPair<Curve: EllipticCurve> {
     pub private: ECCPrivateKey<Curve>
 }
 
+pub enum ECDSAPair {
+    P192(ECCPublicKey<P192>,ECCPrivateKey<P192>),
+    P224(ECCPublicKey<P224>,ECCPrivateKey<P224>),
+    P256(ECCPublicKey<P256>,ECCPrivateKey<P256>),
+    P384(ECCPublicKey<P384>,ECCPrivateKey<P384>),
+    P521(ECCPublicKey<P521>,ECCPrivateKey<P521>),
+}
+
+impl KeyPair for ECDSAPair {
+    type Public = ECDSAPublic;
+    type Private = ECDSAPrivate;
+
+    fn new(pu: ECDSAPublic, pr: ECDSAPrivate) -> ECDSAPair
+    {
+        match (pu, pr) {
+            (ECDSAPublic::P192(pbl),ECDSAPrivate::P192(prv)) => ECDSAPair::P192(pbl,prv),
+            (ECDSAPublic::P224(pbl),ECDSAPrivate::P224(prv)) => ECDSAPair::P224(pbl,prv),
+            (ECDSAPublic::P256(pbl),ECDSAPrivate::P256(prv)) => ECDSAPair::P256(pbl,prv),
+            (ECDSAPublic::P384(pbl),ECDSAPrivate::P384(prv)) => ECDSAPair::P384(pbl,prv),
+            (ECDSAPublic::P521(pbl),ECDSAPrivate::P521(prv)) => ECDSAPair::P521(pbl,prv),
+            _ =>
+                panic!("Non-matching public/private pairs in ECDSAPair::new()")
+        } 
+    }
+}
+
 macro_rules! generate_impl {
     ($curve: ident, $un: ident, $si: ident) => {
         impl KeyPair for ECDSAKeyPair<$curve> {

src/ecdsa/private.rs

@@ -10,6 +10,14 @@ pub struct ECCPrivateKey<Curve: EllipticCurve> {
     d: Curve::Unsigned
 }
 
+pub enum ECDSAPrivate {
+    P192(ECCPrivateKey<P192>),
+    P224(ECCPrivateKey<P224>),
+    P256(ECCPrivateKey<P256>),
+    P384(ECCPrivateKey<P384>),
+    P521(ECCPrivateKey<P521>),
+}
+
 macro_rules! generate_privates
 {
     ($curve: ident, $base: ident, $sig: ident, $dbl: ident, $quad: ident) => {

src/ecdsa/public.rs

@@ -13,11 +13,11 @@ pub struct ECCPublicKey<Curve: EllipticCurve> {
 }
 
 pub enum ECDSAPublic {
-    ECCPublicP192(ECCPublicKey<P192>),
-    ECCPublicP224(ECCPublicKey<P224>),
-    ECCPublicP256(ECCPublicKey<P256>),
-    ECCPublicP384(ECCPublicKey<P384>),
-    ECCPublicP521(ECCPublicKey<P521>),
+    P192(ECCPublicKey<P192>),
+    P224(ECCPublicKey<P224>),
+    P256(ECCPublicKey<P256>),
+    P384(ECCPublicKey<P384>),
+    P521(ECCPublicKey<P521>),
 }
 
 pub enum ECDSAEncodeErr {