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}