use std::sync::Arc;
use tokio_rustls::rustls;
use tokio_rustls::rustls::client::danger::{
HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier,
};
use tokio_rustls::rustls::pki_types::{CertificateDer, ServerName, UnixTime};
use tokio_rustls::rustls::{DigitallySignedStruct, SignatureScheme};
use tokio_rustls::TlsConnector;
use crate::error::{Error, Result};
use crate::tls_tunnel::{TlsTunnel, TunnelMode};
use crate::transport::Transport;
#[derive(Debug)]
pub struct NoCertVerify;
impl ServerCertVerifier for NoCertVerify {
fn verify_server_cert(
&self,
_end_entity: &CertificateDer<'_>,
_intermediates: &[CertificateDer<'_>],
_server_name: &ServerName<'_>,
_ocsp_response: &[u8],
_now: UnixTime,
) -> std::result::Result<ServerCertVerified, rustls::Error> {
Ok(ServerCertVerified::assertion())
}
fn verify_tls12_signature(
&self,
_message: &[u8],
_cert: &CertificateDer<'_>,
_dss: &DigitallySignedStruct,
) -> std::result::Result<HandshakeSignatureValid, rustls::Error> {
Ok(HandshakeSignatureValid::assertion())
}
fn verify_tls13_signature(
&self,
_message: &[u8],
_cert: &CertificateDer<'_>,
_dss: &DigitallySignedStruct,
) -> std::result::Result<HandshakeSignatureValid, rustls::Error> {
Ok(HandshakeSignatureValid::assertion())
}
fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
vec![
SignatureScheme::RSA_PKCS1_SHA256,
SignatureScheme::RSA_PKCS1_SHA384,
SignatureScheme::RSA_PKCS1_SHA512,
SignatureScheme::ECDSA_NISTP256_SHA256,
SignatureScheme::ECDSA_NISTP384_SHA384,
SignatureScheme::ECDSA_NISTP521_SHA512,
SignatureScheme::RSA_PSS_SHA256,
SignatureScheme::RSA_PSS_SHA384,
SignatureScheme::RSA_PSS_SHA512,
SignatureScheme::ED25519,
]
}
}
pub fn client_config_trust_any() -> Arc<rustls::ClientConfig> {
let provider = rustls::crypto::ring::default_provider();
let cfg = rustls::ClientConfig::builder_with_provider(Arc::new(provider))
.with_safe_default_protocol_versions()
.expect("safe default TLS versions available")
.dangerous()
.with_custom_certificate_verifier(Arc::new(NoCertVerify))
.with_no_client_auth();
Arc::new(cfg)
}
pub async fn upgrade_to_tls(
transport: Transport,
server_name: &str,
config: Arc<rustls::ClientConfig>,
) -> Result<Transport> {
let inner = transport.into_stream();
let mode = TunnelMode::new_handshake();
let tunnel = TlsTunnel::new(inner, mode.clone());
let connector = TlsConnector::from(config);
let sn: ServerName<'static> = ServerName::try_from(server_name.to_string())
.map_err(|_| Error::Protocol("tls: invalid server name for SNI"))?;
let tls = connector
.connect(sn, tunnel)
.await
.map_err(|e| Error::Tls(e.to_string()))?;
mode.set_passthrough();
Ok(Transport::new_boxed(Box::new(tls)))
}