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);
}
#[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();
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);
}
}