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 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 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 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}