Limit long-running tests via #[ignore] instead of commenting them out.
This commit is contained in:
@@ -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);
|
||||
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);
|
||||
@@ -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::<Sha224>(mbytes),
|
||||
256 => private.sign::<Sha256>(mbytes),
|
||||
384 => private.sign::<Sha384>(mbytes),
|
||||
512 => private.sign::<Sha512>(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::<Sha224>(mbytes),
|
||||
256 => private.sign::<Sha256>(mbytes),
|
||||
384 => private.sign::<Sha384>(mbytes),
|
||||
512 => private.sign::<Sha512>(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);
|
||||
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);
|
||||
@@ -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::<Sha224>(mbytes, &sig)),
|
||||
256 => assert!(public.verify::<Sha256>(mbytes, &sig)),
|
||||
384 => assert!(public.verify::<Sha384>(mbytes, &sig)),
|
||||
512 => assert!(public.verify::<Sha512>(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::<Sha224>(mbytes, &sig)),
|
||||
256 => assert!(public.verify::<Sha256>(mbytes, &sig)),
|
||||
384 => assert!(public.verify::<Sha384>(mbytes, &sig)),
|
||||
512 => assert!(public.verify::<Sha512>(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);
|
||||
test_impl!(ignore p256,P256,U256,I256);
|
||||
test_impl!(ignore p384,P384,U384,I384);
|
||||
test_impl!(ignore p521,P521,U576,I576);
|
||||
Reference in New Issue
Block a user