Merge pull request #7655 from storytold/refactor/shared-x509

Sign: parse x509 through shared PKCS7 components
This commit is contained in:
Dylan M. Taylor authored and GitHub committed 2026-11-18 09:47:14 -05:00
commit e835554187
1 file changed
+79
+79
View File
@@ -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<String>,
}
#[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<Certificate, SignError> {
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<Certificate, SignError> {
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);
}
}
}
}