use crate::crypto::{PublicKey, Signature, verify};
use crate::der::{
DerReader, Element, OID_COMMON_NAME, OID_EC_PUBLIC_KEY, OID_ECDSA_WITH_SHA256,
OID_MATTER_ATTESTATION_PREFIX, OID_PRIME256V1, TAG_BIT_STRING, TAG_BOOLEAN, TAG_INTEGER,
TAG_OCTET_STRING, TAG_OID, TAG_SEQUENCE, context_constructed, ecdsa_sig_value_to_raw,
read_time,
};
use crate::error::{Error, ErrorCode, Result};
use crate::msg::VendorId;
const TAG_VERSION: u8 = context_constructed(0);
const TAG_EXTENSIONS: u8 = context_constructed(3);
const OID_MATTER_VID_ARC: u8 = 1;
const OID_MATTER_PID_ARC: u8 = 2;
pub const FALLBACK_VID_PREFIX: &[u8] = b"Mvid:";
pub const FALLBACK_PID_PREFIX: &[u8] = b"Mpid:";
pub const MAX_DER_LEN: usize = 600;
pub const KEY_ID_LEN: usize = 20;
fn malformed() -> Error {
Error::new(ErrorCode::DerMalformed)
}
fn invalid() -> Error {
Error::new(ErrorCode::CertInvalid)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct VidPid {
pub vendor_id: Option<VendorId>,
pub product_id: Option<u16>,
}
impl VidPid {
pub fn from_name(name: &[u8]) -> Result<Self> {
let mut out = Self::default();
let mut saw_matter_oid = false;
let mut common_name: Option<&[u8]> = None;
let mut rdns = DerReader::new(name);
while !rdns.is_empty() {
let mut rdn = rdns.expect_set()?;
while !rdn.is_empty() {
let mut atv = rdn.expect_sequence()?;
let oid = atv.expect(TAG_OID)?.content;
let value = atv.next_element()?;
atv.finish()?;
if let Some(arc) = matter_attestation_arc(oid) {
saw_matter_oid = true;
let scalar = parse_hex4(value.content).ok_or_else(invalid)?;
match arc {
OID_MATTER_VID_ARC => out.vendor_id = Some(VendorId(scalar)),
OID_MATTER_PID_ARC => out.product_id = Some(scalar),
_ => {}
}
} else if oid == OID_COMMON_NAME {
common_name = Some(value.content);
}
}
}
if saw_matter_oid {
return Ok(out);
}
if let Some(cn) = common_name {
out.vendor_id = fallback_scalar(cn, FALLBACK_VID_PREFIX)?.map(VendorId);
out.product_id = fallback_scalar(cn, FALLBACK_PID_PREFIX)?;
}
Ok(out)
}
}
fn matter_attestation_arc(oid: &[u8]) -> Option<u8> {
let rest = oid.strip_prefix(OID_MATTER_ATTESTATION_PREFIX)?;
match rest {
[arc] => Some(*arc),
_ => None,
}
}
fn parse_hex4(text: &[u8]) -> Option<u16> {
let [a, b, c, d] = <[u8; 4]>::try_from(text).ok()?;
let mut value = 0u16;
for byte in [a, b, c, d] {
let digit = match byte {
b'0'..=b'9' => byte.checked_sub(b'0')?,
b'A'..=b'F' => byte.checked_sub(b'A')?.checked_add(10)?,
_ => return None,
};
value = value.checked_mul(16)?.checked_add(u16::from(digit))?;
}
Some(value)
}
fn fallback_scalar(common_name: &[u8], prefix: &[u8]) -> Result<Option<u16>> {
let mut saw_prefix = false;
let mut at = 0usize;
while let Some(slice) = common_name.get(at..) {
if slice.len() < prefix.len() {
break;
}
if slice.starts_with(prefix) {
saw_prefix = true;
if let Some(digits) = slice.get(prefix.len()..prefix.len().saturating_add(4))
&& let Some(value) = parse_hex4(digits)
{
return Ok(Some(value));
}
}
at = at.checked_add(1).ok_or_else(invalid)?;
}
if saw_prefix { Err(invalid()) } else { Ok(None) }
}
bitflags::bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct KeyUsage: u16 {
const DIGITAL_SIGNATURE = 1 << 0;
const NON_REPUDIATION = 1 << 1;
const KEY_ENCIPHERMENT = 1 << 2;
const DATA_ENCIPHERMENT = 1 << 3;
const KEY_AGREEMENT = 1 << 4;
const KEY_CERT_SIGN = 1 << 5;
const CRL_SIGN = 1 << 6;
const ENCIPHER_ONLY = 1 << 7;
const DECIPHER_ONLY = 1 << 8;
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct BasicConstraints {
pub is_ca: bool,
pub path_len: Option<u8>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct X509Certificate<'a> {
pub tbs: &'a [u8],
pub serial_number: &'a [u8],
pub issuer: &'a [u8],
pub subject: &'a [u8],
pub issuer_vid_pid: VidPid,
pub subject_vid_pid: VidPid,
pub not_before: u32,
pub not_after: Option<u32>,
pub public_key: PublicKey,
pub basic_constraints: Option<BasicConstraints>,
pub key_usage: Option<KeyUsage>,
pub subject_key_id: Option<[u8; KEY_ID_LEN]>,
pub authority_key_id: Option<[u8; KEY_ID_LEN]>,
pub has_extended_key_usage: bool,
pub signature: Signature,
}
impl<'a> X509Certificate<'a> {
pub fn parse(der: &'a [u8]) -> Result<Self> {
if der.len() > MAX_DER_LEN {
return Err(invalid());
}
let mut outer = DerReader::new(der);
let mut cert = outer.expect_sequence()?;
outer.finish()?;
let tbs_element = cert.expect(TAG_SEQUENCE)?;
let mut tbs = tbs_element.content_reader();
let version = tbs.expect(TAG_VERSION)?;
let mut version_reader = version.content_reader();
if version_reader.expect_uint()? != 2 {
return Err(invalid());
}
version_reader.finish()?;
let serial_number = tbs.expect_unsigned()?;
let mut signature_algo = tbs.expect_sequence()?;
signature_algo.expect_oid(OID_ECDSA_WITH_SHA256)?;
let issuer = tbs.expect(TAG_SEQUENCE)?.content;
let mut validity = tbs.expect_sequence()?;
let not_before = read_time(&validity.next_element()?)?.ok_or_else(invalid)?;
let not_after = read_time(&validity.next_element()?)?;
validity.finish()?;
let subject = tbs.expect(TAG_SEQUENCE)?.content;
let mut spki = tbs.expect_sequence()?;
let mut key_algo = spki.expect_sequence()?;
key_algo.expect_oid(OID_EC_PUBLIC_KEY)?;
key_algo.expect_oid(OID_PRIME256V1)?;
key_algo.finish()?;
let public_key = PublicKey::from_slice(spki.expect(TAG_BIT_STRING)?.bit_string_octets()?)?;
spki.finish()?;
let _ = tbs.take_if(context_constructed(1))?;
let _ = tbs.take_if(context_constructed(2))?;
let mut parsed = Extensions::default();
if let Some(extensions) = tbs.take_if(TAG_EXTENSIONS)? {
let mut explicit = extensions.content_reader();
let mut list = explicit.expect_sequence()?;
explicit.finish()?;
while !list.is_empty() {
parsed.absorb(&mut list.expect_sequence()?)?;
}
}
tbs.finish()?;
let mut sig_algo = cert.expect_sequence()?;
sig_algo.expect_oid(OID_ECDSA_WITH_SHA256)?;
sig_algo.finish()?;
let signature_der = cert.expect(TAG_BIT_STRING)?.bit_string_octets()?;
cert.finish()?;
let mut raw = [0u8; 64];
ecdsa_sig_value_to_raw(signature_der, &mut raw)?;
Ok(Self {
tbs: tbs_element.raw,
serial_number,
issuer,
subject,
issuer_vid_pid: VidPid::from_name(issuer)?,
subject_vid_pid: VidPid::from_name(subject)?,
not_before,
not_after,
public_key,
basic_constraints: parsed.basic_constraints,
key_usage: parsed.key_usage,
subject_key_id: parsed.subject_key_id,
authority_key_id: parsed.authority_key_id,
has_extended_key_usage: parsed.has_extended_key_usage,
signature: Signature::from_bytes(raw),
})
}
#[must_use]
pub const fn is_valid_at(&self, at: u32) -> bool {
at >= self.not_before
&& match self.not_after {
Some(end) => at <= end,
None => true,
}
}
#[must_use]
pub fn is_ca(&self) -> bool {
self.basic_constraints.is_some_and(|b| b.is_ca)
}
pub fn verify_signature_of(&self, subject: &Self) -> Result<bool> {
verify(&self.public_key, subject.tbs, &subject.signature)
}
}
#[derive(Debug, Default)]
struct Extensions {
basic_constraints: Option<BasicConstraints>,
key_usage: Option<KeyUsage>,
subject_key_id: Option<[u8; KEY_ID_LEN]>,
authority_key_id: Option<[u8; KEY_ID_LEN]>,
has_extended_key_usage: bool,
seen: u64,
}
impl Extensions {
fn absorb(&mut self, extension: &mut DerReader<'_>) -> Result<()> {
let oid = extension.expect(TAG_OID)?.content;
let critical = match extension.take_if(TAG_BOOLEAN)? {
Some(element) => element.content == [0xFF],
None => false,
};
let value = extension.expect(TAG_OCTET_STRING)?.content;
extension.finish()?;
let Some([arc]) = oid.strip_prefix(crate::der::OID_CE_PREFIX) else {
return Ok(());
};
if let Some(bit) = 1u64.checked_shl(u32::from(*arc)) {
if self.seen & bit != 0 {
return Err(invalid());
}
self.seen |= bit;
}
let mut reader = DerReader::new(value);
match *arc {
14 => {
self.subject_key_id = Some(key_id(&reader.expect(TAG_OCTET_STRING)?)?);
}
15 => {
if !critical {
return Err(invalid());
}
self.key_usage = Some(read_key_usage(&reader.expect(TAG_BIT_STRING)?)?);
}
19 => {
if !critical {
return Err(invalid());
}
let mut seq = reader.expect_sequence()?;
let is_ca = match seq.take_if(TAG_BOOLEAN)? {
Some(element) => element.content == [0xFF],
None => false,
};
let path_len = match seq.take_if(TAG_INTEGER)? {
Some(element) => match element.content {
[len] if *len < 0x80 => Some(*len),
_ => return Err(malformed()),
},
None => None,
};
seq.finish()?;
if !is_ca && path_len.is_some() {
return Err(invalid());
}
self.basic_constraints = Some(BasicConstraints { is_ca, path_len });
}
35 => {
let mut seq = reader.expect_sequence()?;
if let Some(element) = seq.take_if(crate::der::context_primitive(0))? {
self.authority_key_id = Some(key_id(&element)?);
}
}
37 => self.has_extended_key_usage = true,
_ => {}
}
Ok(())
}
}
fn key_id(element: &Element<'_>) -> Result<[u8; KEY_ID_LEN]> {
<[u8; KEY_ID_LEN]>::try_from(element.content).map_err(|_| invalid())
}
fn read_key_usage(element: &Element<'_>) -> Result<KeyUsage> {
let content = element.content;
let (unused, octets) = content.split_first().ok_or_else(malformed)?;
if *unused > 7 || octets.len() > 2 {
return Err(malformed());
}
if *unused > 0 {
let last = octets.last().copied().unwrap_or(0);
let mask = 0xFFu8
.checked_shr(8u32.saturating_sub(u32::from(*unused)))
.unwrap_or(0);
if last & mask != 0 {
return Err(malformed());
}
}
let mut bits = 0u16;
if let Some(first) = octets.first() {
bits |= u16::from(first.reverse_bits());
}
if let Some(second) = octets.get(1) {
bits |= u16::from(second.reverse_bits()) << 8;
}
KeyUsage::from_bits(bits).ok_or_else(invalid)
}
#[cfg(test)]
mod tests {
use super::*;
fn key_usage_element(unused: u8, octets: &[u8]) -> heapless::Vec<u8, 8> {
let mut out = heapless::Vec::new();
let _ = out.push(TAG_BIT_STRING);
let _ = out.push(u8::try_from(octets.len().saturating_add(1)).unwrap_or(0));
let _ = out.push(unused);
let _ = out.extend_from_slice(octets);
out
}
fn read_usage(unused: u8, octets: &[u8]) -> Result<KeyUsage> {
let bytes = key_usage_element(unused, octets);
let element = DerReader::new(&bytes).next_element()?;
read_key_usage(&element)
}
#[test]
fn key_usage_bits_are_numbered_from_the_most_significant_bit() {
assert_eq!(
read_usage(7, &[0x80]).expect("ds"),
KeyUsage::DIGITAL_SIGNATURE
);
assert_eq!(
read_usage(1, &[0x06]).expect("ca"),
KeyUsage::KEY_CERT_SIGN | KeyUsage::CRL_SIGN
);
assert_eq!(
read_usage(7, &[0x00, 0x80]).expect("do"),
KeyUsage::DECIPHER_ONLY
);
}
#[test]
fn a_bit_string_with_non_zero_unused_bits_is_refused() {
assert!(
read_usage(7, &[0x81]).is_err(),
"bit 7 is not an unused zero"
);
assert!(read_usage(1, &[0x07]).is_err());
assert!(read_usage(0, &[0x81]).is_ok());
}
#[test]
fn an_over_wide_key_usage_is_refused() {
assert!(read_usage(0, &[0x00, 0x00, 0x00]).is_err());
assert!(
read_usage(8, &[0x00]).is_err(),
"8 unused bits is not a thing"
);
}
fn common_name(cn: &str) -> heapless::Vec<u8, 128> {
let mut atv = heapless::Vec::<u8, 128>::new();
let _ = atv.extend_from_slice(&[0x06, 0x03, 0x55, 0x04, 0x03, 0x0C]);
let _ = atv.push(u8::try_from(cn.len()).unwrap_or(0));
let _ = atv.extend_from_slice(cn.as_bytes());
let mut seq = heapless::Vec::<u8, 128>::new();
let _ = seq.push(TAG_SEQUENCE);
let _ = seq.push(u8::try_from(atv.len()).unwrap_or(0));
let _ = seq.extend_from_slice(&atv);
let mut set = heapless::Vec::<u8, 128>::new();
let _ = set.push(crate::der::TAG_SET);
let _ = set.push(u8::try_from(seq.len()).unwrap_or(0));
let _ = set.extend_from_slice(&seq);
set
}
#[test]
fn the_leftmost_correct_match_wins_and_earlier_malformed_ones_do_not_count() {
let name = common_name("Mvid:zzzz and Mvid:ABCD");
let parsed = VidPid::from_name(&name).expect("parse");
assert_eq!(parsed.vendor_id, Some(VendorId(0xABCD)));
}
#[test]
fn a_prefix_with_no_correct_match_anywhere_is_an_error_not_an_absence() {
let name = common_name("Mvid:zzzz");
assert_eq!(
VidPid::from_name(&name).map(|_| ()).unwrap_err().code(),
ErrorCode::CertInvalid
);
}
#[test]
fn hex_must_be_exactly_four_uppercase_digits() {
assert_eq!(parse_hex4(b"FFF1"), Some(0xFFF1));
assert_eq!(parse_hex4(b"002A"), Some(0x002A));
assert_eq!(parse_hex4(b"0000"), Some(0));
assert_eq!(parse_hex4(b"fff1"), None);
assert_eq!(parse_hex4(b"FFF"), None);
assert_eq!(parse_hex4(b"FFF12"), None);
assert_eq!(parse_hex4(b"FFG1"), None);
}
#[test]
fn the_matter_arc_is_matched_exactly() {
let mut vid = heapless::Vec::<u8, 16>::new();
let _ = vid.extend_from_slice(OID_MATTER_ATTESTATION_PREFIX);
let _ = vid.push(1);
assert_eq!(matter_attestation_arc(&vid), Some(OID_MATTER_VID_ARC));
let mut deeper = vid.clone();
let _ = deeper.push(9);
assert_eq!(matter_attestation_arc(&deeper), None);
assert_eq!(
matter_attestation_arc(crate::der::OID_MATTER_DN_PREFIX),
None
);
}
#[test]
fn a_field_using_the_matter_oids_ignores_a_common_name_fallback() {
let mut atv = heapless::Vec::<u8, 128>::new();
let _ = atv.push(TAG_OID);
let _ = atv
.push(u8::try_from(OID_MATTER_ATTESTATION_PREFIX.len().saturating_add(1)).unwrap_or(0));
let _ = atv.extend_from_slice(OID_MATTER_ATTESTATION_PREFIX);
let _ = atv.push(OID_MATTER_VID_ARC);
let _ = atv.extend_from_slice(&[0x0C, 0x04, b'F', b'F', b'F', b'1']);
let mut seq = heapless::Vec::<u8, 128>::new();
let _ = seq.push(TAG_SEQUENCE);
let _ = seq.push(u8::try_from(atv.len()).unwrap_or(0));
let _ = seq.extend_from_slice(&atv);
let mut rdn = heapless::Vec::<u8, 128>::new();
let _ = rdn.push(crate::der::TAG_SET);
let _ = rdn.push(u8::try_from(seq.len()).unwrap_or(0));
let _ = rdn.extend_from_slice(&seq);
let cn = common_name("Matter Test Mpid:8000");
let mut name = heapless::Vec::<u8, 256>::new();
let _ = name.extend_from_slice(&rdn);
let _ = name.extend_from_slice(&cn);
let parsed = VidPid::from_name(&name).expect("parse");
assert_eq!(parsed.vendor_id, Some(VendorId(0xFFF1)));
assert_eq!(
parsed.product_id, None,
"the fallback is skipped for this field"
);
}
}