Skip to main content

rustls_letsencrypt/
issuer.rs

1use std::{sync::Arc, time::Duration};
2
3use async_trait::async_trait;
4use rcgen::{BasicConstraints, CertificateParams, CertifiedIssuer, DistinguishedName, DnType, IsCa, KeyPair, KeyUsagePurpose};
5use time::OffsetDateTime;
6use tokio::sync::RwLock;
7
8use crate::{CertificateProvenance, DnsName, Error, Result, StoredCertificate, StoredLocalCa, event::{EventBus, EventKind, EventLevel}, store::{CertStore, StoreRevision}};
9
10#[derive(Clone, Copy, Debug)]
11pub enum IssueReason { Initial, Renewal, Fallback }
12
13#[derive(Clone, Debug)]
14pub struct IssueRequest {
15    pub domain: DnsName,
16    pub reason: IssueReason,
17    pub deadline: tokio::time::Instant,
18}
19
20pub type IssuedCertificate = StoredCertificate;
21
22#[async_trait]
23pub trait CertIssuer: Send + Sync + 'static {
24    fn id(&self) -> &str;
25    fn provenance(&self) -> CertificateProvenance;
26    async fn issue(&self, request: IssueRequest) -> Result<IssuedCertificate>;
27}
28
29pub struct LocalCaIssuer {
30    store: Arc<dyn CertStore>,
31    ca: RwLock<(StoreRevision, StoredLocalCa)>,
32    leaf_validity_days: u32,
33    events: Arc<EventBus>,
34}
35
36impl LocalCaIssuer {
37    pub(crate) async fn load_or_create(store: Arc<dyn CertStore>, leaf_validity_days: u32, events: Arc<EventBus>) -> Result<Self> {
38        let (revision, ca) = if let Some(pair) = store.local().load_ca().await? {
39            events.emit(EventLevel::Info, EventKind::LocalCaLoaded { fingerprint: pair.1.fingerprint_sha256.clone() });
40            pair
41        } else {
42            let ca = generate_ca()?;
43            let revision = store.local().compare_and_swap_ca(None, &ca).await?;
44            events.emit(EventLevel::Info, EventKind::LocalCaGenerated { fingerprint: ca.fingerprint_sha256.clone() });
45            (revision, ca)
46        };
47        Ok(Self { store, ca: RwLock::new((revision, ca)), leaf_validity_days, events })
48    }
49
50    pub(crate) async fn ca(&self) -> StoredLocalCa { self.ca.read().await.1.clone() }
51
52    pub(crate) async fn install(&self, replacement: StoredLocalCa) -> Result<(String, String)> {
53        let mut ca = self.ca.write().await;
54        let old = ca.1.fingerprint_sha256.clone();
55        let revision = self.store.local().compare_and_swap_ca(Some(ca.0), &replacement).await?;
56        let new = replacement.fingerprint_sha256.clone();
57        *ca = (revision, replacement);
58        self.events.emit(EventLevel::Info, EventKind::LocalCaReplaced { old_fingerprint: old.clone(), new_fingerprint: new.clone() });
59        Ok((old, new))
60    }
61
62    pub(crate) async fn reload(&self) -> Result<Option<(String, String)>> {
63        self.events.emit(EventLevel::Info, EventKind::LocalCaReloadStarted);
64        let Some((revision, replacement)) = self.store.local().load_ca().await? else { return Err(Error::LocalCa("CA files disappeared".into())); };
65        let mut ca = self.ca.write().await;
66        if replacement.fingerprint_sha256 == ca.1.fingerprint_sha256 { return Ok(None); }
67        let old = ca.1.fingerprint_sha256.clone();
68        let new = replacement.fingerprint_sha256.clone();
69        *ca = (revision, replacement);
70        self.events.emit(EventLevel::Info, EventKind::LocalCaReplaced { old_fingerprint: old.clone(), new_fingerprint: new.clone() });
71        Ok(Some((old, new)))
72    }
73}
74
75#[async_trait]
76impl CertIssuer for LocalCaIssuer {
77    fn id(&self) -> &str { "AcmeLocalCA" }
78    fn provenance(&self) -> CertificateProvenance { CertificateProvenance::Local }
79    async fn issue(&self, request: IssueRequest) -> Result<IssuedCertificate> {
80        let remaining = request.deadline.saturating_duration_since(tokio::time::Instant::now());
81        tokio::time::timeout(remaining, self.issue_inner(request.domain)).await.map_err(|_| Error::IssuanceTimeout("AcmeLocalCA".into()))?
82    }
83}
84
85impl LocalCaIssuer {
86    async fn issue_inner(&self, domain: DnsName) -> Result<StoredCertificate> {
87        let ca = self.ca.read().await.1.clone();
88        let issuer_key = KeyPair::from_pem(ca.private_key_pem.expose()).map_err(|e| Error::LocalCa(e.to_string()))?;
89        let issuer = rcgen::Issuer::from_ca_cert_pem(&ca.certificate_pem, issuer_key).map_err(|e| Error::LocalCa(e.to_string()))?;
90        let leaf_key = KeyPair::generate().map_err(|e| Error::Certificate(e.to_string()))?;
91        let mut params = CertificateParams::new(vec![domain.as_str().to_owned()]).map_err(|e| Error::Certificate(e.to_string()))?;
92        params.distinguished_name = DistinguishedName::new();
93        params.distinguished_name.push(DnType::CommonName, domain.as_str());
94        params.not_before = OffsetDateTime::now_utc() - Duration::from_secs(300);
95        params.not_after = OffsetDateTime::now_utc() + Duration::from_secs(u64::from(self.leaf_validity_days) * 86_400);
96        params.key_usages = vec![KeyUsagePurpose::DigitalSignature];
97        let cert = params.signed_by(&leaf_key, &issuer).map_err(|e| Error::Certificate(e.to_string()))?;
98        StoredCertificate::from_pem(domain, leaf_key.serialize_pem(), cert.pem(), vec![ca.certificate_pem], CertificateProvenance::Local, self.id().to_owned(), Some(ca.fingerprint_sha256))
99    }
100}
101
102fn generate_ca() -> Result<StoredLocalCa> {
103    let key = KeyPair::generate().map_err(|e| Error::LocalCa(e.to_string()))?;
104    let key_pem = key.serialize_pem();
105    let mut dn = DistinguishedName::new();
106    dn.push(DnType::CommonName, "AcmeLocalCA");
107    let mut params = CertificateParams::default();
108    params.distinguished_name = dn;
109    params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
110    params.key_usages = vec![KeyUsagePurpose::KeyCertSign, KeyUsagePurpose::CrlSign, KeyUsagePurpose::DigitalSignature];
111    params.not_before = OffsetDateTime::now_utc() - Duration::from_secs(300);
112    params.not_after = OffsetDateTime::now_utc() + Duration::from_secs(10 * 365 * 86_400);
113    let issuer = CertifiedIssuer::self_signed(params, key).map_err(|e| Error::LocalCa(e.to_string()))?;
114    StoredLocalCa::from_pem(issuer.as_ref().pem(), key_pem)
115}
116
117#[cfg(test)]
118mod tests {
119    use super::*;
120    use crate::{EventOutput, FolderCertStore, store::CertStore};
121
122    #[tokio::test]
123    async fn local_issuer_generates_usable_leaf() {
124        let directory = tempfile::tempdir().unwrap();
125        let store: Arc<dyn CertStore> = Arc::new(FolderCertStore::open(directory.path()).await.unwrap());
126        let events = Arc::new(EventBus::new(16, 16, EventOutput::Subscribe, None));
127        let issuer = LocalCaIssuer::load_or_create(Arc::clone(&store), 30, events).await.unwrap();
128        let cert = issuer.issue(IssueRequest { domain: DnsName::parse("example.com").unwrap(), reason: IssueReason::Initial, deadline: tokio::time::Instant::now() + Duration::from_secs(5) }).await.unwrap();
129        assert_eq!(cert.provenance, CertificateProvenance::Local);
130        assert!(cert.certified_key().is_ok());
131        let ca = issuer.ca().await;
132        assert_eq!(cert.local_ca_fingerprint_sha256.as_deref(), Some(ca.fingerprint_sha256.as_str()));
133    }
134
135    #[test]
136    fn rejects_mismatched_ca_key() {
137        let first = generate_ca().unwrap();
138        let second = generate_ca().unwrap();
139        assert!(StoredLocalCa::from_pem(first.certificate_pem, second.private_key_pem.expose().to_owned()).is_err());
140    }
141}