use crate::attestation::cd::CertificationElements;
use crate::attestation::x509::{KeyUsage, X509Certificate};
use crate::error::{Error, ErrorCode, Result};
use crate::msg::VendorId;
fn path_invalid() -> Error {
Error::new(ErrorCode::CertPathInvalid)
}
fn invalid() -> Error {
Error::new(ErrorCode::CertInvalid)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DacChain {
pub vendor_id: VendorId,
pub product_id: u16,
pub paa_key_id: Option<[u8; crate::attestation::x509::KEY_ID_LEN]>,
pub validated_at: u32,
}
pub fn verify_dac_chain(
dac: &X509Certificate<'_>,
pai: &X509Certificate<'_>,
paa: &X509Certificate<'_>,
) -> Result<DacChain> {
check_dac(dac)?;
check_pai(pai)?;
check_paa(paa)?;
let at = dac.not_before;
if !pai.is_valid_at(at) || !paa.is_valid_at(at) {
return Err(Error::new(ErrorCode::CertExpired));
}
if dac.issuer != pai.subject || pai.issuer != paa.subject {
return Err(path_invalid());
}
if !pai.verify_signature_of(dac)? || !paa.verify_signature_of(pai)? {
return Err(path_invalid());
}
let vendor_id = dac.subject_vid_pid.vendor_id.ok_or_else(invalid)?;
if pai.subject_vid_pid.vendor_id != Some(vendor_id) {
return Err(path_invalid());
}
if paa
.subject_vid_pid
.vendor_id
.is_some_and(|paa_vid| paa_vid != vendor_id)
{
return Err(path_invalid());
}
let product_id = dac.subject_vid_pid.product_id.ok_or_else(invalid)?;
if dac
.issuer_vid_pid
.product_id
.is_some_and(|issuer_pid| issuer_pid != product_id)
{
return Err(path_invalid());
}
if pai
.subject_vid_pid
.product_id
.is_some_and(|pai_pid| pai_pid != product_id)
{
return Err(path_invalid());
}
Ok(DacChain {
vendor_id,
product_id,
paa_key_id: paa.subject_key_id,
validated_at: at,
})
}
fn check_dac(dac: &X509Certificate<'_>) -> Result<()> {
let basic = dac.basic_constraints.ok_or_else(invalid)?;
if basic.is_ca {
return Err(invalid());
}
if dac.key_usage != Some(KeyUsage::DIGITAL_SIGNATURE) {
return Err(invalid());
}
if dac.subject_key_id.is_none() || dac.authority_key_id.is_none() {
return Err(invalid());
}
if dac.issuer_vid_pid.vendor_id.is_none()
|| dac.subject_vid_pid.vendor_id.is_none()
|| dac.subject_vid_pid.product_id.is_none()
{
return Err(invalid());
}
if dac.issuer_vid_pid.vendor_id != dac.subject_vid_pid.vendor_id {
return Err(invalid());
}
Ok(())
}
fn check_pai(pai: &X509Certificate<'_>) -> Result<()> {
let basic = pai.basic_constraints.ok_or_else(invalid)?;
if !basic.is_ca || basic.path_len != Some(0) {
return Err(invalid());
}
check_ca_key_usage(pai.key_usage)?;
if pai.subject_key_id.is_none() || pai.authority_key_id.is_none() {
return Err(invalid());
}
if pai.subject_vid_pid.vendor_id.is_none() {
return Err(invalid());
}
Ok(())
}
fn check_paa(paa: &X509Certificate<'_>) -> Result<()> {
let basic = paa.basic_constraints.ok_or_else(invalid)?;
if !basic.is_ca || basic.path_len.is_some_and(|len| len != 1) {
return Err(invalid());
}
check_ca_key_usage(paa.key_usage)?;
if paa.issuer != paa.subject {
return Err(invalid());
}
if paa.subject_vid_pid.product_id.is_some() || paa.issuer_vid_pid.product_id.is_some() {
return Err(invalid());
}
if paa.subject_key_id.is_none() {
return Err(invalid());
}
Ok(())
}
fn check_ca_key_usage(usage: Option<KeyUsage>) -> Result<()> {
let Some(usage) = usage else {
return Err(invalid());
};
let required = KeyUsage::KEY_CERT_SIGN | KeyUsage::CRL_SIGN;
let permitted = required | KeyUsage::DIGITAL_SIGNATURE;
if !usage.contains(required) || !permitted.contains(usage) {
return Err(invalid());
}
Ok(())
}
pub fn check_declaration_against_chain(
cd: &CertificationElements<'_>,
chain: &DacChain,
pai_vendor_id: VendorId,
pai_product_id: Option<u16>,
basic_information: Option<(VendorId, u16)>,
) -> Result<()> {
match (cd.dac_origin_vendor_id, cd.dac_origin_product_id) {
(Some(origin_vid), Some(origin_pid)) => {
if chain.vendor_id != origin_vid || pai_vendor_id != origin_vid {
return Err(path_invalid());
}
if chain.product_id != origin_pid {
return Err(path_invalid());
}
if pai_product_id.is_some_and(|pid| pid != origin_pid) {
return Err(path_invalid());
}
}
(None, None) => {
if chain.vendor_id != cd.vendor_id || pai_vendor_id != cd.vendor_id {
return Err(path_invalid());
}
if !cd.covers_product(chain.product_id) {
return Err(path_invalid());
}
if pai_product_id.is_some_and(|pid| !cd.covers_product(pid)) {
return Err(path_invalid());
}
}
_ => return Err(invalid()),
}
if cd.authorized_paas.is_some() {
let Some(paa_key_id) = chain.paa_key_id else {
return Err(path_invalid());
};
if !cd.authorizes_paa(&paa_key_id) {
return Err(path_invalid());
}
}
if let Some((reported_vid, reported_pid)) = basic_information
&& (cd.vendor_id != reported_vid || !cd.covers_product(reported_pid))
{
return Err(path_invalid());
}
Ok(())
}