use std::path::Path;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::sync::OnceLock;
use rustls::pki_types::{CertificateDer, PrivateKeyDer};
use crate::error::{Error, Result};
static TLS_POLICY_TOKEN_NEXT: AtomicU64 = AtomicU64::new(1);
fn mint_tls_policy_token() -> Arc<u64> {
loop {
let id = TLS_POLICY_TOKEN_NEXT.fetch_add(1, Ordering::Relaxed);
if id != 0 {
return Arc::new(id);
}
}
}
#[derive(Debug, Clone, Default)]
pub enum TrustStore {
#[default]
NativeWithWebPkiFallback,
NativeOnly,
WebPkiOnly,
Custom(Vec<CertificateDer<'static>>),
}
#[derive(Clone)]
pub enum ClientIdentity {
Pem {
cert_chain: Vec<CertificateDer<'static>>,
private_key_der: Vec<u8>,
key_label: String,
},
}
impl std::fmt::Debug for ClientIdentity {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Pem {
cert_chain,
key_label,
..
} => f
.debug_struct("ClientIdentity::Pem")
.field("cert_count", &cert_chain.len())
.field("key_label", key_label)
.finish_non_exhaustive(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum TlsVersion {
Tls12,
Tls13,
}
impl TlsVersion {
fn to_rustls(self) -> &'static rustls::SupportedProtocolVersion {
match self {
Self::Tls12 => &rustls::version::TLS12,
Self::Tls13 => &rustls::version::TLS13,
}
}
}
#[derive(Clone)]
pub struct TlsConfig {
trust_store: TrustStore,
custom_ca_roots: Vec<CertificateDer<'static>>,
additional_ca_roots: Vec<CertificateDer<'static>>,
crypto_provider: Option<Arc<rustls::crypto::CryptoProvider>>,
client_identity: Option<ClientIdentity>,
verify_hostname: bool,
verify_certificate: bool,
min_version: Option<TlsVersion>,
max_version: Option<TlsVersion>,
sni_enabled: bool,
root_store: Arc<OnceLock<Result<rustls::RootCertStore>>>,
policy_token: Arc<u64>,
}
impl std::fmt::Debug for TlsConfig {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("TlsConfig")
.field("trust_store", &self.trust_store)
.field("has_custom_ca", &!self.custom_ca_roots.is_empty())
.field("additional_ca_count", &self.additional_ca_roots.len())
.field(
"has_explicit_crypto_provider",
&self.crypto_provider.is_some(),
)
.field("has_client_identity", &self.client_identity.is_some())
.field("verify_hostname", &self.verify_hostname)
.field("verify_certificate", &self.verify_certificate)
.field("min_version", &self.min_version)
.field("max_version", &self.max_version)
.field("sni_enabled", &self.sni_enabled)
.finish_non_exhaustive()
}
}
impl Default for TlsConfig {
fn default() -> Self {
Self::builder().build()
}
}
impl TlsConfig {
#[cfg(all(feature = "proxy", feature = "tls-rustls"))]
pub(crate) fn connection_identity(&self) -> u64 {
*self.policy_token
}
#[must_use]
pub fn builder() -> TlsConfigBuilder {
TlsConfigBuilder::new()
}
#[must_use]
pub fn builder_with_defaults() -> TlsConfigBuilder {
Self::builder()
}
#[must_use]
pub fn danger_accept_invalid_certs(mut self, accept: bool) -> Self {
self.verify_certificate = !accept;
self.verify_hostname = !accept;
self.policy_token = mint_tls_policy_token();
self
}
pub fn tls_connector(&self) -> Result<tokio_rustls::TlsConnector> {
let config = self.build_rustls_config()?;
Ok(tokio_rustls::TlsConnector::from(Arc::new(config)))
}
pub fn build_rustls_config(&self) -> Result<rustls::ClientConfig> {
let root_store = self.build_root_store()?;
let mut protocol_versions = Vec::new();
match (self.min_version, self.max_version) {
(Some(min), Some(max)) => {
if min > max {
return Err(Error::TlsConfig(format!(
"invalid TLS version range: min ({min:?}) > max ({max:?})"
)));
}
for v in Self::supported_versions() {
if v >= min && v <= max {
protocol_versions.push(v.to_rustls());
}
}
}
(Some(min), None) => {
for v in Self::supported_versions() {
if v >= min {
protocol_versions.push(v.to_rustls());
}
}
}
(None, Some(max)) => {
for v in Self::supported_versions() {
if v <= max {
protocol_versions.push(v.to_rustls());
}
}
}
(None, None) => {
for v in Self::supported_versions() {
protocol_versions.push(v.to_rustls());
}
}
}
if protocol_versions.is_empty() {
return Err(Error::TlsConfig(
"no supported TLS versions in configured range".into(),
));
}
let provider = self.resolve_crypto_provider()?;
let supported_schemes = provider
.signature_verification_algorithms
.supported_schemes();
let mut config = if self.verify_certificate && self.verify_hostname {
rustls::ClientConfig::builder_with_provider(provider.clone())
.with_protocol_versions(&protocol_versions)
.map_err(|e| Error::TlsConfig(format!("TLS version config: {e}")))?
.with_root_certificates(root_store)
.with_no_client_auth()
} else if self.verify_certificate {
rustls::ClientConfig::builder_with_provider(provider.clone())
.with_protocol_versions(&protocol_versions)
.map_err(|e| Error::TlsConfig(format!("TLS version config: {e}")))?
.dangerous()
.with_custom_certificate_verifier(no_hostname_verifier(
&root_store,
provider.clone(),
)?)
.with_no_client_auth()
} else {
rustls::ClientConfig::builder_with_provider(provider.clone())
.with_protocol_versions(&protocol_versions)
.map_err(|e| Error::TlsConfig(format!("TLS version config: {e}")))?
.dangerous()
.with_custom_certificate_verifier(Arc::new(NoVerifier { supported_schemes }))
.with_no_client_auth()
};
#[cfg(feature = "transport-http2")]
{
config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
}
#[cfg(not(feature = "transport-http2"))]
{
config.alpn_protocols = vec![b"http/1.1".to_vec()];
}
config.enable_sni = self.sni_enabled;
if let Some(identity) = &self.client_identity {
config.client_auth_cert_resolver = Arc::new(SingleCertResolver::new(
identity.clone(),
provider.as_ref(),
)?);
}
Ok(config)
}
fn build_root_store(&self) -> Result<rustls::RootCertStore> {
self.root_store
.get_or_init(|| self.build_root_store_uncached())
.clone()
}
fn build_root_store_uncached(&self) -> Result<rustls::RootCertStore> {
let mut roots = match &self.trust_store {
TrustStore::NativeWithWebPkiFallback => match Self::try_native_roots() {
Ok(store) if !store.is_empty() => Ok(store),
_ => Ok(Self::webpki_roots()),
},
TrustStore::NativeOnly => Self::try_native_roots(),
TrustStore::WebPkiOnly => Ok(Self::webpki_roots()),
TrustStore::Custom(certs) => {
if certs.is_empty() {
return Err(Error::CaBundle("custom CA bundle is empty".into()));
}
let mut store = rustls::RootCertStore::empty();
for cert in certs {
store
.add(cert.clone())
.map_err(|e| Error::CaBundle(format!("invalid CA certificate: {e}")))?;
}
Ok(store)
}
}?;
for cert in &self.additional_ca_roots {
roots
.add(cert.clone())
.map_err(|e| Error::CaBundle(format!("invalid additional CA certificate: {e}")))?;
}
Ok(roots)
}
#[cfg(not(feature = "tls-native-roots"))]
fn try_native_roots() -> Result<rustls::RootCertStore> {
Err(Error::TlsConfig(
"native root certificates are disabled; enable tls-native-roots".into(),
))
}
#[cfg(feature = "tls-native-roots")]
fn try_native_roots() -> Result<rustls::RootCertStore> {
let mut roots = rustls::RootCertStore::empty();
#[cfg(target_os = "linux")]
let pem_paths: &[&str] = &[
"/etc/ssl/certs/ca-certificates.crt",
"/etc/pki/tls/certs/ca-bundle.crt",
"/etc/ssl/ca-bundle.pem",
];
#[cfg(target_os = "macos")]
let pem_paths: &[&str] = &["/etc/ssl/cert.pem", "/usr/local/etc/openssl/cert.pem"];
#[cfg(any(target_os = "linux", target_os = "macos"))]
for path in pem_paths {
match load_pem_certs_from_path(Path::new(path)) {
Ok(certs) => {
for cert in certs {
if let Err(e) = roots.add(cert) {
#[cfg(feature = "tracing")]
tracing::warn!(
"eggfetch: skipped invalid CA certificate in {path}: {e}"
);
#[cfg(not(feature = "tracing"))]
let _ = (path, &e);
}
}
}
Err(e) => {
#[cfg(feature = "tracing")]
tracing::warn!("eggfetch: failed to load native CA bundle {path}: {e}");
#[cfg(not(feature = "tracing"))]
let _ = (path, &e);
}
}
}
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
{
for cert in rustls_native_certs::load_native_certs().certs {
if let Err(e) = roots.add(cert) {
#[cfg(feature = "tracing")]
tracing::warn!("eggfetch: skipped invalid native CA certificate: {e}");
#[cfg(not(feature = "tracing"))]
let _ = &e;
}
}
}
if roots.is_empty() {
return Err(Error::TlsConfig(
"native root certificates not available".into(),
));
}
Ok(roots)
}
fn webpki_roots() -> rustls::RootCertStore {
let mut roots = rustls::RootCertStore::empty();
roots.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
roots
}
fn supported_versions() -> impl Iterator<Item = TlsVersion> {
[TlsVersion::Tls12, TlsVersion::Tls13].into_iter()
}
#[must_use]
pub fn verify_hostname(&self) -> bool {
self.verify_hostname
}
#[must_use]
pub fn verify_certificate(&self) -> bool {
self.verify_certificate
}
#[must_use]
pub fn sni_enabled(&self) -> bool {
self.sni_enabled
}
#[must_use]
pub fn has_explicit_crypto_provider(&self) -> bool {
self.crypto_provider.is_some()
}
fn resolve_crypto_provider(&self) -> Result<Arc<rustls::crypto::CryptoProvider>> {
if let Some(provider) = &self.crypto_provider {
return Ok(provider.clone());
}
process_crypto_provider()
}
#[allow(
dead_code,
reason = "the QUIC client config is only built by the HTTP/3 transport, which is compiled out when the http3 feature is disabled"
)]
pub(crate) fn build_quic_rustls_config(&self) -> Result<rustls::ClientConfig> {
let root_store = self.build_root_store()?;
let provider = self.resolve_crypto_provider()?;
let supported_schemes = provider
.signature_verification_algorithms
.supported_schemes();
let mut config = if self.verify_certificate && self.verify_hostname {
rustls::ClientConfig::builder_with_provider(provider.clone())
.with_protocol_versions(&[&rustls::version::TLS13])
.map_err(|e| Error::Tls(format!("TLS version config: {e}")))?
.with_root_certificates(root_store)
.with_no_client_auth()
} else if self.verify_certificate {
rustls::ClientConfig::builder_with_provider(provider.clone())
.with_protocol_versions(&[&rustls::version::TLS13])
.map_err(|e| Error::Tls(format!("TLS version config: {e}")))?
.dangerous()
.with_custom_certificate_verifier(no_hostname_verifier(
&root_store,
provider.clone(),
)?)
.with_no_client_auth()
} else {
rustls::ClientConfig::builder_with_provider(provider.clone())
.with_protocol_versions(&[&rustls::version::TLS13])
.map_err(|e| Error::Tls(format!("TLS version config: {e}")))?
.dangerous()
.with_custom_certificate_verifier(Arc::new(NoVerifier { supported_schemes }))
.with_no_client_auth()
};
config.alpn_protocols = vec![b"h3".to_vec()];
config.enable_sni = self.sni_enabled;
if let Some(identity) = &self.client_identity {
config.client_auth_cert_resolver = Arc::new(SingleCertResolver::new(
identity.clone(),
provider.as_ref(),
)?);
}
Ok(config)
}
}
pub struct TlsConfigBuilder {
trust_store: TrustStore,
custom_ca_roots: Vec<CertificateDer<'static>>,
additional_ca_roots: Vec<CertificateDer<'static>>,
crypto_provider: Option<Arc<rustls::crypto::CryptoProvider>>,
client_identity: Option<ClientIdentity>,
verify_hostname: bool,
verify_certificate: bool,
min_version: Option<TlsVersion>,
max_version: Option<TlsVersion>,
sni_enabled: bool,
}
impl Default for TlsConfigBuilder {
fn default() -> Self {
Self::new()
}
}
impl TlsConfigBuilder {
#[must_use]
pub fn new() -> Self {
Self {
trust_store: TrustStore::NativeWithWebPkiFallback,
custom_ca_roots: Vec::new(),
additional_ca_roots: Vec::new(),
crypto_provider: None,
client_identity: None,
verify_hostname: true,
verify_certificate: true,
min_version: None,
max_version: None,
sni_enabled: true,
}
}
#[must_use]
pub fn trust_store(mut self, store: TrustStore) -> Self {
self.trust_store = store;
self
}
pub fn ca_certificate_path(mut self, path: impl AsRef<Path>) -> Result<Self> {
let certs = load_pem_certs_from_path(path.as_ref())?;
if certs.is_empty() {
return Err(Error::CaBundle(format!(
"no certificates found in {}",
path.as_ref().display()
)));
}
self.custom_ca_roots = certs;
self.trust_store = TrustStore::Custom(self.custom_ca_roots.clone());
Ok(self)
}
pub fn add_ca_certificate_path(mut self, path: impl AsRef<Path>) -> Result<Self> {
let certs = load_pem_certs_from_path(path.as_ref())?;
if certs.is_empty() {
if path.as_ref().is_dir() {
return Ok(self);
}
return Err(Error::CaBundle(format!(
"no certificates found in {}",
path.as_ref().display()
)));
}
if !matches!(&self.trust_store, TrustStore::Custom(_)) {
self.custom_ca_roots.clear();
}
for cert in certs {
if !self
.custom_ca_roots
.iter()
.any(|existing| existing.as_ref() == cert.as_ref())
{
self.custom_ca_roots.push(cert);
}
}
self.trust_store = TrustStore::Custom(self.custom_ca_roots.clone());
Ok(self)
}
pub fn additional_ca_certificate_path(mut self, path: impl AsRef<Path>) -> Result<Self> {
let certs = load_pem_certs_from_path(path.as_ref())?;
if certs.is_empty() {
if path.as_ref().is_dir() {
return Ok(self);
}
return Err(Error::CaBundle(format!(
"no certificates found in {}",
path.as_ref().display()
)));
}
append_unique_certs(&mut self.additional_ca_roots, certs);
Ok(self)
}
pub fn ca_certificate_pem(mut self, pem_bytes: &[u8]) -> Result<Self> {
let certs = parse_pem_certificates(pem_bytes)?;
if certs.is_empty() {
return Err(Error::CaBundle("no certificates found in PEM data".into()));
}
self.custom_ca_roots = certs;
self.trust_store = TrustStore::Custom(self.custom_ca_roots.clone());
Ok(self)
}
pub fn ca_certificate_der(mut self, der_certs: Vec<Vec<u8>>) -> Result<Self> {
let certs: Vec<CertificateDer<'static>> =
der_certs.into_iter().map(CertificateDer::from).collect();
if certs.is_empty() {
return Err(Error::CaBundle("no DER certificates provided".into()));
}
self.custom_ca_roots = certs;
self.trust_store = TrustStore::Custom(self.custom_ca_roots.clone());
Ok(self)
}
pub fn additional_ca_certificate_pem(mut self, pem_bytes: &[u8]) -> Result<Self> {
let certs = parse_pem_certificates(pem_bytes)?;
if certs.is_empty() {
return Err(Error::CaBundle(
"no certificates found in additional PEM data".into(),
));
}
append_unique_certs(&mut self.additional_ca_roots, certs);
Ok(self)
}
pub fn additional_ca_certificate_der(mut self, der_certs: Vec<Vec<u8>>) -> Result<Self> {
if der_certs.is_empty() {
return Err(Error::CaBundle(
"no additional DER certificates provided".into(),
));
}
append_unique_certs(
&mut self.additional_ca_roots,
der_certs.into_iter().map(CertificateDer::from),
);
Ok(self)
}
#[must_use]
pub fn crypto_provider(mut self, provider: Arc<rustls::crypto::CryptoProvider>) -> Self {
self.crypto_provider = Some(provider);
self
}
#[must_use]
pub fn client_identity(mut self, identity: ClientIdentity) -> Self {
self.client_identity = Some(identity);
self
}
pub fn client_cert_path(
self,
cert_path: impl AsRef<Path>,
key_path: impl AsRef<Path>,
) -> Result<Self> {
let certs = load_pem_certs_from_path(cert_path.as_ref())?;
if certs.is_empty() {
return Err(Error::ClientCert(format!(
"no certificates found in {}",
cert_path.as_ref().display()
)));
}
let key_bytes = std::fs::read(key_path.as_ref()).map_err(|e| {
Error::PrivateKey(format!(
"failed to read private key {}: {e}",
key_path.as_ref().display()
))
})?;
let (key_data, key_label) = parse_private_key(&key_bytes)?;
Ok(self.client_identity(ClientIdentity::Pem {
cert_chain: certs,
private_key_der: key_data,
key_label,
}))
}
#[must_use]
pub fn verify_hostname(mut self, enabled: bool) -> Self {
self.verify_hostname = enabled;
self
}
#[must_use]
pub fn danger_accept_invalid_certs(mut self, accept: bool) -> Self {
self.verify_certificate = !accept;
self.verify_hostname = !accept;
self
}
#[must_use]
pub fn min_tls_version(mut self, version: TlsVersion) -> Self {
self.min_version = Some(version);
self
}
#[must_use]
pub fn max_tls_version(mut self, version: TlsVersion) -> Self {
self.max_version = Some(version);
self
}
#[must_use]
pub fn sni(mut self, enabled: bool) -> Self {
self.sni_enabled = enabled;
self
}
#[must_use]
pub fn build(self) -> TlsConfig {
TlsConfig {
trust_store: self.trust_store,
custom_ca_roots: self.custom_ca_roots,
additional_ca_roots: self.additional_ca_roots,
crypto_provider: self.crypto_provider,
client_identity: self.client_identity,
verify_hostname: self.verify_hostname,
verify_certificate: self.verify_certificate,
min_version: self.min_version,
max_version: self.max_version,
sni_enabled: self.sni_enabled,
root_store: Arc::new(OnceLock::new()),
policy_token: mint_tls_policy_token(),
}
}
}
#[derive(Debug)]
struct NoVerifier {
supported_schemes: Vec<rustls::SignatureScheme>,
}
pub(crate) fn process_crypto_provider() -> Result<Arc<rustls::crypto::CryptoProvider>> {
if let Some(provider) = rustls::crypto::CryptoProvider::get_default() {
return Ok(provider.clone());
}
#[cfg(feature = "tls-rustls")]
{
let provider = rustls::crypto::ring::default_provider();
let _ = provider.install_default();
if let Some(provider) = rustls::crypto::CryptoProvider::get_default() {
return Ok(provider.clone());
}
}
let _ = rustls::ClientConfig::builder();
rustls::crypto::CryptoProvider::get_default()
.cloned()
.ok_or_else(|| Error::TlsConfig("no default TLS crypto provider".into()))
}
#[derive(Debug)]
struct NoHostnameVerifier {
roots: Arc<rustls::RootCertStore>,
delegate: Arc<rustls::client::WebPkiServerVerifier>,
supported_algs: rustls::crypto::WebPkiSupportedAlgorithms,
}
fn no_hostname_verifier(
roots: &rustls::RootCertStore,
provider: Arc<rustls::crypto::CryptoProvider>,
) -> Result<Arc<dyn rustls::client::danger::ServerCertVerifier>> {
let roots = Arc::new(roots.clone());
let supported_algs = provider.signature_verification_algorithms;
let delegate =
rustls::client::WebPkiServerVerifier::builder_with_provider(roots.clone(), provider)
.build()
.map_err(|e| Error::TlsConfig(format!("failed to build certificate verifier: {e}")))?;
Ok(Arc::new(NoHostnameVerifier {
roots,
delegate,
supported_algs,
}))
}
impl rustls::client::danger::ServerCertVerifier for NoHostnameVerifier {
fn verify_server_cert(
&self,
end_entity: &CertificateDer<'_>,
intermediates: &[CertificateDer<'_>],
_server_name: &rustls::pki_types::ServerName<'_>,
_ocsp_response: &[u8],
now: rustls::pki_types::UnixTime,
) -> std::result::Result<rustls::client::danger::ServerCertVerified, rustls::Error> {
let cert = rustls::server::ParsedCertificate::try_from(end_entity)?;
rustls::client::verify_server_cert_signed_by_trust_anchor(
&cert,
&self.roots,
intermediates,
now,
self.supported_algs.all,
)?;
Ok(rustls::client::danger::ServerCertVerified::assertion())
}
fn verify_tls12_signature(
&self,
message: &[u8],
cert: &CertificateDer<'_>,
dss: &rustls::DigitallySignedStruct,
) -> std::result::Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
self.delegate.verify_tls12_signature(message, cert, dss)
}
fn verify_tls13_signature(
&self,
message: &[u8],
cert: &CertificateDer<'_>,
dss: &rustls::DigitallySignedStruct,
) -> std::result::Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
self.delegate.verify_tls13_signature(message, cert, dss)
}
fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
self.delegate.supported_verify_schemes()
}
}
impl rustls::client::danger::ServerCertVerifier for NoVerifier {
fn verify_server_cert(
&self,
_end_entity: &CertificateDer<'_>,
_intermediates: &[CertificateDer<'_>],
_server_name: &rustls::pki_types::ServerName<'_>,
_ocsp_response: &[u8],
_now: rustls::pki_types::UnixTime,
) -> std::result::Result<rustls::client::danger::ServerCertVerified, rustls::Error> {
Ok(rustls::client::danger::ServerCertVerified::assertion())
}
fn verify_tls12_signature(
&self,
_message: &[u8],
_cert: &CertificateDer<'_>,
_dss: &rustls::DigitallySignedStruct,
) -> std::result::Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
Ok(rustls::client::danger::HandshakeSignatureValid::assertion())
}
fn verify_tls13_signature(
&self,
_message: &[u8],
_cert: &CertificateDer<'_>,
_dss: &rustls::DigitallySignedStruct,
) -> std::result::Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
Ok(rustls::client::danger::HandshakeSignatureValid::assertion())
}
fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
self.supported_schemes.clone()
}
}
struct SingleCertResolver {
certified_key: Arc<rustls::sign::CertifiedKey>,
key_label: String,
}
impl std::fmt::Debug for SingleCertResolver {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SingleCertResolver")
.field("cert_count", &self.certified_key.cert.len())
.field("key_label", &self.key_label)
.finish_non_exhaustive()
}
}
impl SingleCertResolver {
fn new(identity: ClientIdentity, provider: &rustls::crypto::CryptoProvider) -> Result<Self> {
match identity {
ClientIdentity::Pem {
cert_chain,
private_key_der,
key_label,
} => {
let key_der = private_key_der_from_parts(&private_key_der, &key_label);
let certified_key = rustls::sign::CertifiedKey::from_der(
cert_chain, key_der, provider,
)
.map_err(|e| Error::PrivateKey(format!("failed to load private key: {e}")))?;
Ok(Self {
certified_key: Arc::new(certified_key),
key_label,
})
}
}
}
}
impl rustls::client::ResolvesClientCert for SingleCertResolver {
fn resolve(
&self,
_root_hint_subjects: &[&[u8]],
_sigschemes: &[rustls::SignatureScheme],
) -> Option<Arc<rustls::sign::CertifiedKey>> {
self.has_certs().then(|| self.certified_key.clone())
}
fn has_certs(&self) -> bool {
!self.certified_key.cert.is_empty()
}
}
fn private_key_der_from_parts(bytes: &[u8], label: &str) -> PrivateKeyDer<'static> {
match label {
"RSA PRIVATE KEY" => PrivateKeyDer::Pkcs1(rustls::pki_types::PrivatePkcs1KeyDer::from(
bytes.to_owned(),
)),
"EC PRIVATE KEY" => {
PrivateKeyDer::Sec1(rustls::pki_types::PrivateSec1KeyDer::from(bytes.to_owned()))
}
_ => PrivateKeyDer::Pkcs8(rustls::pki_types::PrivatePkcs8KeyDer::from(
bytes.to_owned(),
)),
}
}
fn append_unique_certs(
destination: &mut Vec<CertificateDer<'static>>,
certificates: impl IntoIterator<Item = CertificateDer<'static>>,
) {
for certificate in certificates {
if !destination
.iter()
.any(|existing| existing.as_ref() == certificate.as_ref())
{
destination.push(certificate);
}
}
}
const PEM_BEGIN: &[u8] = b"-----BEGIN ";
const PEM_END: &[u8] = b"-----END ";
fn load_pem_certs_from_path(path: &Path) -> Result<Vec<CertificateDer<'static>>> {
if path.is_dir() {
let mut entries = std::fs::read_dir(path)
.map_err(|e| Error::CaBundle(format!("failed to read {}: {e}", path.display())))?
.filter_map(std::result::Result::ok)
.collect::<Vec<_>>();
entries.sort_by_key(std::fs::DirEntry::file_name);
let mut certs = Vec::new();
for entry in entries {
if !entry.metadata().is_ok_and(|metadata| metadata.is_file()) {
continue;
}
if let Ok(data) = std::fs::read(entry.path()) {
certs.extend(parse_pem_certificates(&data)?);
}
}
return Ok(certs);
}
let data = std::fs::read(path)
.map_err(|e| Error::CaBundle(format!("failed to read {}: {e}", path.display())))?;
parse_pem_certificates(&data)
}
fn parse_pem_certificates(pem_bytes: &[u8]) -> Result<Vec<CertificateDer<'static>>> {
let mut certs = Vec::new();
let mut rest = pem_bytes;
while let Some(pos) = find_pem_start(rest) {
let section = &rest[pos..];
let section_len = pem_section_len(section)
.ok_or_else(|| Error::CaBundle("unterminated PEM block in certificate data".into()))?;
let (label, data) = pem_rfc7468::decode_vec(§ion[..section_len])
.map_err(|e| Error::CaBundle(format!("invalid PEM block in certificate data: {e}")))?;
if label == "CERTIFICATE" {
certs.push(CertificateDer::from(data));
} else {
#[cfg(feature = "tracing")]
tracing::warn!("eggfetch: ignoring non-certificate PEM block `{label}` in CA bundle");
#[cfg(not(feature = "tracing"))]
let _ = &label;
}
rest = §ion[section_len..];
}
Ok(certs)
}
fn find_pem_start(data: &[u8]) -> Option<usize> {
if data.len() < PEM_BEGIN.len() {
return None;
}
data.windows(PEM_BEGIN.len()).position(|w| w == PEM_BEGIN)
}
fn pem_section_len(data: &[u8]) -> Option<usize> {
let after_begin = &data[PEM_BEGIN.len()..];
let end_marker = after_begin
.windows(PEM_END.len())
.position(|w| w == PEM_END)?
+ PEM_BEGIN.len();
let line_end = data[end_marker..]
.iter()
.position(|&b| b == b'\n')
.map_or(data.len(), |p| end_marker + p + 1);
Some(line_end)
}
fn parse_private_key(key_bytes: &[u8]) -> Result<(Vec<u8>, String)> {
let mut rest = key_bytes;
while let Some(pos) = find_pem_start(rest) {
let section = &rest[pos..];
let section_len = pem_section_len(section).ok_or_else(|| {
Error::PrivateKey("unterminated PEM block in private key data".into())
})?;
let (label, data) = pem_rfc7468::decode_vec(§ion[..section_len]).map_err(|e| {
Error::PrivateKey(format!("invalid PEM block in private key data: {e}"))
})?;
if matches!(label, "PRIVATE KEY" | "RSA PRIVATE KEY" | "EC PRIVATE KEY") {
return Ok((data, label.to_string()));
}
rest = §ion[section_len..];
}
Err(Error::PrivateKey("no private key found in PEM data".into()))
}
#[cfg(test)]
mod tests {
use super::*;
use proptest::prelude::*;
#[test]
fn default_tls_config() {
let config = TlsConfig::default();
assert!(config.verify_hostname());
assert!(config.verify_certificate());
assert!(config.sni_enabled());
}
#[test]
fn explicit_provider_is_local_and_retained_by_tls_config() {
let provider = Arc::new(rustls::crypto::ring::default_provider());
let before = rustls::crypto::CryptoProvider::get_default().cloned();
let config = TlsConfig::builder()
.crypto_provider(provider.clone())
.trust_store(TrustStore::WebPkiOnly)
.build();
assert!(config.has_explicit_crypto_provider());
assert!(config.build_rustls_config().is_ok());
let provider_ptr =
|value: Option<&Arc<rustls::crypto::CryptoProvider>>| value.map(Arc::as_ptr);
assert_eq!(
provider_ptr(rustls::crypto::CryptoProvider::get_default()),
provider_ptr(before.as_ref()),
"explicit provider configuration must not mutate the global provider"
);
}
#[test]
fn additional_ca_roots_augment_without_changing_replacement_semantics() {
let mut params = rcgen::CertificateParams::default();
params.is_ca = rcgen::IsCa::Ca(rcgen::BasicConstraints::Unconstrained);
let key = rcgen::KeyPair::generate().unwrap();
let cert = params.self_signed(&key).unwrap();
let der = cert.der().to_vec();
let config = TlsConfig::builder()
.trust_store(TrustStore::WebPkiOnly)
.additional_ca_certificate_der(vec![der.clone(), der])
.unwrap()
.build();
let debug = format!("{config:?}");
assert!(debug.contains("additional_ca_count: 1"));
assert!(config.build_rustls_config().is_ok());
let replacement = TlsConfig::builder()
.ca_certificate_der(vec![cert.der().to_vec()])
.unwrap()
.build();
assert!(replacement.build_rustls_config().is_ok());
}
#[test]
fn malformed_additional_ca_fails_closed() {
let result = TlsConfig::builder().additional_ca_certificate_pem(b"not a certificate");
assert!(result.is_err());
assert_eq!(
result.err().expect("error checked above").kind(),
"ca_bundle"
);
}
#[test]
fn builder_defaults() {
let config = TlsConfig::builder().build();
assert!(config.verify_hostname());
assert!(config.verify_certificate());
assert!(config.sni_enabled());
}
#[test]
fn builder_disable_verification() {
let config = TlsConfig::builder()
.danger_accept_invalid_certs(true)
.build();
assert!(!config.verify_hostname());
assert!(!config.verify_certificate());
}
#[test]
fn config_disable_verification_preserves_other_settings() {
let config = TlsConfig::builder()
.sni(false)
.min_tls_version(TlsVersion::Tls13)
.build()
.danger_accept_invalid_certs(true);
assert!(!config.verify_hostname());
assert!(!config.verify_certificate());
assert!(!config.sni_enabled());
assert_eq!(config.min_version, Some(TlsVersion::Tls13));
}
#[test]
fn builder_custom_tls_version() {
let config = TlsConfig::builder()
.min_tls_version(TlsVersion::Tls13)
.build();
assert_eq!(config.min_version, Some(TlsVersion::Tls13));
}
#[test]
fn builder_invalid_version_range() {
let config = TlsConfig::builder()
.min_tls_version(TlsVersion::Tls13)
.max_tls_version(TlsVersion::Tls12)
.build();
let err = config.build_rustls_config().unwrap_err();
assert_eq!(err.kind(), "tls_config");
}
#[test]
fn builder_sni_disabled() {
let config = TlsConfig::builder().sni(false).build();
assert!(!config.sni_enabled());
}
#[test]
fn trust_store_default() {
let config = TlsConfig::builder().build();
assert!(matches!(
config.trust_store,
TrustStore::NativeWithWebPkiFallback
));
}
#[test]
fn trust_store_custom_empty_rejected() {
let result = TlsConfig::builder()
.ca_certificate_pem(b"")
.map(super::TlsConfigBuilder::build);
assert!(result.is_err());
}
#[test]
fn add_ca_certificate_path_combines_files_and_directories() {
let make_ca_pem = || {
let mut params = rcgen::CertificateParams::default();
params.is_ca = rcgen::IsCa::Ca(rcgen::BasicConstraints::Unconstrained);
let key = rcgen::KeyPair::generate().unwrap();
params.self_signed(&key).unwrap().pem()
};
let first = make_ca_pem();
let second = make_ca_pem();
let tempdir = tempfile::tempdir().unwrap();
let first_path = tempdir.path().join("first.pem");
let cert_dir = tempdir.path().join("certs");
std::fs::create_dir(&cert_dir).unwrap();
std::fs::write(&first_path, first).unwrap();
std::fs::write(cert_dir.join("second.pem"), second).unwrap();
let config = TlsConfig::builder()
.ca_certificate_path(first_path)
.unwrap()
.add_ca_certificate_path(cert_dir)
.unwrap()
.build();
assert_eq!(config.custom_ca_roots.len(), 2);
let empty_dir = tempdir.path().join("empty");
std::fs::create_dir(&empty_dir).unwrap();
let config = TlsConfig::builder()
.ca_certificate_path(tempdir.path().join("first.pem"))
.unwrap()
.add_ca_certificate_path(empty_dir)
.unwrap()
.build();
assert_eq!(config.custom_ca_roots.len(), 1);
}
#[test]
fn tls_version_ordering() {
assert!(TlsVersion::Tls12 < TlsVersion::Tls13);
}
#[test]
fn build_rustls_config_verification() {
let config = TlsConfig::builder().build();
let result = config.build_rustls_config();
assert!(result.is_ok());
}
#[test]
fn webpki_only_builds_without_native_roots() {
let config = TlsConfig::builder()
.trust_store(TrustStore::WebPkiOnly)
.build();
assert!(config.build_rustls_config().is_ok());
}
#[cfg(not(feature = "tls-native-roots"))]
#[test]
fn native_only_reports_disabled_feature() {
let config = TlsConfig::builder()
.trust_store(TrustStore::NativeOnly)
.build();
let error = config.build_rustls_config().unwrap_err();
assert!(error.to_string().contains("tls-native-roots"));
}
#[test]
fn build_rustls_config_no_verify() {
let config = TlsConfig::builder()
.danger_accept_invalid_certs(true)
.sni(false)
.build();
let rustls_config = config.build_rustls_config().unwrap();
assert!(!rustls_config.enable_sni);
}
#[test]
fn build_rustls_config_version_range() {
let config = TlsConfig::builder()
.min_tls_version(TlsVersion::Tls12)
.max_tls_version(TlsVersion::Tls13)
.build();
let result = config.build_rustls_config();
assert!(result.is_ok());
}
#[test]
fn parse_empty_pem_certificates() {
let result = parse_pem_certificates(b"");
assert_eq!(result.unwrap(), []);
}
#[test]
fn parse_invalid_pem_certificates() {
let result = parse_pem_certificates(b"not valid pem data");
assert_eq!(result.unwrap(), []);
}
#[test]
fn parse_pem_certificates_skip_garbage_between_blocks() {
let valid_block = |body: &[u8]| -> Vec<u8> {
let mut block = b"-----BEGIN CERTIFICATE-----\n".to_vec();
block.extend_from_slice(body);
block.extend_from_slice(b"\n-----END CERTIFICATE-----\n");
block
};
let first = valid_block(b"AAAA");
let second = valid_block(b"BBBB");
let mut pem = first;
pem.extend_from_slice(b"\nthis is not valid PEM \x01\x02 data\n");
pem.extend_from_slice(&second);
let certs = parse_pem_certificates(&pem).unwrap();
assert_eq!(certs.len(), 2, "both certificates must be recovered");
}
#[test]
fn parse_pem_certificates_multi_block_bundle() {
let mut pem = b"-----BEGIN CERTIFICATE-----\nAAAA\n-----END CERTIFICATE-----\n".to_vec();
pem.extend_from_slice(b"-----BEGIN CERTIFICATE-----\nBBBB\n-----END CERTIFICATE-----\n");
pem.extend_from_slice(b"-----BEGIN PRIVATE KEY-----\nAAAA\n-----END PRIVATE KEY-----\n");
let certs = parse_pem_certificates(&pem).unwrap();
assert_eq!(certs.len(), 2, "both certificates, key section skipped");
}
#[test]
fn parse_private_key_skips_leading_garbage() {
let key_block = b"-----BEGIN PRIVATE KEY-----\nAAAA\n-----END PRIVATE KEY-----\n";
let mut pem = b"corrupt \x03 preamble\n".to_vec();
pem.extend_from_slice(key_block);
let (der, label) = parse_private_key(&pem).unwrap();
assert_eq!(label, "PRIVATE KEY");
assert_eq!(der, vec![0u8, 0, 0]);
}
#[test]
fn parse_pem_certificates_rejects_corrupted_blocks() {
let pem = b"-----BEGIN CERTIFICATE-----\nAAAA\n-----END CERTIFICATE-----\n\
-----BEGIN CERTIFICATE-----\n%%%\n-----END CERTIFICATE-----\n";
let err = parse_pem_certificates(pem).unwrap_err();
assert_eq!(err.kind(), "ca_bundle");
}
#[test]
fn error_variants() {
let err = Error::TlsConfig("test".into());
assert_eq!(err.kind(), "tls_config");
let err = Error::CaBundle("test".into());
assert_eq!(err.kind(), "ca_bundle");
let err = Error::ClientCert("test".into());
assert_eq!(err.kind(), "client_cert");
let err = Error::PrivateKey("test".into());
assert_eq!(err.kind(), "private_key");
let err = Error::CertificateVerification("test".into());
assert_eq!(err.kind(), "certificate_verification");
let err = Error::HostnameVerification("test".into());
assert_eq!(err.kind(), "hostname_verification");
}
#[test]
fn debug_impl_no_secrets() {
let config = TlsConfig::builder().build();
let debug = format!("{config:?}");
assert!(debug.contains("verify_hostname: true"));
assert!(debug.contains("verify_certificate: true"));
}
#[cfg(all(feature = "proxy", feature = "tls-rustls"))]
#[test]
fn unchanged_clone_shares_connection_identity() {
let base = TlsConfig::builder().build();
let strict = base.clone();
assert_eq!(
base.connection_identity(),
strict.connection_identity(),
"unchanged clones must remain cache-compatible"
);
}
#[cfg(all(feature = "proxy", feature = "tls-rustls"))]
#[test]
fn danger_mutation_mints_new_connection_identity() {
let base = TlsConfig::builder().build();
let strict = base.clone();
let weak = base.clone().danger_accept_invalid_certs(true);
assert_ne!(
strict.connection_identity(),
weak.connection_identity(),
"changed verification policy must not alias through clone ancestry"
);
}
#[cfg(all(feature = "proxy", feature = "tls-rustls"))]
#[test]
fn independent_builds_never_share_connection_identity() {
let first = TlsConfig::builder().build();
let second = TlsConfig::builder().build();
assert_ne!(
first.connection_identity(),
second.connection_identity(),
"separate builds mint fresh identity even for identical policy"
);
}
#[cfg(all(feature = "proxy", feature = "tls-rustls"))]
#[test]
fn connection_identity_covers_policy_dimensions() {
let base = TlsConfig::builder().build();
let base_id = base.connection_identity();
let sni_off = TlsConfig::builder().sni(false).build();
assert_ne!(base_id, sni_off.connection_identity());
let min_tls = TlsConfig::builder()
.min_tls_version(TlsVersion::Tls13)
.build();
assert_ne!(base_id, min_tls.connection_identity());
let max_tls = TlsConfig::builder()
.max_tls_version(TlsVersion::Tls12)
.build();
assert_ne!(base_id, max_tls.connection_identity());
let webpki = TlsConfig::builder()
.trust_store(TrustStore::WebPkiOnly)
.build();
assert_ne!(base_id, webpki.connection_identity());
let provider = Arc::new(rustls::crypto::ring::default_provider());
let explicit_provider = TlsConfig::builder()
.crypto_provider(provider)
.trust_store(TrustStore::WebPkiOnly)
.build();
assert_ne!(base_id, explicit_provider.connection_identity());
let custom_ca = TlsConfig::builder()
.ca_certificate_der(vec![vec![0u8; 32]])
.unwrap()
.build();
assert_ne!(base_id, custom_ca.connection_identity());
let additional_ca = TlsConfig::builder()
.trust_store(TrustStore::WebPkiOnly)
.additional_ca_certificate_der(vec![vec![1u8; 32]])
.unwrap()
.build();
assert_ne!(base_id, additional_ca.connection_identity());
let identity = ClientIdentity::Pem {
cert_chain: vec![],
private_key_der: vec![2u8; 16],
key_label: "PRIVATE KEY".to_string(),
};
let mtls = TlsConfig::builder().client_identity(identity).build();
assert_ne!(base_id, mtls.connection_identity());
}
#[cfg(all(feature = "proxy", feature = "tls-rustls"))]
#[test]
fn connection_identity_is_opaque_and_non_renderable() {
let config = TlsConfig::builder().build();
let id = config.connection_identity();
assert_ne!(id, 0, "0 is reserved for no-TLS-config keys");
let debug = format!("{config:?}");
assert!(
!debug.contains(&id.to_string()),
"opaque token must never appear in diagnostics: {debug}"
);
}
#[test]
fn client_identity_debug_no_private_key() {
let identity = ClientIdentity::Pem {
cert_chain: vec![],
private_key_der: b"super-secret-private-key-data".to_vec(),
key_label: "PRIVATE KEY".to_string(),
};
let debug = format!("{identity:?}");
assert!(
!debug.contains("super-secret"),
"ClientIdentity Debug must not leak private key bytes: {debug}"
);
assert!(debug.contains("cert_count"));
assert!(debug.contains("key_label"));
}
proptest::proptest! {
#[test]
fn parse_pem_certificates_empty_input(_ in 0u64..100) {
let result = parse_pem_certificates(b"");
prop_assert!(result.unwrap().is_empty());
}
#[test]
fn parse_pem_certificates_garbage(input in ".{0,200}") {
let _ = parse_pem_certificates(input.as_bytes());
}
#[test]
fn tls_config_builder_round_trip(sni in prop::bool::ANY) {
let config = TlsConfig::builder()
.sni(sni)
.build();
prop_assert_eq!(config.sni_enabled(), sni);
prop_assert!(config.verify_hostname());
prop_assert!(config.verify_certificate());
}
#[test]
fn build_rustls_config_valid_for_defaults(_ in 0u64..100) {
let config = TlsConfig::default();
let result = config.build_rustls_config();
prop_assert!(result.is_ok());
}
}
}