rushls_common/outbound/
client_tls.rs1use std::{path::PathBuf, sync::Arc, time::Duration};
11
12use crate::tls::{ClientIdentity, TlsError, TlsObserver, load_roots};
13use rustls::pki_types::CertificateDer;
14use thiserror::Error;
15
16use crate::outbound::{ClientConfig, HttpClient, OutboundError};
17
18#[derive(Clone, Debug, Default, Eq, PartialEq)]
20pub struct ClientTlsFiles {
21 pub certificate: Option<PathBuf>,
23 pub key: Option<PathBuf>,
25 pub ca: Option<PathBuf>,
27}
28
29#[derive(Debug, Error)]
31pub enum ClientTlsError {
32 #[error("client_cert is set without client_key")]
38 MissingKey,
39 #[error("client_key is set without client_cert")]
40 MissingCertificate,
41 #[error(transparent)]
42 Tls(#[from] TlsError),
43}
44
45impl ClientTlsFiles {
46 pub fn is_configured(&self) -> bool {
48 self.certificate.is_some() || self.key.is_some() || self.ca.is_some()
49 }
50
51 pub fn load<O: TlsObserver>(&self, observer: Arc<O>) -> Result<ClientTls, ClientTlsError> {
58 let identity = match (&self.certificate, &self.key) {
59 (Some(certificate), Some(key)) => Some(ClientIdentity::new(
60 certificate.clone(),
61 key.clone(),
62 observer,
63 )?),
64 (None, None) => None,
65 (Some(_), None) => return Err(ClientTlsError::MissingKey),
66 (None, Some(_)) => return Err(ClientTlsError::MissingCertificate),
67 };
68 let roots = self.ca.as_deref().map(load_roots).transpose()?;
69 Ok(ClientTls { identity, roots })
70 }
71}
72
73pub struct ClientTls {
75 identity: Option<ClientIdentity>,
77 roots: Option<Vec<CertificateDer<'static>>>,
78}
79
80impl ClientTls {
81 pub fn client(
89 &self,
90 request_timeout: Duration,
91 maximum_response_bytes: usize,
92 ) -> Result<HttpClient, OutboundError> {
93 HttpClient::with_identity(
94 ClientConfig::default(),
95 self.identity.as_ref().map(ClientIdentity::resolver),
96 self.roots.clone(),
97 )
98 .map(|client| client.with_limits(request_timeout, maximum_response_bytes))
99 }
100}
101
102#[cfg(test)]
103mod tests {
104 use super::*;
105 use crate::tls::IgnoreTlsEvents;
106
107 fn files(certificate: Option<&str>, key: Option<&str>, ca: Option<&str>) -> ClientTlsFiles {
108 ClientTlsFiles {
109 certificate: certificate.map(PathBuf::from),
110 key: key.map(PathBuf::from),
111 ca: ca.map(PathBuf::from),
112 }
113 }
114
115 #[test]
116 fn half_a_pair_is_refused() {
117 let observer = Arc::new(IgnoreTlsEvents);
118 assert!(matches!(
119 files(Some("cert.pem"), None, None).load(Arc::clone(&observer)),
120 Err(ClientTlsError::MissingKey)
121 ));
122 assert!(matches!(
123 files(None, Some("key.pem"), None).load(observer),
124 Err(ClientTlsError::MissingCertificate)
125 ));
126 }
127
128 #[test]
129 fn nothing_configured_needs_no_client_of_its_own() -> Result<(), ClientTlsError> {
130 assert!(!ClientTlsFiles::default().is_configured());
131 assert!(files(None, None, Some("ca.pem")).is_configured());
132 ClientTlsFiles::default().load(Arc::new(IgnoreTlsEvents))?;
134 Ok(())
135 }
136
137 #[test]
138 fn an_unreadable_authority_is_refused() {
139 let missing = files(None, None, Some("/nonexistent/rushls-ca.pem"));
140 assert!(matches!(
141 missing.load(Arc::new(IgnoreTlsEvents)),
142 Err(ClientTlsError::Tls(_))
143 ));
144 }
145}