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

Limit long-running tests via #[ignore] instead of commenting them out.

Browse Source
This commit is contained in:
Adam Wick
2019-03-07 21:38:07 -07:00
parent 40254014d3
commit 5a69795fdf
5 changed files with 532 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
src/ecdsa/point.rs
View File

@@ -147,16 +147,10 @@ point_impl!(P256, I256, I512, U512, I576, U576);
point_impl!(P384, I384, I768, U768, I832, U832); point_impl!(P384, I384, I768, U768, I832, U832);
point_impl!(P521, I576, I1152, U1152, I1216, U1216); point_impl!(P521, I576, I1152, U1152, I1216, U1216);
macro_rules! point_tests #[cfg(test)]
macro_rules! negate_test_body
{ {
($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => { ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
#[cfg(test)]
mod $lcurve {
use super::*;
use testing::*;
#[test]
fn negate() {
let fname = build_test_path("ecc/negate",stringify!($curve)); let fname = build_test_path("ecc/negate",stringify!($curve));
run_test(fname.to_string(), 4, |case| { run_test(fname.to_string(), 4, |case| {
let (negx, xbytes) = case.get("x").unwrap(); let (negx, xbytes) = case.get("x").unwrap();
@@ -174,9 +168,12 @@ macro_rules! point_tests
assert_eq!(b, dbl.y, "y equivalence"); assert_eq!(b, dbl.y, "y equivalence");
}); });
} }
}
#[test] #[cfg(test)]
fn double() { macro_rules! double_test_body
{
($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
let fname = build_test_path("ecc/double",stringify!($curve)); let fname = build_test_path("ecc/double",stringify!($curve));
run_test(fname.to_string(), 4, |case| { run_test(fname.to_string(), 4, |case| {
let (negx, xbytes) = case.get("x").unwrap(); let (negx, xbytes) = case.get("x").unwrap();
@@ -194,9 +191,12 @@ macro_rules! point_tests
assert_eq!(b, dbl.y, "y equivalence"); assert_eq!(b, dbl.y, "y equivalence");
}); });
} }
}
#[test] #[cfg(test)]
fn add() { macro_rules! add_test_body
{
($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
let fname = build_test_path("ecc/add",stringify!($curve)); let fname = build_test_path("ecc/add",stringify!($curve));
run_test(fname.to_string(), 6, move |case| { run_test(fname.to_string(), 6, move |case| {
let (negx, xbytes) = case.get("x").unwrap(); let (negx, xbytes) = case.get("x").unwrap();
@@ -219,9 +219,12 @@ macro_rules! point_tests
assert_eq!(b, res.y, "y equivalence"); assert_eq!(b, res.y, "y equivalence");
}); });
} }
}
#[test] #[cfg(test)]
fn scale() { macro_rules! scale_test_body
{
($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
let fname = build_test_path("ecc/scale",stringify!($curve)); let fname = build_test_path("ecc/scale",stringify!($curve));
run_test(fname.to_string(), 5, |case| { run_test(fname.to_string(), 5, |case| {
let (negx, xbytes) = case.get("x").unwrap(); let (negx, xbytes) = case.get("x").unwrap();
@@ -241,9 +244,12 @@ macro_rules! point_tests
assert_eq!(b, res.y, "y equivalence"); assert_eq!(b, res.y, "y equivalence");
}); });
} }
}
#[test] #[cfg(test)]
fn add_scale2() { macro_rules! add_scale2_test_body
{
($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
let fname = build_test_path("ecc/add_scale2",stringify!($curve)); let fname = build_test_path("ecc/add_scale2",stringify!($curve));
run_test(fname.to_string(), 8, |case| { run_test(fname.to_string(), 8, |case| {
let (negx, xbytes) = case.get("x").unwrap(); let (negx, xbytes) = case.get("x").unwrap();
@@ -270,13 +276,53 @@ macro_rules! point_tests
assert_eq!(s, res.y, "y equivalence"); assert_eq!(s, res.y, "y equivalence");
}); });
} }
}
macro_rules! point_tests
{
($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
#[cfg(test)]
mod $lcurve {
use super::*;
use testing::*;
#[test]
fn negate() { negate_test_body!($curve, $lcurve, $stype, $utype); }
#[test]
fn double() { double_test_body!($curve, $lcurve, $stype, $utype); }
#[test]
fn add() { add_test_body!($curve, $lcurve, $stype, $utype); }
#[test]
fn scale() { scale_test_body!($curve, $lcurve, $stype, $utype); }
#[ignore]
#[test]
fn add_scale2() { add_scale2_test_body!($curve, $lcurve, $stype, $utype); }
}
};
(ignore_expensive $curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
#[cfg(test)]
mod $lcurve {
use super::*;
use testing::*;
#[test]
fn negate() { negate_test_body!($curve, $lcurve, $stype, $utype); }
#[test]
fn double() { double_test_body!($curve, $lcurve, $stype, $utype); }
#[test]
fn add() { add_test_body!($curve, $lcurve, $stype, $utype); }
#[ignore]
#[test]
fn scale() { scale_test_body!($curve, $lcurve, $stype, $utype); }
#[ignore]
#[test]
fn add_scale2() { add_scale2_test_body!($curve, $lcurve, $stype, $utype); }
} }
} }
} }
point_tests!(P192, p192, I192, U192); point_tests!(P192, p192, I192, U192);
point_tests!(P224, p224, I256, U256); point_tests!(ignore_expensive P224, p224, I256, U256);
point_tests!(P256, p256, I256, U256); point_tests!(ignore_expensive P256, p256, I256, U256);
point_tests!(P384, p384, I384, U384); point_tests!(ignore_expensive P384, p384, I384, U384);
point_tests!(P521, p521, I576, U576); point_tests!(ignore_expensive P521, p521, I576, U576);

