From 355c186cfdf5d1c0c27468a3f8d98300af97f260 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 17 Nov 2026 11:57:46 -0500 Subject: [PATCH] Parse X509 certificates through shared components, retaining app policy --- Cargo.lock | 2 +- crates/sign/Cargo.toml | 2 +- crates/sign/src/x509.rs | 79 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 81 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7230c7db39..c0e440a282 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1384,7 +1384,7 @@ dependencies = [ [[package]] name = "craft-pkcs7" version = "0.1.0" -source = "git+https://github.com/storytold/craft-libs?rev=8479a1f3bbabb0e0b25194c508ab2eb14aa5490f#8479a1f3bbabb0e0b25194c508ab2eb14aa5490f" +source = "git+https://github.com/storytold/craft-libs?rev=a62ce81f2447b1791a8d8c0aa6317fb6388f189b#a62ce81f2447b1791a8d8c0aa6317fb6388f189b" dependencies = [ "aes", "aws-lc-rs", diff --git a/crates/sign/Cargo.toml b/crates/sign/Cargo.toml index 72698021f5..86e0215cbd 100644 --- a/crates/sign/Cargo.toml +++ b/crates/sign/Cargo.toml @@ -12,7 +12,7 @@ workspace = true [dependencies] # Existing shared ASN.1 codec; PDF signature policy remains local. -craft-pkcs7 = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "8479a1f3bbabb0e0b25194c508ab2eb14aa5490f" } +craft-pkcs7 = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "a62ce81f2447b1791a8d8c0aa6317fb6388f189b" } pdfcraft-cos = { workspace = true } pdfcraft-annot = { workspace = true } pdfcraft-content = { workspace = true } diff --git a/crates/sign/src/x509.rs b/crates/sign/src/x509.rs index 1cf586b3e8..c7232304dd 100644 --- a/crates/sign/src/x509.rs +++ b/crates/sign/src/x509.rs @@ -151,6 +151,7 @@ pub struct Certificate { /// qcStatements (1.3.6.1.5.5.7.1.3) is included: RFC 3739 lets qualified (eIDAS and other national) /// certificates mark it critical, and it declares the certificate's status rather than limiting /// what the key may sign. +#[cfg(test)] const PROCESSED_EXTENSIONS: [&str; 11] = [ "2.5.29.19", "2.5.29.15", @@ -178,6 +179,7 @@ const DOCUMENT_SIGNING_EKUS: [&str; 6] = /// extension that does not parse leaves its field at the default instead of failing the /// certificate (real-world issuers use encodings with edge cases, e.g. a single-URI CRL /// distribution point whose `fullName [0]` is IMPLICIT over a bare GeneralName). +#[cfg(test)] #[derive(Default)] struct Extensions { is_ca: bool, @@ -191,6 +193,7 @@ struct Extensions { crl_urls: Vec, } +#[cfg(test)] impl Extensions { fn read(&mut self, oid: &str, value: &Tlv<'_>) { match oid { @@ -288,6 +291,51 @@ impl Extensions { impl Certificate { pub fn parse(raw: &[u8]) -> Result { + craft_pkcs7::x509::Certificate::parse(raw).map(Self::from_shared).map_err(crate::der::app_error) + } + + pub(crate) fn from_shared(cert: craft_pkcs7::x509::Certificate) -> Self { + let parsed = cert.into_parts(); + use craft_pkcs7::keys::PublicKey as Shared; + let public_key = match parsed.public_key { + Shared::Rsa { n, e } => PublicKey::Rsa { n, e }, + Shared::P256(v) => PublicKey::P256(v), + Shared::P384(v) => PublicKey::P384(v), + Shared::P521(v) => PublicKey::P521(v), + Shared::BrainpoolP256(v) => PublicKey::BrainpoolP256(v), + Shared::BrainpoolP384(v) => PublicKey::BrainpoolP384(v), + Shared::BrainpoolP512(v) => PublicKey::BrainpoolP512(v), + Shared::Ed25519(v) => PublicKey::Ed25519(v), + Shared::Unsupported { what, spki } => PublicKey::Unsupported { what, spki }, + }; + Self { + raw: parsed.raw, + tbs: parsed.tbs, + sig_alg: parsed.sig_alg, + signature: parsed.signature, + serial: parsed.serial, + issuer: Name { attrs: parsed.issuer.attrs, raw: parsed.issuer.raw }, + subject: Name { attrs: parsed.subject.attrs, raw: parsed.subject.raw }, + not_before: parsed.not_before, + not_after: parsed.not_after, + public_key, + is_ca: parsed.is_ca, + has_basic_constraints: parsed.has_basic_constraints, + path_len: parsed.path_len, + key_usage: parsed.key_usage, + subject_key_id: parsed.subject_key_id, + authority_key_id: parsed.authority_key_id, + extended_key_usage: parsed.extended_key_usage, + ocsp_urls: parsed.ocsp_urls, + crl_urls: parsed.crl_urls, + version: parsed.version, + unknown_critical: parsed.unknown_critical, + } + } + + // Original certificate reader retained as an independent parity oracle; see source history. + #[cfg(test)] + fn parse_legacy(raw: &[u8]) -> Result { let cert = Tlv::parse_all(raw)?.expect(tag::SEQUENCE, "Certificate")?; let parts = cert.children()?; let [tbs, sig_alg, sig] = parts.as_slice() else { return Err(SignError::Malformed("Certificate".into())) }; @@ -695,3 +743,34 @@ mod xfa_ext_tests { } } } + +#[cfg(test)] +mod shared_certificate_tests { + use super::*; + + #[test] + fn shared_certificate_matches_retained_parser_and_error_policy() { + let compare = |bytes: &[u8]| match (Certificate::parse(bytes), Certificate::parse_legacy(bytes)) { + (Ok(a), Ok(b)) => assert_eq!(a, b), + (Err(a), Err(b)) => assert_eq!(format!("{a:?}"), format!("{b:?}")), + _ => panic!("shared and retained certificate parsers disagree"), + }; + for fixture in [ + include_bytes!("../tests/data/ec-p256.p12").as_slice(), + include_bytes!("../tests/data/ec-p384.p12").as_slice(), + include_bytes!("../tests/data/rsa-aes.p12").as_slice(), + ] { + let id = crate::pkcs12::open(fixture, "test").unwrap(); + let raw = &id.certificate.raw; + compare(raw); + for end in 0..raw.len() { + compare(&raw[..end]); + } + for i in 0..raw.len() { + let mut changed = raw.clone(); + changed[i] ^= 0x80; + compare(&changed); + } + } + } +}