use std::{path::PathBuf, sync::Arc, time::Duration};
use crate::tls::{ClientIdentity, TlsError, TlsObserver, load_roots};
use rustls::pki_types::CertificateDer;
use thiserror::Error;
use crate::outbound::{ClientConfig, HttpClient, OutboundError};
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ClientTlsFiles {
pub certificate: Option<PathBuf>,
pub key: Option<PathBuf>,
pub ca: Option<PathBuf>,
}
#[derive(Debug, Error)]
pub enum ClientTlsError {
#[error("client_cert is set without client_key")]
MissingKey,
#[error("client_key is set without client_cert")]
MissingCertificate,
#[error(transparent)]
Tls(#[from] TlsError),
}
impl ClientTlsFiles {
pub fn is_configured(&self) -> bool {
self.certificate.is_some() || self.key.is_some() || self.ca.is_some()
}
pub fn load<O: TlsObserver>(&self, observer: Arc<O>) -> Result<ClientTls, ClientTlsError> {
let identity = match (&self.certificate, &self.key) {
(Some(certificate), Some(key)) => Some(ClientIdentity::new(
certificate.clone(),
key.clone(),
observer,
)?),
(None, None) => None,
(Some(_), None) => return Err(ClientTlsError::MissingKey),
(None, Some(_)) => return Err(ClientTlsError::MissingCertificate),
};
let roots = self.ca.as_deref().map(load_roots).transpose()?;
Ok(ClientTls { identity, roots })
}
}
pub struct ClientTls {
identity: Option<ClientIdentity>,
roots: Option<Vec<CertificateDer<'static>>>,
}
impl ClientTls {
pub fn client(
&self,
request_timeout: Duration,
maximum_response_bytes: usize,
) -> Result<HttpClient, OutboundError> {
HttpClient::with_identity(
ClientConfig::default(),
self.identity.as_ref().map(ClientIdentity::resolver),
self.roots.clone(),
)
.map(|client| client.with_limits(request_timeout, maximum_response_bytes))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tls::IgnoreTlsEvents;
fn files(certificate: Option<&str>, key: Option<&str>, ca: Option<&str>) -> ClientTlsFiles {
ClientTlsFiles {
certificate: certificate.map(PathBuf::from),
key: key.map(PathBuf::from),
ca: ca.map(PathBuf::from),
}
}
#[test]
fn half_a_pair_is_refused() {
let observer = Arc::new(IgnoreTlsEvents);
assert!(matches!(
files(Some("cert.pem"), None, None).load(Arc::clone(&observer)),
Err(ClientTlsError::MissingKey)
));
assert!(matches!(
files(None, Some("key.pem"), None).load(observer),
Err(ClientTlsError::MissingCertificate)
));
}
#[test]
fn nothing_configured_needs_no_client_of_its_own() -> Result<(), ClientTlsError> {
assert!(!ClientTlsFiles::default().is_configured());
assert!(files(None, None, Some("ca.pem")).is_configured());
ClientTlsFiles::default().load(Arc::new(IgnoreTlsEvents))?;
Ok(())
}
#[test]
fn an_unreadable_authority_is_refused() {
let missing = files(None, None, Some("/nonexistent/rushls-ca.pem"));
assert!(matches!(
missing.load(Arc::new(IgnoreTlsEvents)),
Err(ClientTlsError::Tls(_))
));
}
}