use alloc::sync::Arc;
use alloc::vec::Vec;
use rustls::client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier};
use rustls::crypto::{verify_tls13_signature, CryptoProvider};
use rustls::pki_types::{CertificateDer, ServerName, UnixTime};
use rustls::{ClientConfig, DigitallySignedStruct, SignatureScheme};
use super::TlsIdentity;
const PLACEHOLDER_SERVER_NAME: &str = "adb";
#[derive(Debug)]
#[non_exhaustive]
pub enum TlsConfigError {
Rustls(rustls::Error),
}
impl core::fmt::Display for TlsConfigError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Rustls(e) => write!(f, "tls configuration: {e}"),
}
}
}
impl core::error::Error for TlsConfigError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
Self::Rustls(e) => Some(e),
}
}
}
#[derive(Clone, Debug)]
pub struct TlsClientConfig {
inner: Arc<ClientConfig>,
server_name: ServerName<'static>,
}
impl TlsClientConfig {
pub fn adb(identity: &TlsIdentity) -> Result<Self, TlsConfigError> {
let provider = Arc::new(rustls::crypto::ring::default_provider());
let (chain, key) = identity.rustls_parts();
let mut inner = ClientConfig::builder_with_provider(Arc::clone(&provider))
.with_protocol_versions(&[&rustls::version::TLS13])
.map_err(TlsConfigError::Rustls)?
.dangerous()
.with_custom_certificate_verifier(Arc::new(AcceptAnyDevice { provider }))
.with_client_auth_cert(chain, key)
.map_err(TlsConfigError::Rustls)?;
inner.enable_sni = false;
inner.resumption = rustls::client::Resumption::disabled();
Ok(Self {
inner: Arc::new(inner),
server_name: ServerName::try_from(PLACEHOLDER_SERVER_NAME)
.expect("a bare DNS label is a valid server name"),
})
}
pub fn from_rustls(config: Arc<ClientConfig>, server_name: ServerName<'static>) -> Self {
Self {
inner: config,
server_name,
}
}
pub fn rustls(&self) -> &Arc<ClientConfig> {
&self.inner
}
pub(crate) fn server_name(&self) -> &ServerName<'static> {
&self.server_name
}
}
#[derive(Debug)]
struct AcceptAnyDevice {
provider: Arc<CryptoProvider>,
}
impl ServerCertVerifier for AcceptAnyDevice {
fn verify_server_cert(
&self,
_end_entity: &CertificateDer<'_>,
_intermediates: &[CertificateDer<'_>],
_server_name: &ServerName<'_>,
_ocsp_response: &[u8],
_now: UnixTime,
) -> Result<ServerCertVerified, rustls::Error> {
Ok(ServerCertVerified::assertion())
}
fn verify_tls12_signature(
&self,
_message: &[u8],
_cert: &CertificateDer<'_>,
_dss: &DigitallySignedStruct,
) -> Result<HandshakeSignatureValid, rustls::Error> {
Err(rustls::Error::PeerIncompatible(
rustls::PeerIncompatible::Tls12NotOffered,
))
}
fn verify_tls13_signature(
&self,
message: &[u8],
cert: &CertificateDer<'_>,
dss: &DigitallySignedStruct,
) -> Result<HandshakeSignatureValid, rustls::Error> {
verify_tls13_signature(
message,
cert,
dss,
&self.provider.signature_verification_algorithms,
)
}
fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
self.provider
.signature_verification_algorithms
.supported_schemes()
}
}