use crate::cert::{CERT_DER_MAX, CertType, DnAttributeKind, MatterCertificate, der};
use crate::crypto::verify;
use crate::error::{Error, ErrorCode, Result};
use crate::msg::{FabricId, NodeId};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VerifiedIdentity {
pub node_id: NodeId,
pub fabric_id: FabricId,
pub cats: heapless::Vec<crate::msg::CaseAuthenticatedTag, { crate::cert::dn::MAX_NOC_CATS }>,
}
fn path_invalid() -> Error {
Error::new(ErrorCode::CertPathInvalid)
}
pub fn verify_chain(
noc: &MatterCertificate<'_>,
icac: Option<&MatterCertificate<'_>>,
root: &MatterCertificate<'_>,
at: Option<u32>,
) -> Result<VerifiedIdentity> {
root.validate_as(CertType::Rcac)?;
noc.validate_as(CertType::Noc)?;
if let Some(icac) = icac {
icac.validate_as(CertType::Icac)?;
}
let noc_issuer = icac.unwrap_or(root);
check_link(noc, noc_issuer, at)?;
if let Some(icac) = icac {
check_link(icac, root, at)?;
if root
.extensions
.basic_constraints()
.and_then(|b| b.path_len_constraint)
.is_some_and(|limit| limit < 1)
{
return Err(path_invalid());
}
}
if let Some(at) = at {
check_validity(root, at)?;
}
let fabric_id = noc.fabric_id().ok_or_else(path_invalid)?;
for authority in [Some(root), icac].into_iter().flatten() {
if authority.subject.count(DnAttributeKind::MatterFabricId) != 0
&& authority.fabric_id() != Some(fabric_id)
{
return Err(path_invalid());
}
}
Ok(VerifiedIdentity {
node_id: noc.node_id().ok_or_else(path_invalid)?,
fabric_id,
cats: noc.subject.noc_cats(),
})
}
fn check_link(
subject: &MatterCertificate<'_>,
issuer: &MatterCertificate<'_>,
at: Option<u32>,
) -> Result<()> {
if !issuer.is_ca() {
return Err(path_invalid());
}
if subject.issuer != issuer.subject {
return Err(path_invalid());
}
match (
subject.extensions.authority_key_id(),
issuer.extensions.subject_key_id(),
) {
(Some(authority), Some(subject_key)) if authority == subject_key => {}
_ => return Err(path_invalid()),
}
if let Some(at) = at {
check_validity(subject, at)?;
}
let mut buf = [0u8; CERT_DER_MAX];
let tbs = der::tbs_certificate(subject, &mut buf)?;
if !verify(&issuer.public_key, tbs, &subject.signature)? {
return Err(path_invalid());
}
Ok(())
}
fn check_validity(cert: &MatterCertificate<'_>, at: u32) -> Result<()> {
if cert.is_valid_at(at) {
Ok(())
} else {
Err(Error::new(ErrorCode::CertExpired))
}
}
pub fn verify_self_signed(root: &MatterCertificate<'_>) -> Result<bool> {
root.validate_as(CertType::Rcac)?;
if root.issuer != root.subject {
return Ok(false);
}
let mut buf = [0u8; CERT_DER_MAX];
let tbs = der::tbs_certificate(root, &mut buf)?;
verify(&root.public_key, tbs, &root.signature)
}