rustls-letsencrypt 0.1.4

Automatic Let's Encrypt, ACME, and local-CA certificate management for rustls listeners
Documentation
use std::{net::SocketAddr, sync::{Arc, atomic::Ordering}, time::Duration};

use rustls::{ServerConfig, server::{ClientHello, ResolvesServerCert}, sign::CertifiedKey};
use tokio::net::{TcpListener, TcpStream};
use tokio_rustls::{LazyConfigAcceptor, server::TlsStream};

use crate::{ACME_TLS_ALPN_NAME, AlpnHandlerConfig, DnsName, Error, Result, manager::{GLOBAL, GLOBAL_STATE, Manager, global}};

pub struct AcceptedTls {
    stream: TlsStream<TcpStream>,
    server_name: DnsName,
    negotiated_alpn: Option<Vec<u8>>,
    peer_addr: SocketAddr,
}

impl AcceptedTls {
    #[must_use] pub fn server_name(&self) -> &DnsName { &self.server_name }
    #[must_use] pub fn negotiated_alpn(&self) -> Option<&[u8]> { self.negotiated_alpn.as_deref() }
    #[must_use] pub fn peer_addr(&self) -> SocketAddr { self.peer_addr }
    #[must_use] pub fn into_stream(self) -> TlsStream<TcpStream> { self.stream }
}

