rustls_letsencrypt/
cert.rs1use std::sync::Arc;
2
3use rustls::{crypto::aws_lc_rs::sign::any_supported_type, pki_types::PrivateKeyDer, sign::CertifiedKey};
4use rcgen::PublicKeyData;
5use serde::{Deserialize, Serialize};
6use sha2::{Digest, Sha256};
7use time::OffsetDateTime;
8use zeroize::{Zeroize, ZeroizeOnDrop};
9
10use crate::{DnsName, Error, Result};
11
12#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
13#[serde(rename_all = "snake_case")]
14pub enum CertificateProvenance { Acme, Local }
15
16#[derive(Clone, Serialize, Deserialize, Zeroize, ZeroizeOnDrop)]
17pub struct SecretPem(String);
18impl SecretPem { pub fn new(value: String) -> Self { Self(value) } pub fn expose(&self) -> &str { &self.0 } }
19impl std::fmt::Debug for SecretPem { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.write_str("SecretPem([REDACTED])") } }
20
21#[derive(Clone, Debug, Serialize, Deserialize)]
22pub struct StoredCertificate {
23 pub schema_version: u32,
24 pub primary_name: DnsName,
25 pub sans: Vec<DnsName>,
26 pub private_key_pem: SecretPem,
27 pub leaf_pem: String,
28 pub chain_pem: Vec<String>,
29 pub not_before: i64,
30 pub not_after: i64,
31 pub stored_at: i64,
32 pub provenance: CertificateProvenance,
33 pub issuer_id: String,
34 pub fingerprint_sha256: String,
35 pub local_ca_fingerprint_sha256: Option<String>,
36}
37
38impl StoredCertificate {
39 #[must_use] pub fn is_valid_at(&self, now: i64) -> bool { self.not_before <= now && now < self.not_after }
40 #[must_use] pub fn not_after(&self) -> i64 { self.not_after }
41 #[must_use] pub fn issuer_id(&self) -> &str { &self.issuer_id }
42 #[must_use] pub fn leaf_pem(&self) -> &str { &self.leaf_pem }
43 #[must_use] pub fn chain_pem(&self) -> &[String] { &self.chain_pem }
44 #[must_use] pub fn private_key_pem(&self) -> &str { self.private_key_pem.expose() }
45
46 pub fn certified_key(&self) -> Result<Arc<CertifiedKey>> {
47 let mut reader = self.leaf_pem.as_bytes();
48 let mut certs = rustls_pemfile::certs(&mut reader).collect::<std::result::Result<Vec<_>, _>>()?;
49 for pem in &self.chain_pem {
50 let mut reader = pem.as_bytes();
51 certs.extend(rustls_pemfile::certs(&mut reader).collect::<std::result::Result<Vec<_>, _>>()?);
52 }
53 let mut reader = self.private_key_pem.expose().as_bytes();
54 let key = rustls_pemfile::private_key(&mut reader)?.ok_or_else(|| Error::Certificate("private key PEM is empty".into()))?;
55 let signer = any_supported_type(&key).map_err(|e| Error::Certificate(e.to_string()))?;
56 let certified = CertifiedKey::new(certs, signer);
57 certified.keys_match().map_err(|e| Error::Certificate(e.to_string()))?;
58 Ok(Arc::new(certified))
59 }
60
61 pub fn from_pem(
62 name: DnsName, private_key_pem: String, leaf_pem: String, chain_pem: Vec<String>,
63 provenance: CertificateProvenance, issuer_id: String, local_ca_fingerprint: Option<String>,
64 ) -> Result<Self> {
65 let (_, pem) = x509_parser::pem::parse_x509_pem(leaf_pem.as_bytes()).map_err(|e| Error::Certificate(e.to_string()))?;
66 let (_, cert) = x509_parser::parse_x509_certificate(&pem.contents).map_err(|e| Error::Certificate(e.to_string()))?;
67 let san_matches = cert.subject_alternative_name().map_err(|e| Error::Certificate(e.to_string()))?.is_some_and(|extension| extension.value.general_names.iter().any(|value| matches!(value, x509_parser::extensions::GeneralName::DNSName(candidate) if candidate.eq_ignore_ascii_case(name.as_str()))));
68 if !san_matches { return Err(Error::Certificate(format!("certificate SAN does not cover {name}"))); }
69 let not_before = cert.validity().not_before.timestamp();
70 let not_after = cert.validity().not_after.timestamp();
71 let fingerprint = hex_digest(&pem.contents);
72 let record = Self { schema_version: 1, primary_name: name.clone(), sans: vec![name], private_key_pem: SecretPem::new(private_key_pem), leaf_pem, chain_pem, not_before, not_after, stored_at: OffsetDateTime::now_utc().unix_timestamp(), provenance, issuer_id, fingerprint_sha256: fingerprint, local_ca_fingerprint_sha256: local_ca_fingerprint };
73 let _ = record.certified_key()?;
74 Ok(record)
75 }
76}
77
78pub(crate) fn validate_local_signature(cert: &StoredCertificate, ca: &StoredLocalCa) -> Result<()> {
79 let (_, leaf_pem) = x509_parser::pem::parse_x509_pem(cert.leaf_pem.as_bytes()).map_err(|e| Error::Certificate(e.to_string()))?;
80 let (_, leaf) = x509_parser::parse_x509_certificate(&leaf_pem.contents).map_err(|e| Error::Certificate(e.to_string()))?;
81 let (_, ca_pem) = x509_parser::pem::parse_x509_pem(ca.certificate_pem.as_bytes()).map_err(|e| Error::LocalCa(e.to_string()))?;
82 let (_, issuer) = x509_parser::parse_x509_certificate(&ca_pem.contents).map_err(|e| Error::LocalCa(e.to_string()))?;
83 leaf.verify_signature(Some(issuer.public_key())).map_err(|e| Error::Certificate(format!("local certificate signature is invalid: {e}")))
84}
85
86#[derive(Clone, Debug, Serialize, Deserialize)]
87pub struct StoredLocalCa {
88 pub certificate_pem: String,
89 pub private_key_pem: SecretPem,
90 pub fingerprint_sha256: String,
91 pub created_at: i64,
92}
93
94impl StoredLocalCa {
95 pub fn from_pem(certificate_pem: String, private_key_pem: String) -> Result<Self> {
96 let key = rcgen::KeyPair::from_pem(&private_key_pem).map_err(|e| Error::LocalCa(e.to_string()))?;
97 let (_, pem) = x509_parser::pem::parse_x509_pem(certificate_pem.as_bytes()).map_err(|e| Error::LocalCa(e.to_string()))?;
98 let (_, cert) = x509_parser::parse_x509_certificate(&pem.contents).map_err(|e| Error::LocalCa(e.to_string()))?;
99 if !cert.is_ca() { return Err(Error::LocalCa("certificate does not have CA basic constraints".into())); }
100 if cert.public_key().raw != key.subject_public_key_info() { return Err(Error::LocalCa("CA private key does not match CA certificate".into())); }
101 if let Some(usage) = cert.key_usage().map_err(|e| Error::LocalCa(e.to_string()))? {
102 if !usage.value.key_cert_sign() { return Err(Error::LocalCa("CA key usage does not permit certificate signing".into())); }
103 }
104 let now = OffsetDateTime::now_utc().unix_timestamp();
105 if now < cert.validity().not_before.timestamp() || now >= cert.validity().not_after.timestamp() { return Err(Error::LocalCa("CA certificate is not currently valid".into())); }
106 rcgen::Issuer::from_ca_cert_pem(&certificate_pem, key).map_err(|e| Error::LocalCa(e.to_string()))?;
107 Ok(Self { fingerprint_sha256: hex_digest(&pem.contents), certificate_pem, private_key_pem: SecretPem::new(private_key_pem), created_at: OffsetDateTime::now_utc().unix_timestamp() })
108 }
109}
110
111pub(crate) fn hex_digest(bytes: &[u8]) -> String { Sha256::digest(bytes).iter().map(|b| format!("{b:02x}")).collect() }
112
113pub(crate) fn private_key_der(pem: &str) -> Result<PrivateKeyDer<'static>> {
114 rustls_pemfile::private_key(&mut pem.as_bytes())?.ok_or_else(|| Error::Certificate("missing private key".into()))
115}