yggdrasil/ring
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move ECDSA integration/functional tests to tests/.

Browse Source
This commit is contained in:
Brian Smith 2017-05-13 00:10:26 -10:00
parent 21f9750087
commit 0124565a52
5 changed files with 108 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Cargo.toml
View File

@ -66,8 +66,6 @@ include = [
"src/ec/suite_b/ecdh.rs", "src/ec/suite_b/ecdh.rs",
"src/ec/suite_b/ecdsa.rs", "src/ec/suite_b/ecdsa.rs",
"src/ec/suite_b/ecdsa_digest_scalar_tests.txt", "src/ec/suite_b/ecdsa_digest_scalar_tests.txt",
"src/ec/suite_b/ecdsa_verify_asn1_tests.txt",
"src/ec/suite_b/ecdsa_verify_fixed_tests.txt",
"src/ec/suite_b/ops/elem.rs", "src/ec/suite_b/ops/elem.rs",
"src/ec/suite_b/ops/ops.rs", "src/ec/suite_b/ops/ops.rs",
"src/ec/suite_b/ops/p256.rs", "src/ec/suite_b/ops/p256.rs",
@ -235,6 +233,9 @@ include = [
"include/GFp/mem.h", "include/GFp/mem.h",
"include/GFp/type_check.h", "include/GFp/type_check.h",
"examples/checkdigest.rs", "examples/checkdigest.rs",
"tests/ecdsa_tests.rs",
"tests/ecdsa_verify_asn1_tests.txt",
"tests/ecdsa_verify_fixed_tests.txt",
"tests/ed25519_tests.rs", "tests/ed25519_tests.rs",
"tests/ed25519_tests.txt", "tests/ed25519_tests.txt",
"tests/ed25519_from_pkcs8_tests.txt", "tests/ed25519_from_pkcs8_tests.txt",

122
src/ec/suite_b/ecdsa.rs
View File

@ -294,71 +294,11 @@ pub static ECDSA_P384_SHA384_ASN1: ECDSAVerificationAlgorithm =
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use {digest, test, signature}; use {digest, test};
use super::digest_scalar_; use super::digest_scalar_;
use super::super::ops::*; use super::super::ops::*;
use untrusted; use untrusted;
#[test]
fn signature_ecdsa_verify_asn1_test() {
test::from_file("src/ec/suite_b/ecdsa_verify_asn1_tests.txt",
|section, test_case| {
assert_eq!(section, "");
let curve_name = test_case.consume_string("Curve");
let digest_name = test_case.consume_string("Digest");
let msg = test_case.consume_bytes("Msg");
let msg = untrusted::Input::from(&msg);
let public_key = test_case.consume_bytes("Q");
let public_key = untrusted::Input::from(&public_key);
let sig = test_case.consume_bytes("Sig");
let sig = untrusted::Input::from(&sig);
let expected_result = test_case.consume_string("Result");
let (alg, _, _) =
alg_from_curve_and_digest_asn1(&curve_name, &digest_name);
let actual_result = signature::verify(alg, public_key, msg, sig);
assert_eq!(actual_result.is_ok(), expected_result == "P (0 )");
Ok(())
});
}
#[test]
fn signature_ecdsa_verify_fixed_test() {
test::from_file("src/ec/suite_b/ecdsa_verify_fixed_tests.txt",
|section, test_case| {
assert_eq!(section, "");
let curve_name = test_case.consume_string("Curve");
let digest_name = test_case.consume_string("Digest");
let msg = test_case.consume_bytes("Msg");
let msg = untrusted::Input::from(&msg);
let public_key = test_case.consume_bytes("Q");
let public_key = untrusted::Input::from(&public_key);
let sig = test_case.consume_bytes("Sig");
let sig = untrusted::Input::from(&sig);
let expected_result = test_case.consume_string("Result");
let (alg, _, _) =
alg_from_curve_and_digest_fixed(&curve_name, &digest_name);
let actual_result = signature::verify(alg, public_key, msg, sig);
assert_eq!(actual_result.is_ok(), expected_result == "P (0 )");
Ok(())
});
}
#[test] #[test]
fn ecdsa_digest_scalar_test() { fn ecdsa_digest_scalar_test() {
test::from_file("src/ec/suite_b/ecdsa_digest_scalar_tests.txt", test::from_file("src/ec/suite_b/ecdsa_digest_scalar_tests.txt",
@ -367,13 +307,24 @@ mod tests {
let curve_name = test_case.consume_string("Curve"); let curve_name = test_case.consume_string("Curve");
let digest_name = test_case.consume_string("Digest"); let digest_name = test_case.consume_string("Digest");
let input = test_case.consume_bytes("Input"); let input = test_case.consume_bytes("Input");
let output = test_case.consume_bytes("Output"); let output = test_case.consume_bytes("Output");
let (_, ops, digest_alg) = let (ops, digest_alg) = match
alg_from_curve_and_digest_asn1(&curve_name, &digest_name); (curve_name.as_str(), digest_name.as_str()) {
("P-256", "SHA256") =>
(&p256::PUBLIC_SCALAR_OPS, &digest::SHA256),
("P-256", "SHA384") =>
(&p256::PUBLIC_SCALAR_OPS, &digest::SHA384),
("P-384", "SHA256") =>
(&p384::PUBLIC_SCALAR_OPS, &digest::SHA256),
("P-384", "SHA384") =>
(&p384::PUBLIC_SCALAR_OPS, &digest::SHA384),
_ => {
panic!("Unsupported curve+digest: {}+{}", curve_name,
digest_name);
}
};
let num_limbs = ops.public_key_ops.common.num_limbs; let num_limbs = ops.public_key_ops.common.num_limbs;
assert_eq!(input.len(), digest_alg.output_len); assert_eq!(input.len(), digest_alg.output_len);
@ -391,47 +342,6 @@ mod tests {
Ok(()) Ok(())
}); });
} }
fn alg_from_curve_and_digest_asn1(curve_name: &str, digest_name: &str)
-> (&'static signature::VerificationAlgorithm,
&'static PublicScalarOps, &'static digest::Algorithm) {
match (curve_name, digest_name) {
("P-256", "SHA256") =>
(&signature::ECDSA_P256_SHA256_ASN1, &p256::PUBLIC_SCALAR_OPS,
&digest::SHA256),
("P-256", "SHA384") =>
(&signature::ECDSA_P256_SHA384_ASN1, &p256::PUBLIC_SCALAR_OPS,
&digest::SHA384),
("P-384", "SHA256") =>
(&signature::ECDSA_P384_SHA256_ASN1, &p384::PUBLIC_SCALAR_OPS,
&digest::SHA256),
("P-384", "SHA384") =>
(&signature::ECDSA_P384_SHA384_ASN1, &p384::PUBLIC_SCALAR_OPS,
&digest::SHA384),
_ => {
panic!("Unsupported curve+digest: {}+{}", curve_name,
digest_name);
}
}
}
fn alg_from_curve_and_digest_fixed(curve_name: &str, digest_name: &str)
-> (&'static signature::VerificationAlgorithm,
&'static PublicScalarOps, &'static digest::Algorithm) {
match (curve_name, digest_name) {
("P-256", "SHA256") =>
(&signature::ECDSA_P256_SHA256_FIXED, &p256::PUBLIC_SCALAR_OPS,
&digest::SHA256),
("P-384", "SHA384") =>
(&signature::ECDSA_P384_SHA384_FIXED, &p384::PUBLIC_SCALAR_OPS,
&digest::SHA384),
_ => {
panic!("Unsupported curve+digest: {}+{}", curve_name,
digest_name);
}
}
}
} }
#[cfg(feature = "internal_benches")] #[cfg(feature = "internal_benches")]