impl tokio::io::AsyncRead for AcceptedTls {
    fn poll_read(mut self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>, buf: &mut tokio::io::ReadBuf<'_>) -> std::task::Poll<std::io::Result<()>> { std::pin::Pin::new(&mut self.stream).poll_read(cx, buf) }
}
impl tokio::io::AsyncWrite for AcceptedTls {
    fn poll_write(mut self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>, buf: &[u8]) -> std::task::Poll<std::io::Result<usize>> { std::pin::Pin::new(&mut self.stream).poll_write(cx, buf) }
    fn poll_flush(mut self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> std::task::Poll<std::io::Result<()>> { std::pin::Pin::new(&mut self.stream).poll_flush(cx) }
    fn poll_shutdown(mut self: std::pin::Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> std::task::Poll<std::io::Result<()>> { std::pin::Pin::new(&mut self.stream).poll_shutdown(cx) }
}

pub struct ManagedTlsListener { receiver: tokio::sync::mpsc::Receiver<Result<AcceptedTls>>, local_addr: SocketAddr }

impl ManagedTlsListener {
    pub async fn accept(&mut self) -> Result<Option<AcceptedTls>> {
        match self.receiver.recv().await { Some(result) => result.map(Some), None => Ok(None) }
    }

    pub fn local_addr(&self) -> std::io::Result<SocketAddr> { Ok(self.local_addr) }
}

pub async fn register_alpn_handler(listener: TcpListener, config: Option<AlpnHandlerConfig>) -> Result<ManagedTlsListener> {
    GLOBAL_STATE.compare_exchange(0, 1, Ordering::AcqRel, Ordering::Acquire).map_err(|_| Error::AlpnHandlerAlreadyRegistered)?;
    let config = config.unwrap_or_default();
    let port = listener.local_addr()?.port();
    if port != 443 && !config.allow_non_443_listener { GLOBAL_STATE.store(0, Ordering::Release); return Err(Error::InvalidAlpnPort(port)); }
    match Manager::new(config, port).await {
        Ok(manager) => {
            if GLOBAL.set(Arc::clone(&manager)).is_err() { GLOBAL_STATE.store(2, Ordering::Release); return Err(Error::AlpnHandlerAlreadyRegistered); }
            GLOBAL_STATE.store(2, Ordering::Release);
            Ok(spawn_listener(listener, manager, true))
        }
        Err(error) => { GLOBAL_STATE.store(0, Ordering::Release); Err(error) }
    }
}

pub async fn register_handler(listener: TcpListener) -> Result<ManagedTlsListener> {
    Ok(spawn_listener(listener, Arc::clone(global()?), false))
}

fn spawn_listener(listener: TcpListener, manager: Arc<Manager>, challenge_capable: bool) -> ManagedTlsListener {
    let local_addr = listener.local_addr().expect("bound listener has local address");
    let (sender, receiver) = tokio::sync::mpsc::channel(256);
    tokio::spawn(async move {
        loop {
            let (stream, peer_addr) = match listener.accept().await { Ok(value) => value, Err(error) => { let _ = sender.send(Err(error.into())).await; break; } };
            let manager = Arc::clone(&manager);
            let sender = sender.clone();
            tokio::spawn(async move {
                match accept_one(manager, stream, peer_addr, challenge_capable).await {
                    Ok(Some(stream)) => { let _ = sender.send(Ok(stream)).await; }
                    Ok(None) => {}
                    Err(error) => { let _ = sender.send(Err(error)).await; }
                }
            });
        }
    });
    ManagedTlsListener { receiver, local_addr }
}

async fn accept_one(manager: Arc<Manager>, stream: TcpStream, peer_addr: SocketAddr, challenge_capable: bool) -> Result<Option<AcceptedTls>> {
    let lazy = LazyConfigAcceptor::new(rustls::server::Acceptor::default(), stream);
    let start = tokio::time::timeout(Duration::from_secs(manager.config.client_hello_timeout_secs), lazy).await.map_err(|_| Error::ClientHelloTimeout)??;
    let hello = start.client_hello();
    let name = DnsName::parse(hello.server_name().ok_or(Error::MissingSni)?)?;
    let offered_acme = hello.alpn().is_some_and(|mut values| values.any(|v| v == ACME_TLS_ALPN_NAME));
    if offered_acme {
        if !challenge_capable { return Err(Error::ChallengeListenerUnavailable); }
        let key = manager.challenges.get(&name).ok_or(Error::ChallengeListenerUnavailable)?;
        let mut config = ServerConfig::builder().with_no_client_auth().with_cert_resolver(Arc::new(FixedResolver(key)));
        config.alpn_protocols = vec![ACME_TLS_ALPN_NAME.to_vec()];
        let _stream = tokio::time::timeout(Duration::from_secs(manager.config.client_hello_timeout_secs), start.into_stream(Arc::new(config))).await.map_err(|_| Error::HandshakeTimeout)??;
        return Ok(None);
    }
    let active = tokio::time::timeout(Duration::from_secs(manager.config.initial_connection_wait_timeout_secs), manager.ensure(name.clone())).await.map_err(|_| Error::IssuanceTimeout(name.to_string()))??;
    let mut config = ServerConfig::builder().with_no_client_auth().with_cert_resolver(Arc::new(FixedResolver(active.key.clone())));
    config.alpn_protocols.clone_from(&manager.config.application_alpn_protocols);
    let stream = tokio::time::timeout(Duration::from_secs(manager.config.client_hello_timeout_secs), start.into_stream(Arc::new(config))).await.map_err(|_| Error::HandshakeTimeout)??;
    let negotiated_alpn = stream.get_ref().1.alpn_protocol().map(<[u8]>::to_vec);
    Ok(Some(AcceptedTls { stream, server_name: name, negotiated_alpn, peer_addr }))
}

#[derive(Debug)]
struct FixedResolver(Arc<CertifiedKey>);
impl ResolvesServerCert for FixedResolver {
    fn resolve(&self, _client_hello: ClientHello<'_>) -> Option<Arc<CertifiedKey>> { Some(self.0.clone()) }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{EventOutput, HostPattern};
    use rustls::{ClientConfig, RootCertStore, pki_types::{CertificateDer, ServerName}};
    use tokio::io::{AsyncReadExt, AsyncWriteExt};
    use tokio_rustls::TlsConnector;

    #[tokio::test]
    async fn accepts_normal_tls_with_local_certificate() {
        let directory = tempfile::tempdir().unwrap();
        let mut config = AlpnHandlerConfig::default();
        config.allowed_hosts = vec![HostPattern::exact("example.com").unwrap()];
        config.verify_dns_before_issuance = false;
        config.cert_store_directory = directory.path().to_owned();
        config.events = EventOutput::Subscribe;
        let manager = Manager::new(config, 0).await.unwrap();
        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let address = listener.local_addr().unwrap();
        let mut managed = spawn_listener(listener, Arc::clone(&manager), true);

        let server = tokio::spawn(async move {
            let mut accepted = managed.accept().await.unwrap().unwrap();
            let mut byte = [0_u8; 1];
            accepted.read_exact(&mut byte).await.unwrap();
            byte[0]
        });

        let ca = manager.local_issuer.ca().await;
        let (_, pem) = x509_parser::pem::parse_x509_pem(ca.certificate_pem.as_bytes()).unwrap();
        let mut roots = RootCertStore::empty();
        roots.add(CertificateDer::from(pem.contents)).unwrap();
        let client = ClientConfig::builder().with_root_certificates(roots).with_no_client_auth();
        let connector = TlsConnector::from(Arc::new(client));
        let tcp = TcpStream::connect(address).await.unwrap();
        let mut tls = connector.connect(ServerName::try_from("example.com").unwrap(), tcp).await.unwrap();
        tls.write_all(&[42]).await.unwrap();
        assert_eq!(server.await.unwrap(), 42);
    }

    /// Runs a real Pebble process, completes a TLS-ALPN-01 order through this
    /// crate's challenge listener, persists the ACME certificate, and then uses
    /// that certificate for an application TLS connection.
    #[cfg(feature = "managed-pebble")]
    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
    #[ignore = "requires the pebble executable in PATH"]
    async fn managed_pebble_issues_and_serves_acme_certificate() {
        use crate::{AcmeEndpoint, CertificateProvenance, ManagedPebbleConfig};

        fn free_port_pair() -> (u16, u16) {
            for _ in 0..100 {
                let first = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
                let port = first.local_addr().unwrap().port();
                if let Some(next) = port.checked_add(1) {
                    if let Ok(second) = std::net::TcpListener::bind(("127.0.0.1", next)) {
                        drop(second);
                        drop(first);
                        return (port, next);
                    }
                }
            }
            panic!("could not reserve a consecutive loopback port pair");
        }

        let directory = tempfile::tempdir().unwrap();
        let challenge_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let challenge_port = challenge_listener.local_addr().unwrap().port();
        // Pebble needs adjacent directory and management ports. Its configured
        // HTTP validation port is unused for TLS-ALPN-01.
        let (pebble_port, _) = free_port_pair();
        let domain = DnsName::parse("service.test").unwrap();

        let mut config = AlpnHandlerConfig::default();
        config.allowed_hosts = vec![HostPattern::exact(domain.as_str()).unwrap()];
        config.verify_dns_before_issuance = false;
        config.local_fallback_enabled = false;
        config.cert_store_directory = directory.path().join("certificates");
        config.events = EventOutput::Subscribe;
        config.issuance_attempt_timeout_secs = 30;
        config.pebble_startup_timeout_secs = 10;
        config.acme_endpoint = AcmeEndpoint::Pebble(ManagedPebbleConfig {
            pebble_bind: format!("127.0.0.1:{pebble_port}").parse().unwrap(),
            pebble_executable: None,
            working_directory: None,
            state_directory: None,
        });

        let manager = Manager::new(config, challenge_port).await.unwrap();
        let mut lifecycle_events = manager.events.subscribe();
        let _challenge_listener = spawn_listener(
            challenge_listener,
            Arc::clone(&manager),
            true,
        );

        let issued = tokio::time::timeout(
            Duration::from_secs(35),
            manager.ensure(domain.clone()),
        )
        .await
        .expect("Pebble issuance timed out")
        .expect("Pebble issuance failed");
        assert_eq!(issued.record.provenance, CertificateProvenance::Acme);
        assert_eq!(issued.record.issuer_id, "pebble");
        assert!(manager.store.acme().load_certificate(&domain, "pebble").await.unwrap().is_some());
        let mut observed = Vec::new();
        while let Some(event) = lifecycle_events.try_recv().unwrap() { observed.push(event); }
        assert!(observed.iter().any(|event| matches!(&event.kind, crate::EventKind::ChallengeInstalled { domain: value } if value == &domain)));
        assert!(observed.iter().any(|event| matches!(&event.kind, crate::EventKind::ChallengeValidated { domain: value } if value == &domain)));
        assert!(observed.iter().any(|event| matches!(&event.kind, crate::EventKind::ChallengeRemoved { domain: value, reason } if value == &domain && reason == "completed")));

        let application_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
        let application_address = application_listener.local_addr().unwrap();
        let mut application = spawn_listener(application_listener, Arc::clone(&manager), false);
        let server = tokio::spawn(async move {
            let mut accepted = application.accept().await.unwrap().unwrap();
            assert_eq!(accepted.server_name(), &domain);
            let mut byte = [0_u8; 1];
            accepted.read_exact(&mut byte).await.unwrap();
            byte[0]
        });

        let mut roots = RootCertStore::empty();
        let trust_pem = issued.record.chain_pem.last().unwrap_or(&issued.record.leaf_pem);
        let (_, trust) = x509_parser::pem::parse_x509_pem(trust_pem.as_bytes()).unwrap();
        roots.add(CertificateDer::from(trust.contents)).unwrap();
        let client = ClientConfig::builder().with_root_certificates(roots).with_no_client_auth();
        let connector = TlsConnector::from(Arc::new(client));
        let tcp = TcpStream::connect(application_address).await.unwrap();
        let mut tls = connector
            .connect(ServerName::try_from("service.test").unwrap(), tcp)
            .await
            .unwrap();
        tls.write_all(&[73]).await.unwrap();
        assert_eq!(server.await.unwrap(), 73);
    }
}