29
src/ecdsa/private.rs
View File

@@ -112,10 +112,10 @@ use sha2::{Sha224,Sha256,Sha384,Sha512};
#[cfg(test)] #[cfg(test)]
use testing::*; use testing::*;
macro_rules! generate_tests { #[cfg(test)]
macro_rules! sign_test_body
{
($name: ident, $curve: ident, $base: ident) => { ($name: ident, $curve: ident, $base: ident) => {
#[test]
fn $name() {
let fname = build_test_path("ecc/sign",stringify!($curve)); let fname = build_test_path("ecc/sign",stringify!($curve));
run_test(fname.to_string(), 9, |case| { run_test(fname.to_string(), 9, |case| {
let (negd, dbytes) = case.get("d").unwrap(); let (negd, dbytes) = case.get("d").unwrap();
@@ -148,11 +148,26 @@ macro_rules! generate_tests {
assert_eq!(s, sig.s, "s signature check"); assert_eq!(s, sig.s, "s signature check");
}); });
} }
}
macro_rules! generate_tests {
($name: ident, $curve: ident, $base: ident) => {
#[test]
fn $name() {
sign_test_body!($name, $curve, $base);
}
};
(ignore $name: ident, $curve: ident, $base: ident) => {
#[ignore]
#[test]
fn $name() {
sign_test_body!($name, $curve, $base);
}
}; };
} }
generate_tests!(p192_sign, P192, U192); generate_tests!(p192_sign, P192, U192);
generate_tests!(p224_sign, P224, U256); generate_tests!(ignore p224_sign, P224, U256);
generate_tests!(p256_sign, P256, U256); generate_tests!(ignore p256_sign, P256, U256);
generate_tests!(p384_sign, P384, U384); generate_tests!(ignore p384_sign, P384, U384);
generate_tests!(p521_sign, P521, U576); generate_tests!(ignore p521_sign, P521, U576);

27
src/ecdsa/public.rs
View File

@@ -176,10 +176,10 @@ use sha2::{Sha224,Sha256,Sha384,Sha512};
#[cfg(test)] #[cfg(test)]
use testing::*; use testing::*;
macro_rules! test_impl { #[cfg(test)]
macro_rules! verify_test_body
{
($name: ident, $curve: ident, $un: ident, $si: ident) => { ($name: ident, $curve: ident, $un: ident, $si: ident) => {
#[test]
fn $name() {
let fname = build_test_path("ecc/sign",stringify!($curve)); let fname = build_test_path("ecc/sign",stringify!($curve));
run_test(fname.to_string(), 9, |case| { run_test(fname.to_string(), 9, |case| {
let (negd, dbytes) = case.get("d").unwrap(); let (negd, dbytes) = case.get("d").unwrap();
@@ -212,11 +212,26 @@ macro_rules! test_impl {
}; };
}); });
} }
}
macro_rules! test_impl {
($name: ident, $curve: ident, $un: ident, $si: ident) => {
#[test]
fn $name() {
verify_test_body!($name, $curve, $un, $si);
}
};
(ignore $name: ident, $curve: ident, $un: ident, $si: ident) => {
#[ignore]
#[test]
fn $name() {
verify_test_body!($name, $curve, $un, $si);
}
}; };
} }
test_impl!(p192,P192,U192,I192); test_impl!(p192,P192,U192,I192);
test_impl!(p224,P224,U256,I256); test_impl!(p224,P224,U256,I256);
test_impl!(p256,P256,U256,I256); test_impl!(ignore p256,P256,U256,I256);
test_impl!(p384,P384,U384,I384); test_impl!(ignore p384,P384,U384,I384);
test_impl!(p521,P521,U576,I576); test_impl!(ignore p521,P521,U576,I576);