89
tests/ecdsa_tests.rs Normal file
View File

@ -0,0 +1,89 @@
// Copyright 2015-2016 Brian Smith.
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
extern crate ring;
extern crate untrusted;
use ring::{signature, test};
#[test]
fn signature_ecdsa_verify_asn1_test() {
test::from_file("tests/ecdsa_verify_asn1_tests.txt", |section, test_case| {
assert_eq!(section, "");
let curve_name = test_case.consume_string("Curve");
let digest_name = test_case.consume_string("Digest");
let msg = test_case.consume_bytes("Msg");
let msg = untrusted::Input::from(&msg);
let public_key = test_case.consume_bytes("Q");
let public_key = untrusted::Input::from(&public_key);
let sig = test_case.consume_bytes("Sig");
let sig = untrusted::Input::from(&sig);
let expected_result = test_case.consume_string("Result");
let alg = match (curve_name.as_str(), digest_name.as_str()) {
("P-256", "SHA256") => &signature::ECDSA_P256_SHA256_ASN1,
("P-256", "SHA384") => &signature::ECDSA_P256_SHA384_ASN1,
("P-384", "SHA256") => &signature::ECDSA_P384_SHA256_ASN1,
("P-384", "SHA384") => &signature::ECDSA_P384_SHA384_ASN1,
_ => {
panic!("Unsupported curve+digest: {}+{}", curve_name,
digest_name);
}
};
let actual_result = signature::verify(alg, public_key, msg, sig);
assert_eq!(actual_result.is_ok(), expected_result == "P (0 )");
Ok(())
});
}
#[test]
fn signature_ecdsa_verify_fixed_test() {
test::from_file("tests/ecdsa_verify_fixed_tests.txt", |section, test_case| {
assert_eq!(section, "");
let curve_name = test_case.consume_string("Curve");
let digest_name = test_case.consume_string("Digest");
let msg = test_case.consume_bytes("Msg");
let msg = untrusted::Input::from(&msg);
let public_key = test_case.consume_bytes("Q");
let public_key = untrusted::Input::from(&public_key);
let sig = test_case.consume_bytes("Sig");
let sig = untrusted::Input::from(&sig);
let expected_result = test_case.consume_string("Result");
let alg = match (curve_name.as_str(), digest_name.as_str()) {
("P-256", "SHA256") => &signature::ECDSA_P256_SHA256_FIXED,
("P-384", "SHA384") => &signature::ECDSA_P384_SHA384_FIXED,
_ => {
panic!("Unsupported curve+digest: {}+{}", curve_name, digest_name);
}
};
let actual_result = signature::verify(alg, public_key, msg, sig);
assert_eq!(actual_result.is_ok(), expected_result == "P (0 )");
Ok(())
});
}

0
src/ec/suite_b/ecdsa_verify_asn1_tests.txt → tests/ecdsa_verify_asn1_tests.txt
View File

0
src/ec/suite_b/ecdsa_verify_fixed_tests.txt → tests/ecdsa_verify_fixed_tests.txt
View File