use std::{collections::HashMap, path::PathBuf, process::Child, sync::{Arc, Mutex}, time::Duration};
#[cfg(feature = "managed-pebble")]
use std::{path::Path, process::{Command, Stdio}};
use async_trait::async_trait;
use base64::Engine;
use instant_acme::{Account, AccountCredentials, AuthorizationStatus, ChallengeType, Identifier, NewAccount, NewOrder, OrderStatus, RetryPolicy};
use rcgen::{CertificateParams, CustomExtension, DistinguishedName, KeyPair};
#[cfg(feature = "managed-pebble")]
use rcgen::{BasicConstraints, CertifiedIssuer, IsCa, KeyUsagePurpose};
use rustls::{crypto::aws_lc_rs::sign::any_supported_type, sign::CertifiedKey};
use time::OffsetDateTime;
use tokio::sync::Mutex as AsyncMutex;
use url::Url;
use crate::{AcmeEndpoint, CertificateProvenance, DnsName, Error, Result, StoredCertificate, config::AlpnHandlerConfig, event::{EventBus, EventKind, EventLevel}, issuer::{CertIssuer, IssueRequest, IssuedCertificate}, store::{CertStore, StoredAccount}};
#[derive(Default)]
pub(crate) struct ChallengeRegistry(Mutex<HashMap<DnsName, Arc<CertifiedKey>>>);
impl ChallengeRegistry {
pub fn get(&self, name: &DnsName) -> Option<Arc<CertifiedKey>> { self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner).get(name).cloned() }
fn insert(&self, name: DnsName, key: Arc<CertifiedKey>) { self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner).insert(name, key); }
fn remove(&self, name: &DnsName) { self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner).remove(name); }
}
struct ChallengeGuard {
registry: Arc<ChallengeRegistry>,
events: Arc<EventBus>,
domain: DnsName,
removed: bool,
}
impl ChallengeGuard {
fn finish(mut self, reason: &str) {
self.registry.remove(&self.domain);
self.events.emit(EventLevel::Info, EventKind::ChallengeRemoved { domain: self.domain.clone(), reason: reason.into() });
self.removed = true;
}
}
impl Drop for ChallengeGuard {
fn drop(&mut self) {
if !self.removed {
self.registry.remove(&self.domain);
self.events.emit(EventLevel::Warn, EventKind::ChallengeRemoved { domain: self.domain.clone(), reason: "cancelled-or-timed-out".into() });
}
}
}
pub(crate) struct AcmeIssuer {
store: Arc<dyn CertStore>,
endpoint: AcmeEndpoint,
contacts: Vec<String>,
account: AsyncMutex<Option<Account>>,
challenges: Arc<ChallengeRegistry>,
events: Arc<EventBus>,
config: AlpnHandlerConfig,
pebble_root: Option<PathBuf>,
_custom_root: Option<tempfile::NamedTempFile>,
}
impl AcmeIssuer {
pub fn new(store: Arc<dyn CertStore>, config: AlpnHandlerConfig, challenges: Arc<ChallengeRegistry>, events: Arc<EventBus>, pebble_root: Option<PathBuf>) -> Result<Self> {
let mut custom_root = None;
let effective_root = if pebble_root.is_some() { pebble_root } else if let AcmeEndpoint::Custom { tls_trust_roots, .. } = &config.acme_endpoint {
if tls_trust_roots.is_empty() { None } else {
let mut file = tempfile::NamedTempFile::new()?;
use std::io::Write;
for root in tls_trust_roots {
if root.starts_with(b"-----BEGIN") { file.write_all(root)?; if !root.ends_with(b"\n") { file.write_all(b"\n")?; } }
else {
let encoded = base64::engine::general_purpose::STANDARD.encode(root);
writeln!(file, "-----BEGIN CERTIFICATE-----")?;
for line in encoded.as_bytes().chunks(64) { writeln!(file, "{}", String::from_utf8_lossy(line))?; }
writeln!(file, "-----END CERTIFICATE-----")?;
}
}
let path = file.path().to_owned(); custom_root = Some(file); Some(path)
}
} else { None };
Ok(Self { endpoint: config.acme_endpoint.clone(), contacts: config.acme_contacts.clone(), store, account: AsyncMutex::new(None), challenges, events, config, pebble_root: effective_root, _custom_root: custom_root })
}
fn endpoint(&self) -> Result<(Url, String)> {
match &self.endpoint {
AcmeEndpoint::LocalOnly => Err(Error::InvalidConfig("ACME issuance is disabled by AcmeEndpoint::LocalOnly".into())),
AcmeEndpoint::LetsEncrypt(profile) => { let url = Url::parse(profile.directory_url()).map_err(|e| Error::Acme(e.to_string()))?; Ok((url, match profile { crate::LetsEncryptAcmeProfile::Production => "lets-encrypt-production", crate::LetsEncryptAcmeProfile::Staging => "lets-encrypt-staging" }.into())) }
AcmeEndpoint::Custom { directory_url, issuer_id, .. } => Ok((directory_url.clone(), issuer_id.clone())),
AcmeEndpoint::Pebble(config) => Url::parse(&format!("https://{}/dir", config.pebble_bind)).map(|u| (u, "pebble".into())).map_err(|e| Error::Acme(e.to_string())),
}
}
async fn account(&self) -> Result<Account> {
let mut account = self.account.lock().await;
if let Some(value) = account.as_ref() { return Ok(value.clone()); }
let (directory, _) = self.endpoint()?;
let builder = if let Some(root) = &self.pebble_root { Account::builder_with_root(root).map_err(|e| Error::Acme(e.to_string()))? } else { Account::builder().map_err(|e| Error::Acme(e.to_string()))? };
let value = if let Some(stored) = self.store.acme().load_account(&directory).await? {
let credentials: AccountCredentials = serde_json::from_value(stored.credentials_json).map_err(|e| Error::Acme(e.to_string()))?;
builder.from_credentials(credentials).await.map_err(|e| Error::Acme(e.to_string()))?
} else {
let contacts: Vec<&str> = self.contacts.iter().map(String::as_str).collect();
let (created, credentials) = builder.create(&NewAccount { contact: &contacts, terms_of_service_agreed: true, only_return_existing: false }, directory.to_string(), None).await.map_err(|e| Error::Acme(e.to_string()))?;
self.store.acme().save_account(&StoredAccount { directory_url: directory, credentials_json: serde_json::to_value(credentials).map_err(|e| Error::Acme(e.to_string()))? }).await?;
created
};
*account = Some(value.clone());
Ok(value)
}
async fn issue_inner(&self, domain: DnsName) -> Result<StoredCertificate> {
self.verify_dns(&domain).await?;
let account = self.account().await?;
let (_, issuer_id) = self.endpoint()?;
let mut order = account.new_order(&NewOrder::new(&[Identifier::Dns(domain.to_string())])).await.map_err(|e| Error::Acme(e.to_string()))?;
let mut challenge_guard = None;
let result = async {
let mut authorizations = order.authorizations();
while let Some(result) = authorizations.next().await {
let mut auth = result.map_err(|e| Error::Acme(e.to_string()))?;
match auth.status { AuthorizationStatus::Valid => continue, AuthorizationStatus::Pending => {}, status => return Err(Error::Acme(format!("authorization is {status:?}"))) }
let mut challenge = auth.challenge(ChallengeType::TlsAlpn01).ok_or_else(|| Error::Acme("server did not offer tls-alpn-01".into()))?;
let digest = challenge.key_authorization().digest().as_ref().to_vec();
let challenge_key = make_challenge_key(&domain, digest)?;
self.challenges.insert(domain.clone(), challenge_key);
self.events.emit(EventLevel::Info, EventKind::ChallengeInstalled { domain: domain.clone() });
challenge_guard = Some(ChallengeGuard { registry: Arc::clone(&self.challenges), events: Arc::clone(&self.events), domain: domain.clone(), removed: false });
challenge.set_ready().await.map_err(|e| Error::Acme(e.to_string()))?;
}
let status = order.poll_ready(&RetryPolicy::default()).await.map_err(|e| Error::Acme(e.to_string()))?;
if status != OrderStatus::Ready { return Err(Error::Acme(format!("order is {status:?}"))); }
let key_pem = order.finalize().await.map_err(|e| Error::Acme(e.to_string()))?;
let chain = order.poll_certificate(&RetryPolicy::default()).await.map_err(|e| Error::Acme(e.to_string()))?;
self.events.emit(EventLevel::Info, EventKind::ChallengeValidated { domain: domain.clone() });
let mut blocks = split_certificates(&chain);
if blocks.is_empty() { return Err(Error::Acme("certificate response was empty".into())); }
let leaf = blocks.remove(0);
StoredCertificate::from_pem(domain.clone(), key_pem, leaf, blocks, CertificateProvenance::Acme, issuer_id, None)
}.await;
if let Some(guard) = challenge_guard { guard.finish(if result.is_ok() { "completed" } else { "failed" }); }
result
}
async fn verify_dns(&self, domain: &DnsName) -> Result<()> {
if !self.config.verify_dns_before_issuance || matches!(self.endpoint, AcmeEndpoint::Pebble(_) | AcmeEndpoint::LocalOnly) { return Ok(()); }
let resolved = if let Some(servers) = &self.config.dns_servers {
lookup_explicit_dns(domain.as_str(), servers, self.config.dns_lookup_timeout_secs).await?
} else {
tokio::time::timeout(Duration::from_secs(self.config.dns_lookup_timeout_secs), tokio::net::lookup_host((domain.as_str(), 0))).await.map_err(|_| Error::DnsOwnershipMismatch { host: domain.to_string(), resolved: Vec::new() })??.map(|a| a.ip()).collect::<Vec<_>>()
};
if resolved.iter().any(|ip| self.config.public_ip_addresses.contains(ip)) { Ok(()) } else { self.events.emit(EventLevel::Warn, EventKind::DnsOwnershipCheckFailed { domain: domain.clone(), resolved: resolved.clone() }); Err(Error::DnsOwnershipMismatch { host: domain.to_string(), resolved }) }
}
}
async fn lookup_explicit_dns(domain: &str, servers: &[crate::DnsServer], timeout_secs: u64) -> Result<Vec<std::net::IpAddr>> {
use hickory_resolver::{TokioAsyncResolver, config::{NameServerConfig, Protocol, ResolverConfig, ResolverOpts}};
let nameservers = servers.iter().flat_map(|server| match server.transport {
crate::DnsTransport::Udp => vec![NameServerConfig::new(server.address, Protocol::Udp)],
crate::DnsTransport::Tcp => vec![NameServerConfig::new(server.address, Protocol::Tcp)],
crate::DnsTransport::UdpThenTcp => vec![
NameServerConfig::new(server.address, Protocol::Udp),
NameServerConfig::new(server.address, Protocol::Tcp),
],
}).collect::<Vec<_>>();
let resolver = TokioAsyncResolver::tokio(ResolverConfig::from_parts(None, Vec::new(), nameservers), ResolverOpts::default());
tokio::time::timeout(Duration::from_secs(timeout_secs), resolver.lookup_ip(domain)).await
.map_err(|_| Error::Acme(format!("DNS lookup for {domain} timed out")))?
.map_err(|error| Error::Acme(format!("DNS lookup failed: {error}")))
.map(|lookup| lookup.iter().collect())
}
pub(crate) struct PebbleSupervisor {
child: Child,
dns_task: tokio::task::JoinHandle<()>,
_temporary_state: Option<tempfile::TempDir>,
pub https_root: PathBuf,
}
impl Drop for PebbleSupervisor {
fn drop(&mut self) {
self.dns_task.abort();
let _ = self.child.kill();
let _ = self.child.wait();
}
}
#[cfg(feature = "managed-pebble")]
pub(crate) async fn start_managed_pebble(config: &crate::ManagedPebbleConfig, challenge_port: u16, timeout_secs: u64, events: &EventBus) -> Result<PebbleSupervisor> {
if !config.pebble_bind.ip().is_loopback() { return Err(Error::InvalidConfig("managed Pebble must bind a loopback address".into())); }
if let Some(directory) = &config.working_directory {
if !directory.is_dir() { return Err(Error::InvalidConfig(format!("Pebble working directory does not exist or is not a directory: {}", directory.display()))); }
}
let executable = find_executable(config.pebble_executable.as_deref())?;
let (state, temporary) = if let Some(path) = &config.state_directory { std::fs::create_dir_all(path)?; (path.clone(), None) } else { let temp = tempfile::tempdir()?; (temp.path().to_owned(), Some(temp)) };
let root_key = KeyPair::generate().map_err(|e| Error::Acme(e.to_string()))?;
let mut root_params = CertificateParams::default();
root_params.is_ca = IsCa::Ca(BasicConstraints::Unconstrained);
root_params.key_usages = vec![KeyUsagePurpose::KeyCertSign, KeyUsagePurpose::CrlSign];
let root = CertifiedIssuer::self_signed(root_params, root_key).map_err(|e| Error::Acme(e.to_string()))?;
let https_key = KeyPair::generate().map_err(|e| Error::Acme(e.to_string()))?;
let mut https_params = CertificateParams::new(vec!["localhost".into(), "127.0.0.1".into()]).map_err(|e| Error::Acme(e.to_string()))?;
https_params.not_before = OffsetDateTime::now_utc() - Duration::from_secs(60);
https_params.not_after = OffsetDateTime::now_utc() + Duration::from_secs(365 * 86_400);
let https_cert = https_params.signed_by(&https_key, &root).map_err(|e| Error::Acme(e.to_string()))?;
let cert_path = state.join("pebble-https.pem");
let key_path = state.join("pebble-https.key");
let root_path = state.join("pebble-https-root.pem");
let config_path = state.join("pebble-config.json");
std::fs::write(&cert_path, https_cert.pem())?;
std::fs::write(&key_path, https_key.serialize_pem())?;
std::fs::write(&root_path, root.pem())?;
let dns_tcp = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
let dns_address = dns_tcp.local_addr()?;
let dns_udp = tokio::net::UdpSocket::bind(dns_address).await?;
let dns_task = tokio::spawn(async move {
tokio::join!(run_test_dns(dns_udp), run_test_dns_tcp(dns_tcp));
});
let management_port = config.pebble_bind.port().checked_add(1).ok_or_else(|| Error::InvalidConfig("PebbleBind port cannot be 65535".into()))?;
let json = serde_json::json!({ "pebble": {
"listenAddress": config.pebble_bind.to_string(),
"managementListenAddress": format!("{}:{management_port}", config.pebble_bind.ip()),
"certificate": cert_path,
"privateKey": key_path,
"httpPort": challenge_port.saturating_add(1),
"tlsPort": challenge_port,
"ocspResponderURL": "", "externalAccountBindingRequired": false,
"domainBlocklist": [], "retryAfter": { "authz": 1, "order": 1 },
"keyAlgorithm": "ecdsa", "profiles": { "default": { "description": "managed local test profile", "validityPeriod": 2592000 } }
}});
std::fs::write(&config_path, serde_json::to_vec_pretty(&json).map_err(|e| Error::Acme(e.to_string()))?)?;
let mut command = Command::new(&executable);
command.arg("-config").arg(&config_path).arg("-dnsserver").arg(dns_address.to_string()).arg("-strict").env("PEBBLE_VA_NOSLEEP", "1").stdout(Stdio::null()).stderr(Stdio::inherit());
if let Some(directory) = &config.working_directory { command.current_dir(directory); }
let child = command.spawn().map_err(|e| if e.kind() == std::io::ErrorKind::NotFound { Error::PebbleExecutableNotFound(executable.display().to_string()) } else { Error::Io(e) })?;
let deadline = tokio::time::Instant::now() + Duration::from_secs(timeout_secs);
loop {
if tokio::net::TcpStream::connect(config.pebble_bind).await.is_ok() { break; }
if tokio::time::Instant::now() >= deadline { let mut child = child; let _ = child.kill(); let _ = child.wait(); dns_task.abort(); return Err(Error::Acme("managed Pebble readiness timed out".into())); }
tokio::time::sleep(Duration::from_millis(50)).await;
}
events.emit(EventLevel::Info, EventKind::PebbleStarted { address: config.pebble_bind.to_string() });
Ok(PebbleSupervisor { child, dns_task, _temporary_state: temporary, https_root: root_path })
}
#[cfg(feature = "managed-pebble")]
fn find_executable(explicit: Option<&Path>) -> Result<PathBuf> {
if let Some(path) = explicit { if path.is_file() { return Ok(path.to_owned()); } return Err(Error::PebbleExecutableNotFound(path.display().to_string())); }
let Some(path) = std::env::var_os("PATH") else { return Err(Error::PebbleExecutableNotFound("pebble (PATH is unset)".into())); };
for directory in std::env::split_paths(&path) { let candidate = directory.join("pebble"); if candidate.is_file() { return Ok(candidate); } }
Err(Error::PebbleExecutableNotFound("pebble".into()))
}
#[cfg(feature = "managed-pebble")]
async fn run_test_dns(socket: tokio::net::UdpSocket) {
let mut buffer = [0_u8; 1500];
while let Ok((length, peer)) = socket.recv_from(&mut buffer).await {
if let Some(response) = dns_response(&buffer[..length]) { let _ = socket.send_to(&response, peer).await; }
}
}
#[cfg(feature = "managed-pebble")]
async fn run_test_dns_tcp(listener: tokio::net::TcpListener) {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
while let Ok((mut stream, _)) = listener.accept().await {
tokio::spawn(async move {
loop {
let length = match stream.read_u16().await {
Ok(length) => usize::from(length),
Err(_) => return,
};
let mut query = vec![0_u8; length];
if stream.read_exact(&mut query).await.is_err() { return; }
let Some(response) = dns_response(&query) else { return; };
let Ok(response_length) = u16::try_from(response.len()) else { return; };
if stream.write_u16(response_length).await.is_err()
|| stream.write_all(&response).await.is_err()
{
return;
}
}
});
}
}
#[cfg(feature = "managed-pebble")]
fn dns_response(query: &[u8]) -> Option<Vec<u8>> {
if query.len() < 17 { return None; }
let mut cursor = 12;
loop { let length = *query.get(cursor)? as usize; cursor += 1; if length == 0 { break; } cursor = cursor.checked_add(length)?; if cursor > query.len() { return None; } }
let question_end = cursor.checked_add(4)?;
if question_end > query.len() { return None; }
let qtype = u16::from_be_bytes([query[cursor], query[cursor + 1]]);
let answer = qtype == 1;
let mut response = Vec::with_capacity(question_end + 16);
response.extend_from_slice(&query[0..2]);
response.extend_from_slice(&0x8180_u16.to_be_bytes());
response.extend_from_slice(&1_u16.to_be_bytes());
response.extend_from_slice(&(u16::from(answer)).to_be_bytes());
response.extend_from_slice(&0_u16.to_be_bytes()); response.extend_from_slice(&0_u16.to_be_bytes());
response.extend_from_slice(&query[12..question_end]);
if answer { response.extend_from_slice(&[0xc0, 0x0c]); response.extend_from_slice(&1_u16.to_be_bytes()); response.extend_from_slice(&1_u16.to_be_bytes()); response.extend_from_slice(&30_u32.to_be_bytes()); response.extend_from_slice(&4_u16.to_be_bytes()); response.extend_from_slice(&[127, 0, 0, 1]); }
Some(response)
}
#[async_trait]
impl CertIssuer for AcmeIssuer {
fn id(&self) -> &str { "acme" }
fn provenance(&self) -> CertificateProvenance { CertificateProvenance::Acme }
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.clone())).await.map_err(|_| Error::IssuanceTimeout(request.domain.to_string()))?
}
}
fn make_challenge_key(domain: &DnsName, digest: Vec<u8>) -> Result<Arc<CertifiedKey>> {
let key = KeyPair::generate().map_err(|e| Error::Certificate(e.to_string()))?;
let mut params = CertificateParams::new(vec![domain.to_string()]).map_err(|e| Error::Certificate(e.to_string()))?;
params.distinguished_name = DistinguishedName::new();
params.not_before = OffsetDateTime::now_utc() - Duration::from_secs(60);
params.not_after = OffsetDateTime::now_utc() + Duration::from_secs(3600);
let mut value = vec![0x04, 0x20];
value.extend(digest);
let mut extension = CustomExtension::from_oid_content(&[1, 3, 6, 1, 5, 5, 7, 1, 31], value);
extension.set_criticality(true);
params.custom_extensions.push(extension);
let cert = params.self_signed(&key).map_err(|e| Error::Certificate(e.to_string()))?;
let signer = any_supported_type(&crate::cert::private_key_der(&key.serialize_pem())?).map_err(|e| Error::Certificate(e.to_string()))?;
Ok(Arc::new(CertifiedKey::new(vec![cert.der().clone()], signer)))
}
fn split_certificates(pem: &str) -> Vec<String> {
pem.split_inclusive("-----END CERTIFICATE-----")
.filter(|part| part.contains("-----BEGIN CERTIFICATE-----"))
.map(|part| format!("{}\n", part.trim()))
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn challenge_certificate_has_critical_acme_extension() {
let key = make_challenge_key(&DnsName::parse("example.com").unwrap(), vec![7; 32]).unwrap();
let (_, cert) = x509_parser::parse_x509_certificate(key.cert[0].as_ref()).unwrap();
let extension = cert.extensions().iter().find(|ext| ext.oid.to_id_string() == "1.3.6.1.5.5.7.1.31").unwrap();
assert!(extension.critical);
assert_eq!(extension.value, &[0x04, 0x20].into_iter().chain([7_u8; 32]).collect::<Vec<_>>());
}
#[cfg(feature = "managed-pebble")]
#[test]
fn managed_dns_answers_ipv4() {
let query = [0x12, 0x34, 0x01, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0, 7, b'e', b'x', b'a', b'm', b'p', b'l', b'e', 3, b'c', b'o', b'm', 0, 0, 1, 0, 1];
let response = dns_response(&query).unwrap();
assert_eq!(&response[0..2], &[0x12, 0x34]);
assert_eq!(&response[response.len() - 4..], &[127, 0, 0, 1]);
}
#[test]
fn dropping_challenge_guard_removes_stale_challenge() {
let domain = DnsName::parse("cancelled.test").unwrap();
let registry = Arc::new(ChallengeRegistry::default());
registry.insert(domain.clone(), make_challenge_key(&domain, vec![1; 32]).unwrap());
let events = Arc::new(EventBus::new(8, 8, crate::EventOutput::Subscribe, None));
let mut receiver = events.subscribe();
{
let _guard = ChallengeGuard { registry: Arc::clone(®istry), events, domain: domain.clone(), removed: false };
}
assert!(registry.get(&domain).is_none());
assert!(matches!(&receiver.try_recv().unwrap().unwrap().kind, EventKind::ChallengeRemoved { reason, .. } if reason == "cancelled-or-timed-out"));
}
#[tokio::test]
#[ignore = "requires outbound UDP DNS access"]
async fn explicit_cloudflare_udp_dns_resolves() {
let server: crate::DnsServer = "udp://1.1.1.1:53".parse().unwrap();
assert!(!lookup_explicit_dns("example.com", &[server], 5).await.unwrap().is_empty());
}
#[tokio::test]
#[ignore = "requires outbound TCP DNS access"]
async fn explicit_google_tcp_dns_resolves() {
let server: crate::DnsServer = "tcp://8.8.8.8:53".parse().unwrap();
assert!(!lookup_explicit_dns("example.com", &[server], 5).await.unwrap().is_empty());
}
}