Skip to main content

rustls_letsencrypt/
store.rs

1use std::{path::{Path, PathBuf}, sync::{Arc, atomic::{AtomicU64, Ordering}}};
2
3use async_trait::async_trait;
4use serde::{Deserialize, Serialize, de::DeserializeOwned};
5use sha2::{Digest, Sha256};
6use tokio::sync::{Mutex, broadcast};
7use url::Url;
8
9use crate::{DnsName, StoreError, StoredCertificate, StoredLocalCa};
10
11#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
12pub struct StoreRevision(pub u64);
13
14#[derive(Clone, Copy, Debug, Default)]
15pub struct StoreCapabilities { pub transactions: bool, pub change_notifications: bool, pub multi_process_writers: bool, pub durable_quarantine: bool }
16
17#[derive(Clone, Debug)]
18pub enum StoreChange { AcmeCertificate(DnsName), LocalCertificate(DnsName), LocalCa, Account(String) }
19
20pub type StoreChangeStream = broadcast::Receiver<StoreChange>;
21
22#[derive(Clone, Debug, Serialize, Deserialize)]
23pub struct StoredAccount { pub directory_url: Url, pub credentials_json: serde_json::Value }
24
25#[derive(Clone, Debug, Serialize, Deserialize)]
26pub struct StoredRetryState { pub domain: DnsName, pub issuer_id: String, pub failures: u32, pub retry_at: i64 }
27
28#[async_trait]
29pub trait CertStore: Send + Sync + 'static {
30    fn acme(&self) -> &dyn AcmeStoreNamespace;
31    fn local(&self) -> &dyn LocalStoreNamespace;
32    fn subscribe_changes(&self) -> StoreChangeStream;
33    fn capabilities(&self) -> StoreCapabilities;
34}
35
36#[async_trait]
37pub trait AcmeStoreNamespace: Send + Sync {
38    async fn load_certificate(&self, name: &DnsName, issuer: &str) -> Result<Option<StoredCertificate>, StoreError>;
39    async fn list_certificates(&self) -> Result<Vec<StoredCertificate>, StoreError>;
40    async fn commit_certificate(&self, cert: &StoredCertificate) -> Result<StoreRevision, StoreError>;
41    async fn remove_certificate(&self, name: &DnsName, issuer: &str) -> Result<StoreRevision, StoreError>;
42    async fn quarantine_certificate(&self, cert: &StoredCertificate, reason: &str) -> Result<StoreRevision, StoreError>;
43    async fn load_account(&self, directory: &Url) -> Result<Option<StoredAccount>, StoreError>;
44    async fn save_account(&self, account: &StoredAccount) -> Result<StoreRevision, StoreError>;
45    async fn load_retry_state(&self, name: &DnsName, issuer: &str) -> Result<Option<StoredRetryState>, StoreError>;
46    async fn save_retry_state(&self, state: &StoredRetryState) -> Result<StoreRevision, StoreError>;
47}
48
49#[async_trait]
50pub trait LocalStoreNamespace: Send + Sync {
51    async fn load_certificate(&self, name: &DnsName) -> Result<Option<StoredCertificate>, StoreError>;
52    async fn list_certificates(&self) -> Result<Vec<StoredCertificate>, StoreError>;
53    async fn commit_certificate(&self, cert: &StoredCertificate) -> Result<StoreRevision, StoreError>;
54    async fn remove_certificate(&self, name: &DnsName) -> Result<StoreRevision, StoreError>;
55    async fn quarantine_certificate(&self, cert: &StoredCertificate, reason: &str) -> Result<StoreRevision, StoreError>;
56    async fn load_ca(&self) -> Result<Option<(StoreRevision, StoredLocalCa)>, StoreError>;
57    async fn compare_and_swap_ca(&self, expected: Option<StoreRevision>, replacement: &StoredLocalCa) -> Result<StoreRevision, StoreError>;
58    async fn load_retry_state(&self, name: &DnsName) -> Result<Option<StoredRetryState>, StoreError>;
59    async fn save_retry_state(&self, state: &StoredRetryState) -> Result<StoreRevision, StoreError>;
60}
61
62pub struct FolderCertStore {
63    root: PathBuf,
64    write_lock: Mutex<()>,
65    revision: AtomicU64,
66    changes: broadcast::Sender<StoreChange>,
67}
68
69impl FolderCertStore {
70    pub async fn open(path: impl Into<PathBuf>) -> Result<Self, StoreError> {
71        let root = path.into();
72        for child in ["accounts", "ACME", "Local", "quarantine/ACME", "quarantine/Local", "retry/ACME", "retry/Local"] {
73            tokio::fs::create_dir_all(root.join(child)).await?;
74        }
75        let (changes, _) = broadcast::channel(256);
76        Ok(Self { root, write_lock: Mutex::new(()), revision: AtomicU64::new(1), changes })
77    }
78
79    #[must_use] pub fn root(&self) -> &Path { &self.root }
80    fn next_revision(&self) -> StoreRevision { StoreRevision(self.revision.fetch_add(1, Ordering::SeqCst)) }
81    fn cert_file(&self, namespace: &str, name: &DnsName, issuer: Option<&str>) -> PathBuf {
82        let key = match issuer { Some(i) => format!("{}\0{i}", name.as_str()), None => name.as_str().to_owned() };
83        self.root.join(namespace).join(format!("{}.json", hash_name(&key)))
84    }
85    async fn read_json<T: DeserializeOwned>(&self, path: &Path) -> Result<Option<T>, StoreError> {
86        match tokio::fs::read(path).await {
87            Ok(bytes) => Ok(Some(serde_json::from_slice(&bytes)?)),
88            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
89            Err(e) => Err(e.into()),
90        }
91    }
92    async fn write_json<T: Serialize + Sync>(&self, path: &Path, value: &T, secret: bool) -> Result<(), StoreError> {
93        let bytes = serde_json::to_vec_pretty(value)?;
94        self.atomic_write(path, &bytes, secret).await
95    }
96    async fn atomic_write(&self, path: &Path, bytes: &[u8], secret: bool) -> Result<(), StoreError> {
97        let parent = path.parent().ok_or_else(|| StoreError::Corrupt("path has no parent".into()))?;
98        tokio::fs::create_dir_all(parent).await?;
99        let temp = parent.join(format!(".{}.{}.tmp", path.file_name().and_then(|v| v.to_str()).unwrap_or("record"), self.revision.load(Ordering::Relaxed)));
100        let mut options = tokio::fs::OpenOptions::new();
101        options.create_new(true).write(true);
102        #[cfg(unix)] { options.mode(if secret { 0o600 } else { 0o644 }); }
103        let mut file = options.open(&temp).await?;
104        use tokio::io::AsyncWriteExt;
105        file.write_all(bytes).await?;
106        file.sync_all().await?;
107        drop(file);
108        tokio::fs::rename(&temp, path).await?;
109        Ok(())
110    }
111    async fn list_json<T: DeserializeOwned>(&self, dir: &Path) -> Result<Vec<T>, StoreError> {
112        let mut entries = tokio::fs::read_dir(dir).await?;
113        let mut values = Vec::new();
114        while let Some(entry) = entries.next_entry().await? {
115            if entry.path().extension().is_some_and(|v| v == "json") {
116                if let Some(value) = self.read_json(&entry.path()).await? { values.push(value); }
117            }
118        }
119        Ok(values)
120    }
121    async fn remove_file(&self, path: &Path) -> Result<(), StoreError> {
122        match tokio::fs::remove_file(path).await { Ok(()) => Ok(()), Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()), Err(e) => Err(e.into()) }
123    }
124}
125
126impl CertStore for FolderCertStore {
127    fn acme(&self) -> &dyn AcmeStoreNamespace { self }
128    fn local(&self) -> &dyn LocalStoreNamespace { self }
129    fn subscribe_changes(&self) -> StoreChangeStream { self.changes.subscribe() }
130    fn capabilities(&self) -> StoreCapabilities { StoreCapabilities { transactions: false, change_notifications: true, multi_process_writers: false, durable_quarantine: true } }
131}
132
133#[async_trait]
134impl AcmeStoreNamespace for FolderCertStore {
135    async fn load_certificate(&self, name: &DnsName, issuer: &str) -> Result<Option<StoredCertificate>, StoreError> { self.read_json(&self.cert_file("ACME", name, Some(issuer))).await }
136    async fn list_certificates(&self) -> Result<Vec<StoredCertificate>, StoreError> { self.list_json(&self.root.join("ACME")).await }
137    async fn commit_certificate(&self, cert: &StoredCertificate) -> Result<StoreRevision, StoreError> { let _g = self.write_lock.lock().await; self.write_json(&self.cert_file("ACME", &cert.primary_name, Some(&cert.issuer_id)), cert, true).await?; let r = self.next_revision(); let _ = self.changes.send(StoreChange::AcmeCertificate(cert.primary_name.clone())); Ok(r) }
138    async fn remove_certificate(&self, name: &DnsName, issuer: &str) -> Result<StoreRevision, StoreError> { let _g = self.write_lock.lock().await; self.remove_file(&self.cert_file("ACME", name, Some(issuer))).await?; Ok(self.next_revision()) }
139    async fn quarantine_certificate(&self, cert: &StoredCertificate, reason: &str) -> Result<StoreRevision, StoreError> { let _g = self.write_lock.lock().await; let p = self.root.join("quarantine/ACME").join(format!("{}-{}.json", hash_name(cert.primary_name.as_str()), hash_name(reason))); self.write_json(&p, cert, true).await?; self.remove_file(&self.cert_file("ACME", &cert.primary_name, Some(&cert.issuer_id))).await?; Ok(self.next_revision()) }
140    async fn load_account(&self, directory: &Url) -> Result<Option<StoredAccount>, StoreError> { self.read_json(&self.root.join("accounts").join(format!("{}.json", hash_name(directory.as_str())))).await }
141    async fn save_account(&self, account: &StoredAccount) -> Result<StoreRevision, StoreError> { let _g = self.write_lock.lock().await; self.write_json(&self.root.join("accounts").join(format!("{}.json", hash_name(account.directory_url.as_str()))), account, true).await?; Ok(self.next_revision()) }
142    async fn load_retry_state(&self, name: &DnsName, issuer: &str) -> Result<Option<StoredRetryState>, StoreError> { self.read_json(&self.root.join("retry/ACME").join(format!("{}.json", hash_name(&format!("{name}\0{issuer}"))))).await }
143    async fn save_retry_state(&self, state: &StoredRetryState) -> Result<StoreRevision, StoreError> { let _g = self.write_lock.lock().await; self.write_json(&self.root.join("retry/ACME").join(format!("{}.json", hash_name(&format!("{}\0{}", state.domain, state.issuer_id)))), state, false).await?; Ok(self.next_revision()) }
144}
145
146#[async_trait]
147impl LocalStoreNamespace for FolderCertStore {
148    async fn load_certificate(&self, name: &DnsName) -> Result<Option<StoredCertificate>, StoreError> { self.read_json(&self.cert_file("Local", name, None)).await }
149    async fn list_certificates(&self) -> Result<Vec<StoredCertificate>, StoreError> { self.list_json(&self.root.join("Local")).await }
150    async fn commit_certificate(&self, cert: &StoredCertificate) -> Result<StoreRevision, StoreError> { let _g = self.write_lock.lock().await; self.write_json(&self.cert_file("Local", &cert.primary_name, None), cert, true).await?; let r = self.next_revision(); let _ = self.changes.send(StoreChange::LocalCertificate(cert.primary_name.clone())); Ok(r) }
151    async fn remove_certificate(&self, name: &DnsName) -> Result<StoreRevision, StoreError> { let _g = self.write_lock.lock().await; self.remove_file(&self.cert_file("Local", name, None)).await?; Ok(self.next_revision()) }
152    async fn quarantine_certificate(&self, cert: &StoredCertificate, reason: &str) -> Result<StoreRevision, StoreError> { let _g = self.write_lock.lock().await; let p = self.root.join("quarantine/Local").join(format!("{}-{}.json", hash_name(cert.primary_name.as_str()), hash_name(reason))); self.write_json(&p, cert, true).await?; self.remove_file(&self.cert_file("Local", &cert.primary_name, None)).await?; Ok(self.next_revision()) }
153    async fn load_ca(&self) -> Result<Option<(StoreRevision, StoredLocalCa)>, StoreError> {
154        let cert = tokio::fs::read_to_string(self.root.join("Local/CA.pem")).await;
155        let key = tokio::fs::read_to_string(self.root.join("Local/CA.key")).await;
156        match (cert, key) {
157            (Err(a), Err(b)) if a.kind() == std::io::ErrorKind::NotFound && b.kind() == std::io::ErrorKind::NotFound => Ok(None),
158            (Ok(c), Ok(k)) => { let ca = StoredLocalCa::from_pem(c, k).map_err(|e| StoreError::Corrupt(e.to_string()))?; Ok(Some((StoreRevision(1), ca))) }
159            (Err(e), _) | (_, Err(e)) if e.kind() == std::io::ErrorKind::NotFound => Err(StoreError::Corrupt("Local/CA.pem and Local/CA.key must both exist".into())),
160            (Err(e), _) | (_, Err(e)) => Err(e.into()),
161        }
162    }
163    async fn compare_and_swap_ca(&self, expected: Option<StoreRevision>, replacement: &StoredLocalCa) -> Result<StoreRevision, StoreError> { let _g = self.write_lock.lock().await; let current_exists = tokio::fs::try_exists(self.root.join("Local/CA.pem")).await?; if expected.is_none() && current_exists { return Err(StoreError::Conflict); } self.atomic_write(&self.root.join("Local/CA.pem"), replacement.certificate_pem.as_bytes(), false).await?; self.atomic_write(&self.root.join("Local/CA.key"), replacement.private_key_pem.expose().as_bytes(), true).await?; let r = self.next_revision(); let _ = self.changes.send(StoreChange::LocalCa); Ok(r) }
164    async fn load_retry_state(&self, name: &DnsName) -> Result<Option<StoredRetryState>, StoreError> { self.read_json(&self.root.join("retry/Local").join(format!("{}.json", hash_name(name.as_str())))).await }
165    async fn save_retry_state(&self, state: &StoredRetryState) -> Result<StoreRevision, StoreError> { let _g = self.write_lock.lock().await; self.write_json(&self.root.join("retry/Local").join(format!("{}.json", hash_name(state.domain.as_str()))), state, false).await?; Ok(self.next_revision()) }
166}
167
168fn hash_name(value: &str) -> String { Sha256::digest(value.as_bytes()).iter().map(|b| format!("{b:02x}")).collect() }
169
170impl From<FolderCertStore> for Arc<dyn CertStore> { fn from(value: FolderCertStore) -> Self { Arc::new(value) } }
171
172#[cfg(test)]
173mod tests {
174    use super::*;
175    use crate::{CertificateProvenance, cert::SecretPem};
176
177    fn record(name: &str, provenance: CertificateProvenance, issuer: &str) -> StoredCertificate {
178        StoredCertificate {
179            schema_version: 1, primary_name: DnsName::parse(name).unwrap(), sans: vec![DnsName::parse(name).unwrap()],
180            private_key_pem: SecretPem::new("secret".into()), leaf_pem: "leaf".into(), chain_pem: vec![],
181            not_before: 1, not_after: 2, stored_at: 1, provenance, issuer_id: issuer.into(), fingerprint_sha256: "fp".into(), local_ca_fingerprint_sha256: None,
182        }
183    }
184
185    #[tokio::test]
186    async fn namespaces_coexist() {
187        let directory = tempfile::tempdir().unwrap();
188        let store = FolderCertStore::open(directory.path()).await.unwrap();
189        let acme = record("example.com", CertificateProvenance::Acme, "staging");
190        let local = record("example.com", CertificateProvenance::Local, "AcmeLocalCA");
191        store.acme().commit_certificate(&acme).await.unwrap();
192        store.local().commit_certificate(&local).await.unwrap();
193        assert_eq!(store.acme().load_certificate(&DnsName::parse("example.com").unwrap(), "staging").await.unwrap().unwrap().provenance, CertificateProvenance::Acme);
194        assert_eq!(store.local().load_certificate(&DnsName::parse("example.com").unwrap()).await.unwrap().unwrap().provenance, CertificateProvenance::Local);
195    }
196}