acw/simple_crypto
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up the DSA struct parameter types.

Browse Source
This commit is contained in:
Adam Wick
2019-04-04 16:32:15 -07:00
parent 54c5244bc5
commit 68ddc7096b
6 changed files with 36 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/dsa/mod.rs
View File

@@ -14,10 +14,10 @@ use cryptonum::unsigned::*;
use rand::Rng;
use rand::distributions::Standard;
pub struct DSAKeyPair<P,L,N>
pub struct DSAKeyPair<P: DSAParameters>
{
pub private: DSAPrivKey<P,N>,
pub public: DSAPubKey<P,L>
pub private: DSAPrivKey<P>,
pub public: DSAPubKey<P>
}
pub trait DSAKeyGeneration
@@ -29,7 +29,7 @@ pub trait DSAKeyGeneration
macro_rules! generate_dsa_pair {
($ptype: ident, $ltype: ident, $ntype: ident, $nbig: ident) => {
impl DSAKeyGeneration for DSAKeyPair<$ptype,$ltype,$ntype>
impl DSAKeyGeneration for DSAKeyPair<$ptype>
{
type Params = $ptype;

18
src/dsa/private.rs
View File

@@ -21,28 +21,28 @@ pub trait DSAPrivateKey {
Hmac<Hash>: Mac;
}
pub struct DSAPrivKey<Params,N>
pub struct DSAPrivKey<Params: DSAParameters>
{
pub(crate) params: Params,
pub(crate) x: N
pub(crate) x: Params::N
}
pub enum DSAPrivate {
DSA1024Private(DSAPrivKey<L1024N160,U192>),
DSA2048SmallPrivate(DSAPrivKey<L2048N224,U256>),
DSA2048Private(DSAPrivKey<L2048N256,U256>),
DSA3072Private(DSAPrivKey<L3072N256,U256>)
DSA1024Private(DSAPrivKey<L1024N160>),
DSA2048SmallPrivate(DSAPrivKey<L2048N224>),
DSA2048Private(DSAPrivKey<L2048N256>),
DSA3072Private(DSAPrivKey<L3072N256>)
}
macro_rules! privkey_impls {
($ptype: ident, $ltype: ident, $ntype: ident, $big: ident, $bigger: ident, $biggest: ident) => {
impl DSAPrivateKey for DSAPrivKey<$ptype,$ntype>
impl DSAPrivateKey for DSAPrivKey<$ptype>
{
type Params = $ptype;
type L = $ltype;
type N = $ntype;
fn new(params: $ptype, x: $ntype) -> DSAPrivKey<$ptype,$ntype>
fn new(params: $ptype, x: $ntype) -> DSAPrivKey<$ptype>
{
DSAPrivKey{ params, x }
}
@@ -155,7 +155,7 @@ macro_rules! generate_tests {
let s = $nt::from_bytes(sbytes);
let params = $params::new(p,g,q);
let private = DSAPrivKey::<$params,$nt>::new(params, x);
let private = DSAPrivKey::<$params>::new(params, x);
let sig = match h {
224 => private.sign::<Sha224>(mbytes),
256 => private.sign::<Sha256>(mbytes),

20
src/dsa/public.rs
View File

@@ -20,27 +20,27 @@ pub trait DSAPublicKey {
where Hash: Digest;
}
pub struct DSAPubKey<Params,L> {
pub struct DSAPubKey<Params: DSAParameters> {
pub(crate) params: Params,
pub(crate) y: L
pub(crate) y: Params::L
}
pub enum DSAPublic {
DSAPublicL1024N160(DSAPubKey<L1024N160,U1024>),
DSAPublicL2048N224(DSAPubKey<L2048N224,U2048>),
DSAPublicL2048N256(DSAPubKey<L2048N256,U2048>),
DSAPublicL3072N256(DSAPubKey<L3072N256,U3072>)
DSAPublicL1024N160(DSAPubKey<L1024N160>),
DSAPublicL2048N224(DSAPubKey<L2048N224>),
DSAPublicL2048N256(DSAPubKey<L2048N256>),
DSAPublicL3072N256(DSAPubKey<L3072N256>)
}
macro_rules! pubkey_impls {
($ptype: ident, $ltype: ident, $ntype: ident, $dbl: ident, $bdbl: ident) => {
impl DSAPublicKey for DSAPubKey<$ptype,$ltype>
impl DSAPublicKey for DSAPubKey<$ptype>
{
type Params = $ptype;
type L = $ltype;
type N = $ntype;
fn new(params: $ptype, y: $ltype) -> DSAPubKey<$ptype,$ltype>
fn new(params: $ptype, y: $ltype) -> DSAPubKey<$ptype>
{
DSAPubKey{ params, y }
}
@@ -80,7 +80,7 @@ macro_rules! pubkey_impls {
}
}
impl ToASN1 for DSAPubKey<$ptype,$ltype> {
impl ToASN1 for DSAPubKey<$ptype> {
type Error = ASN1EncodeErr;
fn to_asn1_class(&self, c: ASN1Class)
@@ -136,7 +136,7 @@ macro_rules! generate_tests {
let s = $nt::from_bytes(sbytes);
let params = $params::new(p,g,q);
let public = DSAPubKey::<$params,$lt>::new(params, y);
let public = DSAPubKey::<$params>::new(params, y);
let sig = DSASignature::<$nt>::new(r, s);
match h {
224 => assert!(public.verify::<Sha224>(mbytes, &sig)),

8
src/dsa/tests.rs
View File

@@ -99,8 +99,8 @@ fn appendix_a21() {
let params = L1024N160::new(p, g, q);
let x = U192::from_bytes(&xbytes);
let y = U1024::from_bytes(&ybytes);
let private = DSAPrivKey::new(params.clone(), x);
let public = DSAPubKey::<L1024N160,U1024>::new(params.clone(), y);
let private = DSAPrivKey::<L1024N160>::new(params.clone(), x);
let public = DSAPubKey::<L1024N160>::new(params.clone(), y);
//
let sample: [u8; 6] = [115, 97, 109, 112, 108, 101]; // "sample", ASCII
let test: [u8; 4] = [116, 101, 115, 116]; // "test", ASCII
@@ -359,8 +359,8 @@ fn appendix_a22() {
let params = L2048N256::new(p, g, q);
let x = U256::from_bytes(&xbytes);
let y = U2048::from_bytes(&ybytes);
let private = DSAPrivKey::<L2048N256,U256>::new(params.clone(), x);
let public = DSAPubKey::<L2048N256,U2048>::new(params.clone(), y);
let private = DSAPrivKey::<L2048N256>::new(params.clone(), x);
let public = DSAPubKey::<L2048N256>::new(params.clone(), y);
//
let sample: [u8; 6] = [115, 97, 109, 112, 108, 101]; // "sample", ASCII
let test: [u8; 4] = [116, 101, 115, 116]; // "test", ASCII

10
src/ssh/mod.rs
View File

@@ -31,7 +31,7 @@ pub trait SSHKey: Sized {
}
impl SSHKey for DSAKeyPair<L1024N160,U1024,U192> {
impl SSHKey for DSAKeyPair<L1024N160> {
fn decode_ssh_private_key(x: &str) -> Result<(Self,String),SSHKeyParseError>
{
let bytes = parse_ssh_private_key_data(x)?;
@@ -74,7 +74,7 @@ impl SSHKey for DSAKeyPair<L1024N160,U1024,U192> {
let pubg = parse_openssh_number(&mut pubkey_cursor)?;
let pubparams = L1024N160::new(pubp, pubg, pubq);
let puby: U1024 = parse_openssh_number(&mut pubkey_cursor)?;
let pubkey = DSAPubKey::<L1024N160,U1024>::new(pubparams.clone(), puby.clone());
let pubkey = DSAPubKey::<L1024N160>::new(pubparams.clone(), puby.clone());
// And now we can look at the private key!
let mut privkey_cursor = Cursor::new(privkeys);
@@ -99,7 +99,7 @@ impl SSHKey for DSAKeyPair<L1024N160,U1024,U192> {
return Err(SSHKeyParseError::InconsistentPublicKeyValue);
}
let privkey = DSAPrivKey::<L1024N160,U192>::new(pubparams, privx);
let privkey = DSAPrivKey::<L1024N160>::new(pubparams, privx);
let comment = parse_openssh_string(&mut privkey_cursor)?;
for (idx,byte) in privkey_cursor.bytes().enumerate() {
if ((idx+1) as u8) != byte? {
@@ -161,7 +161,7 @@ fn read_dsa_examples() {
for file in test_files.iter() {
let path = format!("testdata/ssh/{}",file);
let mkeypair = DSAKeyPair::<L1024N160,U1024,U192>::read_ssh_private_key_file(path);
let mkeypair = DSAKeyPair::<L1024N160>::read_ssh_private_key_file(path);
match mkeypair {
Err(e) => assert!(false, format!("reading error: {:?}", e)),
Ok((keypair,comment)) => {
@@ -173,7 +173,7 @@ fn read_dsa_examples() {
match keypair.encode_ssh_private_key(&comment) {
Err(e2) => assert!(false, format!("render error: {:?}", e2)),
Ok(encodedstr) => {
match DSAKeyPair::<L1024N160,U1024,U192>::decode_ssh_private_key(&encodedstr) {
match DSAKeyPair::<L1024N160>::decode_ssh_private_key(&encodedstr) {
Err(e3) => assert!(false, format!("reparse error: {:?}", e3)),
Ok((keypair2,comment2)) => {
assert_eq!(keypair.public.params.p,keypair2.public.params.p,"failed to reparse key pair (p)");

8
src/x509/publickey.rs
View File

@@ -174,7 +174,7 @@ fn decode_dsa_key(info: ASN1Block, key: &ASN1Block) -> Result<DSAPublic,X509Pars
let (iblk,_) = blocks.split_first().ok_or(X509ParseError::InvalidDSAKey)?;
if let ASN1Block::Integer(_,_,ynum) = iblk {
let y = U3072::from_num(ynum).ok_or(X509ParseError::InvalidDSAKey)?;
let key = DSAPubKey::<L3072N256,U3072>::new(params, y);
let key = DSAPubKey::<L3072N256>::new(params, y);
let reskey = DSAPublic::DSAPublicL3072N256(key);
return Ok(reskey);
}
@@ -195,7 +195,7 @@ fn decode_dsa_key(info: ASN1Block, key: &ASN1Block) -> Result<DSAPublic,X509Pars
let (iblk,_) = blocks.split_first().ok_or(X509ParseError::InvalidDSAKey)?;
if let ASN1Block::Integer(_,_,ynum) = iblk {
let y = U2048::from_num(ynum).ok_or(X509ParseError::InvalidDSAKey)?;
let key = DSAPubKey::<L2048N256,U2048>::new(params, y);
let key = DSAPubKey::<L2048N256>::new(params, y);
let reskey = DSAPublic::DSAPublicL2048N256(key);
return Ok(reskey);
}
@@ -213,7 +213,7 @@ fn decode_dsa_key(info: ASN1Block, key: &ASN1Block) -> Result<DSAPublic,X509Pars
let (iblk,_) = blocks.split_first().ok_or(X509ParseError::InvalidDSAKey)?;
if let ASN1Block::Integer(_,_,ynum) = iblk {
let y = U2048::from_num(ynum).ok_or(X509ParseError::InvalidDSAKey)?;
let key = DSAPubKey::<L2048N224,U2048>::new(params, y);
let key = DSAPubKey::<L2048N224>::new(params, y);
let reskey = DSAPublic::DSAPublicL2048N224(key);
return Ok(reskey);
}
@@ -233,7 +233,7 @@ fn decode_dsa_key(info: ASN1Block, key: &ASN1Block) -> Result<DSAPublic,X509Pars
let (iblk,_) = blocks.split_first().ok_or(X509ParseError::InvalidDSAKey)?;
if let ASN1Block::Integer(_,_,ynum) = iblk {
let y = U1024::from_num(ynum).ok_or(X509ParseError::InvalidDSAKey)?;
let key = DSAPubKey::<L1024N160,U1024>::new(params, y);
let key = DSAPubKey::<L1024N160>::new(params, y);
let reskey = DSAPublic::DSAPublicL1024N160(key);
return Ok(reskey);
}