rustls-letsencrypt 0.1.1

Automatic Let's Encrypt, ACME, and local-CA certificate management for rustls listeners
Documentation
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>,
    // Retains the temporary trust bundle for as long as the issuer can use it.
    _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())?;
    // Pebble's custom resolver uses DNS-over-TCP. Bind UDP as well so the
    // scoped resolver behaves like an ordinary DNS server for tooling/tests.
    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(&registry), 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());
    }
}