diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e65d1099..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 @@ -125,6 +126,8 @@ jobs: - features: # Default - 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 @@ -150,6 +153,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 @@ -179,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 @@ -190,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: diff --git a/Cargo.toml b/Cargo.toml index 87667942..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", @@ -45,6 +46,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", @@ -65,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 new file mode 100644 index 00000000..adfe6a74 --- /dev/null +++ b/src/alg_tests.rs @@ -0,0 +1,391 @@ +// 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. + +#![allow(clippy::duplicate_mod)] + +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}; + +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!( + "../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) + }) + ); +} + +// 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() +} 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 6f2b8c35..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; @@ -90,13 +93,81 @@ 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, + }; +} + +#[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` and `aws_lc_rs` features. +pub static ALL_VERIFICATION_ALGS: &[&dyn types::SignatureVerificationAlgorithm] = &[ + #[cfg(feature = "ring")] + ring::ECDSA_P256_SHA256, + #[cfg(feature = "ring")] + ring::ECDSA_P256_SHA384, + #[cfg(feature = "ring")] + ring::ECDSA_P384_SHA256, + #[cfg(feature = "ring")] + ring::ECDSA_P384_SHA384, + #[cfg(feature = "ring")] + ring::ED25519, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring::RSA_PKCS1_2048_8192_SHA256, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring::RSA_PKCS1_2048_8192_SHA384, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring::RSA_PKCS1_2048_8192_SHA512, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring::RSA_PKCS1_3072_8192_SHA384, + #[cfg(all(feature = "ring", feature = "alloc"))] + ring::RSA_PSS_2048_8192_SHA256_LEGACY_KEY, + #[cfg(all(feature = "ring", feature = "alloc"))] + 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, +]; diff --git a/src/ring_algs.rs b/src/ring_algs.rs index 2fa04f17..427d36d7 100644 --- a/src/ring_algs.rs +++ b/src/ring_algs.rs @@ -149,398 +149,9 @@ pub static ED25519: &dyn SignatureVerificationAlgorithm = &RingAlgorithm { }; #[cfg(test)] +#[path = "."] 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() - } + use crate::Error; static SUPPORTED_ALGORITHMS_IN_TESTS: &[&dyn super::SignatureVerificationAlgorithm] = &[ // Reasonable algorithms. @@ -565,4 +176,25 @@ mod tests { 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; } 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()])) diff --git a/src/verify_cert.rs b/src/verify_cert.rs index da563f32..8959ed74 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", any(feature = "ring", feature = "aws_lc_rs")))] 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], @@ -696,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; @@ -710,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/better_tls.rs b/tests/better_tls.rs index 616d93e0..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::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 0a3695be..f1fe842c 100644 --- a/tests/client_auth.rs +++ b/tests/client_auth.rs @@ -12,24 +12,12 @@ // 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", any(feature = "ring", feature = "aws_lc_rs")))] 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/client_auth_revocation.rs b/tests/client_auth_revocation.rs index f0efc6b8..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::ECDSA_P256_SHA256], + ALGS, anchors, &intermediates, time, diff --git a/tests/custom_ekus.rs b/tests/custom_ekus.rs index a9e5f2d8..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; @@ -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/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/integration.rs b/tests/integration.rs index 8234d1af..e9d3d76a 100644 --- a/tests/integration.rs +++ b/tests/integration.rs @@ -12,29 +12,13 @@ // 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, 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/signatures.rs b/tests/signatures.rs index d48be991..dd993f5d 100644 --- a/tests/signatures.rs +++ b/tests/signatures.rs @@ -12,9 +12,27 @@ // 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")] +use webpki::ring::{ + ECDSA_P256_SHA256, ECDSA_P256_SHA384, ECDSA_P384_SHA256, ECDSA_P384_SHA384, ED25519, +}; +#[cfg(all(feature = "ring", feature = "alloc"))] +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, +}; + +#[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( @@ -36,7 +54,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 +65,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 +75,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 +101,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 +113,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 +125,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 +137,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 +147,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 +172,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 +184,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 +196,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 +208,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 +218,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 +245,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 +259,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 +273,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 +287,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 +301,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 +315,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 +329,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 +341,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 +355,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 +367,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 +381,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 +393,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 +403,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 +425,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 +439,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 +453,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 +467,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 +481,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 +495,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 +509,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 +521,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 +535,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 +547,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 +561,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 +573,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 +587,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 +601,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 +611,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 +633,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 +647,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 +661,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 +675,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 +689,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 +703,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 +717,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 +729,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 +743,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 +755,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 +769,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 +781,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 +795,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 +809,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 +819,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 +840,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) ); } diff --git a/tests/tls_server_certs.rs b/tests/tls_server_certs.rs index 00000bf2..448b633a 100644 --- a/tests/tls_server_certs.rs +++ b/tests/tls_server_certs.rs @@ -11,25 +11,13 @@ // 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", any(feature = "ring", feature = "aws_lc_rs")))] 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,