86
src/rsa/private.rs
View File

@@ -147,20 +147,9 @@ generate_rsa_private!(RSA4096Private, U4096, BarrettU4096, 4096);
generate_rsa_private!(RSA8192Private, U8192, BarrettU8192, 8192); generate_rsa_private!(RSA8192Private, U8192, BarrettU8192, 8192);
generate_rsa_private!(RSA15360Private, U15360, BarrettU15360, 15360); generate_rsa_private!(RSA15360Private, U15360, BarrettU15360, 15360);
macro_rules! generate_tests { #[cfg(test)]
( $( ($mod: ident, $rsa: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) ),* ) => { macro_rules! sign_test_body {
$( ($mod: ident, $rsa: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
#[cfg(test)]
#[allow(non_snake_case)]
mod $mod {
use cryptonum::unsigned::Decoder;
use super::*;
use testing::run_test;
use rsa::signing_hashes::*;
use sha2::{Sha224,Sha256,Sha384,Sha512};
#[test]
fn sign() {
let fname = format!("testdata/rsa/sign{}.test", $size); let fname = format!("testdata/rsa/sign{}.test", $size);
run_test(fname.to_string(), 7, |case| { run_test(fname.to_string(), 7, |case| {
let (neg0, dbytes) = case.get("d").unwrap(); let (neg0, dbytes) = case.get("d").unwrap();
@@ -188,10 +177,12 @@ macro_rules! generate_tests {
let sig = privkey.sign(sighash, &mbytes); let sig = privkey.sign(sighash, &mbytes);
assert_eq!(*sbytes, sig); assert_eq!(*sbytes, sig);
}); });
} };
}
#[test] #[cfg(test)]
fn decrypt() { macro_rules! decrypt_test_body {
($mod: ident, $rsa: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
let fname = format!("testdata/rsa/encrypt{}.test", $size); let fname = format!("testdata/rsa/encrypt{}.test", $size);
run_test(fname.to_string(), 9, |case| { run_test(fname.to_string(), 9, |case| {
let (neg0, nbytes) = case.get("n").unwrap(); let (neg0, nbytes) = case.get("n").unwrap();
@@ -224,17 +215,60 @@ macro_rules! generate_tests {
assert!(message.is_ok()); assert!(message.is_ok());
assert_eq!(mbytes, &message.unwrap()); assert_eq!(mbytes, &message.unwrap());
}); });
};
}
macro_rules! generate_tests {
($mod: ident, $rsa: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
#[cfg(test)]
#[allow(non_snake_case)]
mod $mod {
use cryptonum::unsigned::Decoder;
use super::*;
use testing::run_test;
use rsa::signing_hashes::*;
use sha2::{Sha224,Sha256,Sha384,Sha512};
#[test]
fn sign() {
sign_test_body!($mod, $rsa, $num, $bar, $num64, $size);
}
#[test]
fn decrypt() {
decrypt_test_body!($mod, $rsa, $num, $bar, $num64, $size);
}
}
};
(ignore $mod: ident, $rsa: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
#[cfg(test)]
#[allow(non_snake_case)]
mod $mod {
use cryptonum::unsigned::Decoder;
use super::*;
use testing::run_test;
use rsa::signing_hashes::*;
use sha2::{Sha224,Sha256,Sha384,Sha512};
#[ignore]
#[test]
fn sign() {
sign_test_body!($mod, $rsa, $num, $bar, $num64, $size);
}
#[ignore]
#[test]
fn decrypt() {
decrypt_test_body!($mod, $rsa, $num, $bar, $num64, $size);
} }
} }
)*
} }
} }
generate_tests!( (RSA512, RSA512Private, U512, BarrettU512, U576, 512), generate_tests!(RSA512, RSA512Private, U512, BarrettU512, U576, 512);
(RSA1024, RSA1024Private, U1024, BarrettU1024, U1088, 1024), generate_tests!(RSA1024, RSA1024Private, U1024, BarrettU1024, U1088, 1024);
(RSA2048, RSA2048Private, U2048, BarrettU2048, U2112, 2048) generate_tests!(RSA2048, RSA2048Private, U2048, BarrettU2048, U2112, 2048);
// (RSA3072, RSA3072Private, U3072, BarrettU3072, U3136, 3072), generate_tests!(RSA3072, RSA3072Private, U3072, BarrettU3072, U3136, 3072);
// (RSA4096, RSA4096Private, U4096, BarrettU4096, U4160, 4096), generate_tests!(RSA4096, RSA4096Private, U4096, BarrettU4096, U4160, 4096);
// (RSA8192, RSA8192Private, U8192, BarrettU8192, U8256, 8192), generate_tests!(ignore RSA8192, RSA8192Private, U8192, BarrettU8192, U8256, 8192);
// (RSA15360, RSA15360Private, U15360, BarrettU15360, U15424, 15360) generate_tests!(ignore RSA15360, RSA15360Private, U15360, BarrettU15360, U15424, 15360);
);

111
src/rsa/public.rs
View File

@@ -334,21 +334,9 @@ generate_rsa_public!(RSA4096Public, U4096, BarrettU4096, Key4096, 4096);
generate_rsa_public!(RSA8192Public, U8192, BarrettU8192, Key8192, 8192); generate_rsa_public!(RSA8192Public, U8192, BarrettU8192, Key8192, 8192);
generate_rsa_public!(RSA15360Public, U15360, BarrettU15360, Key15360, 15360); generate_rsa_public!(RSA15360Public, U15360, BarrettU15360, Key15360, 15360);
macro_rules! generate_tests { #[cfg(test)]
( $( ($mod: ident, $rsa: ident, $priv: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) ),* ) => { macro_rules! new_test_body {
$( ($mod: ident, $rsa: ident, $priv: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
#[cfg(test)]
#[allow(non_snake_case)]
mod $mod {
use cryptonum::unsigned::Decoder;
use super::*;
use testing::run_test;
use rsa::private::*;
use rsa::signing_hashes::*;
use sha2::{Sha224,Sha256,Sha384,Sha512};
#[test]
fn new() {
let fname = format!("testdata/rsa/sign{}.test", $size); let fname = format!("testdata/rsa/sign{}.test", $size);
run_test(fname.to_string(), 7, |case| { run_test(fname.to_string(), 7, |case| {
let (neg0, nbytes) = case.get("n").unwrap(); let (neg0, nbytes) = case.get("n").unwrap();
@@ -366,10 +354,12 @@ macro_rules! generate_tests {
let pubkey1 = $rsa{ n: n, nu: $bar::from_components(k, n64, nu), e: e }; let pubkey1 = $rsa{ n: n, nu: $bar::from_components(k, n64, nu), e: e };
assert_eq!(pubkey1, pubkey2); assert_eq!(pubkey1, pubkey2);
}); });
} };
}
#[test] #[cfg(test)]
fn encode() { macro_rules! encode_test_body {
($mod: ident, $rsa: ident, $priv: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
let fname = format!("testdata/rsa/sign{}.test", $size); let fname = format!("testdata/rsa/sign{}.test", $size);
run_test(fname.to_string(), 7, |case| { run_test(fname.to_string(), 7, |case| {
let (neg0, nbytes) = case.get("n").unwrap(); let (neg0, nbytes) = case.get("n").unwrap();
@@ -388,10 +378,12 @@ macro_rules! generate_tests {
let (pubkey2, _) = $rsa::from_asn1(&asn1).unwrap(); let (pubkey2, _) = $rsa::from_asn1(&asn1).unwrap();
assert_eq!(pubkey, pubkey2); assert_eq!(pubkey, pubkey2);
}); });
} };
}
#[test] #[cfg(test)]
fn verify() { macro_rules! verify_test_body {
($mod: ident, $rsa: ident, $priv: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
let fname = format!("testdata/rsa/sign{}.test", $size); let fname = format!("testdata/rsa/sign{}.test", $size);
run_test(fname.to_string(), 7, |case| { run_test(fname.to_string(), 7, |case| {
let (neg0, nbytes) = case.get("n").unwrap(); let (neg0, nbytes) = case.get("n").unwrap();
@@ -420,10 +412,12 @@ macro_rules! generate_tests {
}; };
assert!(pubkey.verify(sighash, &mbytes, &sbytes)); assert!(pubkey.verify(sighash, &mbytes, &sbytes));
}); });
} };
}
#[test] #[cfg(test)]
fn encrypt() { macro_rules! encrypt_test_body {
($mod: ident, $rsa: ident, $priv: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
let fname = format!("testdata/rsa/encrypt{}.test", $size); let fname = format!("testdata/rsa/encrypt{}.test", $size);
run_test(fname.to_string(), 9, |case| { run_test(fname.to_string(), 9, |case| {
let (neg0, nbytes) = case.get("n").unwrap(); let (neg0, nbytes) = case.get("n").unwrap();
@@ -465,17 +459,62 @@ macro_rules! generate_tests {
assert!(message.is_ok()); assert!(message.is_ok());
assert_eq!(mbytes, &message.unwrap()); assert_eq!(mbytes, &message.unwrap());
}); });
} };
}
)*
}
} }
generate_tests!( (RSA512, RSA512Public, RSA512Private, U512, BarrettU512, U576, 512), macro_rules! generate_tests {
(RSA1024, RSA1024Public, RSA1024Private, U1024, BarrettU1024, U1088, 1024), ($mod: ident, $rsa: ident, $priv: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
(RSA2048, RSA2048Public, RSA2048Private, U2048, BarrettU2048, U2112, 2048), #[cfg(test)]
(RSA3072, RSA3072Public, RSA3072Private, U3072, BarrettU3072, U3136, 3072), #[allow(non_snake_case)]
(RSA4096, RSA4096Public, RSA4096Private, U4096, BarrettU4096, U4160, 4096), mod $mod {
(RSA8192, RSA8192Public, RSA8192Private, U8192, BarrettU8192, U8256, 8192), use cryptonum::unsigned::Decoder;
(RSA15360, RSA15360Public, RSA15360Private, U15360, BarrettU15360, U15424, 15360) use super::*;
); use testing::run_test;
use rsa::private::*;
use rsa::signing_hashes::*;
use sha2::{Sha224,Sha256,Sha384,Sha512};
#[test]
fn new() { new_test_body!($mod, $rsa, $priv, $num, $bar, $num64, $size); }
#[test]
fn encode() { encode_test_body!($mod, $rsa, $priv, $num, $bar, $num64, $size); }
#[test]
fn verify() { verify_test_body!($mod, $rsa, $priv, $num, $bar, $num64, $size); }
#[test]
fn encrypt() { encrypt_test_body!($mod, $rsa, $priv, $num, $bar, $num64, $size); }
}
};
(ignore $mod: ident, $rsa: ident, $priv: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
#[cfg(test)]
#[allow(non_snake_case)]
mod $mod {
use cryptonum::unsigned::Decoder;
use super::*;
use testing::run_test;
use rsa::private::*;
use rsa::signing_hashes::*;
use sha2::{Sha224,Sha256,Sha384,Sha512};
#[ignore]
#[test]
fn new() { new_test_body!($mod, $rsa, $priv, $num, $bar, $num64, $size); }
#[ignore]
#[test]
fn encode() { encode_test_body!($mod, $rsa, $priv, $num, $bar, $num64, $size); }
#[ignore]
#[test]
fn verify() { verify_test_body!($mod, $rsa, $priv, $num, $bar, $num64, $size); }
#[ignore]
#[test]
fn encrypt() { encrypt_test_body!($mod, $rsa, $priv, $num, $bar, $num64, $size); }
}
};
}
generate_tests!(RSA512, RSA512Public, RSA512Private, U512, BarrettU512, U576, 512);
generate_tests!(RSA1024, RSA1024Public, RSA1024Private, U1024, BarrettU1024, U1088, 1024);
generate_tests!(RSA2048, RSA2048Public, RSA2048Private, U2048, BarrettU2048, U2112, 2048);
generate_tests!(RSA3072, RSA3072Public, RSA3072Private, U3072, BarrettU3072, U3136, 3072);
generate_tests!(RSA4096, RSA4096Public, RSA4096Private, U4096, BarrettU4096, U4160, 4096);
generate_tests!(ignore RSA8192, RSA8192Public, RSA8192Private, U8192, BarrettU8192, U8256, 8192);
generate_tests!(ignore RSA15360, RSA15360Public, RSA15360Private, U15360, BarrettU15360, U15424, 15360);