use async_trait::async_trait;
use x509_parser::objects::oid2abbrev;
use x509_parser::oid_registry::asn1_rs::Oid;
use x509_parser::parse_x509_certificate;
use x509_parser::x509::X509Name;
use super::analyzer::{Analyzer, PortContext};
use super::model::{Evidence, SourceId};
use super::response::{Collected, ResponseSet};
use crate::model::confidence::Confidence;
fn distinguished_name(name: &X509Name<'_>) -> String {
let registry = x509_parser::objects::oid_registry();
let mut names: Vec<String> = name
.iter()
.map(|rdn| {
rdn.iter()
.map(|attr| {
let key = oid2abbrev(attr.attr_type(), registry)
.map(str::to_string)
.unwrap_or_else(|_| id_string(attr.attr_type()));
let value = attr.as_str().map(escape_value).unwrap_or_default();
format!("{key}={value}")
})
.collect::<Vec<_>>()
.join("+")
})
.collect();
names.reverse();
names.join(",")
}
fn id_string(oid: &Oid<'_>) -> String {
oid.iter()
.map(|arcs| {
arcs.map(|arc| arc.to_string())
.collect::<Vec<_>>()
.join(".")
})
.unwrap_or_default()
}
fn escape_value(value: &str) -> String {
let mut out = String::with_capacity(value.len());
let last = value.chars().count().saturating_sub(1);
for (at, ch) in value.chars().enumerate() {
let positional = (at == 0 && (ch == '#' || ch == ' ')) || (at == last && ch == ' ');
if positional || matches!(ch, '"' | '+' | ',' | ';' | '<' | '>' | '\\') {
out.push('\\');
}
out.push(ch);
}
out
}
pub struct TlsCertAnalyzer;
#[async_trait]
impl Analyzer for TlsCertAnalyzer {
fn id(&self) -> SourceId {
SourceId::TlsCert
}
fn interested(&self, _ctx: &PortContext) -> bool {
true
}
fn analyze(
&self,
_ctx: &PortContext,
responses: &ResponseSet,
_collected: &Collected,
) -> Vec<Evidence> {
let Some(leaf) = responses.tls.as_ref().and_then(|tls| tls.leaf()) else {
return Vec::new();
};
let mut evidence =
Evidence::new(SourceId::TlsCert, Confidence::Probable).with_service("ssl");
if let Ok((_, cert)) = parse_x509_certificate(leaf) {
let tbs = &cert.tbs_certificate;
let db = super::db::SignatureDb::global();
let names = [
distinguished_name(&tbs.subject),
distinguished_name(&tbs.issuer),
];
let mut found: Vec<Evidence> = names
.iter()
.filter_map(|name| db.identify_field(name))
.collect();
let self_signed = tbs.subject.as_raw() == tbs.issuer.as_raw();
if self_signed
&& let Some(org) = tbs
.subject
.iter_organization()
.next()
.and_then(|attr| attr.as_str().ok())
{
evidence = evidence.with_vendor(org.to_string());
}
found.insert(0, evidence);
return found;
}
vec![evidence]
}
}
#[cfg(test)]
mod names {
use super::*;
const CERT: &[u8] = include_bytes!("testdata/selfsigned.der");
fn fixture() -> x509_parser::certificate::X509Certificate<'static> {
parse_x509_certificate(CERT).expect("the fixture parses").1
}
#[test]
fn a_name_renders_the_way_the_corpus_writes_one() {
let cert = fixture();
let subject = &cert.tbs_certificate.subject;
assert_eq!(
distinguished_name(subject),
"CN=zond-device.local,O=Zond Appliance,C=SE"
);
assert_eq!(
subject.to_string(),
"C=SE, O=Zond Appliance, CN=zond-device.local"
);
}
#[test]
fn a_comma_inside_a_value_is_escaped_rather_than_read_as_structure() {
assert_eq!(escape_value("Cisco-Linksys, LLC"), r"Cisco-Linksys\, LLC");
assert_eq!(escape_value("VMware, Inc."), r"VMware\, Inc.");
}
#[test]
fn the_remaining_rfc_4514_escapes_are_applied() {
assert_eq!(escape_value(r"a+b;c<d>e"), r"a\+b\;c\<d\>e");
assert_eq!(escape_value(r#"quo"te"#), r#"quo\"te"#);
assert_eq!(escape_value(r"back\slash"), r"back\\slash");
assert_eq!(escape_value("#leading"), r"\#leading");
assert_eq!(escape_value(" pad "), r"\ pad\ ");
assert_eq!(escape_value("mid dle#in"), "mid dle#in");
}
#[test]
fn a_certificate_name_the_corpus_knows_names_its_product() {
let db = crate::fingerprint::SignatureDb::global();
let evidence = db
.identify_field(r"CN=SRM01,OU=SRM,O=VMware\, Inc.,L=Palo Alto,ST=California,C=US")
.expect("the corpus names it");
assert_eq!(evidence.product.as_deref(), Some("Site Recovery Manager"));
}
#[test]
fn an_unremarkable_name_yields_nothing() {
let db = crate::fingerprint::SignatureDb::global();
assert!(
db.identify_field("CN=example.invalid,O=Nobody,C=ZZ")
.is_none()
);
}
}