Preliminary x.509 support. This is some of the ugliest code I've ever written, but it works. Ish.

src/dsa/public.rs

@@ -3,17 +3,20 @@ use cryptonum::signed::ModInv;
 use digest::Digest;
 use dsa::params::*;
 use dsa::rfc6979::DSASignature;
-use num::BigInt;
-use simple_asn1::{ToASN1,ASN1Block,ASN1Class,ASN1EncodeErr};
+use simple_asn1::{ASN1Block,ASN1Class,ASN1EncodeErr,ToASN1};
 use std::cmp::min;
 use utils::TranslateNums;
 
-pub trait DSAPublicKey<Params,L,N> {
+pub trait DSAPublicKey {
+    type Params : DSAParameters;
+    type L;
+    type N;
+
     /// Generate a new public key given the parameters and public value.
-    fn new(params: Params, y: L) -> Self;
+    fn new(params: Self::Params, y: Self::L) -> Self;
     /// Verify the given signature against the given message, using the
     /// appropriate hash function.
-    fn verify<Hash>(&self, m: &[u8], sig: &DSASignature<N>) -> bool
+    fn verify<Hash>(&self, m: &[u8], sig: &DSASignature<Self::N>) -> bool
       where Hash: Digest;
 }
 
@@ -22,10 +25,21 @@ pub struct DSAPubKey<Params,L> {
     pub(crate) y: L
 }
 
+pub enum DSAPublic {
+    DSAPublicL1024N160(DSAPubKey<L1024N160,U1024>),
+    DSAPublicL2048N224(DSAPubKey<L2048N224,U2048>),
+    DSAPublicL2048N256(DSAPubKey<L2048N256,U2048>),
+    DSAPublicL3072N256(DSAPubKey<L3072N256,U3072>)
+}
+
 macro_rules! pubkey_impls {
     ($ptype: ident, $ltype: ident, $ntype: ident, $dbl: ident, $bdbl: ident) => {
-        impl DSAPublicKey<$ptype,$ltype,$ntype> for DSAPubKey<$ptype,$ltype>
+        impl DSAPublicKey for DSAPubKey<$ptype,$ltype>
         {
+            type Params = $ptype;
+            type L = $ltype;
+            type N = $ntype;
+
             fn new(params: $ptype, y: $ltype) -> DSAPubKey<$ptype,$ltype>
             {
                 DSAPubKey{ params, y }
@@ -72,8 +86,7 @@ macro_rules! pubkey_impls {
             fn to_asn1_class(&self, c: ASN1Class)
                 -> Result<Vec<ASN1Block>,ASN1EncodeErr>
             {
-                let uinty = self.y.to_num();
-                let inty = BigInt::from(uinty);
+                let inty = self.y.to_num();
                 let yblock = ASN1Block::Integer(c, 0, inty);
                 Ok(vec![yblock])
             }