rustls-letsencrypt 0.1.1

Automatic Let's Encrypt, ACME, and local-CA certificate management for rustls listeners
Documentation
use std::sync::Arc;

use rustls::{crypto::aws_lc_rs::sign::any_supported_type, pki_types::PrivateKeyDer, sign::CertifiedKey};
use rcgen::PublicKeyData;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use time::OffsetDateTime;
use zeroize::{Zeroize, ZeroizeOnDrop};

use crate::{DnsName, Error, Result};

#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum CertificateProvenance { Acme, Local }

#[derive(Clone, Serialize, Deserialize, Zeroize, ZeroizeOnDrop)]
pub struct SecretPem(String);
impl SecretPem { pub fn new(value: String) -> Self { Self(value) } pub fn expose(&self) -> &str { &self.0 } }
impl std::fmt::Debug for SecretPem { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.write_str("SecretPem([REDACTED])") } }

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct StoredCertificate {
    pub schema_version: u32,
    pub primary_name: DnsName,
    pub sans: Vec<DnsName>,
    pub private_key_pem: SecretPem,
    pub leaf_pem: String,
    pub chain_pem: Vec<String>,
    pub not_before: i64,
    pub not_after: i64,
    pub stored_at: i64,
    pub provenance: CertificateProvenance,
    pub issuer_id: String,
    pub fingerprint_sha256: String,
    pub local_ca_fingerprint_sha256: Option<String>,
}

impl StoredCertificate {
    #[must_use] pub fn is_valid_at(&self, now: i64) -> bool { self.not_before <= now && now < self.not_after }
    #[must_use] pub fn not_after(&self) -> i64 { self.not_after }
    #[must_use] pub fn issuer_id(&self) -> &str { &self.issuer_id }
    #[must_use] pub fn leaf_pem(&self) -> &str { &self.leaf_pem }
    #[must_use] pub fn chain_pem(&self) -> &[String] { &self.chain_pem }
    #[must_use] pub fn private_key_pem(&self) -> &str { self.private_key_pem.expose() }

    pub fn certified_key(&self) -> Result<Arc<CertifiedKey>> {
        let mut reader = self.leaf_pem.as_bytes();
        let mut certs = rustls_pemfile::certs(&mut reader).collect::<std::result::Result<Vec<_>, _>>()?;
        for pem in &self.chain_pem {
            let mut reader = pem.as_bytes();
            certs.extend(rustls_pemfile::certs(&mut reader).collect::<std::result::Result<Vec<_>, _>>()?);
        }
        let mut reader = self.private_key_pem.expose().as_bytes();
        let key = rustls_pemfile::private_key(&mut reader)?.ok_or_else(|| Error::Certificate("private key PEM is empty".into()))?;
        let signer = any_supported_type(&key).map_err(|e| Error::Certificate(e.to_string()))?;
        let certified = CertifiedKey::new(certs, signer);
        certified.keys_match().map_err(|e| Error::Certificate(e.to_string()))?;
        Ok(Arc::new(certified))
    }

    pub fn from_pem(
        name: DnsName, private_key_pem: String, leaf_pem: String, chain_pem: Vec<String>,
        provenance: CertificateProvenance, issuer_id: String, local_ca_fingerprint: Option<String>,
    ) -> Result<Self> {
        let (_, pem) = x509_parser::pem::parse_x509_pem(leaf_pem.as_bytes()).map_err(|e| Error::Certificate(e.to_string()))?;
        let (_, cert) = x509_parser::parse_x509_certificate(&pem.contents).map_err(|e| Error::Certificate(e.to_string()))?;
        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()))));
        if !san_matches { return Err(Error::Certificate(format!("certificate SAN does not cover {name}"))); }
        let not_before = cert.validity().not_before.timestamp();
        let not_after = cert.validity().not_after.timestamp();
        let fingerprint = hex_digest(&pem.contents);
        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 };
        let _ = record.certified_key()?;
        Ok(record)
    }
}

pub(crate) fn validate_local_signature(cert: &StoredCertificate, ca: &StoredLocalCa) -> Result<()> {
    let (_, leaf_pem) = x509_parser::pem::parse_x509_pem(cert.leaf_pem.as_bytes()).map_err(|e| Error::Certificate(e.to_string()))?;
    let (_, leaf) = x509_parser::parse_x509_certificate(&leaf_pem.contents).map_err(|e| Error::Certificate(e.to_string()))?;
    let (_, ca_pem) = x509_parser::pem::parse_x509_pem(ca.certificate_pem.as_bytes()).map_err(|e| Error::LocalCa(e.to_string()))?;
    let (_, issuer) = x509_parser::parse_x509_certificate(&ca_pem.contents).map_err(|e| Error::LocalCa(e.to_string()))?;
    leaf.verify_signature(Some(issuer.public_key())).map_err(|e| Error::Certificate(format!("local certificate signature is invalid: {e}")))
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct StoredLocalCa {
    pub certificate_pem: String,
    pub private_key_pem: SecretPem,
    pub fingerprint_sha256: String,
    pub created_at: i64,
}

impl StoredLocalCa {
    pub fn from_pem(certificate_pem: String, private_key_pem: String) -> Result<Self> {
        let key = rcgen::KeyPair::from_pem(&private_key_pem).map_err(|e| Error::LocalCa(e.to_string()))?;
        let (_, pem) = x509_parser::pem::parse_x509_pem(certificate_pem.as_bytes()).map_err(|e| Error::LocalCa(e.to_string()))?;
        let (_, cert) = x509_parser::parse_x509_certificate(&pem.contents).map_err(|e| Error::LocalCa(e.to_string()))?;
        if !cert.is_ca() { return Err(Error::LocalCa("certificate does not have CA basic constraints".into())); }
        if cert.public_key().raw != key.subject_public_key_info() { return Err(Error::LocalCa("CA private key does not match CA certificate".into())); }
        if let Some(usage) = cert.key_usage().map_err(|e| Error::LocalCa(e.to_string()))? {
            if !usage.value.key_cert_sign() { return Err(Error::LocalCa("CA key usage does not permit certificate signing".into())); }
        }
        let now = OffsetDateTime::now_utc().unix_timestamp();
        if now < cert.validity().not_before.timestamp() || now >= cert.validity().not_after.timestamp() { return Err(Error::LocalCa("CA certificate is not currently valid".into())); }
        rcgen::Issuer::from_ca_cert_pem(&certificate_pem, key).map_err(|e| Error::LocalCa(e.to_string()))?;
        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() })
    }
}

pub(crate) fn hex_digest(bytes: &[u8]) -> String { Sha256::digest(bytes).iter().map(|b| format!("{b:02x}")).collect() }

pub(crate) fn private_key_der(pem: &str) -> Result<PrivateKeyDer<'static>> {
    rustls_pemfile::private_key(&mut pem.as_bytes())?.ok_or_else(|| Error::Certificate("missing private key".into()))
}