use super::TlsMetadata;
use anyhow::{Result, anyhow};
use rustls::{
CertificateError, DigitallySignedStruct, Error as TlsError, RootCertStore, SignatureScheme,
client::{
WebPkiServerVerifier,
danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
},
pki_types::{CertificateDer, ServerName, UnixTime},
};
use std::{
fmt,
sync::{Arc, Mutex},
};
use time::OffsetDateTime;
use x509_parser::prelude::{FromDer, X509Certificate};
#[derive(Debug, Clone, Default)]
pub struct CapturedCertMetadata {
pub subject: Option<String>,
pub issuer: Option<String>,
pub expiry_days: Option<i64>,
}
impl From<CapturedCertMetadata> for TlsMetadata {
fn from(captured: CapturedCertMetadata) -> Self {
Self {
cert_subject: captured.subject,
cert_issuer: captured.issuer,
cert_expiry_days: captured.expiry_days,
..Default::default()
}
}
}
#[derive(Clone)]
pub struct CertCapturingVerifier {
captured: Arc<Mutex<Option<CapturedCertMetadata>>>,
inner_verifier: Arc<WebPkiServerVerifier>,
accept_invalid_hostnames: bool,
}
impl fmt::Debug for CertCapturingVerifier {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("CertCapturingVerifier")
.field("captured", &self.captured)
.field("inner_verifier", &"WebPkiServerVerifier")
.field("accept_invalid_hostnames", &self.accept_invalid_hostnames)
.finish()
}
}
impl CertCapturingVerifier {
pub fn new() -> Result<Self> {
let root_store: RootCertStore = webpki_roots::TLS_SERVER_ROOTS.iter().cloned().collect();
let inner_verifier = WebPkiServerVerifier::builder(Arc::new(root_store))
.build()
.map_err(|e| anyhow!("failed to build WebPKI verifier: {e}"))?;
Ok(Self {
captured: Arc::new(Mutex::new(None)),
inner_verifier,
accept_invalid_hostnames: false,
})
}
pub fn with_root_certificates(
root_store: RootCertStore,
accept_invalid_hostnames: bool,
) -> Result<Self> {
let inner_verifier = WebPkiServerVerifier::builder(Arc::new(root_store))
.build()
.map_err(|e| anyhow!("failed to build WebPKI verifier: {e}"))?;
Ok(Self {
captured: Arc::new(Mutex::new(None)),
inner_verifier,
accept_invalid_hostnames,
})
}
#[must_use]
pub fn get_captured(&self) -> Option<CapturedCertMetadata> {
self.captured.lock().ok()?.clone()
}
fn extract_metadata(cert_der: &[u8]) -> Result<CapturedCertMetadata> {
let (_, cert) = X509Certificate::from_der(cert_der)
.map_err(|e| anyhow!("failed to parse certificate: {e}"))?;
let subject = Some(cert.subject().to_string());
let issuer = Some(cert.issuer().to_string());
let not_after = cert.validity().not_after.to_datetime();
let remaining = not_after - OffsetDateTime::now_utc();
let expiry_days = Some(super::probe::expiry_days_from_remaining(remaining));
Ok(CapturedCertMetadata {
subject,
issuer,
expiry_days,
})
}
}
impl ServerCertVerifier for CertCapturingVerifier {
fn verify_server_cert(
&self,
end_entity: &CertificateDer<'_>,
intermediates: &[CertificateDer<'_>],
server_name: &ServerName<'_>,
ocsp_response: &[u8],
now: UnixTime,
) -> Result<ServerCertVerified, TlsError> {
if let Ok(metadata) = Self::extract_metadata(end_entity.as_ref())
&& let Ok(mut captured) = self.captured.lock()
{
*captured = Some(metadata);
}
let verified = self.inner_verifier.verify_server_cert(
end_entity,
intermediates,
server_name,
ocsp_response,
now,
);
match verified {
Err(TlsError::InvalidCertificate(
CertificateError::NotValidForName | CertificateError::NotValidForNameContext { .. },
)) if self.accept_invalid_hostnames => Ok(ServerCertVerified::assertion()),
result => result,
}
}
fn verify_tls12_signature(
&self,
message: &[u8],
cert: &CertificateDer<'_>,
dss: &DigitallySignedStruct,
) -> Result<HandshakeSignatureValid, TlsError> {
self.inner_verifier
.verify_tls12_signature(message, cert, dss)
}
fn verify_tls13_signature(
&self,
message: &[u8],
cert: &CertificateDer<'_>,
dss: &DigitallySignedStruct,
) -> Result<HandshakeSignatureValid, TlsError> {
self.inner_verifier
.verify_tls13_signature(message, cert, dss)
}
fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
self.inner_verifier.supported_verify_schemes()
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use rustls::crypto::ring::default_provider;
use std::{io::Cursor, time::Duration};
fn ensure_crypto_provider() {
let _ = rustls::crypto::CryptoProvider::install_default(default_provider());
}
const CA_PEM: &[u8] = include_bytes!("testdata/ca.crt");
const OTHER_CA_PEM: &[u8] = include_bytes!("testdata/other-ca.crt");
const MISMATCH_PEM: &[u8] = include_bytes!("testdata/mismatch.crt");
const INSIDE_VALIDITY: u64 = 1_798_761_600; const PAST_EXPIRY: u64 = 5_049_129_600;
fn load_certs(pem: &[u8]) -> Vec<CertificateDer<'static>> {
let mut reader = Cursor::new(pem);
rustls_pemfile::certs(&mut reader)
.collect::<std::result::Result<Vec<_>, _>>()
.unwrap()
}
fn root_store(pem: &[u8]) -> RootCertStore {
let mut store = RootCertStore::empty();
for cert in load_certs(pem) {
store.add(cert).unwrap();
}
store
}
fn verify_mismatched_leaf(
ca_pem: &[u8],
accept_invalid_hostnames: bool,
now_secs: u64,
) -> std::result::Result<ServerCertVerified, TlsError> {
ensure_crypto_provider();
let verifier = CertCapturingVerifier::with_root_certificates(
root_store(ca_pem),
accept_invalid_hostnames,
)
.unwrap();
let mut chain = load_certs(MISMATCH_PEM);
let leaf = chain.remove(0);
verifier.verify_server_cert(
&leaf,
&[],
&ServerName::try_from("localhost").unwrap(),
&[],
UnixTime::since_unix_epoch(Duration::from_secs(now_secs)),
)
}
fn is_name_mismatch(error: &TlsError) -> bool {
matches!(
error,
TlsError::InvalidCertificate(
CertificateError::NotValidForName | CertificateError::NotValidForNameContext { .. }
)
)
}
#[test]
fn verify_ca_accepts_a_certificate_issued_for_another_name() {
let result = verify_mismatched_leaf(CA_PEM, true, INSIDE_VALIDITY);
assert!(
result.is_ok(),
"verify-ca must tolerate a name mismatch like sqlx does, got: {:?}",
result.err()
);
}
#[test]
fn verify_full_rejects_a_certificate_issued_for_another_name() {
let error = verify_mismatched_leaf(CA_PEM, false, INSIDE_VALIDITY)
.expect_err("verify-full must reject a name mismatch");
assert!(
is_name_mismatch(&error),
"expected a name-mismatch error, got: {error:?}"
);
}
#[test]
fn name_mismatch_exemption_still_rejects_an_untrusted_issuer() {
let error = verify_mismatched_leaf(OTHER_CA_PEM, true, INSIDE_VALIDITY)
.expect_err("a certificate from an unknown CA must never verify");
assert!(
!is_name_mismatch(&error),
"expected an issuer error, not a name mismatch: {error:?}"
);
}
#[test]
fn name_mismatch_exemption_still_rejects_an_expired_certificate() {
let error = verify_mismatched_leaf(CA_PEM, true, PAST_EXPIRY)
.expect_err("an expired certificate must never verify");
assert!(
!is_name_mismatch(&error),
"expected an expiry error, not a name mismatch: {error:?}"
);
}
#[test]
fn metadata_is_captured_during_verification() {
ensure_crypto_provider();
let verifier =
CertCapturingVerifier::with_root_certificates(root_store(CA_PEM), false).unwrap();
let mut chain = load_certs(MISMATCH_PEM);
let leaf = chain.remove(0);
let _ = verifier.verify_server_cert(
&leaf,
&[],
&ServerName::try_from("localhost").unwrap(),
&[],
UnixTime::since_unix_epoch(Duration::from_secs(INSIDE_VALIDITY)),
);
let captured = verifier
.get_captured()
.expect("metadata should be captured");
assert_eq!(captured.subject.as_deref(), Some("CN=db.internal"));
assert_eq!(captured.issuer.as_deref(), Some("CN=dbpulse Test CA"));
}
#[test]
fn test_verifier_creation() {
ensure_crypto_provider();
let verifier = CertCapturingVerifier::new();
assert!(verifier.is_ok());
}
#[test]
fn test_captured_initially_none() {
ensure_crypto_provider();
let verifier = CertCapturingVerifier::new().unwrap();
assert!(verifier.get_captured().is_none());
}
#[test]
fn test_metadata_conversion() {
let captured = CapturedCertMetadata {
subject: Some("CN=example.com".to_string()),
issuer: Some("CN=CA".to_string()),
expiry_days: Some(90),
};
let tls_metadata: TlsMetadata = captured.clone().into();
assert_eq!(tls_metadata.cert_subject, captured.subject);
assert_eq!(tls_metadata.cert_issuer, captured.issuer);
assert_eq!(tls_metadata.cert_expiry_days, captured.expiry_days);
}
}