diff --git a/crates/sign/src/revocation.rs b/crates/sign/src/revocation.rs index 93191b2528..93f338f89c 100644 --- a/crates/sign/src/revocation.rs +++ b/crates/sign/src/revocation.rs @@ -10,6 +10,7 @@ use crate::{SignError, Time}; /// A DER size cap: real CRLs and OCSP responses are far smaller. pub(crate) const MAX_EVIDENCE: usize = 2 * 1024 * 1024; +#[cfg(test)] const ID_PKIX_OCSP_BASIC: &str = "1.3.6.1.5.5.7.48.1.1"; const EKU_OCSP_SIGNING: &str = "1.3.6.1.5.5.7.3.9"; @@ -177,6 +178,52 @@ pub struct OcspResponse { impl OcspResponse { pub fn parse(bytes: &[u8]) -> Result { + use craft_pkcs7::revocation as shared; + let parsed = shared::OcspResponse::parse(bytes).map_err(crate::der::app_error)?.into_parts(); + let responder_id = match parsed.responder_id { + shared::ResponderId::ByName(v) => ResponderId::ByName(v), + shared::ResponderId::ByKey(v) => ResponderId::ByKey(v), + }; + let responses = parsed + .responses + .into_iter() + .map(|response| { + let (id, status, this_update, next_update) = response.into_parts(); + let hash_alg = match id.hash_alg { + craft_pkcs7::DigestAlg::Sha1 => DigestAlg::Sha1, + craft_pkcs7::DigestAlg::Sha224 => DigestAlg::Sha224, + craft_pkcs7::DigestAlg::Sha256 => DigestAlg::Sha256, + craft_pkcs7::DigestAlg::Sha384 => DigestAlg::Sha384, + craft_pkcs7::DigestAlg::Sha512 => DigestAlg::Sha512, + craft_pkcs7::DigestAlg::Sha512_224 => DigestAlg::Sha512_224, + craft_pkcs7::DigestAlg::Sha512_256 => DigestAlg::Sha512_256, + craft_pkcs7::DigestAlg::Sha3_224 => DigestAlg::Sha3_224, + craft_pkcs7::DigestAlg::Sha3_256 => DigestAlg::Sha3_256, + craft_pkcs7::DigestAlg::Sha3_384 => DigestAlg::Sha3_384, + craft_pkcs7::DigestAlg::Sha3_512 => DigestAlg::Sha3_512, + craft_pkcs7::DigestAlg::Ripemd160 => DigestAlg::Ripemd160, + }; + let cert_id = CertId { hash_alg, issuer_name_hash: id.issuer_name_hash, issuer_key_hash: id.issuer_key_hash, serial: id.serial }; + let status = match status { + shared::CertStatus::Good => CertStatus::Good, + shared::CertStatus::Revoked(at) => CertStatus::Revoked(at), + shared::CertStatus::Unknown => CertStatus::Unknown, + }; + SingleResponse { cert_id, status, this_update, next_update } + }) + .collect(); + Ok(Self { + tbs: parsed.tbs, + sig_alg: parsed.sig_alg, + signature: parsed.signature, + responder_id, + responses, + responder_cert: parsed.responder_cert.map(Certificate::from_shared), + }) + } + + #[cfg(test)] + fn parse_legacy(bytes: &[u8]) -> Result { if bytes.is_empty() || bytes.len() > MAX_EVIDENCE { return Err(bad("OCSP response is empty or exceeds the 2 MiB limit")); } @@ -307,3 +354,64 @@ impl OcspResponse { } } } + +#[cfg(test)] +mod shared_ocsp_tests { + use super::*; + use crate::der; + + fn compare(bytes: &[u8]) { + match (OcspResponse::parse(bytes), OcspResponse::parse_legacy(bytes)) { + (Ok(a), Ok(b)) => { + assert_eq!( + (a.tbs, a.sig_alg, a.signature, a.responses, a.responder_cert), + (b.tbs, b.sig_alg, b.signature, b.responses, b.responder_cert) + ); + match (a.responder_id, b.responder_id) { + (ResponderId::ByName(a), ResponderId::ByName(b)) | (ResponderId::ByKey(a), ResponderId::ByKey(b)) => assert_eq!(a, b), + _ => panic!("responder identifier changed"), + } + } + (Err(a), Err(b)) => assert_eq!(format!("{a:?}"), format!("{b:?}")), + _ => panic!("shared and retained OCSP parsers disagree"), + } + } + + #[test] + fn shared_ocsp_matches_status_digest_identity_and_error_policy() { + let date = Time { year: 2026, month: 6, day: 15, hour: 12, minute: 0, second: 0 }; + let cert = crate::pkcs12::open(include_bytes!("../tests/data/ec-p256.p12"), "test").unwrap().certificate; + let statuses = [der::tlv(tag::ctx_prim(0), &[]), der::tlv(tag::ctx(1), &date.encode()), der::tlv(tag::ctx_prim(2), &[])]; + let identities = [der::tlv(tag::ctx(1), &cert.subject.raw), der::tlv(tag::ctx(2), &der::octets(&[1, 2, 3]))]; + for hash in DigestAlg::ALL { + for status in &statuses { + for identity in &identities { + let id = der::seq(&[&hash.algorithm(), &der::octets(&[1]), &der::octets(&[2]), &der::uint(&[0x80])]); + let single = der::seq(&[&id, status, &date.encode(), &der::explicit(0, &date.encode())]); + let tbs = der::seq(&[identity, &date.encode(), &der::seq(&[&single])]); + // Preserve the existing parser's accepted direct certificate sequence form. + let basic = der::seq(&[&tbs, &hash.algorithm(), &der::bit_string(&[1, 2, 3]), &der::explicit(0, &cert.raw)]); + let response = der::seq(&[ + &der::tlv(tag::ENUMERATED, &[0]), + &der::explicit(0, &der::seq(&[&der::oid(ID_PKIX_OCSP_BASIC), &der::octets(&basic)])), + ]); + compare(&response); + for end in [0, 1, response.len() / 2, response.len() - 1] { + compare(&response[..end]); + } + // Mutate each byte in one representative record, keeping test cost bounded. + if hash == DigestAlg::Sha256 && status == &statuses[0] && identity == &identities[0] { + for i in 0..response.len() { + let mut mutated = response.clone(); + mutated[i] ^= 0x80; + compare(&mutated); + } + } + } + } + } + compare(&vec![0; MAX_EVIDENCE]); + compare(&vec![0; MAX_EVIDENCE + 1]); + compare(&der::seq(&[&der::tlv(tag::ENUMERATED, &[1])])); + } +}