tez 0.0.3

A lightweight, ergonomic, and fast high-level HTTP client for Rust
Documentation
//! TLS protocol policy for Tez clients.

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>,
}

/// A TLS protocol version supported by Tez.
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
#[non_exhaustive]
pub enum Version {
    /// TLS 1.2.
    Tls12,
    /// TLS 1.3.
    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());
    }
}