ring/tests/ecdsa_tests.rs

// 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.

#![forbid(
    anonymous_parameters,
    box_pointers,
    legacy_directory_ownership,
    missing_copy_implementations,
    missing_debug_implementations,
    missing_docs,
    trivial_casts,
    trivial_numeric_casts,
    unsafe_code,
    unstable_features,
    unused_extern_crates,
    unused_import_braces,
    unused_qualifications,
    unused_results,
    variant_size_differences,
    warnings,
)]

extern crate ring;
extern crate untrusted;

use ring::{rand, signature, test};

#[test]
fn ecdsa_from_pkcs8_test() {
    test::from_file("tests/ecdsa_from_pkcs8_tests.txt", |section, test_case| {
        assert_eq!(section, "");

        let curve_name = test_case.consume_string("Curve");
        let ((this_fixed, this_asn1), (other_fixed, other_asn1)) =
            match curve_name.as_str() {
                "P-256" => ((&signature::ECDSA_P256_SHA256_FIXED_SIGNING,
                             &signature::ECDSA_P256_SHA256_ASN1_SIGNING),
                            (&signature::ECDSA_P384_SHA384_FIXED_SIGNING,
                             &signature::ECDSA_P384_SHA384_ASN1_SIGNING)),
                "P-384" => ((&signature::ECDSA_P384_SHA384_FIXED_SIGNING,
                             &signature::ECDSA_P384_SHA384_ASN1_SIGNING),
                            (&signature::ECDSA_P256_SHA256_FIXED_SIGNING,
                             &signature::ECDSA_P256_SHA256_ASN1_SIGNING)),
                _ => unreachable!(),
            };

        let input = test_case.consume_bytes("Input");
        let input = untrusted::Input::from(&input);

        let error = test_case.consume_optional_string("Error");

        assert_eq!(
            signature::key_pair_from_pkcs8(this_fixed, input).is_ok(),
            error.is_none());
        assert_eq!(
            signature::key_pair_from_pkcs8(this_asn1, input).is_ok(),
            error.is_none());
        assert!(
            signature::key_pair_from_pkcs8(other_fixed, input).is_err());
        assert!(
            signature::key_pair_from_pkcs8(other_asn1, input).is_err());

        Ok(())
    });
}

// Verify that, at least, we generate PKCS#8 documents that we can read.
#[test]
fn ecdsa_generate_pkcs8_test() {
    let rng = rand::SystemRandom::new();

    for alg in &[&signature::ECDSA_P256_SHA256_ASN1_SIGNING,
                 &signature::ECDSA_P256_SHA256_FIXED_SIGNING,
                 &signature::ECDSA_P384_SHA384_ASN1_SIGNING,
                 &signature::ECDSA_P384_SHA384_FIXED_SIGNING] {
        let pkcs8 = signature::ECDSAKeyPair::generate_pkcs8(alg, &rng).unwrap();
        println!();
        for b in pkcs8.as_ref() {
            print!("{:02x}", *b);
        }
        println!();
        println!();
        let _ = signature::key_pair_from_pkcs8(
            *alg, untrusted::Input::from(pkcs8.as_ref())).unwrap();
    }
}

#[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(())
    });
}

#[test]
fn signature_ecdsa_sign_fixed_test() {
    test::from_file("tests/ecdsa_sign_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 d = test_case.consume_bytes("d");
        let d = untrusted::Input::from(&d);

        let q = test_case.consume_bytes("Q");
        let q = untrusted::Input::from(&q);

        let k = test_case.consume_bytes("k");

        let expected_result = test_case.consume_bytes("Sig");

        let alg = match (curve_name.as_str(), digest_name.as_str()) {
            ("P-256", "SHA256") => &signature::ECDSA_P256_SHA256_FIXED_SIGNING,
            ("P-384", "SHA384") => &signature::ECDSA_P384_SHA384_FIXED_SIGNING,
            _ => {
                panic!("Unsupported curve+digest: {}+{}", curve_name,
                       digest_name);
            }
        };

        let private_key =
            signature::ECDSAKeyPair::from_private_key_and_public_key(alg, d, q).unwrap();
        let rng = test::rand::FixedSliceRandom { bytes: &k };

        let actual_result = private_key.sign(msg, &rng).unwrap();

        assert_eq!(actual_result.as_ref(), &expected_result[..]);

        Ok(())
    });
}

#[test]
fn signature_ecdsa_sign_asn1_test() {
    test::from_file("tests/ecdsa_sign_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 d = test_case.consume_bytes("d");
        let d = untrusted::Input::from(&d);

        let q = test_case.consume_bytes("Q");
        let q = untrusted::Input::from(&q);

        let k = test_case.consume_bytes("k");

        let expected_result = test_case.consume_bytes("Sig");

        let alg = match (curve_name.as_str(), digest_name.as_str()) {
            ("P-256", "SHA256") => &signature::ECDSA_P256_SHA256_ASN1_SIGNING,
            ("P-384", "SHA384") => &signature::ECDSA_P384_SHA384_ASN1_SIGNING,
            _ => {
                panic!("Unsupported curve+digest: {}+{}", curve_name,
                       digest_name);
            }
        };

        let private_key =
            signature::ECDSAKeyPair::from_private_key_and_public_key(alg, d, q).unwrap();
        let rng = test::rand::FixedSliceRandom { bytes: &k };

        println!("Asfd");
        let actual_result = private_key.sign(msg, &rng).unwrap();

        println!("Asfdasdfasdfasdfasdfsadf");
        assert_eq!(actual_result.as_ref(), &expected_result[..]);

        Ok(())
    });
}