1use std::collections::HashSet;
41use std::sync::Arc;
42use std::time::SystemTime;
43
44use crate::{
45 authentication::credentials::Credential,
46 errors::{AuthError, Result},
47};
48
49#[derive(Debug, Clone)]
53pub struct ClientCertConfig {
54 pub trusted_ca_ders: Vec<Vec<u8>>,
64
65 pub subject_allowlist: Vec<String>,
69
70 pub issuer_allowlist: Vec<String>,
72
73 pub require_san: bool,
77
78 pub token_lifetime_secs: u64,
80}
81
82impl Default for ClientCertConfig {
83 fn default() -> Self {
84 Self {
85 trusted_ca_ders: Vec::new(),
86 subject_allowlist: Vec::new(),
87 issuer_allowlist: Vec::new(),
88 require_san: false,
89 token_lifetime_secs: 3600,
90 }
91 }
92}
93
94impl ClientCertConfig {
95 pub fn new() -> Self {
97 Self::default()
98 }
99
100 pub fn trust_ca(mut self, ca_der: Vec<u8>) -> Self {
102 self.trusted_ca_ders.push(ca_der);
103 self
104 }
105
106 pub fn allow_subject(mut self, pattern: impl Into<String>) -> Self {
108 self.subject_allowlist.push(pattern.into());
109 self
110 }
111
112 pub fn allow_issuer(mut self, pattern: impl Into<String>) -> Self {
114 self.issuer_allowlist.push(pattern.into());
115 self
116 }
117
118 pub fn with_require_san(mut self) -> Self {
120 self.require_san = true;
121 self
122 }
123}
124
125#[derive(Debug, Clone)]
129pub struct CertIdentity {
130 pub subject_dn: String,
132 pub common_name: Option<String>,
134 pub sans: Vec<String>,
138 pub issuer_dn: String,
140}
141
142pub struct ClientCertAuthMethod {
163 config: ClientCertConfig,
164}
165
166impl ClientCertAuthMethod {
167 pub fn new(config: ClientCertConfig) -> Self {
169 Self { config }
170 }
171
172 pub fn authenticate(&self, credential: &Credential) -> Result<CertIdentity> {
179 let cert_der = match credential {
180 Credential::Certificate {
181 certificate,
182 private_key,
183 ..
184 } => {
185 if !private_key.is_empty() {
186 tracing::warn!(
187 "ClientCertAuthMethod received a non-empty private_key — \
188 it will be ignored. For mTLS flows use \
189 `Credential::client_cert_from_tls(der_bytes)`."
190 );
191 }
192 certificate.as_slice()
193 }
194 other => {
195 return Err(AuthError::InvalidCredential {
196 credential_type: other.credential_type().to_string(),
197 message: "ClientCertAuthMethod requires a Credential::Certificate. \
198 Use Credential::client_cert_from_tls(der_bytes) for mTLS flows."
199 .to_string(),
200 });
201 }
202 };
203
204 self.validate_der(cert_der)
205 }
206
207 fn validate_der(&self, cert_der: &[u8]) -> Result<CertIdentity> {
210 use x509_parser::prelude::*;
211
212 if cert_der.is_empty() {
213 return Err(AuthError::InvalidCredential {
214 credential_type: "certificate".to_string(),
215 message: "Certificate DER bytes are empty".to_string(),
216 });
217 }
218
219 let (_, cert) =
220 X509Certificate::from_der(cert_der).map_err(|_| AuthError::InvalidCredential {
221 credential_type: "certificate".to_string(),
222 message: "Failed to parse X.509 DER certificate — verify that the bytes \
223 are DER-encoded (not PEM) and are not truncated."
224 .to_string(),
225 })?;
226
227 self.check_validity(&cert)?;
228 self.check_subject_allowlist(&cert)?;
229 self.check_issuer_allowlist(&cert)?;
230 self.check_san_required(&cert)?;
231 self.check_trust_chain(cert_der)?;
232 self.extract_identity(&cert)
233 }
234
235 fn check_validity(&self, cert: &x509_parser::certificate::X509Certificate<'_>) -> Result<()> {
236 let now = SystemTime::now()
237 .duration_since(SystemTime::UNIX_EPOCH)
238 .unwrap_or_default()
239 .as_secs() as i64;
240
241 let not_before = cert.validity().not_before.timestamp();
242 let not_after = cert.validity().not_after.timestamp();
243
244 if now < not_before {
245 return Err(AuthError::InvalidCredential {
246 credential_type: "certificate".to_string(),
247 message: format!(
248 "Certificate is not yet valid (valid from Unix timestamp {})",
249 not_before
250 ),
251 });
252 }
253 if now > not_after {
254 return Err(AuthError::InvalidCredential {
255 credential_type: "certificate".to_string(),
256 message: "Certificate has expired".to_string(),
257 });
258 }
259 Ok(())
260 }
261
262 fn check_subject_allowlist(
263 &self,
264 cert: &x509_parser::certificate::X509Certificate<'_>,
265 ) -> Result<()> {
266 if self.config.subject_allowlist.is_empty() {
267 return Ok(());
268 }
269 let subject = cert.subject().to_string();
270 if !self
271 .config
272 .subject_allowlist
273 .iter()
274 .any(|p| subject.contains(p.as_str()))
275 {
276 return Err(AuthError::InvalidCredential {
277 credential_type: "certificate".to_string(),
278 message: format!("Subject DN '{}' is not in the subject allowlist", subject),
279 });
280 }
281 Ok(())
282 }
283
284 fn check_issuer_allowlist(
285 &self,
286 cert: &x509_parser::certificate::X509Certificate<'_>,
287 ) -> Result<()> {
288 if self.config.issuer_allowlist.is_empty() {
289 return Ok(());
290 }
291 let issuer = cert.issuer().to_string();
292 if !self
293 .config
294 .issuer_allowlist
295 .iter()
296 .any(|p| issuer.contains(p.as_str()))
297 {
298 return Err(AuthError::InvalidCredential {
299 credential_type: "certificate".to_string(),
300 message: format!("Issuer DN '{}' is not in the issuer allowlist", issuer),
301 });
302 }
303 Ok(())
304 }
305
306 fn check_san_required(
307 &self,
308 cert: &x509_parser::certificate::X509Certificate<'_>,
309 ) -> Result<()> {
310 if !self.config.require_san {
311 return Ok(());
312 }
313 let has_san = cert
315 .extensions()
316 .iter()
317 .any(|ext| ext.oid.to_id_string() == "2.5.29.17");
318 if !has_san {
319 return Err(AuthError::InvalidCredential {
320 credential_type: "certificate".to_string(),
321 message: "Certificate does not contain a Subject Alternative Name (SAN) \
322 extension, but require_san is enabled in the configuration."
323 .to_string(),
324 });
325 }
326 Ok(())
327 }
328
329 fn check_trust_chain(&self, cert_der: &[u8]) -> Result<()> {
335 if self.config.trusted_ca_ders.is_empty() {
336 return Ok(());
337 }
338
339 use x509_parser::prelude::*;
340
341 let (_, cert) =
342 X509Certificate::from_der(cert_der).map_err(|_| AuthError::InvalidCredential {
343 credential_type: "certificate".to_string(),
344 message: "Failed to re-parse certificate for chain check".to_string(),
345 })?;
346 let issuer_dn = cert.issuer().to_string();
347
348 let found = self.config.trusted_ca_ders.iter().any(|ca_der| {
349 if let Ok((_, ca_cert)) = X509Certificate::from_der(ca_der) {
350 ca_cert.subject().to_string() == issuer_dn
351 } else {
352 false
353 }
354 });
355
356 if !found {
357 return Err(AuthError::InvalidCredential {
358 credential_type: "certificate".to_string(),
359 message: format!(
360 "No trusted CA found for issuer '{}'. \
361 Add the issuing CA's DER bytes to ClientCertConfig::trusted_ca_ders.",
362 issuer_dn
363 ),
364 });
365 }
366 Ok(())
367 }
368
369 fn extract_identity(
370 &self,
371 cert: &x509_parser::certificate::X509Certificate<'_>,
372 ) -> Result<CertIdentity> {
373 let subject_dn = cert.subject().to_string();
374 let issuer_dn = cert.issuer().to_string();
375
376 let common_name = cert
378 .subject()
379 .iter_common_name()
380 .next()
381 .and_then(|attr| attr.as_str().ok())
382 .map(str::to_string);
383
384 let mut sans: Vec<String> = Vec::new();
386 for ext in cert.extensions() {
387 if ext.oid.to_id_string() == "2.5.29.17"
388 && let x509_parser::extensions::ParsedExtension::SubjectAlternativeName(san) =
389 ext.parsed_extension()
390 {
391 for gn in &san.general_names {
392 let entry = match gn {
393 x509_parser::extensions::GeneralName::DNSName(s) => {
394 format!("dns:{s}")
395 }
396 x509_parser::extensions::GeneralName::RFC822Name(s) => {
397 format!("email:{s}")
398 }
399 x509_parser::extensions::GeneralName::IPAddress(ip) => {
400 format!("ip:{}", fmt_ip(ip))
401 }
402 _ => continue,
403 };
404 sans.push(entry);
405 }
406 }
407 }
408
409 Ok(CertIdentity {
410 subject_dn,
411 common_name,
412 sans,
413 issuer_dn,
414 })
415 }
416}
417
418fn fmt_ip(bytes: &[u8]) -> String {
420 match bytes.len() {
421 4 => format!("{}.{}.{}.{}", bytes[0], bytes[1], bytes[2], bytes[3]),
422 16 => {
423 let parts: Vec<String> = bytes
424 .chunks(2)
425 .map(|c| format!("{:02x}{:02x}", c[0], c[1]))
426 .collect();
427 parts.join(":")
428 }
429 _ => format!("{:?}", bytes),
430 }
431}
432
433#[derive(Debug, Clone, PartialEq, Eq, Hash)]
439pub struct CertPin {
440 pub sha256_hex: String,
442}
443
444impl CertPin {
445 pub fn from_der(cert_der: &[u8]) -> Self {
447 use sha2::{Digest, Sha256};
448 let digest = Sha256::digest(cert_der);
449 Self {
450 sha256_hex: hex::encode(digest),
451 }
452 }
453
454 pub fn from_hex(hex_fingerprint: impl Into<String>) -> Self {
456 Self {
457 sha256_hex: hex_fingerprint.into().to_lowercase(),
458 }
459 }
460}
461
462#[derive(Debug, Clone, Default)]
467pub struct CertPinStore {
468 pins: Arc<std::sync::RwLock<HashSet<String>>>,
469}
470
471impl CertPinStore {
472 pub fn new() -> Self {
474 Self::default()
475 }
476
477 pub fn add(&self, pin: &CertPin) {
479 self.pins.write().unwrap().insert(pin.sha256_hex.clone());
480 }
481
482 pub fn remove(&self, pin: &CertPin) -> bool {
484 self.pins.write().unwrap().remove(&pin.sha256_hex)
485 }
486
487 pub fn is_pinned(&self, cert_der: &[u8]) -> bool {
489 let pin = CertPin::from_der(cert_der);
490 self.pins.read().unwrap().contains(&pin.sha256_hex)
491 }
492
493 pub fn count(&self) -> usize {
495 self.pins.read().unwrap().len()
496 }
497}
498
499#[derive(Debug, Clone, PartialEq, Eq)]
503pub enum RevocationStatus {
504 Good,
506 Revoked {
508 reason: Option<String>,
510 },
511 Unknown,
513}
514
515#[derive(Debug, Clone, Default)]
521pub struct CrlStore {
522 revoked: Arc<std::sync::RwLock<std::collections::HashMap<String, HashSet<String>>>>,
524}
525
526impl CrlStore {
527 pub fn new() -> Self {
529 Self::default()
530 }
531
532 pub fn add_revoked(&self, issuer_dn: &str, serial_hex: &str) {
534 self.revoked
535 .write()
536 .unwrap()
537 .entry(issuer_dn.to_string())
538 .or_default()
539 .insert(serial_hex.to_lowercase());
540 }
541
542 pub fn check(&self, issuer_dn: &str, serial_hex: &str) -> RevocationStatus {
544 let store = self.revoked.read().unwrap();
545 if let Some(serials) = store.get(issuer_dn) {
546 if serials.contains(&serial_hex.to_lowercase()) {
547 return RevocationStatus::Revoked { reason: None };
548 }
549 }
550 RevocationStatus::Good
551 }
552
553 pub fn check_der(&self, cert_der: &[u8]) -> RevocationStatus {
555 use x509_parser::prelude::*;
556 let Ok((_, cert)) = X509Certificate::from_der(cert_der) else {
557 return RevocationStatus::Unknown;
558 };
559 let issuer = cert.issuer().to_string();
560 let serial = cert.raw_serial_as_string().to_lowercase();
561 self.check(&issuer, &serial)
562 }
563
564 pub fn revoked_count(&self) -> usize {
566 self.revoked.read().unwrap().values().map(|s| s.len()).sum()
567 }
568
569 pub fn clear_issuer(&self, issuer_dn: &str) {
571 self.revoked.write().unwrap().remove(issuer_dn);
572 }
573}
574
575pub fn cert_thumbprint_s256(cert_der: &[u8]) -> String {
583 use base64::Engine;
584 use sha2::{Digest, Sha256};
585 let digest = Sha256::digest(cert_der);
586 base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(digest)
587}
588
589pub fn verify_cert_binding(cert_der: &[u8], expected_thumbprint: &str) -> Result<()> {
592 let actual = cert_thumbprint_s256(cert_der);
593 if actual == expected_thumbprint {
594 Ok(())
595 } else {
596 Err(AuthError::InvalidCredential {
597 credential_type: "certificate".to_string(),
598 message: format!(
599 "Certificate thumbprint mismatch: token bound to '{}', presented cert has '{}'",
600 expected_thumbprint, actual
601 ),
602 })
603 }
604}
605
606#[cfg(test)]
609mod tests {
610 use super::*;
611
612 #[test]
615 fn test_config_default() {
616 let cfg = ClientCertConfig::default();
617 assert!(cfg.trusted_ca_ders.is_empty());
618 assert!(cfg.subject_allowlist.is_empty());
619 assert!(cfg.issuer_allowlist.is_empty());
620 assert!(!cfg.require_san);
621 assert_eq!(cfg.token_lifetime_secs, 3600);
622 }
623
624 #[test]
625 fn test_config_builder_chain() {
626 let cfg = ClientCertConfig::new()
627 .allow_subject("alice")
628 .allow_issuer("MyCA")
629 .with_require_san();
630 assert_eq!(cfg.subject_allowlist, ["alice"]);
631 assert_eq!(cfg.issuer_allowlist, ["MyCA"]);
632 assert!(cfg.require_san);
633 }
634
635 #[test]
638 fn test_wrong_credential_type_rejected() {
639 let method = ClientCertAuthMethod::new(ClientCertConfig::new());
640 let cred = Credential::Password {
641 username: "u".into(),
642 password: "p".into(),
643 };
644 let err = method.authenticate(&cred).unwrap_err();
645 assert!(
646 format!("{err}").contains("Certificate"),
647 "unexpected: {err}"
648 );
649 }
650
651 #[test]
652 fn test_empty_der_rejected() {
653 let method = ClientCertAuthMethod::new(ClientCertConfig::new());
654 let cred = Credential::Certificate {
655 certificate: vec![],
656 private_key: vec![],
657 passphrase: None,
658 };
659 let err = method.authenticate(&cred).unwrap_err();
660 assert!(format!("{err}").contains("empty"), "unexpected: {err}");
661 }
662
663 #[test]
664 fn test_garbage_der_rejected() {
665 let method = ClientCertAuthMethod::new(ClientCertConfig::new());
666 let cred = Credential::Certificate {
667 certificate: vec![0xDE, 0xAD, 0xBE, 0xEF, 0x01, 0x02, 0x03, 0x04],
668 private_key: vec![],
669 passphrase: None,
670 };
671 assert!(method.authenticate(&cred).is_err());
672 }
673
674 fn build_cert_der(
684 cn: &str,
685 not_before_utc: &[u8; 13], not_after_utc: &[u8; 13],
687 ) -> Vec<u8> {
688 use ring::rand::SystemRandom;
689 use ring::signature::{Ed25519KeyPair, KeyPair};
690
691 let rng = SystemRandom::new();
692 let pkcs8 = Ed25519KeyPair::generate_pkcs8(&rng).unwrap();
693 let kp = Ed25519KeyPair::from_pkcs8(pkcs8.as_ref()).unwrap();
694 let pub_key = kp.public_key().as_ref(); let tlv = |tag: u8, content: &[u8]| -> Vec<u8> {
698 assert!(
699 content.len() < 128,
700 "content too large for short-form TLV: {} bytes",
701 content.len()
702 );
703 let mut v = vec![tag, content.len() as u8];
704 v.extend_from_slice(content);
705 v
706 };
707
708 let long_tlv = |tag: u8, content: &[u8]| -> Vec<u8> {
710 let len = content.len();
711 let mut v = vec![tag];
712 if len < 128 {
713 v.push(len as u8);
714 } else {
715 v.push(0x81);
717 v.push(len as u8);
718 }
719 v.extend_from_slice(content);
720 v
721 };
722
723 let alg_id = tlv(0x30, &[0x06, 0x03, 0x2B, 0x65, 0x70]);
725
726 let cn_bytes = cn.as_bytes();
728 let utf8_cn = tlv(0x0C, cn_bytes);
729 let oid_cn = [0x06u8, 0x03, 0x55, 0x04, 0x03];
730 let seq_atv = [oid_cn.as_slice(), utf8_cn.as_slice()].concat();
731 let name = tlv(0x30, &tlv(0x31, &tlv(0x30, &seq_atv)));
732
733 let nb_der = tlv(0x17, not_before_utc);
735 let na_der = tlv(0x17, not_after_utc);
736 let validity = tlv(0x30, &[nb_der.as_slice(), na_der.as_slice()].concat());
737
738 let mut bit_content = vec![0x00u8];
740 bit_content.extend_from_slice(pub_key);
741 let bit_str = tlv(0x03, &bit_content);
742 let spki = tlv(0x30, &[alg_id.as_slice(), bit_str.as_slice()].concat());
743
744 let version = [0xA0u8, 0x03, 0x02, 0x01, 0x02]; let serial = tlv(0x02, &[0x01]);
747 let tbs_body: Vec<u8> = [
748 version.as_slice(),
749 serial.as_slice(),
750 alg_id.as_slice(), name.as_slice(), validity.as_slice(),
753 name.as_slice(), spki.as_slice(),
755 ]
756 .concat();
757 let tbs = long_tlv(0x30, &tbs_body);
758
759 let sig = kp.sign(&tbs);
761 let mut sig_content = vec![0x00u8]; sig_content.extend_from_slice(sig.as_ref()); let sig_bit_str = tlv(0x03, &sig_content);
764
765 let cert_body: Vec<u8> =
767 [tbs.as_slice(), alg_id.as_slice(), sig_bit_str.as_slice()].concat();
768 long_tlv(0x30, &cert_body)
769 }
770
771 fn valid_cert(cn: &str) -> Vec<u8> {
774 build_cert_der(cn, b"250101000000Z", b"270101000000Z")
775 }
776 fn expired_cert(cn: &str) -> Vec<u8> {
778 build_cert_der(cn, b"200101000000Z", b"210101000000Z")
779 }
780 fn future_cert(cn: &str) -> Vec<u8> {
782 build_cert_der(cn, b"280101000000Z", b"300101000000Z")
783 }
784
785 fn cert_cred(der: Vec<u8>) -> Credential {
786 Credential::Certificate {
787 certificate: der,
788 private_key: vec![],
789 passphrase: None,
790 }
791 }
792
793 #[test]
796 fn test_valid_cert_accepted() {
797 let method = ClientCertAuthMethod::new(ClientCertConfig::new());
798 let id = method
799 .authenticate(&cert_cred(valid_cert("alice")))
800 .expect("valid cert should be accepted");
801 assert!(
802 id.subject_dn.contains("alice"),
803 "subject should contain CN: {}",
804 id.subject_dn
805 );
806 assert_eq!(id.common_name.as_deref(), Some("alice"));
807 }
808
809 #[test]
810 fn test_expired_cert_rejected() {
811 let method = ClientCertAuthMethod::new(ClientCertConfig::new());
812 let err = method
813 .authenticate(&cert_cred(expired_cert("bob")))
814 .unwrap_err();
815 let msg = format!("{err}");
816 assert!(msg.contains("expired"), "expected 'expired' in: {msg}");
817 }
818
819 #[test]
820 fn test_future_cert_rejected() {
821 let method = ClientCertAuthMethod::new(ClientCertConfig::new());
822 let err = method
823 .authenticate(&cert_cred(future_cert("carol")))
824 .unwrap_err();
825 let msg = format!("{err}");
826 assert!(msg.contains("valid"), "expected 'valid' in: {msg}");
827 }
828
829 #[test]
830 fn test_subject_allowlist_permits_matching_cn() {
831 let cfg = ClientCertConfig::new().allow_subject("alice");
832 assert!(
833 ClientCertAuthMethod::new(cfg)
834 .authenticate(&cert_cred(valid_cert("alice")))
835 .is_ok()
836 );
837 }
838
839 #[test]
840 fn test_subject_allowlist_blocks_non_matching_cn() {
841 let cfg = ClientCertConfig::new().allow_subject("alice");
842 let err = ClientCertAuthMethod::new(cfg)
843 .authenticate(&cert_cred(valid_cert("mallory")))
844 .unwrap_err();
845 let msg = format!("{err}");
846 assert!(msg.contains("allowlist"), "expected 'allowlist' in: {msg}");
847 }
848
849 #[test]
850 fn test_issuer_allowlist_permits_self_signed_when_matches() {
851 let cfg = ClientCertConfig::new().allow_issuer("alice");
853 assert!(
854 ClientCertAuthMethod::new(cfg)
855 .authenticate(&cert_cred(valid_cert("alice")))
856 .is_ok()
857 );
858 }
859
860 #[test]
861 fn test_issuer_allowlist_blocks_unmatched_issuer() {
862 let cfg = ClientCertConfig::new().allow_issuer("TrustedCorp");
863 let err = ClientCertAuthMethod::new(cfg)
864 .authenticate(&cert_cred(valid_cert("alice")))
865 .unwrap_err();
866 let msg = format!("{err}");
867 assert!(msg.contains("allowlist"), "expected 'allowlist' in: {msg}");
868 }
869
870 #[test]
871 fn test_require_san_rejects_cert_without_san() {
872 let cfg = ClientCertConfig::new().with_require_san();
874 let err = ClientCertAuthMethod::new(cfg)
875 .authenticate(&cert_cred(valid_cert("alice")))
876 .unwrap_err();
877 let msg = format!("{err}");
878 assert!(
879 msg.contains("Subject Alternative Name") || msg.contains("SAN"),
880 "expected SAN mention in: {msg}"
881 );
882 }
883
884 #[test]
885 fn test_trusted_ca_accepts_when_issuer_dn_matches() {
886 let der = valid_cert("alice");
889 let cfg = ClientCertConfig::new().trust_ca(der.clone());
890 assert!(
891 ClientCertAuthMethod::new(cfg)
892 .authenticate(&cert_cred(der))
893 .is_ok()
894 );
895 }
896
897 #[test]
898 fn test_trusted_ca_rejects_when_no_ca_matches() {
899 let untrusted_cert = valid_cert("alice");
900 let different_ca = valid_cert("OtherCA");
902 let cfg = ClientCertConfig::new().trust_ca(different_ca);
903 let err = ClientCertAuthMethod::new(cfg)
904 .authenticate(&cert_cred(untrusted_cert))
905 .unwrap_err();
906 let msg = format!("{err}");
907 assert!(
908 msg.contains("trusted CA") || msg.contains("issuer"),
909 "expected CA/issuer mention in: {msg}"
910 );
911 }
912
913 #[test]
914 fn test_client_cert_from_tls_constructor() {
915 let der = valid_cert("sys");
916 let cred = Credential::client_cert_from_tls(der.clone());
917 match &cred {
918 Credential::Certificate {
919 certificate,
920 private_key,
921 passphrase,
922 } => {
923 assert_eq!(certificate, &der);
924 assert!(private_key.is_empty(), "private_key should be empty");
925 assert!(passphrase.is_none());
926 }
927 _ => panic!("Expected Credential::Certificate"),
928 }
929
930 let method = ClientCertAuthMethod::new(ClientCertConfig::new());
932 assert!(method.authenticate(&cred).is_ok());
933 }
934
935 #[test]
936 fn test_issuer_dn_populated_in_identity() {
937 let method = ClientCertAuthMethod::new(ClientCertConfig::new());
938 let id = method
939 .authenticate(&cert_cred(valid_cert("charlie")))
940 .unwrap();
941 assert_eq!(id.issuer_dn, id.subject_dn);
943 }
944
945 #[test]
948 fn test_cert_pin_from_der() {
949 let der = valid_cert("pin-test");
950 let pin = CertPin::from_der(&der);
951 assert_eq!(pin.sha256_hex.len(), 64); }
953
954 #[test]
955 fn test_cert_pin_deterministic() {
956 let der = vec![0x30, 0x82, 0x01, 0x00];
957 let p1 = CertPin::from_der(&der);
958 let p2 = CertPin::from_der(&der);
959 assert_eq!(p1, p2);
960 }
961
962 #[test]
963 fn test_cert_pin_from_hex() {
964 let pin = CertPin::from_hex("AABB");
965 assert_eq!(pin.sha256_hex, "aabb"); }
967
968 #[test]
969 fn test_cert_pin_store_add_and_check() {
970 let store = CertPinStore::new();
971 let der = valid_cert("pinned");
972 let pin = CertPin::from_der(&der);
973 store.add(&pin);
974 assert_eq!(store.count(), 1);
975 assert!(store.is_pinned(&der));
976 assert!(!store.is_pinned(&valid_cert("not-pinned")));
977 }
978
979 #[test]
980 fn test_cert_pin_store_remove() {
981 let store = CertPinStore::new();
982 let der = valid_cert("removable");
983 let pin = CertPin::from_der(&der);
984 store.add(&pin);
985 assert!(store.remove(&pin));
986 assert!(!store.is_pinned(&der));
987 assert_eq!(store.count(), 0);
988 }
989
990 #[test]
993 fn test_crl_store_add_and_check() {
994 let store = CrlStore::new();
995 store.add_revoked("CN=TestCA", "0a1b2c");
996 assert_eq!(
997 store.check("CN=TestCA", "0a1b2c"),
998 RevocationStatus::Revoked { reason: None }
999 );
1000 assert_eq!(store.check("CN=TestCA", "ffffff"), RevocationStatus::Good);
1001 assert_eq!(store.check("CN=OtherCA", "0a1b2c"), RevocationStatus::Good);
1002 }
1003
1004 #[test]
1005 fn test_crl_store_case_insensitive_serial() {
1006 let store = CrlStore::new();
1007 store.add_revoked("CN=CA", "aAbBcC");
1008 assert_eq!(
1009 store.check("CN=CA", "AABBCC"),
1010 RevocationStatus::Revoked { reason: None }
1011 );
1012 }
1013
1014 #[test]
1015 fn test_crl_store_check_der() {
1016 let store = CrlStore::new();
1017 let der = valid_cert("crl-test");
1018 assert_eq!(store.check_der(&der), RevocationStatus::Good);
1020 }
1021
1022 #[test]
1023 fn test_crl_store_revoked_count() {
1024 let store = CrlStore::new();
1025 store.add_revoked("CN=CA1", "01");
1026 store.add_revoked("CN=CA1", "02");
1027 store.add_revoked("CN=CA2", "01");
1028 assert_eq!(store.revoked_count(), 3);
1029 }
1030
1031 #[test]
1032 fn test_crl_store_clear_issuer() {
1033 let store = CrlStore::new();
1034 store.add_revoked("CN=CA", "01");
1035 store.add_revoked("CN=CA", "02");
1036 store.clear_issuer("CN=CA");
1037 assert_eq!(store.revoked_count(), 0);
1038 }
1039
1040 #[test]
1043 fn test_cert_thumbprint_s256() {
1044 let der = valid_cert("rfc8705");
1045 let thumbprint = cert_thumbprint_s256(&der);
1046 assert_eq!(thumbprint.len(), 43);
1048 }
1049
1050 #[test]
1051 fn test_cert_thumbprint_deterministic() {
1052 let der = vec![0x30, 0x82, 0x00, 0x01];
1053 let t1 = cert_thumbprint_s256(&der);
1054 let t2 = cert_thumbprint_s256(&der);
1055 assert_eq!(t1, t2);
1056 }
1057
1058 #[test]
1059 fn test_verify_cert_binding_success() {
1060 let der = valid_cert("bound");
1061 let thumbprint = cert_thumbprint_s256(&der);
1062 assert!(verify_cert_binding(&der, &thumbprint).is_ok());
1063 }
1064
1065 #[test]
1066 fn test_verify_cert_binding_mismatch() {
1067 let der = valid_cert("bound");
1068 let err = verify_cert_binding(&der, "wrong-thumbprint").unwrap_err();
1069 let msg = format!("{err}");
1070 assert!(msg.contains("mismatch"), "expected 'mismatch' in: {msg}");
1071 }
1072}