#![deny(unsafe_op_in_unsafe_fn)]
use rustls::{
CertificateError, DigitallySignedStruct, Error, SignatureScheme,
client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
crypto::CryptoProvider,
pki_types::{CertificateDer, PrivateKeyDer, ServerName, UnixTime, pem::PemObject},
};
use std::{
sync::{
Arc,
atomic::{AtomicU64, Ordering},
},
time::{Duration, Instant},
};
pub use rustls;
pub use rustls::unbuffered::{ConnectionState, UnbufferedStatus};
#[derive(Debug)]
struct SuppliedTime(AtomicU64);
#[derive(Debug, Clone)]
pub struct HostTime(Arc<SuppliedTime>);
impl HostTime {
pub fn new(unix_seconds: u64) -> Self {
Self(Arc::new(SuppliedTime(AtomicU64::new(unix_seconds))))
}
pub fn set(&self, unix_seconds: u64) {
self.0.0.store(unix_seconds, Ordering::Relaxed);
}
pub fn unix_seconds(&self) -> u64 {
self.0.0.load(Ordering::Relaxed)
}
pub fn time_provider(&self) -> Arc<dyn rustls::time_provider::TimeProvider> {
self.0.clone()
}
}
fn default_provider() -> Result<Arc<CryptoProvider>, Error> {
#[cfg(feature = "ring")]
{
Ok(Arc::new(rustls::crypto::ring::default_provider()))
}
#[cfg(not(feature = "ring"))]
{
CryptoProvider::get_default().cloned().ok_or_else(|| {
Error::General(
"no rustls crypto provider: pass one or install a process default".into(),
)
})
}
}
impl rustls::time_provider::TimeProvider for SuppliedTime {
fn current_time(&self) -> Option<UnixTime> {
Some(UnixTime::since_unix_epoch(Duration::from_secs(
self.0.load(Ordering::Relaxed),
)))
}
}
#[derive(Debug, Clone)]
pub struct ClientOptions {
pub alpn: Vec<Vec<u8>>,
pub ca: Option<Vec<CertificateDer<'static>>>,
pub extra_ca_pem: Vec<u8>,
pub reject_unauthorized: bool,
pub enable_sni: bool,
pub provider: Option<Arc<CryptoProvider>>,
}
impl Default for ClientOptions {
fn default() -> Self {
Self {
alpn: vec![b"http/1.1".to_vec()],
ca: None,
extra_ca_pem: Vec::new(),
reject_unauthorized: true,
enable_sni: true,
provider: None,
}
}
}
#[derive(Clone)]
pub struct ClientConfig {
config: Arc<rustls::ClientConfig>,
time: HostTime,
}
impl ClientConfig {
pub fn new(options: ClientOptions, unix_seconds: u64) -> Result<Self, Error> {
let provider = match options.provider {
Some(provider) => provider,
None => default_provider()?,
};
let time = HostTime::new(unix_seconds);
let mut roots = rustls::RootCertStore::empty();
if let Some(ca) = options.ca {
for cert in ca {
roots.add(cert)?;
}
} else {
roots.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
for cert in CertificateDer::pem_slice_iter(&options.extra_ca_pem) {
roots.add(cert.map_err(|e| Error::General(e.to_string()))?)?;
}
}
let mut config =
rustls::ClientConfig::builder_with_details(provider.clone(), time.time_provider())
.with_safe_default_protocol_versions()?
.with_root_certificates(roots)
.with_no_client_auth();
if !options.reject_unauthorized {
config
.dangerous()
.set_certificate_verifier(Arc::new(Unverified { provider }));
}
config.alpn_protocols = options.alpn;
config.enable_sni = options.enable_sni;
Ok(Self::from_rustls(Arc::new(config), time))
}
pub fn from_rustls(config: Arc<rustls::ClientConfig>, time: HostTime) -> Self {
Self { config, time }
}
pub fn rustls_config(&self) -> &Arc<rustls::ClientConfig> {
&self.config
}
pub fn with_alpn(&self, alpn: Vec<Vec<u8>>) -> Self {
let mut config = (*self.config).clone();
config.alpn_protocols = alpn;
Self::from_rustls(Arc::new(config), self.time.clone())
}
pub fn connect(&self, name: ServerName<'static>) -> Result<Client, Error> {
Ok(Client {
inner: rustls::client::UnbufferedClientConnection::new(self.config.clone(), name)?,
time: self.time.clone(),
deadline: None,
timed_out: false,
})
}
}
#[derive(Clone)]
pub struct ServerConfig {
config: Arc<rustls::ServerConfig>,
time: HostTime,
}
impl ServerConfig {
pub fn new(
chain: Vec<CertificateDer<'static>>,
key: PrivateKeyDer<'static>,
alpn: Vec<Vec<u8>>,
unix_seconds: u64,
) -> Result<Self, Error> {
Self::with_provider(default_provider()?, chain, key, alpn, unix_seconds)
}
pub fn with_provider(
provider: Arc<CryptoProvider>,
chain: Vec<CertificateDer<'static>>,
key: PrivateKeyDer<'static>,
alpn: Vec<Vec<u8>>,
unix_seconds: u64,
) -> Result<Self, Error> {
let time = HostTime::new(unix_seconds);
let mut config = rustls::ServerConfig::builder_with_details(provider, time.time_provider())
.with_safe_default_protocol_versions()?
.with_no_client_auth()
.with_single_cert(chain, key)?;
config.alpn_protocols = alpn;
Ok(Self::from_rustls(Arc::new(config), time))
}
pub fn from_rustls(config: Arc<rustls::ServerConfig>, time: HostTime) -> Self {
Self { config, time }
}
pub fn rustls_config(&self) -> &Arc<rustls::ServerConfig> {
&self.config
}
pub fn accept(&self) -> Result<Server, Error> {
Ok(Server {
inner: rustls::server::UnbufferedServerConnection::new(self.config.clone())?,
time: self.time.clone(),
deadline: None,
timed_out: false,
})
}
}
mod channel_binding;
#[cfg(feature = "ring")]
pub use channel_binding::tls_server_end_point;
pub use channel_binding::{EndPointHash, tls_server_end_point_hash};
macro_rules! endpoint {
($name:ident, $connection:ty, $data:ty) => {
pub struct $name {
inner: $connection,
time: HostTime,
deadline: Option<Instant>,
timed_out: bool,
}
impl $name {
pub fn process<'c, 'i>(
&'c mut self,
incoming: &'i mut [u8],
unix_seconds: u64,
) -> UnbufferedStatus<'c, 'i, $data> {
self.time.set(unix_seconds);
if self.timed_out {
return UnbufferedStatus {
discard: 0,
state: Err(Error::General("TLS handshake timeout".into())),
};
}
self.inner.process_tls_records(incoming)
}
pub fn alpn_protocol(&self) -> Option<&[u8]> {
self.inner.alpn_protocol()
}
pub fn peer_certificates(
&self,
) -> Option<&[rustls::pki_types::CertificateDer<'static>]> {
self.inner.peer_certificates()
}
pub fn is_handshaking(&self) -> bool {
self.inner.is_handshaking()
}
pub fn handshake_kind(&self) -> Option<rustls::HandshakeKind> {
self.inner.handshake_kind()
}
pub fn set_handshake_deadline(&mut self, deadline: Option<Instant>) {
self.deadline = deadline;
}
pub fn next_timeout(&self) -> Option<Instant> {
if self.inner.is_handshaking() && !self.timed_out {
self.deadline
} else {
None
}
}
pub fn handle_timeout(&mut self, now: Instant) -> Option<&'static str> {
if self.next_timeout().is_some_and(|d| now >= d) {
self.timed_out = true;
self.deadline = None;
Some("ERR_TLS_HANDSHAKE_TIMEOUT")
} else {
None
}
}
}
};
}
endpoint!(
Client,
rustls::client::UnbufferedClientConnection,
rustls::client::ClientConnectionData
);
endpoint!(
Server,
rustls::server::UnbufferedServerConnection,
rustls::server::ServerConnectionData
);
pub fn node_error_code(error: &Error) -> &'static str {
match error {
Error::InvalidCertificate(
CertificateError::Expired | CertificateError::ExpiredContext { .. },
) => "CERT_HAS_EXPIRED",
Error::InvalidCertificate(
CertificateError::NotValidYet | CertificateError::NotValidYetContext { .. },
) => "CERT_NOT_YET_VALID",
Error::InvalidCertificate(
CertificateError::NotValidForName | CertificateError::NotValidForNameContext { .. },
) => "ERR_TLS_CERT_ALTNAME_INVALID",
Error::InvalidCertificate(CertificateError::UnknownIssuer) => {
"UNABLE_TO_VERIFY_LEAF_SIGNATURE"
}
Error::InvalidCertificate(CertificateError::Revoked) => "CERT_REVOKED",
Error::NoApplicationProtocol => "ERR_SSL_TLSV1_ALERT_NO_APPLICATION_PROTOCOL",
_ => "ERR_SSL_PROTOCOL_ERROR",
}
}
#[derive(Debug)]
struct Unverified {
provider: Arc<CryptoProvider>,
}
impl ServerCertVerifier for Unverified {
fn verify_server_cert(
&self,
_: &CertificateDer<'_>,
_: &[CertificateDer<'_>],
_: &ServerName<'_>,
_: &[u8],
_: UnixTime,
) -> Result<ServerCertVerified, Error> {
Ok(ServerCertVerified::assertion())
}
fn verify_tls12_signature(
&self,
message: &[u8],
cert: &CertificateDer<'_>,
dss: &DigitallySignedStruct,
) -> Result<HandshakeSignatureValid, Error> {
rustls::crypto::verify_tls12_signature(
message,
cert,
dss,
&self.provider.signature_verification_algorithms,
)
}
fn verify_tls13_signature(
&self,
message: &[u8],
cert: &CertificateDer<'_>,
dss: &DigitallySignedStruct,
) -> Result<HandshakeSignatureValid, Error> {
rustls::crypto::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()
}
}
#[cfg(feature = "turnloop")]
pub mod asynchronous;
#[cfg(feature = "turnloop")]
pub use asynchronous::TlsStream;