Skip to main content

hoike_sign/
crl.rs

1use der::{Decode, Encode};
2use std::collections::BTreeMap;
3use x509_cert::crl::CertificateList;
4use x509_cert::ext::pkix::CrlReason;
5
6use crate::error::{Result, SignError};
7use crate::source::{
8    CaIdentity, CertificateStatus, Epoch, RevocationSource, StatusChange, StatusSnapshot,
9};
10
11pub struct CrlSource {
12    crl: CertificateList,
13    issuer: Option<x509_cert::Certificate>,
14}
15
16impl CrlSource {
17    pub fn from_der(data: Vec<u8>) -> Result<Self> {
18        let crl = CertificateList::from_der(&data)
19            .map_err(|e| SignError::CrlParse(format!("failed to parse CRL DER: {e}")))?;
20        Ok(CrlSource { crl, issuer: None })
21    }
22
23    /// Bind this source to an independently provisioned, authorized issuer certificate.
24    pub fn with_issuer_certificate(mut self, der: &[u8]) -> Result<Self> {
25        self.issuer = Some(
26            crate::rotation::parse_certificate(der)
27                .map_err(|e| SignError::Verify(format!("CRL issuer certificate: {e}")))?,
28        );
29        Ok(self)
30    }
31
32    fn authenticate(&self, ca: &CaIdentity) -> Result<()> {
33        use x509_cert::ext::pkix::KeyUsage;
34        let cert = self.issuer.as_ref().ok_or_else(|| {
35            SignError::Verify("CRL requires an authorized issuer certificate".into())
36        })?;
37        let tbs = &cert.tbs_certificate;
38        let crl = &self.crl;
39        let now = crate::source::unix_now()?;
40        if tbs.subject.to_der()? != ca.issuer_name_der
41            || tbs.subject_public_key_info.subject_public_key.raw_bytes() != ca.issuer_key_bytes
42            || crl.tbs_cert_list.issuer != tbs.subject
43            || tbs.subject.0.is_empty()
44        {
45            return Err(SignError::Verify(
46                "CRL issuer does not match authorized CA".into(),
47            ));
48        }
49        if now < time_to_epoch(tbs.validity.not_before)
50            || now >= time_to_epoch(tbs.validity.not_after)
51        {
52            return Err(SignError::Verify(
53                "CRL issuer certificate is outside validity".into(),
54            ));
55        }
56        if let Some(exts) = &tbs.extensions {
57            for ext in exts {
58                if ext.extn_id == KeyUsage::OID
59                    && !KeyUsage::from_der(ext.extn_value.as_bytes())?.crl_sign()
60                {
61                    return Err(SignError::Verify(
62                        "issuer key usage forbids CRL signing".into(),
63                    ));
64                }
65            }
66        }
67        if crl.signature_algorithm != crl.tbs_cert_list.signature {
68            return Err(SignError::Verify(
69                "CRL signature algorithms disagree".into(),
70            ));
71        }
72        if let Some(exts) = &crl.tbs_cert_list.crl_extensions {
73            let mut seen = std::collections::BTreeSet::new();
74            for ext in exts {
75                let oid = ext.extn_id.to_string();
76                if oid == "2.5.29.20" {
77                    let _ = x509_cert::ext::pkix::CrlNumber::from_der(ext.extn_value.as_bytes())?;
78                }
79                if oid == "2.5.29.35" {
80                    use x509_cert::ext::pkix::{AuthorityKeyIdentifier, SubjectKeyIdentifier};
81                    let aki = AuthorityKeyIdentifier::from_der(ext.extn_value.as_bytes())?;
82                    if let Some(serial) = aki.authority_cert_serial_number {
83                        if serial != tbs.serial_number {
84                            return Err(SignError::Verify("CRL authority serial mismatch".into()));
85                        }
86                    }
87                    if let Some(names) = aki.authority_cert_issuer {
88                        if !names.iter().any(|n| matches!(n, x509_cert::ext::pkix::name::GeneralName::DirectoryName(name) if name == &tbs.issuer)) {
89                            return Err(SignError::Verify("CRL authority certificate issuer mismatch".into()));
90                        }
91                    }
92                    if let Some(id) = aki.key_identifier {
93                        if let Some(ski) = tbs.extensions.as_ref().and_then(|es| {
94                            es.iter().find(|e| e.extn_id == SubjectKeyIdentifier::OID)
95                        }) {
96                            if SubjectKeyIdentifier::from_der(ski.extn_value.as_bytes())?.0 != id {
97                                return Err(SignError::Verify(
98                                    "CRL authority key identifier mismatch".into(),
99                                ));
100                            }
101                        }
102                    }
103                }
104                if !seen.insert(oid.clone())
105                    || matches!(oid.as_str(), "2.5.29.27" | "2.5.29.28")
106                    || (ext.critical && !matches!(oid.as_str(), "2.5.29.20" | "2.5.29.35"))
107                {
108                    return Err(SignError::Verify(format!(
109                        "unsupported or duplicate CRL extension {oid}"
110                    )));
111                }
112            }
113        }
114        let bytes = crl.tbs_cert_list.to_der()?;
115        let signature = crl
116            .signature
117            .as_bytes()
118            .ok_or_else(|| SignError::Verify("invalid CRL signature bit string".into()))?;
119        let spki = &tbs.subject_public_key_info;
120        match crl.signature_algorithm.oid.to_string().as_str() {
121            "1.2.840.10045.4.3.2" => {
122                if crl.signature_algorithm.parameters.is_some() {
123                    return Err(SignError::Verify(
124                        "ECDSA signature parameters must be absent".into(),
125                    ));
126                }
127                use p256::pkcs8::DecodePublicKey;
128                // ecdsa 0.17 verifies via signature v3 (p256's re-export).
129                use p256::ecdsa::signature::Verifier;
130                let key = p256::ecdsa::VerifyingKey::from_public_key_der(&spki.to_der()?)
131                    .map_err(|e| SignError::Verify(format!("CRL P-256 key: {e}")))?;
132                let sig = p256::ecdsa::Signature::from_der(signature)
133                    .map_err(|e| SignError::Verify(format!("CRL signature: {e}")))?;
134                key.verify(&bytes, &sig)
135                    .map_err(|_| SignError::Verify("CRL signature verification failed".into()))
136            }
137            oid @ ("1.2.840.113549.1.1.11" | "1.2.840.113549.1.1.12" | "1.2.840.113549.1.1.13") => {
138                use aws_lc_rs::signature as aws;
139                if spki.algorithm.oid.to_string() != "1.2.840.113549.1.1.1" {
140                    return Err(SignError::Verify(
141                        "CRL signature requires RSA public key".into(),
142                    ));
143                }
144                for parameters in [
145                    &spki.algorithm.parameters,
146                    &crl.signature_algorithm.parameters,
147                ]
148                .into_iter()
149                .flatten()
150                {
151                    if parameters.to_der()? != [5, 0] {
152                        return Err(SignError::Verify("invalid RSA algorithm parameters".into()));
153                    }
154                }
155                let algorithm = match oid {
156                    "1.2.840.113549.1.1.11" => &aws::RSA_PKCS1_2048_8192_SHA256,
157                    "1.2.840.113549.1.1.12" => &aws::RSA_PKCS1_2048_8192_SHA384,
158                    _ => &aws::RSA_PKCS1_2048_8192_SHA512,
159                };
160                let key = spki
161                    .subject_public_key
162                    .as_bytes()
163                    .ok_or_else(|| SignError::Verify("invalid RSA key bit string".into()))?;
164                aws::UnparsedPublicKey::new(algorithm, key).verify(&bytes, signature)
165                    .map_err(|_| SignError::Verify("CRL RSA signature verification failed (supported keys: 2048..8192 bits)".into()))
166            }
167
168            oid @ ("2.16.840.1.101.3.4.3.17"
169            | "2.16.840.1.101.3.4.3.18"
170            | "2.16.840.1.101.3.4.3.19") => {
171                if spki.algorithm.oid.to_string() != oid
172                    || spki.algorithm.parameters.is_some()
173                    || crl.signature_algorithm.parameters.is_some()
174                {
175                    return Err(SignError::Verify(
176                        "ML-DSA CRL algorithm/key mismatch".into(),
177                    ));
178                }
179                let key = spki
180                    .subject_public_key
181                    .as_bytes()
182                    .ok_or_else(|| SignError::Verify("invalid public key bits".into()))?;
183                match oid {
184                    "2.16.840.1.101.3.4.3.17" => {
185                        verify_ml_crl::<ml_dsa::MlDsa44>(&bytes, signature, key)
186                    }
187                    "2.16.840.1.101.3.4.3.18" => {
188                        verify_ml_crl::<ml_dsa::MlDsa65>(&bytes, signature, key)
189                    }
190                    _ => verify_ml_crl::<ml_dsa::MlDsa87>(&bytes, signature, key),
191                }
192            }
193            other => Err(SignError::Verify(format!(
194                "unsupported CRL signature algorithm: {other}; supported: ECDSA P-256/SHA-256, RSA PKCS1v1.5/SHA-256/384/512, ML-DSA"
195            ))),
196        }
197    }
198
199    pub fn from_pem(pem_text: &str) -> Result<Self> {
200        let der_data = pem_to_der(pem_text)?;
201        Self::from_der(der_data)
202    }
203}
204
205impl RevocationSource for CrlSource {
206    fn snapshot(&self, ca: &CaIdentity) -> Result<StatusSnapshot> {
207        self.authenticate(ca)?;
208        let crl = &self.crl;
209        let mut entries = BTreeMap::new();
210
211        if let Some(revoked_certs) = &crl.tbs_cert_list.revoked_certificates {
212            for rc in revoked_certs {
213                if let Some(exts) = &rc.crl_entry_extensions {
214                    for ext in exts {
215                        if ext.extn_id.to_string() == "2.5.29.29"
216                            || (ext.critical && ext.extn_id != CrlReason::OID)
217                        {
218                            return Err(SignError::Verify(
219                                "unsupported CRL entry extension".into(),
220                            ));
221                        }
222                        if ext.extn_id == CrlReason::OID {
223                            let reason = CrlReason::from_der(ext.extn_value.as_bytes())?;
224                            if reason == CrlReason::RemoveFromCRL {
225                                return Err(SignError::Verify(
226                                    "removeFromCRL requires unsupported delta semantics".into(),
227                                ));
228                            }
229                        }
230                    }
231                }
232                let serial = rc.serial_number.as_bytes().to_vec();
233
234                let reason = rc.crl_entry_extensions.as_ref().and_then(|exts| {
235                    exts.iter()
236                        .find(|ext| ext.extn_id == CrlReason::OID)
237                        .and_then(|ext| CrlReason::from_der(ext.extn_value.as_bytes()).ok())
238                });
239
240                let revocation_time = time_to_epoch(rc.revocation_date);
241
242                entries.insert(
243                    serial,
244                    CertificateStatus::Revoked {
245                        revocation_time,
246                        reason,
247                    },
248                );
249            }
250        }
251
252        let this_update = time_to_epoch(crl.tbs_cert_list.this_update);
253        let next_update = crl.tbs_cert_list.next_update.map(time_to_epoch);
254
255        let snapshot = StatusSnapshot {
256            entries,
257            this_update,
258            next_update,
259            // CRLs carry no per-certificate notAfter, so archive_cutoff pruning
260            // is a no-op for this source.
261            not_after: std::collections::BTreeMap::new(),
262        };
263        snapshot.validate_at(crate::source::unix_now()?)?;
264        Ok(snapshot)
265    }
266
267    fn changes_since(&self, ca: &CaIdentity, _since: Epoch) -> Result<Vec<StatusChange>> {
268        let snapshot = self.snapshot(ca)?;
269        Ok(snapshot
270            .entries
271            .into_iter()
272            .map(|(serial, status)| StatusChange {
273                serial,
274                status,
275                timestamp: snapshot.this_update,
276            })
277            .collect())
278    }
279
280    fn supports_streaming(&self) -> bool {
281        false
282    }
283}
284
285fn verify_ml_crl<P: ml_dsa::MlDsaParams>(data: &[u8], sig: &[u8], key: &[u8]) -> Result<()> {
286    use ml_dsa::Verifier;
287    let encoded = ml_dsa::EncodedVerifyingKey::<P>::try_from(key)
288        .map_err(|_| SignError::Verify("invalid ML-DSA key".into()))?;
289    let key = ml_dsa::VerifyingKey::<P>::decode(&encoded);
290    let sig = ml_dsa::Signature::<P>::try_from(sig)
291        .map_err(|_| SignError::Verify("invalid ML-DSA signature".into()))?;
292    key.verify(data, &sig)
293        .map_err(|_| SignError::Verify("CRL signature verification failed".into()))
294}
295
296fn time_to_epoch(time: x509_cert::time::Time) -> u64 {
297    let dt = match time {
298        x509_cert::time::Time::UtcTime(t) => t.to_date_time(),
299        x509_cert::time::Time::GeneralTime(t) => t.to_date_time(),
300    };
301    datetime_to_epoch(dt)
302}
303
304fn datetime_to_epoch(dt: der::DateTime) -> u64 {
305    crate::generate::datetime_to_epoch(dt)
306}
307
308fn pem_to_der(pem: &str) -> Result<Vec<u8>> {
309    use base64::Engine;
310    let mut collecting = false;
311    let mut found_end = false;
312    let mut b64 = String::new();
313    for line in pem.lines() {
314        if line.starts_with("-----BEGIN") {
315            collecting = true;
316            continue;
317        }
318        if line.starts_with("-----END") {
319            found_end = true;
320            break;
321        }
322        if collecting {
323            b64.push_str(line.trim());
324        }
325    }
326    if !collecting {
327        return Err(SignError::CrlParse("PEM has no BEGIN marker".into()));
328    }
329    if !found_end {
330        return Err(SignError::CrlParse(
331            "PEM is truncated: found BEGIN but no END marker".into(),
332        ));
333    }
334    base64::engine::general_purpose::STANDARD
335        .decode(&b64)
336        .map_err(|e| SignError::CrlParse(format!("PEM base64 decode: {e}")))
337}
338
339use const_oid::AssociatedOid;
340
341#[cfg(test)]
342mod tests {
343    use super::*;
344
345    fn build_test_crl_der() -> Vec<u8> {
346        use der::Encode;
347        use der::asn1::BitString;
348        use der::asn1::UtcTime;
349        use spki::AlgorithmIdentifierOwned;
350        use x509_cert::crl::{CertificateList, RevokedCert, TbsCertList};
351        use x509_cert::name::RdnSequence;
352        use x509_cert::time::Time;
353
354        let now_dt = der::DateTime::new(2025, 1, 15, 12, 0, 0).unwrap();
355        let next_dt = der::DateTime::new(2025, 1, 16, 12, 0, 0).unwrap();
356        let revoke_dt = der::DateTime::new(2025, 1, 10, 8, 0, 0).unwrap();
357
358        let this_update = Time::UtcTime(UtcTime::from_date_time(now_dt).unwrap());
359        let next_update = Time::UtcTime(UtcTime::from_date_time(next_dt).unwrap());
360        let revoke_time = Time::UtcTime(UtcTime::from_date_time(revoke_dt).unwrap());
361
362        let serial_42 = x509_cert::serial_number::SerialNumber::new(&[42u8]).unwrap();
363        let serial_100 = x509_cert::serial_number::SerialNumber::new(&[100u8]).unwrap();
364
365        let revoked_certs = vec![
366            RevokedCert {
367                serial_number: serial_42,
368                revocation_date: revoke_time,
369                crl_entry_extensions: None,
370            },
371            RevokedCert {
372                serial_number: serial_100,
373                revocation_date: revoke_time,
374                crl_entry_extensions: None,
375            },
376        ];
377
378        let sha256_with_ecdsa = const_oid::ObjectIdentifier::new_unwrap("1.2.840.10045.4.3.2");
379
380        let tbs = TbsCertList {
381            version: x509_cert::Version::V2,
382            signature: AlgorithmIdentifierOwned {
383                oid: sha256_with_ecdsa,
384                parameters: None,
385            },
386            issuer: RdnSequence::default(),
387            this_update,
388            next_update: Some(next_update),
389            revoked_certificates: Some(revoked_certs),
390            crl_extensions: None,
391        };
392
393        let crl = CertificateList {
394            tbs_cert_list: tbs,
395            signature_algorithm: AlgorithmIdentifierOwned {
396                oid: sha256_with_ecdsa,
397                parameters: None,
398            },
399            signature: BitString::from_bytes(&[0u8; 64]).unwrap(),
400        };
401
402        crl.to_der().expect("CRL encoding failed")
403    }
404
405    #[test]
406    fn parse_crl_extracts_revoked_serials() {
407        let crl_der = build_test_crl_der();
408        let source = CrlSource::from_der(crl_der).unwrap();
409
410        let ca = CaIdentity {
411            label: "test".into(),
412            issuer_name_der: vec![],
413            issuer_key_bytes: vec![],
414        };
415
416        assert!(source.snapshot(&ca).is_err());
417    }
418    fn authenticated_fixture() -> (CrlSource, CaIdentity) {
419        let key = crate::demo_ecdsa_p256_key();
420        let cert_der = crate::generate_seal_cert(&key).unwrap();
421        let cert = x509_cert::Certificate::from_der(&cert_der).unwrap();
422        let ca = CaIdentity {
423            label: "fixture".into(),
424            issuer_name_der: cert.tbs_certificate.subject.to_der().unwrap(),
425            issuer_key_bytes: cert
426                .tbs_certificate
427                .subject_public_key_info
428                .subject_public_key
429                .raw_bytes()
430                .to_vec(),
431        };
432        let mut crl = CertificateList::from_der(&build_test_crl_der()).unwrap();
433        crl.tbs_cert_list.issuer = cert.tbs_certificate.subject;
434        let now = crate::source::unix_now().unwrap();
435        let time = |n| {
436            x509_cert::time::Time::GeneralTime(
437                der::asn1::GeneralizedTime::from_unix_duration(std::time::Duration::from_secs(n))
438                    .unwrap(),
439            )
440        };
441        crl.tbs_cert_list.this_update = time(now - 1);
442        crl.tbs_cert_list.next_update = Some(time(now + 3600));
443        let sig: p256::ecdsa::Signature = {
444            use p256::ecdsa::signature::Signer;
445            key.sign(&crl.tbs_cert_list.to_der().unwrap())
446        };
447        crl.signature = der::asn1::BitString::from_bytes(sig.to_der().as_bytes()).unwrap();
448        (
449            CrlSource::from_der(crl.to_der().unwrap())
450                .unwrap()
451                .with_issuer_certificate(&cert_der)
452                .unwrap(),
453            ca,
454        )
455    }
456
457    #[test]
458    fn authenticated_crl_accepts_only_matching_issuer_and_signature() {
459        let (mut source, ca) = authenticated_fixture();
460        assert_eq!(source.snapshot(&ca).unwrap().entries.len(), 2);
461        let mut wrong = ca.clone();
462        wrong.issuer_key_bytes[0] ^= 1;
463        assert!(source.snapshot(&wrong).is_err());
464        source
465            .crl
466            .tbs_cert_list
467            .revoked_certificates
468            .as_mut()
469            .unwrap()
470            .clear();
471        assert!(source.snapshot(&ca).is_err());
472    }
473
474    #[test]
475    fn authenticated_crl_rejects_delta_semantics() {
476        let (mut source, ca) = authenticated_fixture();
477        source.crl.tbs_cert_list.crl_extensions = Some(vec![x509_cert::ext::Extension {
478            extn_id: const_oid::ObjectIdentifier::new_unwrap("2.5.29.27"),
479            critical: true,
480            extn_value: der::asn1::OctetString::new(vec![2, 1, 1]).unwrap(),
481        }]);
482        assert!(
483            source
484                .snapshot(&ca)
485                .unwrap_err()
486                .to_string()
487                .contains("unsupported")
488        );
489    }
490    #[test]
491    fn rsa_crls_verify_sha256_sha384_sha512_and_reject_tampering() {
492        use aws_lc_rs::signature::{self as aws, KeyPair};
493        let key = aws::RsaKeyPair::generate(aws_lc_rs::rsa::KeySize::Rsa2048).unwrap();
494        let (template, _) = authenticated_fixture();
495        for oid in [
496            "1.2.840.113549.1.1.11",
497            "1.2.840.113549.1.1.12",
498            "1.2.840.113549.1.1.13",
499        ] {
500            let mut cert = template.issuer.clone().unwrap();
501            cert.tbs_certificate.subject_public_key_info = spki::SubjectPublicKeyInfoOwned {
502                algorithm: spki::AlgorithmIdentifierOwned {
503                    oid: "1.2.840.113549.1.1.1".parse().unwrap(),
504                    parameters: None,
505                },
506                subject_public_key: der::asn1::BitString::from_bytes(key.public_key().as_ref())
507                    .unwrap(),
508            };
509            let ca = CaIdentity {
510                label: "rsa".into(),
511                issuer_name_der: cert.tbs_certificate.subject.to_der().unwrap(),
512                issuer_key_bytes: cert
513                    .tbs_certificate
514                    .subject_public_key_info
515                    .subject_public_key
516                    .raw_bytes()
517                    .to_vec(),
518            };
519            let mut crl = template.crl.clone();
520            crl.signature_algorithm.oid = oid.parse().unwrap();
521            crl.tbs_cert_list.signature = crl.signature_algorithm.clone();
522            let tbs = crl.tbs_cert_list.to_der().unwrap();
523            let algorithm = match oid {
524                "1.2.840.113549.1.1.11" => &aws::RSA_PKCS1_SHA256,
525                "1.2.840.113549.1.1.12" => &aws::RSA_PKCS1_SHA384,
526                _ => &aws::RSA_PKCS1_SHA512,
527            };
528            let mut signature = vec![0; key.public_modulus_len()];
529            key.sign(
530                algorithm,
531                &aws_lc_rs::rand::SystemRandom::new(),
532                &tbs,
533                &mut signature,
534            )
535            .unwrap();
536            crl.signature = der::asn1::BitString::from_bytes(&signature).unwrap();
537            let mut source = CrlSource {
538                crl,
539                issuer: Some(cert),
540            };
541            assert!(source.snapshot(&ca).is_ok(), "{oid}");
542            source.crl.tbs_cert_list.revoked_certificates = None;
543            assert!(source.snapshot(&ca).is_err());
544        }
545    }
546    #[test]
547    fn issuer_certificate_accepts_pem_and_der_identically() {
548        use der::EncodePem;
549        let (source, ca) = authenticated_fixture();
550        let pem = source
551            .issuer
552            .as_ref()
553            .unwrap()
554            .to_pem(der::pem::LineEnding::LF)
555            .unwrap();
556        let from_pem = CrlSource::from_der(source.crl.to_der().unwrap())
557            .unwrap()
558            .with_issuer_certificate(pem.as_bytes())
559            .unwrap();
560        assert_eq!(
561            source.snapshot(&ca).unwrap().entries.len(),
562            from_pem.snapshot(&ca).unwrap().entries.len()
563        );
564    }
565}