Skip to main content

rustls_letsencrypt/
tls.rs

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    /// Runs a real Pebble process, completes a TLS-ALPN-01 order through this
150    /// crate's challenge listener, persists the ACME certificate, and then uses
151    /// that certificate for an application TLS connection.
152    #[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        // Pebble needs adjacent directory and management ports. Its configured
177        // HTTP validation port is unused for TLS-ALPN-01.
178        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}