1use std::{net::SocketAddr, sync::{Arc, atomic::Ordering}, time::Duration};
2
3use rustls::{ServerConfig, server::{ClientHello, ResolvesServerCert}, sign::CertifiedKey};
4use tokio::net::{TcpListener, TcpStream};
5use tokio_rustls::{LazyConfigAcceptor, server::TlsStream};
6
7use crate::{ACME_TLS_ALPN_NAME, AlpnHandlerConfig, DnsName, Error, Result, manager::{GLOBAL, GLOBAL_STATE, Manager, global}};
8
9pub struct AcceptedTls {
10 stream: TlsStream<TcpStream>,
11 server_name: DnsName,
12 negotiated_alpn: Option<Vec<u8>>,
13 peer_addr: SocketAddr,
14}
15
16impl AcceptedTls {
17 #[must_use] pub fn server_name(&self) -> &DnsName { &self.server_name }
18 #[must_use] pub fn negotiated_alpn(&self) -> Option<&[u8]> { self.negotiated_alpn.as_deref() }
19 #[must_use] pub fn peer_addr(&self) -> SocketAddr { self.peer_addr }
20 #[must_use] pub fn into_stream(self) -> TlsStream<TcpStream> { self.stream }
21}
22
23impl tokio::io::AsyncRead for AcceptedTls {
24 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) }
25}
26impl tokio::io::AsyncWrite for AcceptedTls {
27 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) }
28 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) }
29 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) }
30}
31
32pub struct ManagedTlsListener { receiver: tokio::sync::mpsc::Receiver<Result<AcceptedTls>>, local_addr: SocketAddr }
33
34impl ManagedTlsListener {
35 pub async fn accept(&mut self) -> Result<Option<AcceptedTls>> {
36 match self.receiver.recv().await { Some(result) => result.map(Some), None => Ok(None) }
37 }
38
39 pub fn local_addr(&self) -> std::io::Result<SocketAddr> { Ok(self.local_addr) }
40}
41
42pub async fn register_alpn_handler(listener: TcpListener, config: Option<AlpnHandlerConfig>) -> Result<ManagedTlsListener> {
43 GLOBAL_STATE.compare_exchange(0, 1, Ordering::AcqRel, Ordering::Acquire).map_err(|_| Error::AlpnHandlerAlreadyRegistered)?;
44 let config = config.unwrap_or_default();
45 let port = listener.local_addr()?.port();
46 if port != 443 && !config.allow_non_443_listener { GLOBAL_STATE.store(0, Ordering::Release); return Err(Error::InvalidAlpnPort(port)); }
47 match Manager::new(config, port).await {
48 Ok(manager) => {
49 if GLOBAL.set(Arc::clone(&manager)).is_err() { GLOBAL_STATE.store(2, Ordering::Release); return Err(Error::AlpnHandlerAlreadyRegistered); }
50 GLOBAL_STATE.store(2, Ordering::Release);
51 Ok(spawn_listener(listener, manager, true))
52 }
53 Err(error) => { GLOBAL_STATE.store(0, Ordering::Release); Err(error) }
54 }
55}
56
57pub async fn register_handler(listener: TcpListener) -> Result<ManagedTlsListener> {
58 Ok(spawn_listener(listener, Arc::clone(global()?), false))
59}
60
61fn spawn_listener(listener: TcpListener, manager: Arc<Manager>, challenge_capable: bool) -> ManagedTlsListener {
62 let local_addr = listener.local_addr().expect("bound listener has local address");
63 let (sender, receiver) = tokio::sync::mpsc::channel(256);
64 tokio::spawn(async move {
65 loop {
66 let (stream, peer_addr) = match listener.accept().await { Ok(value) => value, Err(error) => { let _ = sender.send(Err(error.into())).await; break; } };
67 let manager = Arc::clone(&manager);
68 let sender = sender.clone();
69 tokio::spawn(async move {
70 match accept_one(manager, stream, peer_addr, challenge_capable).await {
71 Ok(Some(stream)) => { let _ = sender.send(Ok(stream)).await; }
72 Ok(None) => {}
73 Err(error) => { let _ = sender.send(Err(error)).await; }
74 }
75 });
76 }
77 });
78 ManagedTlsListener { receiver, local_addr }
79}
80
81async fn accept_one(manager: Arc<Manager>, stream: TcpStream, peer_addr: SocketAddr, challenge_capable: bool) -> Result<Option<AcceptedTls>> {
82 let lazy = LazyConfigAcceptor::new(rustls::server::Acceptor::default(), stream);
83 let start = tokio::time::timeout(Duration::from_secs(manager.config.client_hello_timeout_secs), lazy).await.map_err(|_| Error::ClientHelloTimeout)??;
84 let hello = start.client_hello();
85 let name = DnsName::parse(hello.server_name().ok_or(Error::MissingSni)?)?;
86 let offered_acme = hello.alpn().is_some_and(|mut values| values.any(|v| v == ACME_TLS_ALPN_NAME));
87 if offered_acme {
88 if !challenge_capable { return Err(Error::ChallengeListenerUnavailable); }
89 let key = manager.challenges.get(&name).ok_or(Error::ChallengeListenerUnavailable)?;
90 let mut config = ServerConfig::builder().with_no_client_auth().with_cert_resolver(Arc::new(FixedResolver(key)));
91 config.alpn_protocols = vec![ACME_TLS_ALPN_NAME.to_vec()];
92 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)??;
93 return Ok(None);
94 }
95 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()))??;
96 let mut config = ServerConfig::builder().with_no_client_auth().with_cert_resolver(Arc::new(FixedResolver(active.key.clone())));
97 config.alpn_protocols.clone_from(&manager.config.application_alpn_protocols);
98 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)??;
99 let negotiated_alpn = stream.get_ref().1.alpn_protocol().map(<[u8]>::to_vec);
100 Ok(Some(AcceptedTls { stream, server_name: name, negotiated_alpn, peer_addr }))
101}
102
103#[derive(Debug)]
104struct FixedResolver(Arc<CertifiedKey>);
105impl ResolvesServerCert for FixedResolver {
106 fn resolve(&self, _client_hello: ClientHello<'_>) -> Option<Arc<CertifiedKey>> { Some(self.0.clone()) }
107}
108
109#[cfg(test)]
110mod tests {
111 use super::*;
112 use crate::{EventOutput, HostPattern};
113 use rustls::{ClientConfig, RootCertStore, pki_types::{CertificateDer, ServerName}};
114 use tokio::io::{AsyncReadExt, AsyncWriteExt};
115 use tokio_rustls::TlsConnector;
116
117 #[tokio::test]
118 async fn accepts_normal_tls_with_local_certificate() {
119 let directory = tempfile::tempdir().unwrap();
120 let mut config = AlpnHandlerConfig::default();
121 config.allowed_hosts = vec![HostPattern::exact("example.com").unwrap()];
122 config.verify_dns_before_issuance = false;
123 config.cert_store_directory = directory.path().to_owned();
124 config.events = EventOutput::Subscribe;
125 let manager = Manager::new(config, 0).await.unwrap();
126 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
127 let address = listener.local_addr().unwrap();
128 let mut managed = spawn_listener(listener, Arc::clone(&manager), true);
129
130 let server = tokio::spawn(async move {
131 let mut accepted = managed.accept().await.unwrap().unwrap();
132 let mut byte = [0_u8; 1];
133 accepted.read_exact(&mut byte).await.unwrap();
134 byte[0]
135 });
136
137 let ca = manager.local_issuer.ca().await;
138 let (_, pem) = x509_parser::pem::parse_x509_pem(ca.certificate_pem.as_bytes()).unwrap();
139 let mut roots = RootCertStore::empty();
140 roots.add(CertificateDer::from(pem.contents)).unwrap();
141 let client = ClientConfig::builder().with_root_certificates(roots).with_no_client_auth();
142 let connector = TlsConnector::from(Arc::new(client));
143 let tcp = TcpStream::connect(address).await.unwrap();
144 let mut tls = connector.connect(ServerName::try_from("example.com").unwrap(), tcp).await.unwrap();
145 tls.write_all(&[42]).await.unwrap();
146 assert_eq!(server.await.unwrap(), 42);
147 }
148
149 #[cfg(feature = "managed-pebble")]
153 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
154 #[ignore = "requires the pebble executable in PATH"]
155 async fn managed_pebble_issues_and_serves_acme_certificate() {
156 use crate::{AcmeEndpoint, CertificateProvenance, ManagedPebbleConfig};
157
158 fn free_port_pair() -> (u16, u16) {
159 for _ in 0..100 {
160 let first = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
161 let port = first.local_addr().unwrap().port();
162 if let Some(next) = port.checked_add(1) {
163 if let Ok(second) = std::net::TcpListener::bind(("127.0.0.1", next)) {
164 drop(second);
165 drop(first);
166 return (port, next);
167 }
168 }
169 }
170 panic!("could not reserve a consecutive loopback port pair");
171 }
172
173 let directory = tempfile::tempdir().unwrap();
174 let challenge_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
175 let challenge_port = challenge_listener.local_addr().unwrap().port();
176 let (pebble_port, _) = free_port_pair();
179 let domain = DnsName::parse("service.test").unwrap();
180
181 let mut config = AlpnHandlerConfig::default();
182 config.allowed_hosts = vec![HostPattern::exact(domain.as_str()).unwrap()];
183 config.verify_dns_before_issuance = false;
184 config.local_fallback_enabled = false;
185 config.cert_store_directory = directory.path().join("certificates");
186 config.events = EventOutput::Subscribe;
187 config.issuance_attempt_timeout_secs = 30;
188 config.pebble_startup_timeout_secs = 10;
189 config.acme_endpoint = AcmeEndpoint::Pebble(ManagedPebbleConfig {
190 pebble_bind: format!("127.0.0.1:{pebble_port}").parse().unwrap(),
191 pebble_executable: None,
192 working_directory: None,
193 state_directory: None,
194 });
195
196 let manager = Manager::new(config, challenge_port).await.unwrap();
197 let mut lifecycle_events = manager.events.subscribe();
198 let _challenge_listener = spawn_listener(
199 challenge_listener,
200 Arc::clone(&manager),
201 true,
202 );
203
204 let issued = tokio::time::timeout(
205 Duration::from_secs(35),
206 manager.ensure(domain.clone()),
207 )
208 .await
209 .expect("Pebble issuance timed out")
210 .expect("Pebble issuance failed");
211 assert_eq!(issued.record.provenance, CertificateProvenance::Acme);
212 assert_eq!(issued.record.issuer_id, "pebble");
213 assert!(manager.store.acme().load_certificate(&domain, "pebble").await.unwrap().is_some());
214 let mut observed = Vec::new();
215 while let Some(event) = lifecycle_events.try_recv().unwrap() { observed.push(event); }
216 assert!(observed.iter().any(|event| matches!(&event.kind, crate::EventKind::ChallengeInstalled { domain: value } if value == &domain)));
217 assert!(observed.iter().any(|event| matches!(&event.kind, crate::EventKind::ChallengeValidated { domain: value } if value == &domain)));
218 assert!(observed.iter().any(|event| matches!(&event.kind, crate::EventKind::ChallengeRemoved { domain: value, reason } if value == &domain && reason == "completed")));
219
220 let application_listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
221 let application_address = application_listener.local_addr().unwrap();
222 let mut application = spawn_listener(application_listener, Arc::clone(&manager), false);
223 let server = tokio::spawn(async move {
224 let mut accepted = application.accept().await.unwrap().unwrap();
225 assert_eq!(accepted.server_name(), &domain);
226 let mut byte = [0_u8; 1];
227 accepted.read_exact(&mut byte).await.unwrap();
228 byte[0]
229 });
230
231 let mut roots = RootCertStore::empty();
232 let trust_pem = issued.record.chain_pem.last().unwrap_or(&issued.record.leaf_pem);
233 let (_, trust) = x509_parser::pem::parse_x509_pem(trust_pem.as_bytes()).unwrap();
234 roots.add(CertificateDer::from(trust.contents)).unwrap();
235 let client = ClientConfig::builder().with_root_certificates(roots).with_no_client_auth();
236 let connector = TlsConnector::from(Arc::new(client));
237 let tcp = TcpStream::connect(application_address).await.unwrap();
238 let mut tls = connector
239 .connect(ServerName::try_from("service.test").unwrap(), tcp)
240 .await
241 .unwrap();
242 tls.write_all(&[73]).await.unwrap();
243 assert_eq!(server.await.unwrap(), 73);
244 }
245}