use std::sync::{Arc, OnceLock};
use rustls::{ClientConfig, RootCertStore, crypto::CryptoProvider};
use rustls_pki_types::{CertificateDer, PrivateKeyDer, ServerName, pem::PemObject as _};
use rustls_platform_verifier::{BuilderVerifierExt as _, Verifier};
use crate::{
Error, Result,
connection::Protocol,
runtime::{Deadline, Io},
};
static TLS12_ONLY: [&rustls::SupportedProtocolVersion; 1] = [&rustls::version::TLS12];
static TLS13_ONLY: [&rustls::SupportedProtocolVersion; 1] = [&rustls::version::TLS13];
static TLS_DEFAULT: [&rustls::SupportedProtocolVersion; 2] =
[&rustls::version::TLS13, &rustls::version::TLS12];
#[derive(Clone)]
pub(crate) struct TlsConfig {
pub(crate) target: Arc<ClientConfig>,
pub(crate) proxy: Option<Arc<ClientConfig>>,
}
#[derive(Default)]
pub(crate) struct TlsBuilder {
roots: Option<Vec<u8>>,
extra_roots: Vec<Vec<u8>>,
identity: Option<Vec<u8>>,
https_only: bool,
minimum: Option<Version>,
maximum: Option<Version>,
}
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
#[non_exhaustive]
pub enum Version {
Tls12,
Tls13,
}
impl TlsBuilder {
pub(crate) fn roots(&mut self, pem: &[u8]) {
self.roots = Some(pem.to_vec());
}
pub(crate) fn identity(&mut self, pem: &[u8]) {
self.identity = Some(pem.to_vec());
}
pub(crate) fn add_roots(&mut self, pem: &[u8]) {
self.extra_roots.push(pem.to_vec());
}
pub(crate) const fn require_https(&mut self) {
self.https_only = true;
}
pub(crate) const fn minimum_version(&mut self, version: Version) {
self.minimum = Some(version);
}
pub(crate) const fn maximum_version(&mut self, version: Version) {
self.maximum = Some(version);
}
pub(crate) const fn has_roots(&self) -> bool {
self.roots.is_some()
}
pub(crate) const fn has_identity(&self) -> bool {
self.identity.is_some()
}
pub(crate) fn has_extra_roots(&self) -> bool {
!self.extra_roots.is_empty()
}
pub(crate) const fn is_https_only(&self) -> bool {
self.https_only
}
pub(crate) fn build(self, http2: bool, secure_proxy: bool) -> Result<TlsConfig> {
let Self {
roots,
extra_roots,
identity,
https_only: _,
minimum,
maximum,
} = self;
if minimum
.zip(maximum)
.is_some_and(|(minimum, maximum)| minimum > maximum)
{
return Err(Error::request(
"client minimum TLS version exceeds its maximum",
));
}
let versions = protocol_versions(minimum, maximum);
let roots = roots
.as_deref()
.map(|roots| parse_certificates(roots, "client TLS root certificates are invalid"))
.transpose()?;
let extra_roots = extra_roots
.iter()
.map(|roots| {
parse_certificates(roots, "client additional TLS root certificates are invalid")
})
.collect::<Result<Vec<_>>>()?
.into_iter()
.flatten()
.collect::<Vec<_>>();
let mut target = configuration(
roots.as_deref(),
&extra_roots,
identity.as_deref(),
versions,
)?;
target.alpn_protocols = if http2 {
vec![b"h2".to_vec(), b"http/1.1".to_vec()]
} else {
vec![b"http/1.1".to_vec()]
};
let proxy = if secure_proxy {
let mut proxy = configuration(roots.as_deref(), &extra_roots, None, versions)?;
proxy.alpn_protocols = vec![b"http/1.1".to_vec()];
Some(Arc::new(proxy))
} else {
None
};
Ok(TlsConfig {
target: Arc::new(target),
proxy,
})
}
}
fn configuration(
roots: Option<&[CertificateDer<'static>]>,
extra_roots: &[CertificateDer<'static>],
identity: Option<&[u8]>,
versions: &[&'static rustls::SupportedProtocolVersion],
) -> Result<ClientConfig> {
match roots {
Some(roots) => custom_roots(roots, extra_roots, identity, versions),
None => platform(identity, versions, extra_roots),
}
}
fn platform(
identity: Option<&[u8]>,
versions: &[&'static rustls::SupportedProtocolVersion],
extra_roots: &[CertificateDer<'static>],
) -> Result<ClientConfig> {
let provider = provider();
let builder = ClientConfig::builder_with_provider(Arc::clone(&provider))
.with_protocol_versions(versions)
.map_err(|_| Error::request("client TLS configuration is invalid"))?;
let builder = if extra_roots.is_empty() {
builder
.with_platform_verifier()
.map_err(|_| Error::request("platform certificate verification is unavailable"))?
} else {
let verifier = Verifier::new_with_extra_roots(extra_roots.to_vec(), provider)
.map_err(|_| Error::request("client additional TLS root certificates are invalid"))?;
builder
.dangerous()
.with_custom_certificate_verifier(Arc::new(verifier))
};
match identity {
Some(identity) => {
let (certificates, key) = parse_identity(identity)?;
builder
.with_client_auth_cert(certificates, key)
.map_err(|_| Error::request("client TLS identity is invalid"))
}
None => Ok(builder.with_no_client_auth()),
}
}
fn custom_roots(
roots: &[CertificateDer<'static>],
extra_roots: &[CertificateDer<'static>],
identity: Option<&[u8]>,
versions: &[&'static rustls::SupportedProtocolVersion],
) -> Result<ClientConfig> {
let mut store = RootCertStore::empty();
let (added, _) = store
.add_parsable_certificates(roots.iter().chain(extra_roots).cloned().collect::<Vec<_>>());
if added == 0 {
return Err(Error::request("client TLS root certificates are invalid"));
}
let builder = ClientConfig::builder_with_provider(provider())
.with_protocol_versions(versions)
.map_err(|_| Error::request("client TLS configuration is invalid"))?
.with_root_certificates(store);
match identity {
Some(identity) => {
let (certificates, key) = parse_identity(identity)?;
builder
.with_client_auth_cert(certificates, key)
.map_err(|_| Error::request("client TLS identity is invalid"))
}
None => Ok(builder.with_no_client_auth()),
}
}
fn protocol_versions(
minimum: Option<Version>,
maximum: Option<Version>,
) -> &'static [&'static rustls::SupportedProtocolVersion] {
match (minimum, maximum) {
(Some(Version::Tls13), _) => &TLS13_ONLY,
(_, Some(Version::Tls12)) => &TLS12_ONLY,
_ => &TLS_DEFAULT,
}
}
fn parse_identity(pem: &[u8]) -> Result<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>)> {
let certificates = parse_certificates(pem, "client TLS identity is invalid")?;
let key = PrivateKeyDer::from_pem_slice(pem)
.map_err(|_| Error::request("client TLS identity is invalid"))?;
if certificates.is_empty() {
return Err(Error::request("client TLS identity is invalid"));
}
Ok((certificates, key))
}
fn parse_certificates(pem: &[u8], message: &'static str) -> Result<Vec<CertificateDer<'static>>> {
let certificates = CertificateDer::pem_slice_iter(pem)
.collect::<std::result::Result<Vec<_>, _>>()
.map_err(|_| Error::request(message))?;
if certificates.is_empty() {
return Err(Error::request(message));
}
Ok(certificates)
}
fn provider() -> Arc<CryptoProvider> {
static PROVIDER: OnceLock<Arc<CryptoProvider>> = OnceLock::new();
Arc::clone(PROVIDER.get_or_init(|| Arc::new(rustls::crypto::aws_lc_rs::default_provider())))
}
pub(crate) async fn connect(
stream: Io,
host: &str,
config: Arc<ClientConfig>,
deadline: Deadline,
) -> Result<(Io, Protocol)> {
let server_name = ServerName::try_from(host.to_owned()).map_err(|_| Error::connect())?;
deadline
.run(async {
futures_rustls::TlsConnector::from(config)
.connect(server_name, stream)
.await
.map(|stream| {
let protocol = match stream.get_ref().1.alpn_protocol() {
Some(b"h2") => Protocol::Http2,
_ => Protocol::Http1,
};
(Io::from_futures(stream), protocol)
})
.map_err(|_| Error::connect())
})
.await
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn protocol_version_bounds_select_an_ordered_supported_set() {
assert_eq!(protocol_versions(None, None).len(), 2);
assert_eq!(protocol_versions(Some(Version::Tls13), None).len(), 1);
assert_eq!(protocol_versions(None, Some(Version::Tls12)).len(), 1);
let mut invalid = TlsBuilder::default();
invalid.minimum_version(Version::Tls13);
invalid.maximum_version(Version::Tls12);
let Err(error) = invalid.build(true, false) else {
panic!("an inverted TLS version range unexpectedly built");
};
assert!(error.is_request());
}
}