rustls-letsencrypt 0.1.3

Automatic Let's Encrypt, ACME, and local-CA certificate management for rustls listeners
Documentation
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());
    }
}