use std::sync::Arc;
use std::time::{Duration, SystemTime};
use x509_parser::prelude::*;
use x509_parser::public_key::PublicKey;
use super::response::TlsInfo;
use crate::model::port::{CertificateInfo, Security};
pub fn security(tls: &TlsInfo) -> Security {
let mut record = Security::new();
if let Some(version) = tls.version {
record = record.with_tls_version(version);
}
if let Some(cipher) = tls.cipher_suite {
record = record.with_cipher_suite(cipher);
}
if let Some(alpn) = &tls.alpn {
record = record.with_alpn(alpn.as_str());
}
if let Some(certificate) = tls.leaf().and_then(certificate_info) {
record = record.with_certificate(certificate);
}
record
}
fn certificate_info(der: &[u8]) -> Option<CertificateInfo> {
let (_, cert) = parse_x509_certificate(der).ok()?;
let validity = cert.validity();
let (pubkey_type, pubkey_bits) = public_key_summary(&cert);
Some(
CertificateInfo::new(
first_common_name(cert.subject()).unwrap_or_default(),
first_common_name(cert.issuer()).unwrap_or_default(),
asn1_to_system_time(validity.not_before),
asn1_to_system_time(validity.not_after),
fingerprint_sha256(der),
)
.with_sans(subject_alt_names(&cert))
.with_public_key(pubkey_type, pubkey_bits),
)
}
fn first_common_name(name: &X509Name<'_>) -> Option<Arc<str>> {
name.iter_common_name()
.next()
.and_then(|attr| attr.as_str().ok())
.map(Arc::from)
}
fn subject_alt_names(cert: &X509Certificate<'_>) -> Vec<Arc<str>> {
let Ok(Some(extension)) = cert.subject_alternative_name() else {
return Vec::new();
};
extension
.value
.general_names
.iter()
.filter_map(|name| match name {
GeneralName::DNSName(dns) => Some(Arc::from(*dns)),
GeneralName::IPAddress(bytes) => render_ip_san(bytes),
_ => None,
})
.collect()
}
fn render_ip_san(bytes: &[u8]) -> Option<Arc<str>> {
match bytes.len() {
4 => {
let octets: [u8; 4] = bytes.try_into().ok()?;
Some(Arc::from(std::net::Ipv4Addr::from(octets).to_string()))
}
16 => {
let octets: [u8; 16] = bytes.try_into().ok()?;
Some(Arc::from(std::net::Ipv6Addr::from(octets).to_string()))
}
_ => None,
}
}
fn public_key_summary(cert: &X509Certificate<'_>) -> (&'static str, u32) {
let Ok(key) = cert.public_key().parsed() else {
return ("unknown", 0);
};
let algorithm = match key {
PublicKey::RSA(_) => "RSA",
PublicKey::EC(_) => "EC",
PublicKey::DSA(_) => "DSA",
PublicKey::GostR3410(_) | PublicKey::GostR3410_2012(_) => "GOST",
PublicKey::Unknown(_) => "unknown",
};
(algorithm, key.key_size() as u32)
}
fn fingerprint_sha256(der: &[u8]) -> Arc<str> {
let digest = ring::digest::digest(&ring::digest::SHA256, der);
let mut hex = String::with_capacity(digest.as_ref().len() * 2);
for byte in digest.as_ref() {
use std::fmt::Write;
let _ = write!(hex, "{byte:02x}");
}
Arc::from(hex)
}
fn asn1_to_system_time(time: ASN1Time) -> SystemTime {
let seconds = time.timestamp();
if seconds < 0 {
SystemTime::UNIX_EPOCH
} else {
SystemTime::UNIX_EPOCH + Duration::from_secs(seconds as u64)
}
}
#[cfg(test)]
mod tests {
use super::*;
const SELF_SIGNED: &[u8] = include_bytes!("testdata/selfsigned.der");
fn info() -> CertificateInfo {
certificate_info(SELF_SIGNED).expect("the fixture parses")
}
#[test]
fn the_fingerprint_is_the_one_openssl_computes() {
assert_eq!(
info().fingerprint_sha256(),
"5c8125bb969ab3388da2ab86ce9799828922bdb2c489d33861bc96e47033b3ae"
);
}
#[test]
fn the_subject_issuer_and_key_are_read_off_the_certificate() {
let cert = info();
assert_eq!(cert.common_name(), "zond-device.local");
assert_eq!(cert.issuer(), "zond-device.local", "self-signed");
assert_eq!(cert.pubkey_type(), "RSA");
assert_eq!(cert.pubkey_bits(), 2048);
}
#[test]
fn every_name_the_certificate_claims_is_recorded() {
let cert = info();
let names = cert.sans();
let names: Vec<&str> = names.iter().map(|name| &**name).collect();
assert!(names.contains(&"zond-device.local"));
assert!(names.contains(&"appliance.zond.internal"));
assert!(names.contains(&"10.0.0.5"), "the IP SAN too");
}
#[test]
fn validity_is_recorded_as_the_window_the_certificate_names() {
let cert = info();
let not_before = SystemTime::UNIX_EPOCH + Duration::from_secs(1_785_185_761);
let not_after = SystemTime::UNIX_EPOCH + Duration::from_secs(2_100_545_761);
assert_eq!(cert.validity_start(), not_before);
assert_eq!(cert.validity_end(), not_after);
}
#[test]
fn a_handshake_without_a_usable_certificate_still_records_what_was_negotiated() {
let tls = TlsInfo {
certificates: vec![b"not a certificate".to_vec()],
version: Some("TLSv1.3"),
cipher_suite: Some("TLS13_AES_256_GCM_SHA384"),
alpn: Some("h2".to_string()),
};
let record = security(&tls);
assert_eq!(record.tls_version(), Some("TLSv1.3"));
assert_eq!(record.cipher_suite(), Some("TLS13_AES_256_GCM_SHA384"));
assert_eq!(record.alpn(), [Arc::<str>::from("h2")]);
assert!(
record.certificate().is_none(),
"unparseable is absent, not fabricated"
);
}
#[test]
fn a_complete_handshake_records_both_halves() {
let tls = TlsInfo {
certificates: vec![SELF_SIGNED.to_vec()],
version: Some("TLSv1.2"),
cipher_suite: Some("TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"),
alpn: None,
};
let record = security(&tls);
assert_eq!(record.tls_version(), Some("TLSv1.2"));
assert!(record.alpn().is_empty(), "the server chose no protocol");
assert_eq!(
record.certificate().expect("parsed").common_name(),
"zond-device.local"
);
}
}