rustls-letsencrypt 0.1.4

Automatic Let's Encrypt, ACME, and local-CA certificate management for rustls listeners
Documentation
//! Blocking adapters backed by one long-lived Tokio runtime.

use std::{io::{Read, Write}, net::TcpListener, sync::{Arc, OnceLock}};

use tokio::io::{AsyncReadExt, AsyncWriteExt};

use crate::{AcceptedTls, AlpnHandlerConfig, Error, EventReceiver, Result};

static RUNTIME: OnceLock<Arc<tokio::runtime::Runtime>> = OnceLock::new();

fn runtime() -> Result<&'static Arc<tokio::runtime::Runtime>> {
    RUNTIME.get().ok_or(Error::AlpnHandlerNotRegistered)
}

fn assert_outside_runtime() -> Result<()> {
    if tokio::runtime::Handle::try_current().is_ok() {
        return Err(Error::InvalidConfig("blocking API called from inside an async runtime".into()));
    }
    Ok(())
}

pub struct ManagedTlsListener { inner: crate::ManagedTlsListener, runtime: Arc<tokio::runtime::Runtime> }

impl ManagedTlsListener {
    pub fn accept(&mut self) -> Result<Option<AcceptedTlsStream>> {
        assert_outside_runtime()?;
        self.runtime.block_on(self.inner.accept()).map(|value| value.map(|inner| AcceptedTlsStream { inner, runtime: Arc::clone(&self.runtime) }))
    }
}

pub struct AcceptedTlsStream { inner: AcceptedTls, runtime: Arc<tokio::runtime::Runtime> }
impl AcceptedTlsStream {
    #[must_use] pub fn server_name(&self) -> &crate::DnsName { self.inner.server_name() }
    #[must_use] pub fn negotiated_alpn(&self) -> Option<&[u8]> { self.inner.negotiated_alpn() }
}
impl Read for AcceptedTlsStream {
    fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> { self.runtime.block_on(self.inner.read(buffer)) }
}
impl Write for AcceptedTlsStream {
    fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> { self.runtime.block_on(self.inner.write(buffer)) }
    fn flush(&mut self) -> std::io::Result<()> { self.runtime.block_on(self.inner.flush()) }
}

pub fn register_alpn_handler(listener: TcpListener, config: Option<AlpnHandlerConfig>) -> Result<ManagedTlsListener> {
    assert_outside_runtime()?;
    let runtime = Arc::new(tokio::runtime::Builder::new_multi_thread().enable_all().build()?);
    listener.set_nonblocking(true)?;
    let tokio_listener = { let _guard = runtime.enter(); tokio::net::TcpListener::from_std(listener)? };
    let inner = runtime.block_on(crate::register_alpn_handler(tokio_listener, config))?;
    RUNTIME.set(Arc::clone(&runtime)).map_err(|_| Error::AlpnHandlerAlreadyRegistered)?;
    Ok(ManagedTlsListener { inner, runtime })
}

pub fn register_handler(listener: TcpListener) -> Result<ManagedTlsListener> {
    assert_outside_runtime()?;
    let runtime = Arc::clone(runtime()?);
    listener.set_nonblocking(true)?;
    let tokio_listener = { let _guard = runtime.enter(); tokio::net::TcpListener::from_std(listener)? };
    let inner = runtime.block_on(crate::register_handler(tokio_listener))?;
    Ok(ManagedTlsListener { inner, runtime })
}

pub fn get_certificate(name: &str) -> Result<Arc<crate::StoredCertificate>> { assert_outside_runtime()?; runtime()?.block_on(crate::get_certificate(name)) }
pub fn get_or_issue_certificate(name: &str) -> Result<Arc<crate::StoredCertificate>> { assert_outside_runtime()?; runtime()?.block_on(crate::get_or_issue_certificate(name)) }
pub fn list_certificates() -> Result<Vec<Arc<crate::StoredCertificate>>> { assert_outside_runtime()?; runtime()?.block_on(crate::list_certificates()) }
pub fn subscribe_events() -> Result<EventReceiver> { crate::subscribe_events() }

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{AcmeEndpoint, EventOutput, HostPattern};
    use rustls::{ClientConfig, ClientConnection, RootCertStore, StreamOwned, pki_types::{CertificateDer, ServerName}};

    #[test]
    #[ignore = "uses the process-global manager; run as an isolated filtered test"]
    fn blocking_acceptor_completes_tls_and_supports_read_write() {
        let directory = tempfile::tempdir().unwrap();
        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
        let address = listener.local_addr().unwrap();
        let mut config = AlpnHandlerConfig::default();
        config.allowed_hosts = vec![HostPattern::exact("blocking.test").unwrap()];
        config.verify_dns_before_issuance = false;
        config.acme_endpoint = AcmeEndpoint::LocalOnly;
        config.cert_store_directory = directory.path().to_owned();
        config.events = EventOutput::Subscribe;
        config.allow_non_443_listener = true;
        let mut managed = register_alpn_handler(listener, Some(config)).unwrap();

        let server = std::thread::spawn(move || {
            let mut stream = managed.accept().unwrap().unwrap();
            assert_eq!(stream.server_name().as_str(), "blocking.test");
            let mut byte = [0_u8; 1];
            stream.read_exact(&mut byte).unwrap();
            stream.write_all(&[byte[0] + 1]).unwrap();
            stream.flush().unwrap();
        });

        let ca_pem = std::fs::read(directory.path().join("Local/CA.pem")).unwrap();
        let (_, ca) = x509_parser::pem::parse_x509_pem(&ca_pem).unwrap();
        let mut roots = RootCertStore::empty();
        roots.add(CertificateDer::from(ca.contents)).unwrap();
        let client = Arc::new(ClientConfig::builder().with_root_certificates(roots).with_no_client_auth());
        let connection = ClientConnection::new(client, ServerName::try_from("blocking.test").unwrap()).unwrap();
        let socket = std::net::TcpStream::connect(address).unwrap();
        let mut tls = StreamOwned::new(connection, socket);
        tls.write_all(&[41]).unwrap();
        tls.flush().unwrap();
        let mut response = [0_u8; 1];
        tls.read_exact(&mut response).unwrap();
        assert_eq!(response, [42]);
        server.join().unwrap();
    }
}