From 6ff143a831afa393a7b5dd760339ab42009e096f Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Fri, 15 Sep 2023 16:12:56 +0100 Subject: [PATCH 01/12] Defend `cargo test` without ring --- .github/workflows/ci.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e65d1099..5e22b2ad 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -125,6 +125,7 @@ jobs: - features: # Default - features: --features=alloc - features: --no-default-features + - features: --no-default-features --features alloc,std - features: --all-features mode: --release - features: --all-features @@ -150,6 +151,11 @@ jobs: rust_channel: stable host_os: ubuntu-20.04 + - features: --no-default-features --features alloc,std + mode: # debug + rust_channel: stable + host_os: ubuntu-20.04 + - features: --all-features mode: --release rust_channel: stable From 68680e174e6deb4a069c8d2b00fc67280fb57504 Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Fri, 15 Sep 2023 16:13:22 +0100 Subject: [PATCH 02/12] verify_cert.rs: don't try tests without ring --- src/verify_cert.rs | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/src/verify_cert.rs b/src/verify_cert.rs index da563f32..53531858 100644 --- a/src/verify_cert.rs +++ b/src/verify_cert.rs @@ -495,10 +495,9 @@ enum Role { EndEntity, } -#[cfg(test)] +#[cfg(all(test, feature = "alloc", feature = "ring"))] mod tests { use super::*; - #[cfg(feature = "alloc")] use crate::test_utils::{issuer_params, make_end_entity, make_issuer}; #[test] @@ -513,7 +512,6 @@ mod tests { InChain, } - #[cfg(feature = "alloc")] fn build_degenerate_chain( intermediate_count: usize, trust_anchor: ChainTrustAnchor, @@ -552,7 +550,6 @@ mod tests { } #[test] - #[cfg(feature = "alloc")] fn test_too_many_signatures() { assert!(matches!( build_degenerate_chain(5, ChainTrustAnchor::NotInChain), @@ -561,7 +558,6 @@ mod tests { } #[test] - #[cfg(feature = "alloc")] fn test_too_many_path_calls() { assert!(matches!( dbg!(build_degenerate_chain(10, ChainTrustAnchor::InChain)), @@ -569,7 +565,6 @@ mod tests { )); } - #[cfg(feature = "alloc")] fn build_linear_chain(chain_length: usize) -> Result<(), ControlFlow> { let ca_cert = make_issuer(format!("Bogus Subject {chain_length}")); let ca_cert_der = CertificateDer::from(ca_cert.serialize_der().unwrap()); @@ -592,7 +587,6 @@ mod tests { } #[test] - #[cfg(feature = "alloc")] fn longest_allowed_path() { assert!(build_linear_chain(1).is_ok()); assert!(build_linear_chain(2).is_ok()); @@ -603,7 +597,6 @@ mod tests { } #[test] - #[cfg(feature = "alloc")] fn path_too_long() { assert!(matches!( build_linear_chain(7), @@ -612,7 +605,6 @@ mod tests { } #[test] - #[cfg(feature = "alloc")] fn name_constraint_budget() { // Issue a trust anchor that imposes name constraints. The constraint should match // the end entity certificate SAN. @@ -688,7 +680,6 @@ mod tests { )); } - #[cfg(feature = "alloc")] fn verify_chain( trust_anchor: &CertificateDer<'_>, intermediates_der: &[Vec], From 6a3baae5ba6b256d8a07f773e4e00d53b03481e4 Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Fri, 15 Sep 2023 16:14:18 +0100 Subject: [PATCH 03/12] client_auth.rs: don't try without ring --- tests/client_auth.rs | 2 +- tests/tls_server_certs.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/client_auth.rs b/tests/client_auth.rs index 0a3695be..10aeecc4 100644 --- a/tests/client_auth.rs +++ b/tests/client_auth.rs @@ -12,7 +12,7 @@ // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -#![cfg(feature = "alloc")] +#![cfg(all(feature = "alloc", feature = "ring"))] use core::time::Duration; use pki_types::{CertificateDer, SignatureVerificationAlgorithm, UnixTime}; diff --git a/tests/tls_server_certs.rs b/tests/tls_server_certs.rs index 00000bf2..e01ee8d0 100644 --- a/tests/tls_server_certs.rs +++ b/tests/tls_server_certs.rs @@ -11,7 +11,7 @@ // 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. -#![cfg(feature = "alloc")] +#![cfg(all(feature = "alloc", feature = "ring"))] use core::time::Duration; From 8313d38e92fa680a37d26762d4593aafce09fe9d Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Fri, 15 Sep 2023 16:14:42 +0100 Subject: [PATCH 04/12] test_utils.rs: make_end_entity is not referenced without ring --- src/test_utils.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test_utils.rs b/src/test_utils.rs index 70b931b9..9685bcf7 100644 --- a/src/test_utils.rs +++ b/src/test_utils.rs @@ -27,6 +27,7 @@ pub(crate) fn issuer_params(org_name: impl Into) -> rcgen::CertificatePa ca_params } +#[cfg_attr(not(feature = "ring"), allow(dead_code))] pub(crate) fn make_end_entity(issuer: &rcgen::Certificate) -> CertificateDer<'static> { CertificateDer::from( rcgen::Certificate::from_params(end_entity_params(vec!["example.com".into()])) From 3f1c857a3373a991a03bf28b4515ea36ae9db0d2 Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Fri, 15 Sep 2023 13:08:34 +0100 Subject: [PATCH 05/12] Extract algorithm tests from ring_algs.rs --- Cargo.toml | 1 + src/alg_tests.rs | 426 +++++++++++++++++++++++++++++++++++++++++++++++ src/ring_algs.rs | 419 +--------------------------------------------- 3 files changed, 429 insertions(+), 417 deletions(-) create mode 100644 src/alg_tests.rs diff --git a/Cargo.toml b/Cargo.toml index 87667942..cd8a89d4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -45,6 +45,7 @@ include = [ "src/name/name.rs", "src/signed_data.rs", "src/ring_algs.rs", + "src/alg_tests.rs", "src/time.rs", "src/trust_anchor.rs", "src/x509.rs", diff --git a/src/alg_tests.rs b/src/alg_tests.rs new file mode 100644 index 00000000..4eddf523 --- /dev/null +++ b/src/alg_tests.rs @@ -0,0 +1,426 @@ +// Copyright 2015 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. + +use base64::{engine::general_purpose, Engine as _}; + +use crate::error::{DerTypeId, Error}; +use crate::verify_cert::Budget; +use crate::{der, signed_data}; +use alloc::{string::String, vec::Vec}; + +macro_rules! test_file_bytes { + ( $file_name:expr ) => { + include_bytes!(concat!( + "../third-party/chromium/data/verify_signed_data/", + $file_name + )) + }; +} + +// TODO: The expected results need to be modified for SHA-1 deprecation. + +macro_rules! test_verify_signed_data { + ($fn_name:ident, $file_name:expr, $expected_result:expr) => { + #[test] + fn $fn_name() { + test_verify_signed_data(test_file_bytes!($file_name), $expected_result); + } + }; +} + +fn test_verify_signed_data(file_contents: &[u8], expected_result: Result<(), Error>) { + let tsd = parse_test_signed_data(file_contents); + let spki_value = untrusted::Input::from(&tsd.spki); + let spki_value = spki_value + .read_all(Error::BadDer, |input| { + der::expect_tag(input, der::Tag::Sequence) + }) + .unwrap(); + + // we can't use `parse_signed_data` because it requires `data` + // to be an ASN.1 SEQUENCE, and that isn't the case with + // Chromium's test data. TODO: The test data set should be + // expanded with SEQUENCE-wrapped data so that we can actually + // test `parse_signed_data`. + + let algorithm = untrusted::Input::from(&tsd.algorithm); + let algorithm = algorithm + .read_all( + Error::TrailingData(DerTypeId::SignatureAlgorithm), + |input| der::expect_tag(input, der::Tag::Sequence), + ) + .unwrap(); + + let signature = untrusted::Input::from(&tsd.signature); + let signature = signature + .read_all(Error::TrailingData(DerTypeId::Signature), |input| { + der::bit_string_with_no_unused_bits(input) + }) + .unwrap(); + + let signed_data = signed_data::SignedData { + data: untrusted::Input::from(&tsd.data), + algorithm, + signature, + }; + + assert_eq!( + expected_result, + signed_data::verify_signed_data( + SUPPORTED_ALGORITHMS_IN_TESTS, + spki_value, + &signed_data, + &mut Budget::default(), + ) + ); +} + +// XXX: This is testing code that isn't even in this module. +macro_rules! test_verify_signed_data_signature_outer { + ($fn_name:ident, $file_name:expr, $expected_result:expr) => { + #[test] + fn $fn_name() { + test_verify_signed_data_signature_outer(test_file_bytes!($file_name), $expected_result); + } + }; +} + +fn test_verify_signed_data_signature_outer(file_contents: &[u8], expected_error: Error) { + let tsd = parse_test_signed_data(file_contents); + let signature = untrusted::Input::from(&tsd.signature); + assert_eq!( + Err(expected_error), + signature.read_all(Error::TrailingData(DerTypeId::Signature), |input| { + der::bit_string_with_no_unused_bits(input) + }) + ); +} + +// XXX: This is testing code that is not even in this module. +macro_rules! test_parse_spki_bad_outer { + ($fn_name:ident, $file_name:expr, $error:expr) => { + #[test] + fn $fn_name() { + test_parse_spki_bad_outer(test_file_bytes!($file_name), $error) + } + }; +} + +fn test_parse_spki_bad_outer(file_contents: &[u8], expected_error: Error) { + let tsd = parse_test_signed_data(file_contents); + let spki = untrusted::Input::from(&tsd.spki); + assert_eq!( + Err(expected_error), + spki.read_all(Error::BadDer, |input| { + der::expect_tag(input, der::Tag::Sequence) + }) + ); +} + +const UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY: Error = if cfg!(feature = "alloc") { + Error::UnsupportedSignatureAlgorithmForPublicKey +} else { + Error::UnsupportedSignatureAlgorithm +}; + +const INVALID_SIGNATURE_FOR_RSA_KEY: Error = if cfg!(feature = "alloc") { + Error::InvalidSignatureForPublicKey +} else { + Error::UnsupportedSignatureAlgorithm +}; + +const OK_IF_RSA_AVAILABLE: Result<(), Error> = if cfg!(feature = "alloc") { + Ok(()) +} else { + Err(Error::UnsupportedSignatureAlgorithm) +}; + +// XXX: Some of the BadDer tests should have better error codes, maybe? + +// XXX: We should have a variant of this test with a SHA-256 digest that gives +// `Error::UnsupportedSignatureAlgorithmForPublicKey`. +test_verify_signed_data!( + test_ecdsa_prime256v1_sha512_spki_params_null, + "ecdsa-prime256v1-sha512-spki-params-null.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data_signature_outer!( + test_ecdsa_prime256v1_sha512_unused_bits_signature, + "ecdsa-prime256v1-sha512-unused-bits-signature.pem", + Error::BadDer +); +// XXX: We should have a variant of this test with a SHA-256 digest that gives +// `Error::UnsupportedSignatureAlgorithmForPublicKey`. +test_verify_signed_data!( + test_ecdsa_prime256v1_sha512_using_ecdh_key, + "ecdsa-prime256v1-sha512-using-ecdh-key.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +// XXX: We should have a variant of this test with a SHA-256 digest that gives +// `Error::UnsupportedSignatureAlgorithmForPublicKey`. +test_verify_signed_data!( + test_ecdsa_prime256v1_sha512_using_ecmqv_key, + "ecdsa-prime256v1-sha512-using-ecmqv-key.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data!( + test_ecdsa_prime256v1_sha512_using_rsa_algorithm, + "ecdsa-prime256v1-sha512-using-rsa-algorithm.pem", + Err(UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY) +); +// XXX: We should have a variant of this test with a SHA-256 digest that gives +// `Error::InvalidSignatureForPublicKey`. +test_verify_signed_data!( + test_ecdsa_prime256v1_sha512_wrong_signature_format, + "ecdsa-prime256v1-sha512-wrong-signature-format.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +// Differs from Chromium because we don't support P-256 with SHA-512. +test_verify_signed_data!( + test_ecdsa_prime256v1_sha512, + "ecdsa-prime256v1-sha512.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data!( + test_ecdsa_secp384r1_sha256_corrupted_data, + "ecdsa-secp384r1-sha256-corrupted-data.pem", + Err(Error::InvalidSignatureForPublicKey) +); +test_verify_signed_data!( + test_ecdsa_secp384r1_sha256, + "ecdsa-secp384r1-sha256.pem", + Ok(()) +); +test_verify_signed_data!( + test_ecdsa_using_rsa_key, + "ecdsa-using-rsa-key.pem", + Err(Error::UnsupportedSignatureAlgorithmForPublicKey) +); + +test_parse_spki_bad_outer!( + test_rsa_pkcs1_sha1_bad_key_der_length, + "rsa-pkcs1-sha1-bad-key-der-length.pem", + Error::BadDer +); +test_parse_spki_bad_outer!( + test_rsa_pkcs1_sha1_bad_key_der_null, + "rsa-pkcs1-sha1-bad-key-der-null.pem", + Error::BadDer +); +test_verify_signed_data!( + test_rsa_pkcs1_sha1_key_params_absent, + "rsa-pkcs1-sha1-key-params-absent.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data!( + test_rsa_pkcs1_sha1_using_pss_key_no_params, + "rsa-pkcs1-sha1-using-pss-key-no-params.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data!( + test_rsa_pkcs1_sha1_wrong_algorithm, + "rsa-pkcs1-sha1-wrong-algorithm.pem", + Err(INVALID_SIGNATURE_FOR_RSA_KEY) +); +test_verify_signed_data!( + test_rsa_pkcs1_sha1, + "rsa-pkcs1-sha1.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +// XXX: RSA PKCS#1 with SHA-1 is a supported algorithm, but we only accept +// 2048-8192 bit keys, and this test file is using a 1024 bit key. Thus, +// our results differ from Chromium's. TODO: this means we need a 2048+ bit +// version of this test. +test_verify_signed_data!( + test_rsa_pkcs1_sha256, + "rsa-pkcs1-sha256.pem", + Err(INVALID_SIGNATURE_FOR_RSA_KEY) +); +test_parse_spki_bad_outer!( + test_rsa_pkcs1_sha256_key_encoded_ber, + "rsa-pkcs1-sha256-key-encoded-ber.pem", + Error::BadDer +); +test_verify_signed_data!( + test_rsa_pkcs1_sha256_spki_non_null_params, + "rsa-pkcs1-sha256-spki-non-null-params.pem", + Err(UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY) +); +test_verify_signed_data!( + test_rsa_pkcs1_sha256_using_ecdsa_algorithm, + "rsa-pkcs1-sha256-using-ecdsa-algorithm.pem", + Err(Error::UnsupportedSignatureAlgorithmForPublicKey) +); +test_verify_signed_data!( + test_rsa_pkcs1_sha256_using_id_ea_rsa, + "rsa-pkcs1-sha256-using-id-ea-rsa.pem", + Err(UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY) +); + +// Chromium's PSS test are for parameter combinations we don't support. +test_verify_signed_data!( + test_rsa_pss_sha1_salt20_using_pss_key_no_params, + "rsa-pss-sha1-salt20-using-pss-key-no-params.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data!( + test_rsa_pss_sha1_salt20_using_pss_key_with_null_params, + "rsa-pss-sha1-salt20-using-pss-key-with-null-params.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data!( + test_rsa_pss_sha1_salt20, + "rsa-pss-sha1-salt20.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data!( + test_rsa_pss_sha1_wrong_salt, + "rsa-pss-sha1-wrong-salt.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data!( + test_rsa_pss_sha256_mgf1_sha512_salt33, + "rsa-pss-sha256-mgf1-sha512-salt33.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data!( + test_rsa_pss_sha256_salt10_using_pss_key_with_params, + "rsa-pss-sha256-salt10-using-pss-key-with-params.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data!( + test_rsa_pss_sha256_salt10_using_pss_key_with_wrong_params, + "rsa-pss-sha256-salt10-using-pss-key-with-wrong-params.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); +test_verify_signed_data!( + test_rsa_pss_sha256_salt10, + "rsa-pss-sha256-salt10.pem", + Err(Error::UnsupportedSignatureAlgorithm) +); + +// Our PSS tests that should work. +test_verify_signed_data!( + test_rsa_pss_sha256_salt32, + "ours/rsa-pss-sha256-salt32.pem", + OK_IF_RSA_AVAILABLE +); +test_verify_signed_data!( + test_rsa_pss_sha384_salt48, + "ours/rsa-pss-sha384-salt48.pem", + OK_IF_RSA_AVAILABLE +); +test_verify_signed_data!( + test_rsa_pss_sha512_salt64, + "ours/rsa-pss-sha512-salt64.pem", + OK_IF_RSA_AVAILABLE +); +test_verify_signed_data!( + test_rsa_pss_sha256_salt32_corrupted_data, + "ours/rsa-pss-sha256-salt32-corrupted-data.pem", + Err(INVALID_SIGNATURE_FOR_RSA_KEY) +); +test_verify_signed_data!( + test_rsa_pss_sha384_salt48_corrupted_data, + "ours/rsa-pss-sha384-salt48-corrupted-data.pem", + Err(INVALID_SIGNATURE_FOR_RSA_KEY) +); +test_verify_signed_data!( + test_rsa_pss_sha512_salt64_corrupted_data, + "ours/rsa-pss-sha512-salt64-corrupted-data.pem", + Err(INVALID_SIGNATURE_FOR_RSA_KEY) +); + +test_verify_signed_data!( + test_rsa_using_ec_key, + "rsa-using-ec-key.pem", + Err(UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY) +); +test_verify_signed_data!( + test_rsa2048_pkcs1_sha512, + "rsa2048-pkcs1-sha512.pem", + OK_IF_RSA_AVAILABLE +); + +struct TestSignedData { + spki: Vec, + data: Vec, + algorithm: Vec, + signature: Vec, +} + +fn parse_test_signed_data(file_contents: &[u8]) -> TestSignedData { + let mut lines = core::str::from_utf8(file_contents).unwrap().lines(); + let spki = read_pem_section(&mut lines, "PUBLIC KEY"); + let algorithm = read_pem_section(&mut lines, "ALGORITHM"); + let data = read_pem_section(&mut lines, "DATA"); + let signature = read_pem_section(&mut lines, "SIGNATURE"); + + TestSignedData { + spki, + data, + algorithm, + signature, + } +} + +use alloc::str::Lines; + +fn read_pem_section(lines: &mut Lines, section_name: &str) -> Vec { + // Skip comments and header + let begin_section = format!("-----BEGIN {}-----", section_name); + loop { + let line = lines.next().unwrap(); + if line == begin_section { + break; + } + } + + let mut base64 = String::new(); + + let end_section = format!("-----END {}-----", section_name); + loop { + let line = lines.next().unwrap(); + if line == end_section { + break; + } + base64.push_str(line); + } + + general_purpose::STANDARD.decode(&base64).unwrap() +} + +static SUPPORTED_ALGORITHMS_IN_TESTS: &[&dyn super::SignatureVerificationAlgorithm] = &[ + // Reasonable algorithms. + super::ECDSA_P256_SHA256, + super::ECDSA_P384_SHA384, + super::ED25519, + #[cfg(feature = "alloc")] + super::RSA_PKCS1_2048_8192_SHA256, + #[cfg(feature = "alloc")] + super::RSA_PKCS1_2048_8192_SHA384, + #[cfg(feature = "alloc")] + super::RSA_PKCS1_2048_8192_SHA512, + #[cfg(feature = "alloc")] + super::RSA_PKCS1_3072_8192_SHA384, + #[cfg(feature = "alloc")] + super::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + #[cfg(feature = "alloc")] + super::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, + #[cfg(feature = "alloc")] + super::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, + // Algorithms deprecated because they are nonsensical combinations. + super::ECDSA_P256_SHA384, // Truncates digest. + super::ECDSA_P384_SHA256, // Digest is unnecessarily short. +]; diff --git a/src/ring_algs.rs b/src/ring_algs.rs index 2fa04f17..a5297d59 100644 --- a/src/ring_algs.rs +++ b/src/ring_algs.rs @@ -149,420 +149,5 @@ pub static ED25519: &dyn SignatureVerificationAlgorithm = &RingAlgorithm { }; #[cfg(test)] -mod tests { - use base64::{engine::general_purpose, Engine as _}; - - use crate::error::{DerTypeId, Error}; - use crate::verify_cert::Budget; - use crate::{der, signed_data}; - use alloc::{string::String, vec::Vec}; - - macro_rules! test_file_bytes { - ( $file_name:expr ) => { - include_bytes!(concat!( - "../third-party/chromium/data/verify_signed_data/", - $file_name - )) - }; - } - - // TODO: The expected results need to be modified for SHA-1 deprecation. - - macro_rules! test_verify_signed_data { - ($fn_name:ident, $file_name:expr, $expected_result:expr) => { - #[test] - fn $fn_name() { - test_verify_signed_data(test_file_bytes!($file_name), $expected_result); - } - }; - } - - fn test_verify_signed_data(file_contents: &[u8], expected_result: Result<(), Error>) { - let tsd = parse_test_signed_data(file_contents); - let spki_value = untrusted::Input::from(&tsd.spki); - let spki_value = spki_value - .read_all(Error::BadDer, |input| { - der::expect_tag(input, der::Tag::Sequence) - }) - .unwrap(); - - // we can't use `parse_signed_data` because it requires `data` - // to be an ASN.1 SEQUENCE, and that isn't the case with - // Chromium's test data. TODO: The test data set should be - // expanded with SEQUENCE-wrapped data so that we can actually - // test `parse_signed_data`. - - let algorithm = untrusted::Input::from(&tsd.algorithm); - let algorithm = algorithm - .read_all( - Error::TrailingData(DerTypeId::SignatureAlgorithm), - |input| der::expect_tag(input, der::Tag::Sequence), - ) - .unwrap(); - - let signature = untrusted::Input::from(&tsd.signature); - let signature = signature - .read_all(Error::TrailingData(DerTypeId::Signature), |input| { - der::bit_string_with_no_unused_bits(input) - }) - .unwrap(); - - let signed_data = signed_data::SignedData { - data: untrusted::Input::from(&tsd.data), - algorithm, - signature, - }; - - assert_eq!( - expected_result, - signed_data::verify_signed_data( - SUPPORTED_ALGORITHMS_IN_TESTS, - spki_value, - &signed_data, - &mut Budget::default(), - ) - ); - } - - // XXX: This is testing code that isn't even in this module. - macro_rules! test_verify_signed_data_signature_outer { - ($fn_name:ident, $file_name:expr, $expected_result:expr) => { - #[test] - fn $fn_name() { - test_verify_signed_data_signature_outer( - test_file_bytes!($file_name), - $expected_result, - ); - } - }; - } - - fn test_verify_signed_data_signature_outer(file_contents: &[u8], expected_error: Error) { - let tsd = parse_test_signed_data(file_contents); - let signature = untrusted::Input::from(&tsd.signature); - assert_eq!( - Err(expected_error), - signature.read_all(Error::TrailingData(DerTypeId::Signature), |input| { - der::bit_string_with_no_unused_bits(input) - }) - ); - } - - // XXX: This is testing code that is not even in this module. - macro_rules! test_parse_spki_bad_outer { - ($fn_name:ident, $file_name:expr, $error:expr) => { - #[test] - fn $fn_name() { - test_parse_spki_bad_outer(test_file_bytes!($file_name), $error) - } - }; - } - - fn test_parse_spki_bad_outer(file_contents: &[u8], expected_error: Error) { - let tsd = parse_test_signed_data(file_contents); - let spki = untrusted::Input::from(&tsd.spki); - assert_eq!( - Err(expected_error), - spki.read_all(Error::BadDer, |input| { - der::expect_tag(input, der::Tag::Sequence) - }) - ); - } - - const UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY: Error = if cfg!(feature = "alloc") { - Error::UnsupportedSignatureAlgorithmForPublicKey - } else { - Error::UnsupportedSignatureAlgorithm - }; - - const INVALID_SIGNATURE_FOR_RSA_KEY: Error = if cfg!(feature = "alloc") { - Error::InvalidSignatureForPublicKey - } else { - Error::UnsupportedSignatureAlgorithm - }; - - const OK_IF_RSA_AVAILABLE: Result<(), Error> = if cfg!(feature = "alloc") { - Ok(()) - } else { - Err(Error::UnsupportedSignatureAlgorithm) - }; - - // XXX: Some of the BadDer tests should have better error codes, maybe? - - // XXX: We should have a variant of this test with a SHA-256 digest that gives - // `Error::UnsupportedSignatureAlgorithmForPublicKey`. - test_verify_signed_data!( - test_ecdsa_prime256v1_sha512_spki_params_null, - "ecdsa-prime256v1-sha512-spki-params-null.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data_signature_outer!( - test_ecdsa_prime256v1_sha512_unused_bits_signature, - "ecdsa-prime256v1-sha512-unused-bits-signature.pem", - Error::BadDer - ); - // XXX: We should have a variant of this test with a SHA-256 digest that gives - // `Error::UnsupportedSignatureAlgorithmForPublicKey`. - test_verify_signed_data!( - test_ecdsa_prime256v1_sha512_using_ecdh_key, - "ecdsa-prime256v1-sha512-using-ecdh-key.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - // XXX: We should have a variant of this test with a SHA-256 digest that gives - // `Error::UnsupportedSignatureAlgorithmForPublicKey`. - test_verify_signed_data!( - test_ecdsa_prime256v1_sha512_using_ecmqv_key, - "ecdsa-prime256v1-sha512-using-ecmqv-key.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data!( - test_ecdsa_prime256v1_sha512_using_rsa_algorithm, - "ecdsa-prime256v1-sha512-using-rsa-algorithm.pem", - Err(UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY) - ); - // XXX: We should have a variant of this test with a SHA-256 digest that gives - // `Error::InvalidSignatureForPublicKey`. - test_verify_signed_data!( - test_ecdsa_prime256v1_sha512_wrong_signature_format, - "ecdsa-prime256v1-sha512-wrong-signature-format.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - // Differs from Chromium because we don't support P-256 with SHA-512. - test_verify_signed_data!( - test_ecdsa_prime256v1_sha512, - "ecdsa-prime256v1-sha512.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data!( - test_ecdsa_secp384r1_sha256_corrupted_data, - "ecdsa-secp384r1-sha256-corrupted-data.pem", - Err(Error::InvalidSignatureForPublicKey) - ); - test_verify_signed_data!( - test_ecdsa_secp384r1_sha256, - "ecdsa-secp384r1-sha256.pem", - Ok(()) - ); - test_verify_signed_data!( - test_ecdsa_using_rsa_key, - "ecdsa-using-rsa-key.pem", - Err(Error::UnsupportedSignatureAlgorithmForPublicKey) - ); - - test_parse_spki_bad_outer!( - test_rsa_pkcs1_sha1_bad_key_der_length, - "rsa-pkcs1-sha1-bad-key-der-length.pem", - Error::BadDer - ); - test_parse_spki_bad_outer!( - test_rsa_pkcs1_sha1_bad_key_der_null, - "rsa-pkcs1-sha1-bad-key-der-null.pem", - Error::BadDer - ); - test_verify_signed_data!( - test_rsa_pkcs1_sha1_key_params_absent, - "rsa-pkcs1-sha1-key-params-absent.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data!( - test_rsa_pkcs1_sha1_using_pss_key_no_params, - "rsa-pkcs1-sha1-using-pss-key-no-params.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data!( - test_rsa_pkcs1_sha1_wrong_algorithm, - "rsa-pkcs1-sha1-wrong-algorithm.pem", - Err(INVALID_SIGNATURE_FOR_RSA_KEY) - ); - test_verify_signed_data!( - test_rsa_pkcs1_sha1, - "rsa-pkcs1-sha1.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - // XXX: RSA PKCS#1 with SHA-1 is a supported algorithm, but we only accept - // 2048-8192 bit keys, and this test file is using a 1024 bit key. Thus, - // our results differ from Chromium's. TODO: this means we need a 2048+ bit - // version of this test. - test_verify_signed_data!( - test_rsa_pkcs1_sha256, - "rsa-pkcs1-sha256.pem", - Err(INVALID_SIGNATURE_FOR_RSA_KEY) - ); - test_parse_spki_bad_outer!( - test_rsa_pkcs1_sha256_key_encoded_ber, - "rsa-pkcs1-sha256-key-encoded-ber.pem", - Error::BadDer - ); - test_verify_signed_data!( - test_rsa_pkcs1_sha256_spki_non_null_params, - "rsa-pkcs1-sha256-spki-non-null-params.pem", - Err(UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY) - ); - test_verify_signed_data!( - test_rsa_pkcs1_sha256_using_ecdsa_algorithm, - "rsa-pkcs1-sha256-using-ecdsa-algorithm.pem", - Err(Error::UnsupportedSignatureAlgorithmForPublicKey) - ); - test_verify_signed_data!( - test_rsa_pkcs1_sha256_using_id_ea_rsa, - "rsa-pkcs1-sha256-using-id-ea-rsa.pem", - Err(UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY) - ); - - // Chromium's PSS test are for parameter combinations we don't support. - test_verify_signed_data!( - test_rsa_pss_sha1_salt20_using_pss_key_no_params, - "rsa-pss-sha1-salt20-using-pss-key-no-params.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data!( - test_rsa_pss_sha1_salt20_using_pss_key_with_null_params, - "rsa-pss-sha1-salt20-using-pss-key-with-null-params.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data!( - test_rsa_pss_sha1_salt20, - "rsa-pss-sha1-salt20.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data!( - test_rsa_pss_sha1_wrong_salt, - "rsa-pss-sha1-wrong-salt.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data!( - test_rsa_pss_sha256_mgf1_sha512_salt33, - "rsa-pss-sha256-mgf1-sha512-salt33.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data!( - test_rsa_pss_sha256_salt10_using_pss_key_with_params, - "rsa-pss-sha256-salt10-using-pss-key-with-params.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data!( - test_rsa_pss_sha256_salt10_using_pss_key_with_wrong_params, - "rsa-pss-sha256-salt10-using-pss-key-with-wrong-params.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - test_verify_signed_data!( - test_rsa_pss_sha256_salt10, - "rsa-pss-sha256-salt10.pem", - Err(Error::UnsupportedSignatureAlgorithm) - ); - - // Our PSS tests that should work. - test_verify_signed_data!( - test_rsa_pss_sha256_salt32, - "ours/rsa-pss-sha256-salt32.pem", - OK_IF_RSA_AVAILABLE - ); - test_verify_signed_data!( - test_rsa_pss_sha384_salt48, - "ours/rsa-pss-sha384-salt48.pem", - OK_IF_RSA_AVAILABLE - ); - test_verify_signed_data!( - test_rsa_pss_sha512_salt64, - "ours/rsa-pss-sha512-salt64.pem", - OK_IF_RSA_AVAILABLE - ); - test_verify_signed_data!( - test_rsa_pss_sha256_salt32_corrupted_data, - "ours/rsa-pss-sha256-salt32-corrupted-data.pem", - Err(INVALID_SIGNATURE_FOR_RSA_KEY) - ); - test_verify_signed_data!( - test_rsa_pss_sha384_salt48_corrupted_data, - "ours/rsa-pss-sha384-salt48-corrupted-data.pem", - Err(INVALID_SIGNATURE_FOR_RSA_KEY) - ); - test_verify_signed_data!( - test_rsa_pss_sha512_salt64_corrupted_data, - "ours/rsa-pss-sha512-salt64-corrupted-data.pem", - Err(INVALID_SIGNATURE_FOR_RSA_KEY) - ); - - test_verify_signed_data!( - test_rsa_using_ec_key, - "rsa-using-ec-key.pem", - Err(UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY) - ); - test_verify_signed_data!( - test_rsa2048_pkcs1_sha512, - "rsa2048-pkcs1-sha512.pem", - OK_IF_RSA_AVAILABLE - ); - - struct TestSignedData { - spki: Vec, - data: Vec, - algorithm: Vec, - signature: Vec, - } - - fn parse_test_signed_data(file_contents: &[u8]) -> TestSignedData { - let mut lines = core::str::from_utf8(file_contents).unwrap().lines(); - let spki = read_pem_section(&mut lines, "PUBLIC KEY"); - let algorithm = read_pem_section(&mut lines, "ALGORITHM"); - let data = read_pem_section(&mut lines, "DATA"); - let signature = read_pem_section(&mut lines, "SIGNATURE"); - - TestSignedData { - spki, - data, - algorithm, - signature, - } - } - - use alloc::str::Lines; - - fn read_pem_section(lines: &mut Lines, section_name: &str) -> Vec { - // Skip comments and header - let begin_section = format!("-----BEGIN {}-----", section_name); - loop { - let line = lines.next().unwrap(); - if line == begin_section { - break; - } - } - - let mut base64 = String::new(); - - let end_section = format!("-----END {}-----", section_name); - loop { - let line = lines.next().unwrap(); - if line == end_section { - break; - } - base64.push_str(line); - } - - general_purpose::STANDARD.decode(&base64).unwrap() - } - - static SUPPORTED_ALGORITHMS_IN_TESTS: &[&dyn super::SignatureVerificationAlgorithm] = &[ - // Reasonable algorithms. - super::ECDSA_P256_SHA256, - super::ECDSA_P384_SHA384, - super::ED25519, - #[cfg(feature = "alloc")] - super::RSA_PKCS1_2048_8192_SHA256, - #[cfg(feature = "alloc")] - super::RSA_PKCS1_2048_8192_SHA384, - #[cfg(feature = "alloc")] - super::RSA_PKCS1_2048_8192_SHA512, - #[cfg(feature = "alloc")] - super::RSA_PKCS1_3072_8192_SHA384, - #[cfg(feature = "alloc")] - super::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - #[cfg(feature = "alloc")] - super::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, - #[cfg(feature = "alloc")] - super::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, - // Algorithms deprecated because they are nonsensical combinations. - super::ECDSA_P256_SHA384, // Truncates digest. - super::ECDSA_P384_SHA256, // Digest is unnecessarily short. - ]; -} +#[path = "alg_tests.rs"] +mod alg_tests; From 437519b27a77873200f3866ed8b6e1caef6ff7f7 Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Fri, 15 Sep 2023 13:26:06 +0100 Subject: [PATCH 06/12] Extract feature-gated configuration from alg_tests.rs --- src/alg_tests.rs | 47 +++++--------------------------------------- src/ring_algs.rs | 51 ++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 54 insertions(+), 44 deletions(-) diff --git a/src/alg_tests.rs b/src/alg_tests.rs index 4eddf523..8fe988a4 100644 --- a/src/alg_tests.rs +++ b/src/alg_tests.rs @@ -19,6 +19,11 @@ use crate::verify_cert::Budget; use crate::{der, signed_data}; use alloc::{string::String, vec::Vec}; +use super::{ + INVALID_SIGNATURE_FOR_RSA_KEY, OK_IF_RSA_AVAILABLE, SUPPORTED_ALGORITHMS_IN_TESTS, + UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY, +}; + macro_rules! test_file_bytes { ( $file_name:expr ) => { include_bytes!(concat!( @@ -128,24 +133,6 @@ fn test_parse_spki_bad_outer(file_contents: &[u8], expected_error: Error) { ); } -const UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY: Error = if cfg!(feature = "alloc") { - Error::UnsupportedSignatureAlgorithmForPublicKey -} else { - Error::UnsupportedSignatureAlgorithm -}; - -const INVALID_SIGNATURE_FOR_RSA_KEY: Error = if cfg!(feature = "alloc") { - Error::InvalidSignatureForPublicKey -} else { - Error::UnsupportedSignatureAlgorithm -}; - -const OK_IF_RSA_AVAILABLE: Result<(), Error> = if cfg!(feature = "alloc") { - Ok(()) -} else { - Err(Error::UnsupportedSignatureAlgorithm) -}; - // XXX: Some of the BadDer tests should have better error codes, maybe? // XXX: We should have a variant of this test with a SHA-256 digest that gives @@ -400,27 +387,3 @@ fn read_pem_section(lines: &mut Lines, section_name: &str) -> Vec { general_purpose::STANDARD.decode(&base64).unwrap() } - -static SUPPORTED_ALGORITHMS_IN_TESTS: &[&dyn super::SignatureVerificationAlgorithm] = &[ - // Reasonable algorithms. - super::ECDSA_P256_SHA256, - super::ECDSA_P384_SHA384, - super::ED25519, - #[cfg(feature = "alloc")] - super::RSA_PKCS1_2048_8192_SHA256, - #[cfg(feature = "alloc")] - super::RSA_PKCS1_2048_8192_SHA384, - #[cfg(feature = "alloc")] - super::RSA_PKCS1_2048_8192_SHA512, - #[cfg(feature = "alloc")] - super::RSA_PKCS1_3072_8192_SHA384, - #[cfg(feature = "alloc")] - super::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - #[cfg(feature = "alloc")] - super::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, - #[cfg(feature = "alloc")] - super::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, - // Algorithms deprecated because they are nonsensical combinations. - super::ECDSA_P256_SHA384, // Truncates digest. - super::ECDSA_P384_SHA256, // Digest is unnecessarily short. -]; diff --git a/src/ring_algs.rs b/src/ring_algs.rs index a5297d59..427d36d7 100644 --- a/src/ring_algs.rs +++ b/src/ring_algs.rs @@ -149,5 +149,52 @@ pub static ED25519: &dyn SignatureVerificationAlgorithm = &RingAlgorithm { }; #[cfg(test)] -#[path = "alg_tests.rs"] -mod alg_tests; +#[path = "."] +mod tests { + use crate::Error; + + static SUPPORTED_ALGORITHMS_IN_TESTS: &[&dyn super::SignatureVerificationAlgorithm] = &[ + // Reasonable algorithms. + super::ECDSA_P256_SHA256, + super::ECDSA_P384_SHA384, + super::ED25519, + #[cfg(feature = "alloc")] + super::RSA_PKCS1_2048_8192_SHA256, + #[cfg(feature = "alloc")] + super::RSA_PKCS1_2048_8192_SHA384, + #[cfg(feature = "alloc")] + super::RSA_PKCS1_2048_8192_SHA512, + #[cfg(feature = "alloc")] + super::RSA_PKCS1_3072_8192_SHA384, + #[cfg(feature = "alloc")] + super::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + #[cfg(feature = "alloc")] + super::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, + #[cfg(feature = "alloc")] + super::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, + // Algorithms deprecated because they are nonsensical combinations. + super::ECDSA_P256_SHA384, // Truncates digest. + super::ECDSA_P384_SHA256, // Digest is unnecessarily short. + ]; + + const UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY: Error = if cfg!(feature = "alloc") { + Error::UnsupportedSignatureAlgorithmForPublicKey + } else { + Error::UnsupportedSignatureAlgorithm + }; + + const INVALID_SIGNATURE_FOR_RSA_KEY: Error = if cfg!(feature = "alloc") { + Error::InvalidSignatureForPublicKey + } else { + Error::UnsupportedSignatureAlgorithm + }; + + const OK_IF_RSA_AVAILABLE: Result<(), Error> = if cfg!(feature = "alloc") { + Ok(()) + } else { + Err(Error::UnsupportedSignatureAlgorithm) + }; + + #[path = "alg_tests.rs"] + mod alg_tests; +} From d139225bd9a6b219edae153812f2197f9f306e4f Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Wed, 30 Aug 2023 11:22:28 +0100 Subject: [PATCH 07/12] Export array of all predefined `SignatureVerificationAlgorithm`s This avoids quite a bit of repetition in tests, and addresses the case that a consuming crate wants to use the full set of predefined algorithms but doesn't much care what they are. --- src/lib.rs | 30 ++++++++++++++++++++++++++++++ src/verify_cert.rs | 3 +-- tests/client_auth.rs | 16 ++-------------- tests/custom_ekus.rs | 13 ++++++++----- tests/integration.rs | 32 ++++++++------------------------ tests/tls_server_certs.rs | 16 ++-------------- 6 files changed, 51 insertions(+), 59 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 6f2b8c35..63d3a7ac 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -100,3 +100,33 @@ pub use ring_algs::{ RSA_PKCS1_3072_8192_SHA384, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, RSA_PSS_2048_8192_SHA384_LEGACY_KEY, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, }; + +/// An array of all the verification algorithms exported by this crate. +/// +/// This will be empty if the crate is built without the `ring` feature. +pub static ALL_VERIFICATION_ALGS: &[&dyn types::SignatureVerificationAlgorithm] = &[ + #[cfg(feature = "ring")] + ring_algs::ECDSA_P256_SHA256, + #[cfg(feature = "ring")] + ring_algs::ECDSA_P256_SHA384, + #[cfg(feature = "ring")] + ring_algs::ECDSA_P384_SHA256, + #[cfg(feature = "ring")] + ring_algs::ECDSA_P384_SHA384, + #[cfg(feature = "ring")] + ring_algs::ED25519, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring_algs::RSA_PKCS1_2048_8192_SHA256, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring_algs::RSA_PKCS1_2048_8192_SHA384, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring_algs::RSA_PKCS1_2048_8192_SHA512, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring_algs::RSA_PKCS1_3072_8192_SHA384, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring_algs::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring_algs::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring_algs::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, +]; diff --git a/src/verify_cert.rs b/src/verify_cert.rs index 53531858..48764bef 100644 --- a/src/verify_cert.rs +++ b/src/verify_cert.rs @@ -687,7 +687,6 @@ mod tests { budget: Option, ) -> Result<(), ControlFlow> { use crate::end_entity::EndEntityCert; - use crate::ring_algs::ECDSA_P256_SHA256; use crate::trust_anchor::extract_trust_anchor; use core::time::Duration; @@ -701,7 +700,7 @@ mod tests { ChainOptions { eku: KeyUsage::server_auth(), - supported_sig_algs: &[ECDSA_P256_SHA256], + supported_sig_algs: crate::ALL_VERIFICATION_ALGS, trust_anchors: anchors, intermediate_certs: &intermediates_der, revocation: None, diff --git a/tests/client_auth.rs b/tests/client_auth.rs index 10aeecc4..b9093d95 100644 --- a/tests/client_auth.rs +++ b/tests/client_auth.rs @@ -15,21 +15,9 @@ #![cfg(all(feature = "alloc", feature = "ring"))] use core::time::Duration; -use pki_types::{CertificateDer, SignatureVerificationAlgorithm, UnixTime}; +use pki_types::{CertificateDer, UnixTime}; use webpki::{extract_trust_anchor, KeyUsage}; -static ALL_SIGALGS: &[&dyn SignatureVerificationAlgorithm] = &[ - webpki::ECDSA_P256_SHA256, - webpki::ECDSA_P256_SHA384, - webpki::ECDSA_P384_SHA256, - webpki::ECDSA_P384_SHA384, - webpki::ED25519, - webpki::RSA_PKCS1_2048_8192_SHA256, - webpki::RSA_PKCS1_2048_8192_SHA384, - webpki::RSA_PKCS1_2048_8192_SHA512, - webpki::RSA_PKCS1_3072_8192_SHA384, -]; - fn check_cert(ee: &[u8], ca: &[u8]) -> Result<(), webpki::Error> { let ca = CertificateDer::from(ca); let anchors = &[extract_trust_anchor(&ca).unwrap()]; @@ -38,7 +26,7 @@ fn check_cert(ee: &[u8], ca: &[u8]) -> Result<(), webpki::Error> { let ee = CertificateDer::from(ee); let cert = webpki::EndEntityCert::try_from(&ee).unwrap(); cert.verify_for_usage( - ALL_SIGALGS, + webpki::ALL_VERIFICATION_ALGS, anchors, &[], time, diff --git a/tests/custom_ekus.rs b/tests/custom_ekus.rs index a9e5f2d8..0cc0bbbf 100644 --- a/tests/custom_ekus.rs +++ b/tests/custom_ekus.rs @@ -14,16 +14,19 @@ fn check_cert( ) { let ca = CertificateDer::from(ca); let anchors = [extract_trust_anchor(&ca).unwrap()]; - let algs = &[ - webpki::RSA_PKCS1_2048_8192_SHA256, - webpki::ECDSA_P256_SHA256, - ]; let ee = CertificateDer::from(ee); let cert = webpki::EndEntityCert::try_from(&ee).unwrap(); assert_eq!( - cert.verify_for_usage(algs, &anchors, &[], time, eku, None), + cert.verify_for_usage( + webpki::ALL_VERIFICATION_ALGS, + &anchors, + &[], + time, + eku, + None + ), result ); } diff --git a/tests/integration.rs b/tests/integration.rs index 8234d1af..bc3277bd 100644 --- a/tests/integration.rs +++ b/tests/integration.rs @@ -16,25 +16,9 @@ use core::time::Duration; -use pki_types::{CertificateDer, SignatureVerificationAlgorithm, UnixTime}; +use pki_types::{CertificateDer, UnixTime}; use webpki::{extract_trust_anchor, KeyUsage}; -static ALL_SIGALGS: &[&dyn SignatureVerificationAlgorithm] = &[ - webpki::ECDSA_P256_SHA256, - webpki::ECDSA_P256_SHA384, - webpki::ECDSA_P384_SHA256, - webpki::ECDSA_P384_SHA384, - webpki::ED25519, - #[cfg(feature = "alloc")] - webpki::RSA_PKCS1_2048_8192_SHA256, - #[cfg(feature = "alloc")] - webpki::RSA_PKCS1_2048_8192_SHA384, - #[cfg(feature = "alloc")] - webpki::RSA_PKCS1_2048_8192_SHA512, - #[cfg(feature = "alloc")] - webpki::RSA_PKCS1_3072_8192_SHA384, -]; - /* Checks we can verify netflix's cert chain. This is notable * because they're rooted at a Verisign v1 root. */ #[cfg(feature = "alloc")] @@ -53,7 +37,7 @@ pub fn netflix() { assert_eq!( Ok(()), cert.verify_for_usage( - ALL_SIGALGS, + webpki::ALL_VERIFICATION_ALGS, &anchors, &[inter], time, @@ -81,7 +65,7 @@ pub fn cloudflare_dns() { assert_eq!( Ok(()), cert.verify_for_usage( - ALL_SIGALGS, + webpki::ALL_VERIFICATION_ALGS, &anchors, &[inter], time, @@ -134,7 +118,7 @@ pub fn wpt() { assert_eq!( Ok(()), cert.verify_for_usage( - ALL_SIGALGS, + webpki::ALL_VERIFICATION_ALGS, &anchors, &[], time, @@ -157,7 +141,7 @@ pub fn ed25519() { assert_eq!( Ok(()), cert.verify_for_usage( - ALL_SIGALGS, + webpki::ALL_VERIFICATION_ALGS, &anchors, &[], time, @@ -181,7 +165,7 @@ fn critical_extensions() { ); let res = webpki::EndEntityCert::try_from(&ee).and_then(|cert| { cert.verify_for_usage( - ALL_SIGALGS, + webpki::ALL_VERIFICATION_ALGS, &anchors, &[ca.clone()], time, @@ -196,7 +180,7 @@ fn critical_extensions() { ); let res = webpki::EndEntityCert::try_from(&ee).and_then(|cert| { cert.verify_for_usage( - ALL_SIGALGS, + webpki::ALL_VERIFICATION_ALGS, &anchors, &[ca], time, @@ -237,7 +221,7 @@ fn read_ee_with_neg_serial() { assert_eq!( Ok(()), cert.verify_for_usage( - ALL_SIGALGS, + webpki::ALL_VERIFICATION_ALGS, &anchors, &[], time, diff --git a/tests/tls_server_certs.rs b/tests/tls_server_certs.rs index e01ee8d0..19b1e92e 100644 --- a/tests/tls_server_certs.rs +++ b/tests/tls_server_certs.rs @@ -15,21 +15,9 @@ use core::time::Duration; -use pki_types::{CertificateDer, SignatureVerificationAlgorithm, UnixTime}; +use pki_types::{CertificateDer, UnixTime}; use webpki::{extract_trust_anchor, KeyUsage}; -static ALL_SIGALGS: &[&dyn SignatureVerificationAlgorithm] = &[ - webpki::ECDSA_P256_SHA256, - webpki::ECDSA_P256_SHA384, - webpki::ECDSA_P384_SHA256, - webpki::ECDSA_P384_SHA384, - webpki::ED25519, - webpki::RSA_PKCS1_2048_8192_SHA256, - webpki::RSA_PKCS1_2048_8192_SHA384, - webpki::RSA_PKCS1_2048_8192_SHA512, - webpki::RSA_PKCS1_3072_8192_SHA384, -]; - fn check_cert( ee: &[u8], ca: &[u8], @@ -43,7 +31,7 @@ fn check_cert( let time = UnixTime::since_unix_epoch(Duration::from_secs(0x1fed_f00d)); let cert = webpki::EndEntityCert::try_from(&ee_der).unwrap(); cert.verify_for_usage( - ALL_SIGALGS, + webpki::ALL_VERIFICATION_ALGS, &anchors, &[], time, From bf2d36a2ac0d3373a88a09ef3e3812dc74ef59c8 Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Fri, 15 Sep 2023 13:38:17 +0100 Subject: [PATCH 08/12] tests/signatures.rs: import algorithms at top --- tests/generate.py | 6 +- tests/signatures.rs | 306 ++++++++++++++++---------------------------- 2 files changed, 109 insertions(+), 203 deletions(-) diff --git a/tests/generate.py b/tests/generate.py index 11657ee1..28b3cc12 100755 --- a/tests/generate.py +++ b/tests/generate.py @@ -669,7 +669,7 @@ def _test( let message = include_bytes!("%(message_path)s"); let signature = include_bytes!("%(sig_path)s"); assert_eq!( - check_sig(ee, webpki::%(algorithm)s, message, signature), + check_sig(ee, %(algorithm)s, message, signature), %(expected)s ); }""" @@ -712,9 +712,7 @@ def bad_algorithms_for_key( ) -> None: cert_path: str = _cert_path(cert_type) test_name_lower: str = test_name.lower() - unusable_algs_str: str = ", ".join( - "webpki::" + alg for alg in sorted(unusable_algs) - ) + unusable_algs_str: str = ", ".join(alg for alg in sorted(unusable_algs)) print( """ #[test] diff --git a/tests/signatures.rs b/tests/signatures.rs index d48be991..6a1ec89e 100644 --- a/tests/signatures.rs +++ b/tests/signatures.rs @@ -15,6 +15,16 @@ #![cfg(feature = "ring")] use pki_types::{CertificateDer, SignatureVerificationAlgorithm}; +#[cfg(feature = "ring")] +use webpki::{ + ECDSA_P256_SHA256, ECDSA_P256_SHA384, ECDSA_P384_SHA256, ECDSA_P384_SHA384, ED25519, +}; +#[cfg(all(feature = "ring", feature = "alloc"))] +use webpki::{ + RSA_PKCS1_2048_8192_SHA256, RSA_PKCS1_2048_8192_SHA384, RSA_PKCS1_2048_8192_SHA512, + RSA_PKCS1_3072_8192_SHA384, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + RSA_PSS_2048_8192_SHA384_LEGACY_KEY, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, +}; #[cfg(feature = "alloc")] fn check_sig( @@ -36,7 +46,7 @@ fn ed25519_key_and_ed25519_good_signature() { let ee = include_bytes!("signatures/ed25519.ee.der"); let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/ed25519_key_and_ed25519_good_signature.sig.bin"); - assert_eq!(check_sig(ee, webpki::ED25519, message, signature), Ok(())); + assert_eq!(check_sig(ee, ED25519, message, signature), Ok(())); } #[test] @@ -47,7 +57,7 @@ fn ed25519_key_and_ed25519_detects_bad_signature() { let signature = include_bytes!("signatures/ed25519_key_and_ed25519_detects_bad_signature.sig.bin"); assert_eq!( - check_sig(ee, webpki::ED25519, message, signature), + check_sig(ee, ED25519, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -57,17 +67,17 @@ fn ed25519_key_and_ed25519_detects_bad_signature() { fn ed25519_key_rejected_by_other_algorithms() { let ee = include_bytes!("signatures/ed25519.ee.der"); for algorithm in &[ - webpki::ECDSA_P256_SHA256, - webpki::ECDSA_P256_SHA384, - webpki::ECDSA_P384_SHA256, - webpki::ECDSA_P384_SHA384, - webpki::RSA_PKCS1_2048_8192_SHA256, - webpki::RSA_PKCS1_2048_8192_SHA384, - webpki::RSA_PKCS1_2048_8192_SHA512, - webpki::RSA_PKCS1_3072_8192_SHA384, - webpki::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - webpki::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, - webpki::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, + ECDSA_P256_SHA256, + ECDSA_P256_SHA384, + ECDSA_P384_SHA256, + ECDSA_P384_SHA384, + RSA_PKCS1_2048_8192_SHA256, + RSA_PKCS1_2048_8192_SHA384, + RSA_PKCS1_2048_8192_SHA512, + RSA_PKCS1_3072_8192_SHA384, + RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + RSA_PSS_2048_8192_SHA384_LEGACY_KEY, + RSA_PSS_2048_8192_SHA512_LEGACY_KEY, ] { assert_eq!( check_sig(ee, *algorithm, b"", b""), @@ -83,10 +93,7 @@ fn ecdsa_p256_key_and_ecdsa_p256_sha384_good_signature() { let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/ecdsa_p256_key_and_ecdsa_p256_sha384_good_signature.sig.bin"); - assert_eq!( - check_sig(ee, webpki::ECDSA_P256_SHA384, message, signature), - Ok(()) - ); + assert_eq!(check_sig(ee, ECDSA_P256_SHA384, message, signature), Ok(())); } #[test] @@ -98,7 +105,7 @@ fn ecdsa_p256_key_and_ecdsa_p256_sha384_detects_bad_signature() { "signatures/ecdsa_p256_key_and_ecdsa_p256_sha384_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::ECDSA_P256_SHA384, message, signature), + check_sig(ee, ECDSA_P256_SHA384, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -110,10 +117,7 @@ fn ecdsa_p256_key_and_ecdsa_p256_sha256_good_signature() { let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/ecdsa_p256_key_and_ecdsa_p256_sha256_good_signature.sig.bin"); - assert_eq!( - check_sig(ee, webpki::ECDSA_P256_SHA256, message, signature), - Ok(()) - ); + assert_eq!(check_sig(ee, ECDSA_P256_SHA256, message, signature), Ok(())); } #[test] @@ -125,7 +129,7 @@ fn ecdsa_p256_key_and_ecdsa_p256_sha256_detects_bad_signature() { "signatures/ecdsa_p256_key_and_ecdsa_p256_sha256_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::ECDSA_P256_SHA256, message, signature), + check_sig(ee, ECDSA_P256_SHA256, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -135,16 +139,16 @@ fn ecdsa_p256_key_and_ecdsa_p256_sha256_detects_bad_signature() { fn ecdsa_p256_key_rejected_by_other_algorithms() { let ee = include_bytes!("signatures/ecdsa_p256.ee.der"); for algorithm in &[ - webpki::ECDSA_P384_SHA256, - webpki::ECDSA_P384_SHA384, - webpki::ED25519, - webpki::RSA_PKCS1_2048_8192_SHA256, - webpki::RSA_PKCS1_2048_8192_SHA384, - webpki::RSA_PKCS1_2048_8192_SHA512, - webpki::RSA_PKCS1_3072_8192_SHA384, - webpki::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - webpki::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, - webpki::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, + ECDSA_P384_SHA256, + ECDSA_P384_SHA384, + ED25519, + RSA_PKCS1_2048_8192_SHA256, + RSA_PKCS1_2048_8192_SHA384, + RSA_PKCS1_2048_8192_SHA512, + RSA_PKCS1_3072_8192_SHA384, + RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + RSA_PSS_2048_8192_SHA384_LEGACY_KEY, + RSA_PSS_2048_8192_SHA512_LEGACY_KEY, ] { assert_eq!( check_sig(ee, *algorithm, b"", b""), @@ -160,10 +164,7 @@ fn ecdsa_p384_key_and_ecdsa_p384_sha384_good_signature() { let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/ecdsa_p384_key_and_ecdsa_p384_sha384_good_signature.sig.bin"); - assert_eq!( - check_sig(ee, webpki::ECDSA_P384_SHA384, message, signature), - Ok(()) - ); + assert_eq!(check_sig(ee, ECDSA_P384_SHA384, message, signature), Ok(())); } #[test] @@ -175,7 +176,7 @@ fn ecdsa_p384_key_and_ecdsa_p384_sha384_detects_bad_signature() { "signatures/ecdsa_p384_key_and_ecdsa_p384_sha384_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::ECDSA_P384_SHA384, message, signature), + check_sig(ee, ECDSA_P384_SHA384, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -187,10 +188,7 @@ fn ecdsa_p384_key_and_ecdsa_p384_sha256_good_signature() { let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/ecdsa_p384_key_and_ecdsa_p384_sha256_good_signature.sig.bin"); - assert_eq!( - check_sig(ee, webpki::ECDSA_P384_SHA256, message, signature), - Ok(()) - ); + assert_eq!(check_sig(ee, ECDSA_P384_SHA256, message, signature), Ok(())); } #[test] @@ -202,7 +200,7 @@ fn ecdsa_p384_key_and_ecdsa_p384_sha256_detects_bad_signature() { "signatures/ecdsa_p384_key_and_ecdsa_p384_sha256_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::ECDSA_P384_SHA256, message, signature), + check_sig(ee, ECDSA_P384_SHA256, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -212,16 +210,16 @@ fn ecdsa_p384_key_and_ecdsa_p384_sha256_detects_bad_signature() { fn ecdsa_p384_key_rejected_by_other_algorithms() { let ee = include_bytes!("signatures/ecdsa_p384.ee.der"); for algorithm in &[ - webpki::ECDSA_P256_SHA256, - webpki::ECDSA_P256_SHA384, - webpki::ED25519, - webpki::RSA_PKCS1_2048_8192_SHA256, - webpki::RSA_PKCS1_2048_8192_SHA384, - webpki::RSA_PKCS1_2048_8192_SHA512, - webpki::RSA_PKCS1_3072_8192_SHA384, - webpki::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - webpki::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, - webpki::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, + ECDSA_P256_SHA256, + ECDSA_P256_SHA384, + ED25519, + RSA_PKCS1_2048_8192_SHA256, + RSA_PKCS1_2048_8192_SHA384, + RSA_PKCS1_2048_8192_SHA512, + RSA_PKCS1_3072_8192_SHA384, + RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + RSA_PSS_2048_8192_SHA384_LEGACY_KEY, + RSA_PSS_2048_8192_SHA512_LEGACY_KEY, ] { assert_eq!( check_sig(ee, *algorithm, b"", b""), @@ -239,7 +237,7 @@ fn rsa_2048_key_and_rsa_pkcs1_2048_8192_sha256_good_signature() { "signatures/rsa_2048_key_and_rsa_pkcs1_2048_8192_sha256_good_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA256, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA256, message, signature), Ok(()) ); } @@ -253,7 +251,7 @@ fn rsa_2048_key_and_rsa_pkcs1_2048_8192_sha256_detects_bad_signature() { "signatures/rsa_2048_key_and_rsa_pkcs1_2048_8192_sha256_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA256, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA256, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -267,7 +265,7 @@ fn rsa_2048_key_and_rsa_pkcs1_2048_8192_sha384_good_signature() { "signatures/rsa_2048_key_and_rsa_pkcs1_2048_8192_sha384_good_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA384, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA384, message, signature), Ok(()) ); } @@ -281,7 +279,7 @@ fn rsa_2048_key_and_rsa_pkcs1_2048_8192_sha384_detects_bad_signature() { "signatures/rsa_2048_key_and_rsa_pkcs1_2048_8192_sha384_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA384, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA384, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -295,7 +293,7 @@ fn rsa_2048_key_and_rsa_pkcs1_2048_8192_sha512_good_signature() { "signatures/rsa_2048_key_and_rsa_pkcs1_2048_8192_sha512_good_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA512, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA512, message, signature), Ok(()) ); } @@ -309,7 +307,7 @@ fn rsa_2048_key_and_rsa_pkcs1_2048_8192_sha512_detects_bad_signature() { "signatures/rsa_2048_key_and_rsa_pkcs1_2048_8192_sha512_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA512, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA512, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -323,12 +321,7 @@ fn rsa_2048_key_and_rsa_pss_2048_8192_sha256_legacy_key_good_signature() { "signatures/rsa_2048_key_and_rsa_pss_2048_8192_sha256_legacy_key_good_signature.sig.bin" ); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, message, signature), Ok(()) ); } @@ -340,12 +333,7 @@ fn rsa_2048_key_and_rsa_pss_2048_8192_sha256_legacy_key_detects_bad_signature() let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/rsa_2048_key_and_rsa_pss_2048_8192_sha256_legacy_key_detects_bad_signature.sig.bin"); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -359,12 +347,7 @@ fn rsa_2048_key_and_rsa_pss_2048_8192_sha384_legacy_key_good_signature() { "signatures/rsa_2048_key_and_rsa_pss_2048_8192_sha384_legacy_key_good_signature.sig.bin" ); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA384_LEGACY_KEY, message, signature), Ok(()) ); } @@ -376,12 +359,7 @@ fn rsa_2048_key_and_rsa_pss_2048_8192_sha384_legacy_key_detects_bad_signature() let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/rsa_2048_key_and_rsa_pss_2048_8192_sha384_legacy_key_detects_bad_signature.sig.bin"); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA384_LEGACY_KEY, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -395,12 +373,7 @@ fn rsa_2048_key_and_rsa_pss_2048_8192_sha512_legacy_key_good_signature() { "signatures/rsa_2048_key_and_rsa_pss_2048_8192_sha512_legacy_key_good_signature.sig.bin" ); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, message, signature), Ok(()) ); } @@ -412,12 +385,7 @@ fn rsa_2048_key_and_rsa_pss_2048_8192_sha512_legacy_key_detects_bad_signature() let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/rsa_2048_key_and_rsa_pss_2048_8192_sha512_legacy_key_detects_bad_signature.sig.bin"); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -427,11 +395,11 @@ fn rsa_2048_key_and_rsa_pss_2048_8192_sha512_legacy_key_detects_bad_signature() fn rsa_2048_key_rejected_by_other_algorithms() { let ee = include_bytes!("signatures/rsa_2048.ee.der"); for algorithm in &[ - webpki::ECDSA_P256_SHA256, - webpki::ECDSA_P256_SHA384, - webpki::ECDSA_P384_SHA256, - webpki::ECDSA_P384_SHA384, - webpki::ED25519, + ECDSA_P256_SHA256, + ECDSA_P256_SHA384, + ECDSA_P384_SHA256, + ECDSA_P384_SHA384, + ED25519, ] { assert_eq!( check_sig(ee, *algorithm, b"", b""), @@ -449,7 +417,7 @@ fn rsa_3072_key_and_rsa_pkcs1_2048_8192_sha256_good_signature() { "signatures/rsa_3072_key_and_rsa_pkcs1_2048_8192_sha256_good_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA256, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA256, message, signature), Ok(()) ); } @@ -463,7 +431,7 @@ fn rsa_3072_key_and_rsa_pkcs1_2048_8192_sha256_detects_bad_signature() { "signatures/rsa_3072_key_and_rsa_pkcs1_2048_8192_sha256_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA256, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA256, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -477,7 +445,7 @@ fn rsa_3072_key_and_rsa_pkcs1_2048_8192_sha384_good_signature() { "signatures/rsa_3072_key_and_rsa_pkcs1_2048_8192_sha384_good_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA384, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA384, message, signature), Ok(()) ); } @@ -491,7 +459,7 @@ fn rsa_3072_key_and_rsa_pkcs1_2048_8192_sha384_detects_bad_signature() { "signatures/rsa_3072_key_and_rsa_pkcs1_2048_8192_sha384_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA384, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA384, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -505,7 +473,7 @@ fn rsa_3072_key_and_rsa_pkcs1_2048_8192_sha512_good_signature() { "signatures/rsa_3072_key_and_rsa_pkcs1_2048_8192_sha512_good_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA512, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA512, message, signature), Ok(()) ); } @@ -519,7 +487,7 @@ fn rsa_3072_key_and_rsa_pkcs1_2048_8192_sha512_detects_bad_signature() { "signatures/rsa_3072_key_and_rsa_pkcs1_2048_8192_sha512_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA512, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA512, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -533,12 +501,7 @@ fn rsa_3072_key_and_rsa_pss_2048_8192_sha256_legacy_key_good_signature() { "signatures/rsa_3072_key_and_rsa_pss_2048_8192_sha256_legacy_key_good_signature.sig.bin" ); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, message, signature), Ok(()) ); } @@ -550,12 +513,7 @@ fn rsa_3072_key_and_rsa_pss_2048_8192_sha256_legacy_key_detects_bad_signature() let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/rsa_3072_key_and_rsa_pss_2048_8192_sha256_legacy_key_detects_bad_signature.sig.bin"); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -569,12 +527,7 @@ fn rsa_3072_key_and_rsa_pss_2048_8192_sha384_legacy_key_good_signature() { "signatures/rsa_3072_key_and_rsa_pss_2048_8192_sha384_legacy_key_good_signature.sig.bin" ); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA384_LEGACY_KEY, message, signature), Ok(()) ); } @@ -586,12 +539,7 @@ fn rsa_3072_key_and_rsa_pss_2048_8192_sha384_legacy_key_detects_bad_signature() let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/rsa_3072_key_and_rsa_pss_2048_8192_sha384_legacy_key_detects_bad_signature.sig.bin"); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA384_LEGACY_KEY, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -605,12 +553,7 @@ fn rsa_3072_key_and_rsa_pss_2048_8192_sha512_legacy_key_good_signature() { "signatures/rsa_3072_key_and_rsa_pss_2048_8192_sha512_legacy_key_good_signature.sig.bin" ); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, message, signature), Ok(()) ); } @@ -622,12 +565,7 @@ fn rsa_3072_key_and_rsa_pss_2048_8192_sha512_legacy_key_detects_bad_signature() let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/rsa_3072_key_and_rsa_pss_2048_8192_sha512_legacy_key_detects_bad_signature.sig.bin"); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -641,7 +579,7 @@ fn rsa_3072_key_and_rsa_pkcs1_3072_8192_sha384_good_signature() { "signatures/rsa_3072_key_and_rsa_pkcs1_3072_8192_sha384_good_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_3072_8192_SHA384, message, signature), + check_sig(ee, RSA_PKCS1_3072_8192_SHA384, message, signature), Ok(()) ); } @@ -655,7 +593,7 @@ fn rsa_3072_key_and_rsa_pkcs1_3072_8192_sha384_detects_bad_signature() { "signatures/rsa_3072_key_and_rsa_pkcs1_3072_8192_sha384_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_3072_8192_SHA384, message, signature), + check_sig(ee, RSA_PKCS1_3072_8192_SHA384, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -665,11 +603,11 @@ fn rsa_3072_key_and_rsa_pkcs1_3072_8192_sha384_detects_bad_signature() { fn rsa_3072_key_rejected_by_other_algorithms() { let ee = include_bytes!("signatures/rsa_3072.ee.der"); for algorithm in &[ - webpki::ECDSA_P256_SHA256, - webpki::ECDSA_P256_SHA384, - webpki::ECDSA_P384_SHA256, - webpki::ECDSA_P384_SHA384, - webpki::ED25519, + ECDSA_P256_SHA256, + ECDSA_P256_SHA384, + ECDSA_P384_SHA256, + ECDSA_P384_SHA384, + ED25519, ] { assert_eq!( check_sig(ee, *algorithm, b"", b""), @@ -687,7 +625,7 @@ fn rsa_4096_key_and_rsa_pkcs1_2048_8192_sha256_good_signature() { "signatures/rsa_4096_key_and_rsa_pkcs1_2048_8192_sha256_good_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA256, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA256, message, signature), Ok(()) ); } @@ -701,7 +639,7 @@ fn rsa_4096_key_and_rsa_pkcs1_2048_8192_sha256_detects_bad_signature() { "signatures/rsa_4096_key_and_rsa_pkcs1_2048_8192_sha256_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA256, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA256, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -715,7 +653,7 @@ fn rsa_4096_key_and_rsa_pkcs1_2048_8192_sha384_good_signature() { "signatures/rsa_4096_key_and_rsa_pkcs1_2048_8192_sha384_good_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA384, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA384, message, signature), Ok(()) ); } @@ -729,7 +667,7 @@ fn rsa_4096_key_and_rsa_pkcs1_2048_8192_sha384_detects_bad_signature() { "signatures/rsa_4096_key_and_rsa_pkcs1_2048_8192_sha384_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA384, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA384, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -743,7 +681,7 @@ fn rsa_4096_key_and_rsa_pkcs1_2048_8192_sha512_good_signature() { "signatures/rsa_4096_key_and_rsa_pkcs1_2048_8192_sha512_good_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA512, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA512, message, signature), Ok(()) ); } @@ -757,7 +695,7 @@ fn rsa_4096_key_and_rsa_pkcs1_2048_8192_sha512_detects_bad_signature() { "signatures/rsa_4096_key_and_rsa_pkcs1_2048_8192_sha512_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_2048_8192_SHA512, message, signature), + check_sig(ee, RSA_PKCS1_2048_8192_SHA512, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -771,12 +709,7 @@ fn rsa_4096_key_and_rsa_pss_2048_8192_sha256_legacy_key_good_signature() { "signatures/rsa_4096_key_and_rsa_pss_2048_8192_sha256_legacy_key_good_signature.sig.bin" ); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, message, signature), Ok(()) ); } @@ -788,12 +721,7 @@ fn rsa_4096_key_and_rsa_pss_2048_8192_sha256_legacy_key_detects_bad_signature() let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/rsa_4096_key_and_rsa_pss_2048_8192_sha256_legacy_key_detects_bad_signature.sig.bin"); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -807,12 +735,7 @@ fn rsa_4096_key_and_rsa_pss_2048_8192_sha384_legacy_key_good_signature() { "signatures/rsa_4096_key_and_rsa_pss_2048_8192_sha384_legacy_key_good_signature.sig.bin" ); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA384_LEGACY_KEY, message, signature), Ok(()) ); } @@ -824,12 +747,7 @@ fn rsa_4096_key_and_rsa_pss_2048_8192_sha384_legacy_key_detects_bad_signature() let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/rsa_4096_key_and_rsa_pss_2048_8192_sha384_legacy_key_detects_bad_signature.sig.bin"); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA384_LEGACY_KEY, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -843,12 +761,7 @@ fn rsa_4096_key_and_rsa_pss_2048_8192_sha512_legacy_key_good_signature() { "signatures/rsa_4096_key_and_rsa_pss_2048_8192_sha512_legacy_key_good_signature.sig.bin" ); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, message, signature), Ok(()) ); } @@ -860,12 +773,7 @@ fn rsa_4096_key_and_rsa_pss_2048_8192_sha512_legacy_key_detects_bad_signature() let message = include_bytes!("signatures/message.bin"); let signature = include_bytes!("signatures/rsa_4096_key_and_rsa_pss_2048_8192_sha512_legacy_key_detects_bad_signature.sig.bin"); assert_eq!( - check_sig( - ee, - webpki::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, - message, - signature - ), + check_sig(ee, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -879,7 +787,7 @@ fn rsa_4096_key_and_rsa_pkcs1_3072_8192_sha384_good_signature() { "signatures/rsa_4096_key_and_rsa_pkcs1_3072_8192_sha384_good_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_3072_8192_SHA384, message, signature), + check_sig(ee, RSA_PKCS1_3072_8192_SHA384, message, signature), Ok(()) ); } @@ -893,7 +801,7 @@ fn rsa_4096_key_and_rsa_pkcs1_3072_8192_sha384_detects_bad_signature() { "signatures/rsa_4096_key_and_rsa_pkcs1_3072_8192_sha384_detects_bad_signature.sig.bin" ); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_3072_8192_SHA384, message, signature), + check_sig(ee, RSA_PKCS1_3072_8192_SHA384, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } @@ -903,11 +811,11 @@ fn rsa_4096_key_and_rsa_pkcs1_3072_8192_sha384_detects_bad_signature() { fn rsa_4096_key_rejected_by_other_algorithms() { let ee = include_bytes!("signatures/rsa_4096.ee.der"); for algorithm in &[ - webpki::ECDSA_P256_SHA256, - webpki::ECDSA_P256_SHA384, - webpki::ECDSA_P384_SHA256, - webpki::ECDSA_P384_SHA384, - webpki::ED25519, + ECDSA_P256_SHA256, + ECDSA_P256_SHA384, + ECDSA_P384_SHA256, + ECDSA_P384_SHA384, + ED25519, ] { assert_eq!( check_sig(ee, *algorithm, b"", b""), @@ -924,7 +832,7 @@ fn rsa_2048_key_rejected_by_rsa_pkcs1_3072_8192_sha384() { let signature = include_bytes!("signatures/rsa_2048_key_rejected_by_rsa_pkcs1_3072_8192_sha384.sig.bin"); assert_eq!( - check_sig(ee, webpki::RSA_PKCS1_3072_8192_SHA384, message, signature), + check_sig(ee, RSA_PKCS1_3072_8192_SHA384, message, signature), Err(webpki::Error::InvalidSignatureForPublicKey) ); } From eaed18c1be9b4e749d80fdf745d1da505595cd20 Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Wed, 30 Aug 2023 10:46:37 +0100 Subject: [PATCH 09/12] Export *ring*-backed signature algorithms in crate::ring. This is a breaking change -- previously these were in the crate root. This is necessary to keep crate features additive: the `ring` crate feature provides this set of items. --- src/lib.rs | 45 ++++++++++++++++++--------------- tests/better_tls.rs | 2 +- tests/client_auth_revocation.rs | 2 +- tests/signatures.rs | 4 +-- 4 files changed, 28 insertions(+), 25 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 63d3a7ac..0c268df4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -90,43 +90,46 @@ pub use { }; #[cfg(feature = "ring")] -pub use ring_algs::{ - ECDSA_P256_SHA256, ECDSA_P256_SHA384, ECDSA_P384_SHA256, ECDSA_P384_SHA384, ED25519, -}; +/// Signature verification algorithm implementations using the *ring* crypto library. +pub mod ring { + pub use super::ring_algs::{ + ECDSA_P256_SHA256, ECDSA_P256_SHA384, ECDSA_P384_SHA256, ECDSA_P384_SHA384, ED25519, + }; -#[cfg(all(feature = "ring", feature = "alloc"))] -pub use ring_algs::{ - RSA_PKCS1_2048_8192_SHA256, RSA_PKCS1_2048_8192_SHA384, RSA_PKCS1_2048_8192_SHA512, - RSA_PKCS1_3072_8192_SHA384, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, - RSA_PSS_2048_8192_SHA384_LEGACY_KEY, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, -}; + #[cfg(feature = "alloc")] + pub use super::ring_algs::{ + RSA_PKCS1_2048_8192_SHA256, RSA_PKCS1_2048_8192_SHA384, RSA_PKCS1_2048_8192_SHA512, + RSA_PKCS1_3072_8192_SHA384, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + RSA_PSS_2048_8192_SHA384_LEGACY_KEY, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, + }; +} /// An array of all the verification algorithms exported by this crate. /// /// This will be empty if the crate is built without the `ring` feature. pub static ALL_VERIFICATION_ALGS: &[&dyn types::SignatureVerificationAlgorithm] = &[ #[cfg(feature = "ring")] - ring_algs::ECDSA_P256_SHA256, + ring::ECDSA_P256_SHA256, #[cfg(feature = "ring")] - ring_algs::ECDSA_P256_SHA384, + ring::ECDSA_P256_SHA384, #[cfg(feature = "ring")] - ring_algs::ECDSA_P384_SHA256, + ring::ECDSA_P384_SHA256, #[cfg(feature = "ring")] - ring_algs::ECDSA_P384_SHA384, + ring::ECDSA_P384_SHA384, #[cfg(feature = "ring")] - ring_algs::ED25519, + ring::ED25519, #[cfg(all(feature = "ring", feature = "alloc"))] - ring_algs::RSA_PKCS1_2048_8192_SHA256, + ring::RSA_PKCS1_2048_8192_SHA256, #[cfg(all(feature = "ring", feature = "alloc"))] - ring_algs::RSA_PKCS1_2048_8192_SHA384, + ring::RSA_PKCS1_2048_8192_SHA384, #[cfg(all(feature = "ring", feature = "alloc"))] - ring_algs::RSA_PKCS1_2048_8192_SHA512, + ring::RSA_PKCS1_2048_8192_SHA512, #[cfg(all(feature = "ring", feature = "alloc"))] - ring_algs::RSA_PKCS1_3072_8192_SHA384, + ring::RSA_PKCS1_3072_8192_SHA384, #[cfg(all(feature = "ring", feature = "alloc"))] - ring_algs::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + ring::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, #[cfg(all(feature = "ring", feature = "alloc"))] - ring_algs::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, + ring::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, #[cfg(all(feature = "ring", feature = "alloc"))] - ring_algs::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, + ring::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, ]; diff --git a/tests/better_tls.rs b/tests/better_tls.rs index 616d93e0..fa6466dd 100644 --- a/tests/better_tls.rs +++ b/tests/better_tls.rs @@ -69,7 +69,7 @@ fn run_testsuite(suite_name: &str, suite: &BetterTlsSuite, roots: &[TrustAnchor] let result = ee_cert .verify_for_usage( - &[webpki::ECDSA_P256_SHA256], // All of the BetterTLS testcases use P256 keys. + &[webpki::ring::ECDSA_P256_SHA256], // All of the BetterTLS testcases use P256 keys. roots, intermediates, now, diff --git a/tests/client_auth_revocation.rs b/tests/client_auth_revocation.rs index f0efc6b8..ae37b4d7 100644 --- a/tests/client_auth_revocation.rs +++ b/tests/client_auth_revocation.rs @@ -39,7 +39,7 @@ fn check_cert( .collect::>(); cert.verify_for_usage( - &[webpki::ECDSA_P256_SHA256], + &[webpki::ring::ECDSA_P256_SHA256], anchors, &intermediates, time, diff --git a/tests/signatures.rs b/tests/signatures.rs index 6a1ec89e..d2faf042 100644 --- a/tests/signatures.rs +++ b/tests/signatures.rs @@ -16,11 +16,11 @@ use pki_types::{CertificateDer, SignatureVerificationAlgorithm}; #[cfg(feature = "ring")] -use webpki::{ +use webpki::ring::{ ECDSA_P256_SHA256, ECDSA_P256_SHA384, ECDSA_P384_SHA256, ECDSA_P384_SHA384, ED25519, }; #[cfg(all(feature = "ring", feature = "alloc"))] -use webpki::{ +use webpki::ring::{ RSA_PKCS1_2048_8192_SHA256, RSA_PKCS1_2048_8192_SHA384, RSA_PKCS1_2048_8192_SHA512, RSA_PKCS1_3072_8192_SHA384, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, RSA_PSS_2048_8192_SHA384_LEGACY_KEY, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, From 8890ddca7157feafa7e7936fdd63848f32723b7d Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Wed, 30 Aug 2023 10:26:46 +0100 Subject: [PATCH 10/12] Add aws-lc-rs as optional dependency Export SignatureVerificationAlgorithms backed by it in webpki::aws_lc_rs --- Cargo.toml | 5 +- src/alg_tests.rs | 2 + src/aws_lc_rs_algs.rs | 164 ++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 40 ++++++++++- 4 files changed, 209 insertions(+), 2 deletions(-) create mode 100644 src/aws_lc_rs_algs.rs diff --git a/Cargo.toml b/Cargo.toml index cd8a89d4..25ab1aa6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -29,6 +29,7 @@ include = [ "/LICENSE", "README.md", + "src/aws_lc_rs_algs.rs", "src/calendar.rs", "src/cert.rs", "src/crl/mod.rs", @@ -66,11 +67,13 @@ name = "webpki" [features] default = ["std", "ring"] -ring = ["dep:ring"] alloc = ["ring?/alloc", "pki-types/alloc"] +aws_lc_rs = ["dep:aws-lc-rs"] +ring = ["dep:ring"] std = ["alloc"] [dependencies] +aws-lc-rs = { version = "1.0.0", optional = true } pki-types = { package = "rustls-pki-types", version = "0.2.1", default-features = false } ring = { version = "0.16.19", default-features = false, optional = true } untrusted = "0.7.1" diff --git a/src/alg_tests.rs b/src/alg_tests.rs index 8fe988a4..adfe6a74 100644 --- a/src/alg_tests.rs +++ b/src/alg_tests.rs @@ -12,6 +12,8 @@ // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +#![allow(clippy::duplicate_mod)] + use base64::{engine::general_purpose, Engine as _}; use crate::error::{DerTypeId, Error}; diff --git a/src/aws_lc_rs_algs.rs b/src/aws_lc_rs_algs.rs new file mode 100644 index 00000000..3c2989d2 --- /dev/null +++ b/src/aws_lc_rs_algs.rs @@ -0,0 +1,164 @@ +use aws_lc_rs::signature; +use pki_types::{AlgorithmIdentifier, InvalidSignature, SignatureVerificationAlgorithm}; + +use crate::signed_data::alg_id; + +// nb. aws-lc-rs has an API that is broadly compatible with *ring*, +// so this is very similar to ring_algs.rs. + +/// A `SignatureVerificationAlgorithm` implemented using aws-lc-rs. +struct AwsLcRsAlgorithm { + public_key_alg_id: AlgorithmIdentifier, + signature_alg_id: AlgorithmIdentifier, + verification_alg: &'static dyn signature::VerificationAlgorithm, +} + +impl SignatureVerificationAlgorithm for AwsLcRsAlgorithm { + fn public_key_alg_id(&self) -> AlgorithmIdentifier { + self.public_key_alg_id + } + + fn signature_alg_id(&self) -> AlgorithmIdentifier { + self.signature_alg_id + } + + fn verify_signature( + &self, + public_key: &[u8], + message: &[u8], + signature: &[u8], + ) -> Result<(), InvalidSignature> { + signature::UnparsedPublicKey::new(self.verification_alg, public_key) + .verify(message, signature) + .map_err(|_| InvalidSignature) + } +} + +/// ECDSA signatures using the P-256 curve and SHA-256. +pub static ECDSA_P256_SHA256: &dyn SignatureVerificationAlgorithm = &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::ECDSA_P256, + signature_alg_id: alg_id::ECDSA_SHA256, + verification_alg: &signature::ECDSA_P256_SHA256_ASN1, +}; + +/// ECDSA signatures using the P-256 curve and SHA-384. Deprecated. +pub static ECDSA_P256_SHA384: &dyn SignatureVerificationAlgorithm = &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::ECDSA_P256, + signature_alg_id: alg_id::ECDSA_SHA384, + verification_alg: &signature::ECDSA_P256_SHA384_ASN1, +}; + +/// ECDSA signatures using the P-384 curve and SHA-256. Deprecated. +pub static ECDSA_P384_SHA256: &dyn SignatureVerificationAlgorithm = &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::ECDSA_P384, + signature_alg_id: alg_id::ECDSA_SHA256, + verification_alg: &signature::ECDSA_P384_SHA256_ASN1, +}; + +/// ECDSA signatures using the P-384 curve and SHA-384. +pub static ECDSA_P384_SHA384: &dyn SignatureVerificationAlgorithm = &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::ECDSA_P384, + signature_alg_id: alg_id::ECDSA_SHA384, + verification_alg: &signature::ECDSA_P384_SHA384_ASN1, +}; + +/// RSA PKCS#1 1.5 signatures using SHA-256 for keys of 2048-8192 bits. +pub static RSA_PKCS1_2048_8192_SHA256: &dyn SignatureVerificationAlgorithm = &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::RSA_ENCRYPTION, + signature_alg_id: alg_id::RSA_PKCS1_SHA256, + verification_alg: &signature::RSA_PKCS1_2048_8192_SHA256, +}; + +/// RSA PKCS#1 1.5 signatures using SHA-384 for keys of 2048-8192 bits. +pub static RSA_PKCS1_2048_8192_SHA384: &dyn SignatureVerificationAlgorithm = &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::RSA_ENCRYPTION, + signature_alg_id: alg_id::RSA_PKCS1_SHA384, + verification_alg: &signature::RSA_PKCS1_2048_8192_SHA384, +}; + +/// RSA PKCS#1 1.5 signatures using SHA-512 for keys of 2048-8192 bits. +pub static RSA_PKCS1_2048_8192_SHA512: &dyn SignatureVerificationAlgorithm = &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::RSA_ENCRYPTION, + signature_alg_id: alg_id::RSA_PKCS1_SHA512, + verification_alg: &signature::RSA_PKCS1_2048_8192_SHA512, +}; + +/// RSA PKCS#1 1.5 signatures using SHA-384 for keys of 3072-8192 bits. +pub static RSA_PKCS1_3072_8192_SHA384: &dyn SignatureVerificationAlgorithm = &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::RSA_ENCRYPTION, + signature_alg_id: alg_id::RSA_PKCS1_SHA384, + verification_alg: &signature::RSA_PKCS1_3072_8192_SHA384, +}; + +/// RSA PSS signatures using SHA-256 for keys of 2048-8192 bits and of +/// type rsaEncryption; see [RFC 4055 Section 1.2]. +/// +/// [RFC 4055 Section 1.2]: https://tools.ietf.org/html/rfc4055#section-1.2 +pub static RSA_PSS_2048_8192_SHA256_LEGACY_KEY: &dyn SignatureVerificationAlgorithm = + &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::RSA_ENCRYPTION, + signature_alg_id: alg_id::RSA_PSS_SHA256, + verification_alg: &signature::RSA_PSS_2048_8192_SHA256, + }; + +/// RSA PSS signatures using SHA-384 for keys of 2048-8192 bits and of +/// type rsaEncryption; see [RFC 4055 Section 1.2]. +/// +/// [RFC 4055 Section 1.2]: https://tools.ietf.org/html/rfc4055#section-1.2 +pub static RSA_PSS_2048_8192_SHA384_LEGACY_KEY: &dyn SignatureVerificationAlgorithm = + &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::RSA_ENCRYPTION, + signature_alg_id: alg_id::RSA_PSS_SHA384, + verification_alg: &signature::RSA_PSS_2048_8192_SHA384, + }; + +/// RSA PSS signatures using SHA-512 for keys of 2048-8192 bits and of +/// type rsaEncryption; see [RFC 4055 Section 1.2]. +/// +/// [RFC 4055 Section 1.2]: https://tools.ietf.org/html/rfc4055#section-1.2 +pub static RSA_PSS_2048_8192_SHA512_LEGACY_KEY: &dyn SignatureVerificationAlgorithm = + &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::RSA_ENCRYPTION, + signature_alg_id: alg_id::RSA_PSS_SHA512, + verification_alg: &signature::RSA_PSS_2048_8192_SHA512, + }; + +/// ED25519 signatures according to RFC 8410 +pub static ED25519: &dyn SignatureVerificationAlgorithm = &AwsLcRsAlgorithm { + public_key_alg_id: alg_id::ED25519, + signature_alg_id: alg_id::ED25519, + verification_alg: &signature::ED25519, +}; + +#[cfg(test)] +#[path = "."] +mod tests { + use crate::Error; + + static SUPPORTED_ALGORITHMS_IN_TESTS: &[&dyn super::SignatureVerificationAlgorithm] = &[ + // Reasonable algorithms. + super::ECDSA_P256_SHA256, + super::ECDSA_P384_SHA384, + super::ED25519, + super::RSA_PKCS1_2048_8192_SHA256, + super::RSA_PKCS1_2048_8192_SHA384, + super::RSA_PKCS1_2048_8192_SHA512, + super::RSA_PKCS1_3072_8192_SHA384, + super::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + super::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, + super::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, + // Algorithms deprecated because they are nonsensical combinations. + super::ECDSA_P256_SHA384, // Truncates digest. + super::ECDSA_P384_SHA256, // Digest is unnecessarily short. + ]; + + const UNSUPPORTED_SIGNATURE_ALGORITHM_FOR_RSA_KEY: Error = + Error::UnsupportedSignatureAlgorithmForPublicKey; + + const INVALID_SIGNATURE_FOR_RSA_KEY: Error = Error::InvalidSignatureForPublicKey; + + const OK_IF_RSA_AVAILABLE: Result<(), Error> = Ok(()); + + #[path = "alg_tests.rs"] + mod alg_tests; +} diff --git a/src/lib.rs b/src/lib.rs index 0c268df4..2218798f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -24,6 +24,7 @@ //! | `alloc` | Enable features that require use of the heap. Currently all RSA signature algorithms require this feature. | //! | `std` | Enable features that require libstd. Implies `alloc`. | //! | `ring` | Enable use of the *ring* crate for cryptography. | +//! | `aws_lc_rs` | Enable use of the aws-lc-rs crate for cryptography. | #![cfg_attr(not(feature = "std"), no_std)] #![warn(unreachable_pub)] @@ -46,6 +47,8 @@ extern crate alloc; #[macro_use] mod der; +#[cfg(feature = "aws_lc_rs")] +mod aws_lc_rs_algs; mod cert; mod end_entity; mod error; @@ -104,9 +107,20 @@ pub mod ring { }; } +#[cfg(feature = "aws_lc_rs")] +/// Signature verification algorithm implementations using the aws-lc-rs crypto library. +pub mod aws_lc_rs { + pub use super::aws_lc_rs_algs::{ + ECDSA_P256_SHA256, ECDSA_P256_SHA384, ECDSA_P384_SHA256, ECDSA_P384_SHA384, ED25519, + RSA_PKCS1_2048_8192_SHA256, RSA_PKCS1_2048_8192_SHA384, RSA_PKCS1_2048_8192_SHA512, + RSA_PKCS1_3072_8192_SHA384, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + RSA_PSS_2048_8192_SHA384_LEGACY_KEY, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, + }; +} + /// An array of all the verification algorithms exported by this crate. /// -/// This will be empty if the crate is built without the `ring` feature. +/// This will be empty if the crate is built without the `ring` and `aws_lc_rs` features. pub static ALL_VERIFICATION_ALGS: &[&dyn types::SignatureVerificationAlgorithm] = &[ #[cfg(feature = "ring")] ring::ECDSA_P256_SHA256, @@ -132,4 +146,28 @@ pub static ALL_VERIFICATION_ALGS: &[&dyn types::SignatureVerificationAlgorithm] ring::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, #[cfg(all(feature = "ring", feature = "alloc"))] ring::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::ECDSA_P256_SHA256, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::ECDSA_P256_SHA384, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::ECDSA_P384_SHA256, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::ECDSA_P384_SHA384, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::ED25519, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::RSA_PKCS1_2048_8192_SHA256, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::RSA_PKCS1_2048_8192_SHA384, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::RSA_PKCS1_2048_8192_SHA512, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::RSA_PKCS1_3072_8192_SHA384, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::RSA_PSS_2048_8192_SHA384_LEGACY_KEY, + #[cfg(feature = "aws_lc_rs")] + aws_lc_rs::RSA_PSS_2048_8192_SHA512_LEGACY_KEY, ]; From 3e672aea7b480704a7417fcfe70ea1bf61a8d1e5 Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Wed, 20 Sep 2023 10:49:47 +0100 Subject: [PATCH 11/12] Enable test coverage with aws-lc-rs When run with --feature aws_lc_rs but not --feature ring, use aws-lc-rs to run the same set of tests. --- src/verify_cert.rs | 2 +- tests/better_tls.rs | 14 +++++++++++--- tests/client_auth.rs | 2 +- tests/client_auth_revocation.rs | 13 ++++++++++--- tests/custom_ekus.rs | 2 +- tests/integration.rs | 2 +- tests/signatures.rs | 10 +++++++++- tests/tls_server_certs.rs | 2 +- 8 files changed, 35 insertions(+), 12 deletions(-) diff --git a/src/verify_cert.rs b/src/verify_cert.rs index 48764bef..8959ed74 100644 --- a/src/verify_cert.rs +++ b/src/verify_cert.rs @@ -495,7 +495,7 @@ enum Role { EndEntity, } -#[cfg(all(test, feature = "alloc", feature = "ring"))] +#[cfg(all(test, feature = "alloc", any(feature = "ring", feature = "aws_lc_rs")))] mod tests { use super::*; use crate::test_utils::{issuer_params, make_end_entity, make_issuer}; diff --git a/tests/better_tls.rs b/tests/better_tls.rs index fa6466dd..63febf93 100644 --- a/tests/better_tls.rs +++ b/tests/better_tls.rs @@ -1,4 +1,4 @@ -#![cfg(feature = "ring")] +#![cfg(any(feature = "ring", feature = "aws_lc_rs"))] use core::time::Duration; use std::collections::HashMap; @@ -9,9 +9,17 @@ use bzip2::read::BzDecoder; use pki_types::UnixTime; use serde::Deserialize; -use webpki::types::{CertificateDer, TrustAnchor}; +use webpki::types::{CertificateDer, SignatureVerificationAlgorithm, TrustAnchor}; use webpki::{extract_trust_anchor, KeyUsage, SubjectNameRef}; +// All of the BetterTLS testcases use P256 keys. +static ALGS: &[&dyn SignatureVerificationAlgorithm] = &[ + #[cfg(feature = "ring")] + webpki::ring::ECDSA_P256_SHA256, + #[cfg(feature = "aws_lc_rs")] + webpki::aws_lc_rs::ECDSA_P256_SHA256, +]; + #[ignore] // Runs slower than other unit tests - opt-in with `cargo test -- --ignored` #[test] fn path_building() { @@ -69,7 +77,7 @@ fn run_testsuite(suite_name: &str, suite: &BetterTlsSuite, roots: &[TrustAnchor] let result = ee_cert .verify_for_usage( - &[webpki::ring::ECDSA_P256_SHA256], // All of the BetterTLS testcases use P256 keys. + ALGS, roots, intermediates, now, diff --git a/tests/client_auth.rs b/tests/client_auth.rs index b9093d95..f1fe842c 100644 --- a/tests/client_auth.rs +++ b/tests/client_auth.rs @@ -12,7 +12,7 @@ // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -#![cfg(all(feature = "alloc", feature = "ring"))] +#![cfg(all(feature = "alloc", any(feature = "ring", feature = "aws_lc_rs")))] use core::time::Duration; use pki_types::{CertificateDer, UnixTime}; diff --git a/tests/client_auth_revocation.rs b/tests/client_auth_revocation.rs index ae37b4d7..504d5c0d 100644 --- a/tests/client_auth_revocation.rs +++ b/tests/client_auth_revocation.rs @@ -12,16 +12,23 @@ // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -#![cfg(feature = "ring")] +#![cfg(any(feature = "ring", feature = "aws_lc_rs"))] use core::time::Duration; -use pki_types::{CertificateDer, UnixTime}; +use pki_types::{CertificateDer, SignatureVerificationAlgorithm, UnixTime}; use webpki::{ extract_trust_anchor, KeyUsage, RevocationCheckDepth, RevocationOptions, RevocationOptionsBuilder, }; +static ALGS: &[&dyn SignatureVerificationAlgorithm] = &[ + #[cfg(feature = "ring")] + webpki::ring::ECDSA_P256_SHA256, + #[cfg(feature = "aws_lc_rs")] + webpki::aws_lc_rs::ECDSA_P256_SHA256, +]; + fn check_cert( ee: &[u8], intermediates: &[&[u8]], @@ -39,7 +46,7 @@ fn check_cert( .collect::>(); cert.verify_for_usage( - &[webpki::ring::ECDSA_P256_SHA256], + ALGS, anchors, &intermediates, time, diff --git a/tests/custom_ekus.rs b/tests/custom_ekus.rs index 0cc0bbbf..0a485089 100644 --- a/tests/custom_ekus.rs +++ b/tests/custom_ekus.rs @@ -1,4 +1,4 @@ -#![cfg(all(feature = "alloc", feature = "ring"))] +#![cfg(all(feature = "alloc", any(feature = "ring", feature = "aws_lc_rs")))] use core::time::Duration; diff --git a/tests/integration.rs b/tests/integration.rs index bc3277bd..e9d3d76a 100644 --- a/tests/integration.rs +++ b/tests/integration.rs @@ -12,7 +12,7 @@ // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -#![cfg(feature = "ring")] +#![cfg(any(feature = "ring", feature = "aws_lc_rs"))] use core::time::Duration; diff --git a/tests/signatures.rs b/tests/signatures.rs index d2faf042..dd993f5d 100644 --- a/tests/signatures.rs +++ b/tests/signatures.rs @@ -12,7 +12,7 @@ // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -#![cfg(feature = "ring")] +#![cfg(any(feature = "ring", feature = "aws_lc_rs"))] use pki_types::{CertificateDer, SignatureVerificationAlgorithm}; #[cfg(feature = "ring")] @@ -26,6 +26,14 @@ use webpki::ring::{ RSA_PSS_2048_8192_SHA384_LEGACY_KEY, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, }; +#[cfg(all(not(feature = "ring"), feature = "aws_lc_rs"))] +use webpki::aws_lc_rs::{ + ECDSA_P256_SHA256, ECDSA_P256_SHA384, ECDSA_P384_SHA256, ECDSA_P384_SHA384, ED25519, + RSA_PKCS1_2048_8192_SHA256, RSA_PKCS1_2048_8192_SHA384, RSA_PKCS1_2048_8192_SHA512, + RSA_PKCS1_3072_8192_SHA384, RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + RSA_PSS_2048_8192_SHA384_LEGACY_KEY, RSA_PSS_2048_8192_SHA512_LEGACY_KEY, +}; + #[cfg(feature = "alloc")] fn check_sig( ee: &[u8], diff --git a/tests/tls_server_certs.rs b/tests/tls_server_certs.rs index 19b1e92e..448b633a 100644 --- a/tests/tls_server_certs.rs +++ b/tests/tls_server_certs.rs @@ -11,7 +11,7 @@ // 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. -#![cfg(all(feature = "alloc", feature = "ring"))] +#![cfg(all(feature = "alloc", any(feature = "ring", feature = "aws_lc_rs")))] use core::time::Duration; From 45b74d08ef45da79f9ec849cb2ebd8ef76e2745f Mon Sep 17 00:00:00 2001 From: Joseph Birr-Pixton Date: Wed, 20 Sep 2023 10:52:34 +0100 Subject: [PATCH 12/12] Exercise aws-lc-rs in CI - ensure `cargo package` works with --all-features, otherwise optional modules could be missing from the list in Cargo.toml. - install nasm on windows for aws-lc-rs - run tests against aws-lc-rs on all platforms --- .github/workflows/ci.yml | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5e22b2ad..8d08e691 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,7 +99,7 @@ jobs: - name: Install rust toolchain uses: dtolnay/rust-toolchain@stable - - run: cargo package + - run: cargo package --all-features test: name: Build+test @@ -111,6 +111,7 @@ jobs: - --features=alloc - --all-features - --no-default-features + - --no-default-features --features alloc,std,aws_lc_rs mode: - # debug @@ -126,6 +127,7 @@ jobs: - features: --features=alloc - features: --no-default-features - features: --no-default-features --features alloc,std + - features: --no-default-features --features alloc,std,aws_lc_rs - features: --all-features mode: --release - features: --all-features @@ -185,6 +187,23 @@ jobs: mode: # debug rust_channel: stable host_os: ubuntu-latest + + # check aws-lc-rs alone + - features: --no-default-features --features alloc,std,aws_lc_rs + mode: # debug + rust_channel: stable + host_os: macos-latest + + - features: --no-default-features --features alloc,std,aws_lc_rs + mode: # debug + rust_channel: stable + host_os: windows-latest + + - features: --no-default-features --features alloc,std,aws_lc_rs + mode: # debug + rust_channel: stable + host_os: ubuntu-latest + steps: - name: Checkout sources uses: actions/checkout@v4 @@ -196,6 +215,10 @@ jobs: with: toolchain: ${{ matrix.rust_channel }} + - name: Install NASM for aws-lc-rs on Windows + if: runner.os == 'Windows' + uses: ilammy/setup-nasm@v1 + - name: cargo test (${{ matrix.mode }}, ${{ matrix.features }}) run: cargo test -vv ${{ matrix.features }} ${{ matrix.mode }} -- --ignored env: