diff --git a/src/ecdsa/point.rs b/src/ecdsa/point.rs index c3ce169..525e1b9 100644 --- a/src/ecdsa/point.rs +++ b/src/ecdsa/point.rs @@ -147,6 +147,137 @@ point_impl!(P256, I256, I512, U512, I576, U576); point_impl!(P384, I384, I768, U768, I832, U832); point_impl!(P521, I576, I1152, U1152, I1216, U1216); +#[cfg(test)] +macro_rules! negate_test_body +{ + ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => { + let fname = build_test_path("ecc/negate",stringify!($curve)); + run_test(fname.to_string(), 4, |case| { + let (negx, xbytes) = case.get("x").unwrap(); + let (negy, ybytes) = case.get("y").unwrap(); + let (nega, abytes) = case.get("a").unwrap(); + let (negb, bbytes) = case.get("b").unwrap(); + + let x = $stype::new(*negx, $utype::from_bytes(xbytes)); + let y = $stype::new(*negy, $utype::from_bytes(ybytes)); + let a = $stype::new(*nega, $utype::from_bytes(abytes)); + let b = $stype::new(*negb, $utype::from_bytes(bbytes)); + let point = Point::<$curve>{ x, y }; + let dbl = point.negate(); + assert_eq!(a, dbl.x, "x equivalence"); + assert_eq!(b, dbl.y, "y equivalence"); + }); + } +} + +#[cfg(test)] +macro_rules! double_test_body +{ + ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => { + let fname = build_test_path("ecc/double",stringify!($curve)); + run_test(fname.to_string(), 4, |case| { + let (negx, xbytes) = case.get("x").unwrap(); + let (negy, ybytes) = case.get("y").unwrap(); + let (nega, abytes) = case.get("a").unwrap(); + let (negb, bbytes) = case.get("b").unwrap(); + + let x = $stype::new(*negx, $utype::from_bytes(xbytes)); + let y = $stype::new(*negy, $utype::from_bytes(ybytes)); + let a = $stype::new(*nega, $utype::from_bytes(abytes)); + let b = $stype::new(*negb, $utype::from_bytes(bbytes)); + let point = Point::<$curve>{ x, y }; + let dbl = point.double(); + assert_eq!(a, dbl.x, "x equivalence"); + assert_eq!(b, dbl.y, "y equivalence"); + }); + } +} + +#[cfg(test)] +macro_rules! add_test_body +{ + ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => { + let fname = build_test_path("ecc/add",stringify!($curve)); + run_test(fname.to_string(), 6, move |case| { + let (negx, xbytes) = case.get("x").unwrap(); + let (negy, ybytes) = case.get("y").unwrap(); + let (negu, ubytes) = case.get("u").unwrap(); + let (negv, vbytes) = case.get("v").unwrap(); + let (nega, abytes) = case.get("a").unwrap(); + let (negb, bbytes) = case.get("b").unwrap(); + + let x = $stype::new(*negx, $utype::from_bytes(xbytes)); + let y = $stype::new(*negy, $utype::from_bytes(ybytes)); + let u = $stype::new(*negu, $utype::from_bytes(ubytes)); + let v = $stype::new(*negv, $utype::from_bytes(vbytes)); + let a = $stype::new(*nega, $utype::from_bytes(abytes)); + let b = $stype::new(*negb, $utype::from_bytes(bbytes)); + let point1 = Point::<$curve>{ x: x, y: y }; + let point2 = Point::<$curve>{ x: u, y: v }; + let res = point1.add(&point2); + assert_eq!(a, res.x, "x equivalence"); + assert_eq!(b, res.y, "y equivalence"); + }); + } +} + +#[cfg(test)] +macro_rules! scale_test_body +{ + ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => { + let fname = build_test_path("ecc/scale",stringify!($curve)); + run_test(fname.to_string(), 5, |case| { + let (negx, xbytes) = case.get("x").unwrap(); + let (negy, ybytes) = case.get("y").unwrap(); + let (negk, kbytes) = case.get("k").unwrap(); + let (nega, abytes) = case.get("a").unwrap(); + let (negb, bbytes) = case.get("b").unwrap(); + + let x = $stype::new(*negx, $utype::from_bytes(xbytes)); + let y = $stype::new(*negy, $utype::from_bytes(ybytes)); + let k = $stype::new(*negk, $utype::from_bytes(kbytes)); + let a = $stype::new(*nega, $utype::from_bytes(abytes)); + let b = $stype::new(*negb, $utype::from_bytes(bbytes)); + let point = Point::<$curve>{ x: x, y: y }; + let res = point.scale(&k); + assert_eq!(a, res.x, "x equivalence"); + assert_eq!(b, res.y, "y equivalence"); + }); + } +} + +#[cfg(test)] +macro_rules! add_scale2_test_body +{ + ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => { + let fname = build_test_path("ecc/add_scale2",stringify!($curve)); + run_test(fname.to_string(), 8, |case| { + let (negx, xbytes) = case.get("x").unwrap(); + let (negy, ybytes) = case.get("y").unwrap(); + let (negp, pbytes) = case.get("p").unwrap(); + let (negq, qbytes) = case.get("q").unwrap(); + let (negn, nbytes) = case.get("n").unwrap(); + let (negm, mbytes) = case.get("m").unwrap(); + let (negr, rbytes) = case.get("r").unwrap(); + let (negs, sbytes) = case.get("s").unwrap(); + + let x = $stype::new(*negx, $utype::from_bytes(xbytes)); + let y = $stype::new(*negy, $utype::from_bytes(ybytes)); + let p = $stype::new(*negp, $utype::from_bytes(pbytes)); + let q = $stype::new(*negq, $utype::from_bytes(qbytes)); + let n = $stype::new(*negn, $utype::from_bytes(nbytes)); + let m = $stype::new(*negm, $utype::from_bytes(mbytes)); + let r = $stype::new(*negr, $utype::from_bytes(rbytes)); + let s = $stype::new(*negs, $utype::from_bytes(sbytes)); + let p1 = Point::<$curve>{ x: x, y: y }; + let p2 = Point::<$curve>{ x: p, y: q }; + let res = Point::<$curve>::double_scalar_mult(&n, &p1, &m, &p2); + assert_eq!(r, res.x, "x equivalence"); + assert_eq!(s, res.y, "y equivalence"); + }); + } +} + macro_rules! point_tests { ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => { @@ -156,127 +287,42 @@ macro_rules! point_tests use testing::*; #[test] - fn negate() { - let fname = build_test_path("ecc/negate",stringify!($curve)); - run_test(fname.to_string(), 4, |case| { - let (negx, xbytes) = case.get("x").unwrap(); - let (negy, ybytes) = case.get("y").unwrap(); - let (nega, abytes) = case.get("a").unwrap(); - let (negb, bbytes) = case.get("b").unwrap(); - - let x = $stype::new(*negx, $utype::from_bytes(xbytes)); - let y = $stype::new(*negy, $utype::from_bytes(ybytes)); - let a = $stype::new(*nega, $utype::from_bytes(abytes)); - let b = $stype::new(*negb, $utype::from_bytes(bbytes)); - let point = Point::<$curve>{ x, y }; - let dbl = point.negate(); - assert_eq!(a, dbl.x, "x equivalence"); - assert_eq!(b, dbl.y, "y equivalence"); - }); - } + 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 double() { - let fname = build_test_path("ecc/double",stringify!($curve)); - run_test(fname.to_string(), 4, |case| { - let (negx, xbytes) = case.get("x").unwrap(); - let (negy, ybytes) = case.get("y").unwrap(); - let (nega, abytes) = case.get("a").unwrap(); - let (negb, bbytes) = case.get("b").unwrap(); - - let x = $stype::new(*negx, $utype::from_bytes(xbytes)); - let y = $stype::new(*negy, $utype::from_bytes(ybytes)); - let a = $stype::new(*nega, $utype::from_bytes(abytes)); - let b = $stype::new(*negb, $utype::from_bytes(bbytes)); - let point = Point::<$curve>{ x, y }; - let dbl = point.double(); - assert_eq!(a, dbl.x, "x equivalence"); - assert_eq!(b, dbl.y, "y equivalence"); - }); - } - + fn negate() { negate_test_body!($curve, $lcurve, $stype, $utype); } #[test] - fn add() { - let fname = build_test_path("ecc/add",stringify!($curve)); - run_test(fname.to_string(), 6, move |case| { - let (negx, xbytes) = case.get("x").unwrap(); - let (negy, ybytes) = case.get("y").unwrap(); - let (negu, ubytes) = case.get("u").unwrap(); - let (negv, vbytes) = case.get("v").unwrap(); - let (nega, abytes) = case.get("a").unwrap(); - let (negb, bbytes) = case.get("b").unwrap(); - - let x = $stype::new(*negx, $utype::from_bytes(xbytes)); - let y = $stype::new(*negy, $utype::from_bytes(ybytes)); - let u = $stype::new(*negu, $utype::from_bytes(ubytes)); - let v = $stype::new(*negv, $utype::from_bytes(vbytes)); - let a = $stype::new(*nega, $utype::from_bytes(abytes)); - let b = $stype::new(*negb, $utype::from_bytes(bbytes)); - let point1 = Point::<$curve>{ x: x, y: y }; - let point2 = Point::<$curve>{ x: u, y: v }; - let res = point1.add(&point2); - assert_eq!(a, res.x, "x equivalence"); - assert_eq!(b, res.y, "y equivalence"); - }); - } - + fn double() { double_test_body!($curve, $lcurve, $stype, $utype); } #[test] - fn scale() { - let fname = build_test_path("ecc/scale",stringify!($curve)); - run_test(fname.to_string(), 5, |case| { - let (negx, xbytes) = case.get("x").unwrap(); - let (negy, ybytes) = case.get("y").unwrap(); - let (negk, kbytes) = case.get("k").unwrap(); - let (nega, abytes) = case.get("a").unwrap(); - let (negb, bbytes) = case.get("b").unwrap(); - - let x = $stype::new(*negx, $utype::from_bytes(xbytes)); - let y = $stype::new(*negy, $utype::from_bytes(ybytes)); - let k = $stype::new(*negk, $utype::from_bytes(kbytes)); - let a = $stype::new(*nega, $utype::from_bytes(abytes)); - let b = $stype::new(*negb, $utype::from_bytes(bbytes)); - let point = Point::<$curve>{ x: x, y: y }; - let res = point.scale(&k); - assert_eq!(a, res.x, "x equivalence"); - assert_eq!(b, res.y, "y equivalence"); - }); - } - - #[test] - fn add_scale2() { - let fname = build_test_path("ecc/add_scale2",stringify!($curve)); - run_test(fname.to_string(), 8, |case| { - let (negx, xbytes) = case.get("x").unwrap(); - let (negy, ybytes) = case.get("y").unwrap(); - let (negp, pbytes) = case.get("p").unwrap(); - let (negq, qbytes) = case.get("q").unwrap(); - let (negn, nbytes) = case.get("n").unwrap(); - let (negm, mbytes) = case.get("m").unwrap(); - let (negr, rbytes) = case.get("r").unwrap(); - let (negs, sbytes) = case.get("s").unwrap(); - - let x = $stype::new(*negx, $utype::from_bytes(xbytes)); - let y = $stype::new(*negy, $utype::from_bytes(ybytes)); - let p = $stype::new(*negp, $utype::from_bytes(pbytes)); - let q = $stype::new(*negq, $utype::from_bytes(qbytes)); - let n = $stype::new(*negn, $utype::from_bytes(nbytes)); - let m = $stype::new(*negm, $utype::from_bytes(mbytes)); - let r = $stype::new(*negr, $utype::from_bytes(rbytes)); - let s = $stype::new(*negs, $utype::from_bytes(sbytes)); - let p1 = Point::<$curve>{ x: x, y: y }; - let p2 = Point::<$curve>{ x: p, y: q }; - let res = Point::<$curve>::double_scalar_mult(&n, &p1, &m, &p2); - assert_eq!(r, res.x, "x equivalence"); - assert_eq!(s, res.y, "y equivalence"); - }); - } - + 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!(P224, p224, I256, U256); -point_tests!(P256, p256, I256, U256); -point_tests!(P384, p384, I384, U384); -point_tests!(P521, p521, I576, U576); \ No newline at end of file +point_tests!(ignore_expensive P224, p224, I256, U256); +point_tests!(ignore_expensive P256, p256, I256, U256); +point_tests!(ignore_expensive P384, p384, I384, U384); +point_tests!(ignore_expensive P521, p521, I576, U576); \ No newline at end of file diff --git a/src/ecdsa/private.rs b/src/ecdsa/private.rs index fa97371..6aeb471 100644 --- a/src/ecdsa/private.rs +++ b/src/ecdsa/private.rs @@ -112,47 +112,62 @@ use sha2::{Sha224,Sha256,Sha384,Sha512}; #[cfg(test)] use testing::*; +#[cfg(test)] +macro_rules! sign_test_body +{ + ($name: ident, $curve: ident, $base: ident) => { + let fname = build_test_path("ecc/sign",stringify!($curve)); + run_test(fname.to_string(), 9, |case| { + let (negd, dbytes) = case.get("d").unwrap(); + let (negk, _bytes) = case.get("k").unwrap(); + let (negx, xbytes) = case.get("x").unwrap(); + let (negy, ybytes) = case.get("y").unwrap(); + let (negm, mbytes) = case.get("m").unwrap(); + let (negh, hbytes) = case.get("h").unwrap(); + let (negr, rbytes) = case.get("r").unwrap(); + let (negs, sbytes) = case.get("s").unwrap(); + + assert!(!negd && !negk && !negx && !negy && + !negm && !negh && !negr && !negs); + let d = $base::from_bytes(dbytes); + let _ = $base::from_bytes(xbytes); + let _ = $base::from_bytes(ybytes); + let h = $base::from_bytes(hbytes); + let r = $base::from_bytes(rbytes); + let s = $base::from_bytes(sbytes); + + let private = ECCPrivate::<$curve>::new(d); + let sig = match usize::from(h) { + 224 => private.sign::(mbytes), + 256 => private.sign::(mbytes), + 384 => private.sign::(mbytes), + 512 => private.sign::(mbytes), + x => panic!("Unknown hash algorithm {}", x) + }; + assert_eq!(r, sig.r, "r signature check"); + assert_eq!(s, sig.s, "s signature check"); + }); + } +} + macro_rules! generate_tests { ($name: ident, $curve: ident, $base: ident) => { #[test] fn $name() { - let fname = build_test_path("ecc/sign",stringify!($curve)); - run_test(fname.to_string(), 9, |case| { - let (negd, dbytes) = case.get("d").unwrap(); - let (negk, _bytes) = case.get("k").unwrap(); - let (negx, xbytes) = case.get("x").unwrap(); - let (negy, ybytes) = case.get("y").unwrap(); - let (negm, mbytes) = case.get("m").unwrap(); - let (negh, hbytes) = case.get("h").unwrap(); - let (negr, rbytes) = case.get("r").unwrap(); - let (negs, sbytes) = case.get("s").unwrap(); - - assert!(!negd && !negk && !negx && !negy && - !negm && !negh && !negr && !negs); - let d = $base::from_bytes(dbytes); - let _ = $base::from_bytes(xbytes); - let _ = $base::from_bytes(ybytes); - let h = $base::from_bytes(hbytes); - let r = $base::from_bytes(rbytes); - let s = $base::from_bytes(sbytes); - - let private = ECCPrivate::<$curve>::new(d); - let sig = match usize::from(h) { - 224 => private.sign::(mbytes), - 256 => private.sign::(mbytes), - 384 => private.sign::(mbytes), - 512 => private.sign::(mbytes), - x => panic!("Unknown hash algorithm {}", x) - }; - assert_eq!(r, sig.r, "r signature check"); - assert_eq!(s, sig.s, "s signature check"); - }); - } + 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!(p224_sign, P224, U256); -generate_tests!(p256_sign, P256, U256); -generate_tests!(p384_sign, P384, U384); -generate_tests!(p521_sign, P521, U576); \ No newline at end of file +generate_tests!(ignore p224_sign, P224, U256); +generate_tests!(ignore p256_sign, P256, U256); +generate_tests!(ignore p384_sign, P384, U384); +generate_tests!(ignore p521_sign, P521, U576); \ No newline at end of file diff --git a/src/ecdsa/public.rs b/src/ecdsa/public.rs index 3fb4505..cdf6595 100644 --- a/src/ecdsa/public.rs +++ b/src/ecdsa/public.rs @@ -176,47 +176,62 @@ use sha2::{Sha224,Sha256,Sha384,Sha512}; #[cfg(test)] use testing::*; +#[cfg(test)] +macro_rules! verify_test_body +{ + ($name: ident, $curve: ident, $un: ident, $si: ident) => { + let fname = build_test_path("ecc/sign",stringify!($curve)); + run_test(fname.to_string(), 9, |case| { + let (negd, dbytes) = case.get("d").unwrap(); + let (negk, _bytes) = case.get("k").unwrap(); + let (negx, xbytes) = case.get("x").unwrap(); + let (negy, ybytes) = case.get("y").unwrap(); + let (negm, mbytes) = case.get("m").unwrap(); + let (negh, hbytes) = case.get("h").unwrap(); + let (negr, rbytes) = case.get("r").unwrap(); + let (negs, sbytes) = case.get("s").unwrap(); + + assert!(!negd && !negk && !negx && !negy && + !negm && !negh && !negr && !negs); + let _ = $un::from_bytes(dbytes); + let x = $un::from_bytes(xbytes); + let y = $un::from_bytes(ybytes); + let h = $un::from_bytes(hbytes); + let r = $un::from_bytes(rbytes); + let s = $un::from_bytes(sbytes); + + let point = Point::<$curve>{ x: $si::from(x), y: $si::from(y) }; + let public = ECCPubKey::<$curve>::new(point); + let sig = DSASignature::new(r, s); + match usize::from(h) { + 224 => assert!(public.verify::(mbytes, &sig)), + 256 => assert!(public.verify::(mbytes, &sig)), + 384 => assert!(public.verify::(mbytes, &sig)), + 512 => assert!(public.verify::(mbytes, &sig)), + x => panic!("Unknown hash algorithm {}", x) + }; + }); + } +} + macro_rules! test_impl { ($name: ident, $curve: ident, $un: ident, $si: ident) => { #[test] fn $name() { - let fname = build_test_path("ecc/sign",stringify!($curve)); - run_test(fname.to_string(), 9, |case| { - let (negd, dbytes) = case.get("d").unwrap(); - let (negk, _bytes) = case.get("k").unwrap(); - let (negx, xbytes) = case.get("x").unwrap(); - let (negy, ybytes) = case.get("y").unwrap(); - let (negm, mbytes) = case.get("m").unwrap(); - let (negh, hbytes) = case.get("h").unwrap(); - let (negr, rbytes) = case.get("r").unwrap(); - let (negs, sbytes) = case.get("s").unwrap(); - - assert!(!negd && !negk && !negx && !negy && - !negm && !negh && !negr && !negs); - let _ = $un::from_bytes(dbytes); - let x = $un::from_bytes(xbytes); - let y = $un::from_bytes(ybytes); - let h = $un::from_bytes(hbytes); - let r = $un::from_bytes(rbytes); - let s = $un::from_bytes(sbytes); - - let point = Point::<$curve>{ x: $si::from(x), y: $si::from(y) }; - let public = ECCPubKey::<$curve>::new(point); - let sig = DSASignature::new(r, s); - match usize::from(h) { - 224 => assert!(public.verify::(mbytes, &sig)), - 256 => assert!(public.verify::(mbytes, &sig)), - 384 => assert!(public.verify::(mbytes, &sig)), - 512 => assert!(public.verify::(mbytes, &sig)), - x => panic!("Unknown hash algorithm {}", x) - }; - }); - } + 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!(p224,P224,U256,I256); -test_impl!(p256,P256,U256,I256); -test_impl!(p384,P384,U384,I384); -test_impl!(p521,P521,U576,I576); \ No newline at end of file +test_impl!(ignore p256,P256,U256,I256); +test_impl!(ignore p384,P384,U384,I384); +test_impl!(ignore p521,P521,U576,I576); \ No newline at end of file diff --git a/src/rsa/private.rs b/src/rsa/private.rs index b3244a2..aa139cf 100644 --- a/src/rsa/private.rs +++ b/src/rsa/private.rs @@ -147,9 +147,79 @@ generate_rsa_private!(RSA4096Private, U4096, BarrettU4096, 4096); generate_rsa_private!(RSA8192Private, U8192, BarrettU8192, 8192); generate_rsa_private!(RSA15360Private, U15360, BarrettU15360, 15360); +#[cfg(test)] +macro_rules! sign_test_body { + ($mod: ident, $rsa: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => { + let fname = format!("testdata/rsa/sign{}.test", $size); + run_test(fname.to_string(), 7, |case| { + let (neg0, dbytes) = case.get("d").unwrap(); + let (neg1, nbytes) = case.get("n").unwrap(); + let (neg2, hbytes) = case.get("h").unwrap(); + let (neg3, mbytes) = case.get("m").unwrap(); + let (neg4, sbytes) = case.get("s").unwrap(); + let (neg5, ubytes) = case.get("u").unwrap(); + let (neg6, kbytes) = case.get("k").unwrap(); + + assert!(!neg0&&!neg1&&!neg2&&!neg3&&!neg4&&!neg5&&!neg6); + let n = $num64::from_bytes(nbytes); + let nu = $num64::from_bytes(ubytes); + let bigk = $num::from_bytes(kbytes); + let k = usize::from(bigk); + let d = $num::from_bytes(dbytes); + let sighash = match usize::from($num::from_bytes(hbytes)) { + 224 => &SIGNING_HASH_SHA224, + 256 => &SIGNING_HASH_SHA256, + 384 => &SIGNING_HASH_SHA384, + 512 => &SIGNING_HASH_SHA512, + x => panic!("Bad signing hash: {}", x) + }; + let privkey = $rsa{ nu: $bar::from_components(k, n.clone(), nu), d: d }; + let sig = privkey.sign(sighash, &mbytes); + assert_eq!(*sbytes, sig); + }); + }; +} + +#[cfg(test)] +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); + run_test(fname.to_string(), 9, |case| { + let (neg0, nbytes) = case.get("n").unwrap(); + let (neg1, hbytes) = case.get("h").unwrap(); + let (neg2, mbytes) = case.get("m").unwrap(); + let (neg3, _bytes) = case.get("e").unwrap(); + let (neg4, ubytes) = case.get("u").unwrap(); + let (neg5, kbytes) = case.get("k").unwrap(); + let (neg6, dbytes) = case.get("d").unwrap(); + let (neg7, lbytes) = case.get("l").unwrap(); + let (neg8, cbytes) = case.get("c").unwrap(); + + assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5 && !neg6 && !neg7 && !neg8); + let n = $num::from_bytes(nbytes); + let n64 = $num64::from(&n); + let nu = $num64::from_bytes(ubytes); + let bigk = $num::from_bytes(kbytes); + let k = usize::from(bigk); + let d = $num::from_bytes(dbytes); + let nu = $bar::from_components(k, n64, nu); + let privkey = $rsa{ nu: nu, d: d }; + let lstr = String::from_utf8(lbytes.clone()).unwrap(); + let message = match usize::from($num::from_bytes(hbytes)) { + 224 => privkey.decrypt(&OAEPParams::::new(lstr), &cbytes), + 256 => privkey.decrypt(&OAEPParams::::new(lstr), &cbytes), + 384 => privkey.decrypt(&OAEPParams::::new(lstr), &cbytes), + 512 => privkey.decrypt(&OAEPParams::::new(lstr), &cbytes), + x => panic!("Unknown hash number: {}", x) + }; + assert!(message.is_ok()); + assert_eq!(mbytes, &message.unwrap()); + }); + }; +} + macro_rules! generate_tests { - ( $( ($mod: ident, $rsa: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) ),* ) => { - $( + ($mod: ident, $rsa: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => { #[cfg(test)] #[allow(non_snake_case)] mod $mod { @@ -161,80 +231,44 @@ macro_rules! generate_tests { #[test] fn sign() { - let fname = format!("testdata/rsa/sign{}.test", $size); - run_test(fname.to_string(), 7, |case| { - let (neg0, dbytes) = case.get("d").unwrap(); - let (neg1, nbytes) = case.get("n").unwrap(); - let (neg2, hbytes) = case.get("h").unwrap(); - let (neg3, mbytes) = case.get("m").unwrap(); - let (neg4, sbytes) = case.get("s").unwrap(); - let (neg5, ubytes) = case.get("u").unwrap(); - let (neg6, kbytes) = case.get("k").unwrap(); - - assert!(!neg0&&!neg1&&!neg2&&!neg3&&!neg4&&!neg5&&!neg6); - let n = $num64::from_bytes(nbytes); - let nu = $num64::from_bytes(ubytes); - let bigk = $num::from_bytes(kbytes); - let k = usize::from(bigk); - let d = $num::from_bytes(dbytes); - let sighash = match usize::from($num::from_bytes(hbytes)) { - 224 => &SIGNING_HASH_SHA224, - 256 => &SIGNING_HASH_SHA256, - 384 => &SIGNING_HASH_SHA384, - 512 => &SIGNING_HASH_SHA512, - x => panic!("Bad signing hash: {}", x) - }; - let privkey = $rsa{ nu: $bar::from_components(k, n.clone(), nu), d: d }; - let sig = privkey.sign(sighash, &mbytes); - assert_eq!(*sbytes, sig); - }); + sign_test_body!($mod, $rsa, $num, $bar, $num64, $size); } #[test] fn decrypt() { - let fname = format!("testdata/rsa/encrypt{}.test", $size); - run_test(fname.to_string(), 9, |case| { - let (neg0, nbytes) = case.get("n").unwrap(); - let (neg1, hbytes) = case.get("h").unwrap(); - let (neg2, mbytes) = case.get("m").unwrap(); - let (neg3, _bytes) = case.get("e").unwrap(); - let (neg4, ubytes) = case.get("u").unwrap(); - let (neg5, kbytes) = case.get("k").unwrap(); - let (neg6, dbytes) = case.get("d").unwrap(); - let (neg7, lbytes) = case.get("l").unwrap(); - let (neg8, cbytes) = case.get("c").unwrap(); - - assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5 && !neg6 && !neg7 && !neg8); - let n = $num::from_bytes(nbytes); - let n64 = $num64::from(&n); - let nu = $num64::from_bytes(ubytes); - let bigk = $num::from_bytes(kbytes); - let k = usize::from(bigk); - let d = $num::from_bytes(dbytes); - let nu = $bar::from_components(k, n64, nu); - let privkey = $rsa{ nu: nu, d: d }; - let lstr = String::from_utf8(lbytes.clone()).unwrap(); - let message = match usize::from($num::from_bytes(hbytes)) { - 224 => privkey.decrypt(&OAEPParams::::new(lstr), &cbytes), - 256 => privkey.decrypt(&OAEPParams::::new(lstr), &cbytes), - 384 => privkey.decrypt(&OAEPParams::::new(lstr), &cbytes), - 512 => privkey.decrypt(&OAEPParams::::new(lstr), &cbytes), - x => panic!("Unknown hash number: {}", x) - }; - assert!(message.is_ok()); - assert_eq!(mbytes, &message.unwrap()); - }); + 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), - (RSA1024, RSA1024Private, U1024, BarrettU1024, U1088, 1024), - (RSA2048, RSA2048Private, U2048, BarrettU2048, U2112, 2048) -// (RSA3072, RSA3072Private, U3072, BarrettU3072, U3136, 3072), -// (RSA4096, RSA4096Private, U4096, BarrettU4096, U4160, 4096), -// (RSA8192, RSA8192Private, U8192, BarrettU8192, U8256, 8192), -// (RSA15360, RSA15360Private, U15360, BarrettU15360, U15424, 15360) - ); +generate_tests!(RSA512, RSA512Private, U512, BarrettU512, U576, 512); +generate_tests!(RSA1024, RSA1024Private, U1024, BarrettU1024, U1088, 1024); +generate_tests!(RSA2048, RSA2048Private, U2048, BarrettU2048, U2112, 2048); +generate_tests!(RSA3072, RSA3072Private, U3072, BarrettU3072, U3136, 3072); +generate_tests!(RSA4096, RSA4096Private, U4096, BarrettU4096, U4160, 4096); +generate_tests!(ignore RSA8192, RSA8192Private, U8192, BarrettU8192, U8256, 8192); +generate_tests!(ignore RSA15360, RSA15360Private, U15360, BarrettU15360, U15424, 15360); \ No newline at end of file diff --git a/src/rsa/public.rs b/src/rsa/public.rs index 0c0cb86..4b628d5 100644 --- a/src/rsa/public.rs +++ b/src/rsa/public.rs @@ -334,9 +334,136 @@ generate_rsa_public!(RSA4096Public, U4096, BarrettU4096, Key4096, 4096); generate_rsa_public!(RSA8192Public, U8192, BarrettU8192, Key8192, 8192); generate_rsa_public!(RSA15360Public, U15360, BarrettU15360, Key15360, 15360); +#[cfg(test)] +macro_rules! new_test_body { + ($mod: ident, $rsa: ident, $priv: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => { + let fname = format!("testdata/rsa/sign{}.test", $size); + run_test(fname.to_string(), 7, |case| { + let (neg0, nbytes) = case.get("n").unwrap(); + let (neg1, ubytes) = case.get("u").unwrap(); + let (neg2, kbytes) = case.get("k").unwrap(); + + assert!(!neg0&&!neg1&&!neg2); + let n = $num::from_bytes(nbytes); + let n64 = $num64::from(&n); + let nu = $num64::from_bytes(ubytes); + let bigk = $num::from_bytes(kbytes); + let k = usize::from(bigk); + let e = $num::from(65537u64); + let pubkey2 = $rsa::new(n.clone(), e.clone()); + let pubkey1 = $rsa{ n: n, nu: $bar::from_components(k, n64, nu), e: e }; + assert_eq!(pubkey1, pubkey2); + }); + }; +} + +#[cfg(test)] +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); + run_test(fname.to_string(), 7, |case| { + let (neg0, nbytes) = case.get("n").unwrap(); + let (neg1, ubytes) = case.get("u").unwrap(); + let (neg2, kbytes) = case.get("k").unwrap(); + + assert!(!neg0&&!neg1&&!neg2); + let n = $num::from_bytes(nbytes); + let n64 = $num64::from(&n); + let nu = $num64::from_bytes(ubytes); + let bigk = $num::from_bytes(kbytes); + let k = usize::from(bigk); + let e = $num::from(65537u64); + let pubkey = $rsa{ n: n, nu: $bar::from_components(k, n64, nu), e: e }; + let asn1 = pubkey.to_asn1().unwrap(); + let (pubkey2, _) = $rsa::from_asn1(&asn1).unwrap(); + assert_eq!(pubkey, pubkey2); + }); + }; +} + +#[cfg(test)] +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); + run_test(fname.to_string(), 7, |case| { + let (neg0, nbytes) = case.get("n").unwrap(); + let (neg1, hbytes) = case.get("h").unwrap(); + let (neg2, mbytes) = case.get("m").unwrap(); + let (neg3, sbytes) = case.get("s").unwrap(); + let (neg4, ubytes) = case.get("u").unwrap(); + let (neg5, kbytes) = case.get("k").unwrap(); + + assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5); + let n = $num::from_bytes(nbytes); + let n64 = $num64::from(&n); + let nu = $num64::from_bytes(ubytes); + let bigk = $num::from_bytes(kbytes); + let k = usize::from(bigk); + let e = $num::from(65537u64); + let pubkey = $rsa{ n: n, nu: $bar::from_components(k, n64, nu), e: e }; + let hashnum = u64::from($num::from_bytes(hbytes)); + let sighash = match hashnum { + 160 => &SIGNING_HASH_SHA1, + 224 => &SIGNING_HASH_SHA224, + 256 => &SIGNING_HASH_SHA256, + 384 => &SIGNING_HASH_SHA384, + 512 => &SIGNING_HASH_SHA512, + _ => panic!("Bad signing hash: {}", hashnum) + }; + assert!(pubkey.verify(sighash, &mbytes, &sbytes)); + }); + }; +} + +#[cfg(test)] +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); + run_test(fname.to_string(), 9, |case| { + let (neg0, nbytes) = case.get("n").unwrap(); + let (neg1, hbytes) = case.get("h").unwrap(); + let (neg2, mbytes) = case.get("m").unwrap(); + let (neg3, _bytes) = case.get("e").unwrap(); + let (neg4, ubytes) = case.get("u").unwrap(); + let (neg5, kbytes) = case.get("k").unwrap(); + let (neg6, dbytes) = case.get("d").unwrap(); + let (neg7, lbytes) = case.get("l").unwrap(); + + assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5 && !neg6 && !neg7); + let n = $num::from_bytes(nbytes); + let n64 = $num64::from(&n); + let nu = $num64::from_bytes(ubytes); + let bigk = $num::from_bytes(kbytes); + let k = usize::from(bigk); + let e = $num::from(65537u64); + let d = $num::from_bytes(dbytes); + let nu = $bar::from_components(k, n64, nu); + let pubkey = $rsa{ n: n.clone(), nu: nu.clone(), e: e }; + let privkey = $priv{ nu: nu, d: d }; + let lstr = String::from_utf8(lbytes.clone()).unwrap(); + let cipher = match usize::from($num::from_bytes(hbytes)) { + 224 => pubkey.encrypt(&OAEPParams::::new(lstr.clone()), mbytes), + 256 => pubkey.encrypt(&OAEPParams::::new(lstr.clone()), mbytes), + 384 => pubkey.encrypt(&OAEPParams::::new(lstr.clone()), mbytes), + 512 => pubkey.encrypt(&OAEPParams::::new(lstr.clone()), mbytes), + x => panic!("Unknown hash number: {}", x) + }; + assert!(cipher.is_ok()); + let message = match usize::from($num::from_bytes(hbytes)) { + 224 => privkey.decrypt(&OAEPParams::::new(lstr), &cipher.unwrap()), + 256 => privkey.decrypt(&OAEPParams::::new(lstr), &cipher.unwrap()), + 384 => privkey.decrypt(&OAEPParams::::new(lstr), &cipher.unwrap()), + 512 => privkey.decrypt(&OAEPParams::::new(lstr), &cipher.unwrap()), + x => panic!("Unknown hash number: {}", x) + }; + assert!(message.is_ok()); + assert_eq!(mbytes, &message.unwrap()); + }); + }; +} + macro_rules! generate_tests { - ( $( ($mod: ident, $rsa: ident, $priv: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) ),* ) => { - $( + ($mod: ident, $rsa: ident, $priv: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => { #[cfg(test)] #[allow(non_snake_case)] mod $mod { @@ -348,134 +475,46 @@ macro_rules! generate_tests { use sha2::{Sha224,Sha256,Sha384,Sha512}; #[test] - fn new() { - let fname = format!("testdata/rsa/sign{}.test", $size); - run_test(fname.to_string(), 7, |case| { - let (neg0, nbytes) = case.get("n").unwrap(); - let (neg1, ubytes) = case.get("u").unwrap(); - let (neg2, kbytes) = case.get("k").unwrap(); - - assert!(!neg0&&!neg1&&!neg2); - let n = $num::from_bytes(nbytes); - let n64 = $num64::from(&n); - let nu = $num64::from_bytes(ubytes); - let bigk = $num::from_bytes(kbytes); - let k = usize::from(bigk); - let e = $num::from(65537u64); - let pubkey2 = $rsa::new(n.clone(), e.clone()); - let pubkey1 = $rsa{ n: n, nu: $bar::from_components(k, n64, nu), e: e }; - assert_eq!(pubkey1, pubkey2); - }); - } - + fn new() { new_test_body!($mod, $rsa, $priv, $num, $bar, $num64, $size); } #[test] - fn encode() { - let fname = format!("testdata/rsa/sign{}.test", $size); - run_test(fname.to_string(), 7, |case| { - let (neg0, nbytes) = case.get("n").unwrap(); - let (neg1, ubytes) = case.get("u").unwrap(); - let (neg2, kbytes) = case.get("k").unwrap(); - - assert!(!neg0&&!neg1&&!neg2); - let n = $num::from_bytes(nbytes); - let n64 = $num64::from(&n); - let nu = $num64::from_bytes(ubytes); - let bigk = $num::from_bytes(kbytes); - let k = usize::from(bigk); - let e = $num::from(65537u64); - let pubkey = $rsa{ n: n, nu: $bar::from_components(k, n64, nu), e: e }; - let asn1 = pubkey.to_asn1().unwrap(); - let (pubkey2, _) = $rsa::from_asn1(&asn1).unwrap(); - assert_eq!(pubkey, pubkey2); - }); - } - + fn encode() { encode_test_body!($mod, $rsa, $priv, $num, $bar, $num64, $size); } #[test] - fn verify() { - let fname = format!("testdata/rsa/sign{}.test", $size); - run_test(fname.to_string(), 7, |case| { - let (neg0, nbytes) = case.get("n").unwrap(); - let (neg1, hbytes) = case.get("h").unwrap(); - let (neg2, mbytes) = case.get("m").unwrap(); - let (neg3, sbytes) = case.get("s").unwrap(); - let (neg4, ubytes) = case.get("u").unwrap(); - let (neg5, kbytes) = case.get("k").unwrap(); - - assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5); - let n = $num::from_bytes(nbytes); - let n64 = $num64::from(&n); - let nu = $num64::from_bytes(ubytes); - let bigk = $num::from_bytes(kbytes); - let k = usize::from(bigk); - let e = $num::from(65537u64); - let pubkey = $rsa{ n: n, nu: $bar::from_components(k, n64, nu), e: e }; - let hashnum = u64::from($num::from_bytes(hbytes)); - let sighash = match hashnum { - 160 => &SIGNING_HASH_SHA1, - 224 => &SIGNING_HASH_SHA224, - 256 => &SIGNING_HASH_SHA256, - 384 => &SIGNING_HASH_SHA384, - 512 => &SIGNING_HASH_SHA512, - _ => panic!("Bad signing hash: {}", hashnum) - }; - assert!(pubkey.verify(sighash, &mbytes, &sbytes)); - }); - } - + fn verify() { verify_test_body!($mod, $rsa, $priv, $num, $bar, $num64, $size); } #[test] - fn encrypt() { - let fname = format!("testdata/rsa/encrypt{}.test", $size); - run_test(fname.to_string(), 9, |case| { - let (neg0, nbytes) = case.get("n").unwrap(); - let (neg1, hbytes) = case.get("h").unwrap(); - let (neg2, mbytes) = case.get("m").unwrap(); - let (neg3, _bytes) = case.get("e").unwrap(); - let (neg4, ubytes) = case.get("u").unwrap(); - let (neg5, kbytes) = case.get("k").unwrap(); - let (neg6, dbytes) = case.get("d").unwrap(); - let (neg7, lbytes) = case.get("l").unwrap(); - - assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5 && !neg6 && !neg7); - let n = $num::from_bytes(nbytes); - let n64 = $num64::from(&n); - let nu = $num64::from_bytes(ubytes); - let bigk = $num::from_bytes(kbytes); - let k = usize::from(bigk); - let e = $num::from(65537u64); - let d = $num::from_bytes(dbytes); - let nu = $bar::from_components(k, n64, nu); - let pubkey = $rsa{ n: n.clone(), nu: nu.clone(), e: e }; - let privkey = $priv{ nu: nu, d: d }; - let lstr = String::from_utf8(lbytes.clone()).unwrap(); - let cipher = match usize::from($num::from_bytes(hbytes)) { - 224 => pubkey.encrypt(&OAEPParams::::new(lstr.clone()), mbytes), - 256 => pubkey.encrypt(&OAEPParams::::new(lstr.clone()), mbytes), - 384 => pubkey.encrypt(&OAEPParams::::new(lstr.clone()), mbytes), - 512 => pubkey.encrypt(&OAEPParams::::new(lstr.clone()), mbytes), - x => panic!("Unknown hash number: {}", x) - }; - assert!(cipher.is_ok()); - let message = match usize::from($num::from_bytes(hbytes)) { - 224 => privkey.decrypt(&OAEPParams::::new(lstr), &cipher.unwrap()), - 256 => privkey.decrypt(&OAEPParams::::new(lstr), &cipher.unwrap()), - 384 => privkey.decrypt(&OAEPParams::::new(lstr), &cipher.unwrap()), - 512 => privkey.decrypt(&OAEPParams::::new(lstr), &cipher.unwrap()), - x => panic!("Unknown hash number: {}", x) - }; - assert!(message.is_ok()); - assert_eq!(mbytes, &message.unwrap()); - }); - } + 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), - (RSA1024, RSA1024Public, RSA1024Private, U1024, BarrettU1024, U1088, 1024), - (RSA2048, RSA2048Public, RSA2048Private, U2048, BarrettU2048, U2112, 2048), - (RSA3072, RSA3072Public, RSA3072Private, U3072, BarrettU3072, U3136, 3072), - (RSA4096, RSA4096Public, RSA4096Private, U4096, BarrettU4096, U4160, 4096), - (RSA8192, RSA8192Public, RSA8192Private, U8192, BarrettU8192, U8256, 8192), - (RSA15360, RSA15360Public, RSA15360Private, U15360, BarrettU15360, U15424, 15360) - ); \ No newline at end of file +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); \ No newline at end of file