use std::{sync::Arc, time::Duration};
use async_trait::async_trait;
use rcgen::{BasicConstraints, CertificateParams, CertifiedIssuer, DistinguishedName, DnType, IsCa, KeyPair, KeyUsagePurpose};
use time::OffsetDateTime;
use tokio::sync::RwLock;
use crate::{CertificateProvenance, DnsName, Error, Result, StoredCertificate, StoredLocalCa, event::{EventBus, EventKind, EventLevel}, store::{CertStore, StoreRevision}};
#[derive(Clone, Copy, Debug)]
pub enum IssueReason { Initial, Renewal, Fallback }
#[derive(Clone, Debug)]
pub struct IssueRequest {
pub domain: DnsName,
pub reason: IssueReason,
pub deadline: tokio::time::Instant,
}
pub type IssuedCertificate = StoredCertificate;
#[async_trait]
pub trait CertIssuer: Send + Sync + 'static {
fn id(&self) -> &str;
fn provenance(&self) -> CertificateProvenance;
async fn issue(&self, request: IssueRequest) -> Result<IssuedCertificate>;
}
pub struct LocalCaIssuer {
store: Arc<dyn CertStore>,
ca: RwLock<(StoreRevision, StoredLocalCa)>,
leaf_validity_days: u32,
events: Arc<EventBus>,
}
impl LocalCaIssuer {
pub(crate) async fn load_or_create(store: Arc<dyn CertStore>, leaf_validity_days: u32, events: Arc<EventBus>) -> Result<Self> {
let (revision, ca) = if let Some(pair) = store.local().load_ca().await? {
events.emit(EventLevel::Info, EventKind::LocalCaLoaded { fingerprint: pair.1.fingerprint_sha256.clone() });
pair
} else {
let ca = generate_ca()?;
let revision = store.local().compare_and_swap_ca(None, &ca).await?;
events.emit(EventLevel::Info, EventKind::LocalCaGenerated { fingerprint: ca.fingerprint_sha256.clone() });
(revision, ca)
};
Ok(Self { store, ca: RwLock::new((revision, ca)), leaf_validity_days, events })
}
pub(crate) async fn ca(&self) -> StoredLocalCa { self.ca.read().await.1.clone() }
pub(crate) async fn install(&self, replacement: StoredLocalCa) -> Result<(String, String)> {
let mut ca = self.ca.write().await;
let old = ca.1.fingerprint_sha256.clone();
let revision = self.store.local().compare_and_swap_ca(Some(ca.0), &replacement).await?;
let new = replacement.fingerprint_sha256.clone();
*ca = (revision, replacement);
self.events.emit(EventLevel::Info, EventKind::LocalCaReplaced { old_fingerprint: old.clone(), new_fingerprint: new.clone() });
Ok((old, new))
}
pub(crate) async fn reload(&self) -> Result<Option<(String, String)>> {
self.events.emit(EventLevel::Info, EventKind::LocalCaReloadStarted);
let Some((revision, replacement)) = self.store.local().load_ca().await? else { return Err(Error::LocalCa("CA files disappeared".into())); };
let mut ca = self.ca.write().await;
if replacement.fingerprint_sha256 == ca.1.fingerprint_sha256 { return Ok(None); }
let old = ca.1.fingerprint_sha256.clone();
let new = replacement.fingerprint_sha256.clone();
*ca = (revision, replacement);
self.events.emit(EventLevel::Info, EventKind::LocalCaReplaced { old_fingerprint: old.clone(), new_fingerprint: new.clone() });
Ok(Some((old, new)))
}
}
#[async_trait]
impl CertIssuer for LocalCaIssuer {
fn id(&self) -> &str { "AcmeLocalCA" }
fn provenance(&self) -> CertificateProvenance { CertificateProvenance::Local }
async fn issue(&self, request: IssueRequest) -> Result<IssuedCertificate> {
let remaining = request.deadline.saturating_duration_since(tokio::time::Instant::now());
tokio::time::timeout(remaining, self.issue_inner(request.domain)).await.map_err(|_| Error::IssuanceTimeout("AcmeLocalCA".into()))?
}
}
impl LocalCaIssuer {
async fn issue_inner(&self, domain: DnsName) -> Result<StoredCertificate> {
let ca = self.ca.read().await.1.clone();
let issuer_key = KeyPair::from_pem(ca.private_key_pem.expose()).map_err(|e| Error::LocalCa(e.to_string()))?;
let issuer = rcgen::Issuer::from_ca_cert_pem(&ca.certificate_pem, issuer_key).map_err(|e| Error::LocalCa(e.to_string()))?;
let leaf_key = KeyPair::generate().map_err(|e| Error::Certificate(e.to_string()))?;
let mut params = CertificateParams::new(vec![domain.as_str().to_owned()]).map_err(|e| Error::Certificate(e.to_string()))?;
params.distinguished_name = DistinguishedName::new();
params.distinguished_name.push(DnType::CommonName, domain.as_str());
params.not_before = OffsetDateTime::now_utc() - Duration::from_secs(300);
params.not_after = OffsetDateTime::now_utc() + Duration::from_secs(u64::from(self.leaf_validity_days) * 86_400);
params.key_usages = vec![KeyUsagePurpose::DigitalSignature];
let cert = params.signed_by(&leaf_key, &issuer).map_err(|e| Error::Certificate(e.to_string()))?;
StoredCertificate::from_pem(domain, leaf_key.serialize_pem(), cert.pem(), vec![ca.certificate_pem], CertificateProvenance::Local, self.id().to_owned(), Some(ca.fingerprint_sha256))
}
}
fn generate_ca() -> Result<StoredLocalCa> {
let key = KeyPair::generate().map_err(|e| Error::LocalCa(e.to_string()))?;
let key_pem = key.serialize_pem();
let mut dn = DistinguishedName::new();
dn.push(DnType::CommonName, "AcmeLocalCA");
let mut params = CertificateParams::default();
params.distinguished_name = dn;
params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
params.key_usages = vec![KeyUsagePurpose::KeyCertSign, KeyUsagePurpose::CrlSign, KeyUsagePurpose::DigitalSignature];
params.not_before = OffsetDateTime::now_utc() - Duration::from_secs(300);
params.not_after = OffsetDateTime::now_utc() + Duration::from_secs(10 * 365 * 86_400);
let issuer = CertifiedIssuer::self_signed(params, key).map_err(|e| Error::LocalCa(e.to_string()))?;
StoredLocalCa::from_pem(issuer.as_ref().pem(), key_pem)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{EventOutput, FolderCertStore, store::CertStore};
#[tokio::test]
async fn local_issuer_generates_usable_leaf() {
let directory = tempfile::tempdir().unwrap();
let store: Arc<dyn CertStore> = Arc::new(FolderCertStore::open(directory.path()).await.unwrap());
let events = Arc::new(EventBus::new(16, 16, EventOutput::Subscribe, None));
let issuer = LocalCaIssuer::load_or_create(Arc::clone(&store), 30, events).await.unwrap();
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();
assert_eq!(cert.provenance, CertificateProvenance::Local);
assert!(cert.certified_key().is_ok());
let ca = issuer.ca().await;
assert_eq!(cert.local_ca_fingerprint_sha256.as_deref(), Some(ca.fingerprint_sha256.as_str()));
}
#[test]
fn rejects_mismatched_ca_key() {
let first = generate_ca().unwrap();
let second = generate_ca().unwrap();
assert!(StoredLocalCa::from_pem(first.certificate_pem, second.private_key_pem.expose().to_owned()).is_err());
}
}