642d5a256791
rsa_pss_parameters.rs
use craft_anything_formats::{der, pkcs7, verify};
use craft_anything_testkit::{
android::{der as tlv, der_oid},
crypto,
};
use rsa::{
RsaPrivateKey, RsaPublicKey,
pkcs8::EncodePublicKey,
signature::{RandomizedSigner, SignatureEncoding},
};
use std::sync::OnceLock;
const PSS: &str = "1.2.840.113549.1.1.10";
const SHA256: &str = "2.16.840.1.101.3.4.2.1";
const SHA384: &str = "2.16.840.1.101.3.4.2.2";
const SHA512: &str = "2.16.840.1.101.3.4.2.3";
fn key() -> &'static RsaPrivateKey {
static KEY: OnceLock<RsaPrivateKey> = OnceLock::new();
KEY.get_or_init(|| RsaPrivateKey::new(&mut p256::elliptic_curve::rand_core::OsRng, 2048).unwrap())
}
fn seq(fields: &[Vec<u8>]) -> Vec<u8> {
tlv(0x30, &fields.concat())
}
fn fields(data: &[u8]) -> Vec<Vec<u8>> {
der::children(data, &der::read(data, 0).unwrap()).iter().map(|f| f.whole(data).unwrap().to_vec()).collect()
}
fn algorithm(hash: &str, salt: u8) -> Vec<u8> {
let digest = seq(&[der_oid(hash), tlv(0x05, &[])]);
seq(&[der_oid(PSS), seq(&[tlv(0xa0, &digest), tlv(0xa1, &seq(&[der_oid("1.2.840.113549.1.1.8"), digest])), tlv(0xa2, &tlv(0x02, &[salt]))])])
}
fn spki(algorithm: Option<&[u8]>) -> Vec<u8> {
let ordinary = RsaPublicKey::from(key()).to_public_key_der().unwrap().as_bytes().to_vec();
let Some(algorithm) = algorithm else { return ordinary };
let root = der::read(&ordinary, 0).unwrap();
let fields = der::children(&ordinary, &root);
seq(&[algorithm.to_vec(), fields[1].whole(&ordinary).unwrap().to_vec()])
}
fn cert(inner: &[u8], outer: &[u8], public_key: &[u8], digest: verify::Digest, salt: usize) -> Vec<u8> {
let template = crypto::make_cert("PSS Fixture", "Craft Test", "PSS Fixture", public_key, PSS, &|_| vec![1]);
let root = der::read(&template, 0).unwrap();
let fields = der::children(&template, &root);
let mut tbs: Vec<_> = der::children(&template, &fields[0]).iter().map(|f| f.whole(&template).unwrap().to_vec()).collect();
tbs[2] = inner.to_vec();
let tbs = seq(&tbs);
let signature = sign(&tbs, digest, salt);
seq(&[tbs, outer.to_vec(), tlv(0x03, &[&[0][..], &signature].concat())])
}
fn sign(message: &[u8], digest: verify::Digest, salt: usize) -> Vec<u8> {
let mut rng = p256::elliptic_curve::rand_core::OsRng;
match digest {
verify::Digest::Sha256 => rsa::pss::SigningKey::<sha2::Sha256>::new_with_salt_len(key().clone(), salt).sign_with_rng(&mut rng, message).to_vec(),
verify::Digest::Sha384 => rsa::pss::SigningKey::<sha2::Sha384>::new_with_salt_len(key().clone(), salt).sign_with_rng(&mut rng, message).to_vec(),
verify::Digest::Sha512 => rsa::pss::SigningKey::<sha2::Sha512>::new_with_salt_len(key().clone(), salt).sign_with_rng(&mut rng, message).to_vec(),
_ => panic!("fixture signs SHA-256, SHA-384 and SHA-512"),
}
}
fn result(cert: &[u8]) -> verify::Verified {
let chain = verify::verify_chain(&[cert]);
assert_eq!(chain.links.len(), 1);
chain.links[0].signature_verified.clone()
}
#[test]
fn ordinary_pss_sha256_control() {
let alg = algorithm(SHA256, 32);
assert_eq!(result(&cert(&alg, &alg, &spki(None), verify::Digest::Sha256, 32)), verify::Verified::Valid);
}
#[test]
fn respects_declared_pss_hash() {
let alg = algorithm(SHA384, 48);
assert_ne!(result(&cert(&alg, &alg, &spki(None), verify::Digest::Sha256, 32)), verify::Verified::Valid);
}
#[test]
fn respects_declared_pss_salt_length() {
let alg = algorithm(SHA256, 0);
assert_ne!(result(&cert(&alg, &alg, &spki(None), verify::Digest::Sha256, 32)), verify::Verified::Valid);
}
#[test]
fn respects_pss_public_key_constraints() {
let alg = algorithm(SHA256, 32);
let key_alg = algorithm(SHA384, 64);
assert_ne!(result(&cert(&alg, &alg, &spki(Some(&key_alg)), verify::Digest::Sha256, 32)), verify::Verified::Valid);
}
#[test]
fn requires_signed_and_outer_pss_parameters_to_agree() {
let inner = algorithm(SHA384, 48);
let outer = algorithm(SHA256, 32);
assert_ne!(result(&cert(&inner, &outer, &spki(None), verify::Digest::Sha256, 32)), verify::Verified::Valid);
}
#[test]
fn verifies_genuine_sha384_pss() {
let alg = algorithm(SHA384, 48);
assert_eq!(result(&cert(&alg, &alg, &spki(None), verify::Digest::Sha384, 48)), verify::Verified::Valid);
}
#[test]
fn verifies_genuine_zero_salt_pss() {
let alg = algorithm(SHA256, 0);
assert_eq!(result(&cert(&alg, &alg, &spki(None), verify::Digest::Sha256, 0)), verify::Verified::Valid);
}
fn cms(content: &[u8], signature_algorithm: &[u8], digest: verify::Digest, salt: usize, with_attrs: bool) -> Vec<u8> {
let cert_alg = algorithm(SHA256, 32);
let certificate = cert(&cert_alg, &cert_alg, &spki(None), verify::Digest::Sha256, 32);
let parts = der::certificate_parts(&certificate).unwrap();
let digest_oid = match digest {
verify::Digest::Sha256 => SHA256,
verify::Digest::Sha384 => SHA384,
verify::Digest::Sha512 => SHA512,
_ => panic!("fixture uses SHA-2"),
};
let digest_alg = seq(&[der_oid(digest_oid), tlv(0x05, &[])]);
let attributes = [
seq(&[der_oid("1.2.840.113549.1.9.3"), tlv(0x31, &der_oid("1.2.840.113549.1.7.1"))]),
seq(&[der_oid("1.2.840.113549.1.9.4"), tlv(0x31, &tlv(0x04, &digest.hash(content)))]),
]
.concat();
let signed_attrs = tlv(0x31, &attributes);
let signature = sign(if with_attrs { &signed_attrs } else { content }, digest, salt);
let mut signer = vec![tlv(0x02, &[1]), seq(&[parts.issuer.to_vec(), tlv(0x02, parts.serial)]), digest_alg.clone()];
if with_attrs {
signer.push(tlv(0xa0, &attributes));
}
signer.extend([signature_algorithm.to_vec(), tlv(0x04, &signature)]);
let signed_data =
seq(&[tlv(0x02, &[1]), tlv(0x31, &digest_alg), seq(&[der_oid("1.2.840.113549.1.7.1")]), tlv(0xa0, &certificate), tlv(0x31, &seq(&signer))]);
seq(&[der_oid("1.2.840.113549.1.7.2"), tlv(0xa0, &signed_data)])
}
#[test]
fn cms_checks_parameters_with_and_without_signed_attributes() {
let content = b"signed content";
for attrs in [false, true] {
for (oid, digest, salt) in [(SHA256, verify::Digest::Sha256, 0), (SHA384, verify::Digest::Sha384, 8), (SHA512, verify::Digest::Sha512, 64)] {
let valid = cms(content, &algorithm(oid, salt), digest, usize::from(salt), attrs);
let result = verify::verify_pkcs7_detached(content, &valid).unwrap();
assert_eq!(result.signature_valid, verify::Verified::Valid);
assert!(result.certificate_sha256.is_some());
assert_ne!(verify::verify_pkcs7_detached(b"changed content", &valid).unwrap().signature_valid, verify::Verified::Valid);
if attrs {
assert!(verify::verify_macho_cms(&valid, content).unwrap().authenticated);
}
}
let wrong_hash = cms(content, &algorithm(SHA384, 48), verify::Digest::Sha256, 32, attrs);
assert_ne!(verify::verify_pkcs7_detached(content, &wrong_hash).unwrap().signature_valid, verify::Verified::Valid);
let wrong_salt = cms(content, &algorithm(SHA256, 0), verify::Digest::Sha256, 32, attrs);
assert_ne!(verify::verify_pkcs7_detached(content, &wrong_salt).unwrap().signature_valid, verify::Verified::Valid);
if attrs {
assert!(!verify::verify_macho_cms(&wrong_hash, content).unwrap().authenticated);
assert!(!verify::verify_macho_cms(&wrong_salt, content).unwrap().authenticated);
}
}
}
#[test]
fn pss_key_constraints_allow_unrestricted_keys_and_longer_salts() {
let alg = algorithm(SHA256, 32);
for key_alg in [seq(&[der_oid(PSS)]), algorithm(SHA256, 8), algorithm(SHA256, 32)] {
assert_eq!(result(&cert(&alg, &alg, &spki(Some(&key_alg)), verify::Digest::Sha256, 32)), verify::Verified::Valid);
}
let key_alg = algorithm(SHA256, 33);
assert_ne!(result(&cert(&alg, &alg, &spki(Some(&key_alg)), verify::Digest::Sha256, 32)), verify::Verified::Valid);
}
#[test]
fn scheme_projection_does_not_discard_pss_parameters() {
let content = b"explicit PSS parameters";
let standard = cms(content, &algorithm(SHA256, 32), verify::Digest::Sha256, 32, true);
assert_eq!(pkcs7::parse_signed_data(&standard).unwrap().scheme(), Some(verify::SigScheme::RsaPss(verify::Digest::Sha256)));
for alg in [algorithm(SHA256, 0), algorithm(SHA384, 48)] {
let changed = cms(content, &alg, verify::Digest::Sha256, 32, true);
assert!(pkcs7::parse_signed_data(&changed).unwrap().scheme().is_none());
}
let mut parameters = fields(&fields(&algorithm(SHA256, 32))[1]);
parameters[1] = tlv(0xa1, &seq(&[der_oid("1.2.840.113549.1.1.8"), seq(&[der_oid(SHA384)])]));
let different_mask = cms(content, &seq(&[der_oid(PSS), seq(¶meters)]), verify::Digest::Sha256, 32, true);
assert!(pkcs7::parse_signed_data(&different_mask).unwrap().scheme().is_none());
}
#[test]
fn defaults_and_semantically_equivalent_digest_identifiers_are_preserved() {
let full = algorithm(SHA256, 20);
let mut params = fields(&fields(&full)[1]);
params.pop(); // omitted saltLength means 20 even with SHA-256
let inner = seq(&[der_oid(PSS), seq(¶ms)]);
let hash_without_null = seq(&[der_oid(SHA256)]);
params[0] = tlv(0xa0, &hash_without_null);
params[1] = tlv(0xa1, &seq(&[der_oid("1.2.840.113549.1.1.8"), hash_without_null]));
params.push(tlv(0xa2, &tlv(0x02, &[20])));
params.push(tlv(0xa3, &tlv(0x02, &[1])));
let outer = seq(&[der_oid(PSS), seq(¶ms)]);
assert_eq!(result(&cert(&inner, &outer, &spki(None), verify::Digest::Sha256, 20)), verify::Verified::Valid);
let defaults = seq(&[der_oid(PSS), seq(&[])]);
assert!(matches!(result(&cert(&defaults, &defaults, &spki(None), verify::Digest::Sha256, 32)), verify::Verified::Unsupported { .. }));
assert_eq!(verify::scheme_from_oid(PSS), None);
}
#[test]
fn malformed_or_unsupported_parameters_keep_cms_metadata_without_verification() {
let full = algorithm(SHA256, 32);
let params = fields(&fields(&full)[1]);
let mut malformed = vec![seq(&[der_oid(PSS)]), seq(&[der_oid(PSS), tlv(0x05, &[])])];
for replacement in [
tlv(0xa0, &seq(&[der_oid("1.2.3.4")])),
tlv(0xa0, &seq(&[der_oid(SHA256), tlv(0x04, &[])])),
tlv(0xa1, &seq(&[der_oid("1.2.3.4"), seq(&[der_oid(SHA256)])])),
tlv(0xa1, &seq(&[der_oid("1.2.840.113549.1.1.8")])),
tlv(0xa1, &seq(&[der_oid("1.2.840.113549.1.1.8"), seq(&[der_oid(SHA384)])])),
tlv(0xa2, &tlv(0x02, &[])),
tlv(0xa2, &tlv(0x02, &[0xff])),
tlv(0xa2, &tlv(0x02, &[0, 32])),
tlv(0xa2, &tlv(0x02, &[0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])),
] {
let mut changed = params.clone();
let tag = replacement[0];
changed[usize::from(tag - 0xa0)] = replacement;
malformed.push(seq(&[der_oid(PSS), seq(&changed)]));
}
for trailer in [0, 2] {
let mut changed = params.clone();
changed.push(tlv(0xa3, &tlv(0x02, &[trailer])));
malformed.push(seq(&[der_oid(PSS), seq(&changed)]));
}
let mut duplicate = params.clone();
duplicate.push(params[2].clone());
malformed.push(seq(&[der_oid(PSS), seq(&duplicate)]));
let mut out_of_order = params.clone();
out_of_order.swap(0, 1);
malformed.push(seq(&[der_oid(PSS), seq(&out_of_order)]));
malformed.push(seq(&[der_oid(PSS), tlv(0x30, &[params.concat(), vec![0xa3, 2, 2]].concat())]));
malformed.push(seq(&[der_oid(PSS), seq(¶ms), tlv(0x05, &[])]));
let content = b"metadata survives unsupported parameters";
for alg in malformed {
let signed = cms(content, &alg, verify::Digest::Sha256, 32, true);
let parsed = pkcs7::parse_signed_data(&signed).unwrap();
assert_eq!(parsed.certificates.len(), 1);
assert!(parsed.signer_cert().is_some());
assert_eq!(parsed.digest, Some(verify::Digest::Sha256));
let detached = verify::verify_pkcs7_detached(content, &signed).unwrap();
assert_ne!(detached.signature_valid, verify::Verified::Valid);
assert!(detached.signer_subject.is_some());
assert!(detached.certificate_sha256.is_some());
assert!(!verify::verify_macho_cms(&signed, content).unwrap().authenticated);
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.