1use crate::crypto::{PublicKey, Signature, verify};
31use crate::der::{
32 DerReader, Element, OID_COMMON_NAME, OID_EC_PUBLIC_KEY, OID_ECDSA_WITH_SHA256,
33 OID_MATTER_ATTESTATION_PREFIX, OID_PRIME256V1, TAG_BIT_STRING, TAG_BOOLEAN, TAG_INTEGER,
34 TAG_OCTET_STRING, TAG_OID, TAG_SEQUENCE, context_constructed, ecdsa_sig_value_to_raw,
35 read_time,
36};
37use crate::error::{Error, ErrorCode, Result};
38use crate::msg::VendorId;
39
40const TAG_VERSION: u8 = context_constructed(0);
42const TAG_EXTENSIONS: u8 = context_constructed(3);
44
45const OID_MATTER_VID_ARC: u8 = 1;
47const OID_MATTER_PID_ARC: u8 = 2;
49
50pub const FALLBACK_VID_PREFIX: &[u8] = b"Mvid:";
52pub const FALLBACK_PID_PREFIX: &[u8] = b"Mpid:";
54
55pub const MAX_DER_LEN: usize = 600;
58
59pub const KEY_ID_LEN: usize = 20;
61
62fn malformed() -> Error {
63 Error::new(ErrorCode::DerMalformed)
64}
65
66fn invalid() -> Error {
67 Error::new(ErrorCode::CertInvalid)
68}
69
70#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
74pub struct VidPid {
75 pub vendor_id: Option<VendorId>,
77 pub product_id: Option<u16>,
79}
80
81impl VidPid {
82 pub fn from_name(name: &[u8]) -> Result<Self> {
94 let mut out = Self::default();
95 let mut saw_matter_oid = false;
96 let mut common_name: Option<&[u8]> = None;
97
98 let mut rdns = DerReader::new(name);
99 while !rdns.is_empty() {
100 let mut rdn = rdns.expect_set()?;
101 while !rdn.is_empty() {
102 let mut atv = rdn.expect_sequence()?;
103 let oid = atv.expect(TAG_OID)?.content;
104 let value = atv.next_element()?;
105 atv.finish()?;
106
107 if let Some(arc) = matter_attestation_arc(oid) {
108 saw_matter_oid = true;
109 let scalar = parse_hex4(value.content).ok_or_else(invalid)?;
113 match arc {
114 OID_MATTER_VID_ARC => out.vendor_id = Some(VendorId(scalar)),
115 OID_MATTER_PID_ARC => out.product_id = Some(scalar),
116 _ => {}
117 }
118 } else if oid == OID_COMMON_NAME {
119 common_name = Some(value.content);
120 }
121 }
122 }
123
124 if saw_matter_oid {
125 return Ok(out);
129 }
130 if let Some(cn) = common_name {
131 out.vendor_id = fallback_scalar(cn, FALLBACK_VID_PREFIX)?.map(VendorId);
132 out.product_id = fallback_scalar(cn, FALLBACK_PID_PREFIX)?;
133 }
134 Ok(out)
135 }
136}
137
138fn matter_attestation_arc(oid: &[u8]) -> Option<u8> {
140 let rest = oid.strip_prefix(OID_MATTER_ATTESTATION_PREFIX)?;
141 match rest {
142 [arc] => Some(*arc),
143 _ => None,
144 }
145}
146
147fn parse_hex4(text: &[u8]) -> Option<u16> {
149 let [a, b, c, d] = <[u8; 4]>::try_from(text).ok()?;
150 let mut value = 0u16;
151 for byte in [a, b, c, d] {
152 let digit = match byte {
153 b'0'..=b'9' => byte.checked_sub(b'0')?,
154 b'A'..=b'F' => byte.checked_sub(b'A')?.checked_add(10)?,
156 _ => return None,
157 };
158 value = value.checked_mul(16)?.checked_add(u16::from(digit))?;
159 }
160 Some(value)
161}
162
163fn fallback_scalar(common_name: &[u8], prefix: &[u8]) -> Result<Option<u16>> {
173 let mut saw_prefix = false;
174 let mut at = 0usize;
175 while let Some(slice) = common_name.get(at..) {
176 if slice.len() < prefix.len() {
177 break;
178 }
179 if slice.starts_with(prefix) {
180 saw_prefix = true;
181 if let Some(digits) = slice.get(prefix.len()..prefix.len().saturating_add(4))
182 && let Some(value) = parse_hex4(digits)
183 {
184 return Ok(Some(value));
186 }
187 }
188 at = at.checked_add(1).ok_or_else(invalid)?;
189 }
190 if saw_prefix { Err(invalid()) } else { Ok(None) }
191}
192
193bitflags::bitflags! {
196 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
199 pub struct KeyUsage: u16 {
200 const DIGITAL_SIGNATURE = 1 << 0;
202 const NON_REPUDIATION = 1 << 1;
204 const KEY_ENCIPHERMENT = 1 << 2;
206 const DATA_ENCIPHERMENT = 1 << 3;
208 const KEY_AGREEMENT = 1 << 4;
210 const KEY_CERT_SIGN = 1 << 5;
212 const CRL_SIGN = 1 << 6;
214 const ENCIPHER_ONLY = 1 << 7;
216 const DECIPHER_ONLY = 1 << 8;
218 }
219}
220
221#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
224pub struct BasicConstraints {
225 pub is_ca: bool,
227 pub path_len: Option<u8>,
229}
230
231#[derive(Debug, Clone, PartialEq, Eq)]
233pub struct X509Certificate<'a> {
234 pub tbs: &'a [u8],
236 pub serial_number: &'a [u8],
238 pub issuer: &'a [u8],
241 pub subject: &'a [u8],
243 pub issuer_vid_pid: VidPid,
245 pub subject_vid_pid: VidPid,
247 pub not_before: u32,
249 pub not_after: Option<u32>,
251 pub public_key: PublicKey,
253 pub basic_constraints: Option<BasicConstraints>,
255 pub key_usage: Option<KeyUsage>,
257 pub subject_key_id: Option<[u8; KEY_ID_LEN]>,
259 pub authority_key_id: Option<[u8; KEY_ID_LEN]>,
261 pub has_extended_key_usage: bool,
264 pub signature: Signature,
266}
267
268impl<'a> X509Certificate<'a> {
269 pub fn parse(der: &'a [u8]) -> Result<Self> {
271 if der.len() > MAX_DER_LEN {
272 return Err(invalid());
274 }
275 let mut outer = DerReader::new(der);
276 let mut cert = outer.expect_sequence()?;
277 outer.finish()?;
278
279 let tbs_element = cert.expect(TAG_SEQUENCE)?;
280 let mut tbs = tbs_element.content_reader();
281
282 let version = tbs.expect(TAG_VERSION)?;
284 let mut version_reader = version.content_reader();
285 if version_reader.expect_uint()? != 2 {
286 return Err(invalid());
287 }
288 version_reader.finish()?;
289
290 let serial_number = tbs.expect_unsigned()?;
291
292 let mut signature_algo = tbs.expect_sequence()?;
295 signature_algo.expect_oid(OID_ECDSA_WITH_SHA256)?;
296
297 let issuer = tbs.expect(TAG_SEQUENCE)?.content;
298
299 let mut validity = tbs.expect_sequence()?;
300 let not_before = read_time(&validity.next_element()?)?.ok_or_else(invalid)?;
301 let not_after = read_time(&validity.next_element()?)?;
302 validity.finish()?;
303
304 let subject = tbs.expect(TAG_SEQUENCE)?.content;
305
306 let mut spki = tbs.expect_sequence()?;
309 let mut key_algo = spki.expect_sequence()?;
310 key_algo.expect_oid(OID_EC_PUBLIC_KEY)?;
311 key_algo.expect_oid(OID_PRIME256V1)?;
312 key_algo.finish()?;
313 let public_key = PublicKey::from_slice(spki.expect(TAG_BIT_STRING)?.bit_string_octets()?)?;
314 spki.finish()?;
315
316 let _ = tbs.take_if(context_constructed(1))?;
320 let _ = tbs.take_if(context_constructed(2))?;
321
322 let mut parsed = Extensions::default();
323 if let Some(extensions) = tbs.take_if(TAG_EXTENSIONS)? {
324 let mut explicit = extensions.content_reader();
325 let mut list = explicit.expect_sequence()?;
326 explicit.finish()?;
327 while !list.is_empty() {
328 parsed.absorb(&mut list.expect_sequence()?)?;
329 }
330 }
331 tbs.finish()?;
332
333 let mut sig_algo = cert.expect_sequence()?;
334 sig_algo.expect_oid(OID_ECDSA_WITH_SHA256)?;
335 sig_algo.finish()?;
336
337 let signature_der = cert.expect(TAG_BIT_STRING)?.bit_string_octets()?;
338 cert.finish()?;
339 let mut raw = [0u8; 64];
340 ecdsa_sig_value_to_raw(signature_der, &mut raw)?;
341
342 Ok(Self {
343 tbs: tbs_element.raw,
344 serial_number,
345 issuer,
346 subject,
347 issuer_vid_pid: VidPid::from_name(issuer)?,
348 subject_vid_pid: VidPid::from_name(subject)?,
349 not_before,
350 not_after,
351 public_key,
352 basic_constraints: parsed.basic_constraints,
353 key_usage: parsed.key_usage,
354 subject_key_id: parsed.subject_key_id,
355 authority_key_id: parsed.authority_key_id,
356 has_extended_key_usage: parsed.has_extended_key_usage,
357 signature: Signature::from_bytes(raw),
358 })
359 }
360
361 #[must_use]
363 pub const fn is_valid_at(&self, at: u32) -> bool {
364 at >= self.not_before
365 && match self.not_after {
366 Some(end) => at <= end,
367 None => true,
368 }
369 }
370
371 #[must_use]
373 pub fn is_ca(&self) -> bool {
374 self.basic_constraints.is_some_and(|b| b.is_ca)
375 }
376
377 pub fn verify_signature_of(&self, subject: &Self) -> Result<bool> {
379 verify(&self.public_key, subject.tbs, &subject.signature)
380 }
381}
382
383#[derive(Debug, Default)]
385struct Extensions {
386 basic_constraints: Option<BasicConstraints>,
387 key_usage: Option<KeyUsage>,
388 subject_key_id: Option<[u8; KEY_ID_LEN]>,
389 authority_key_id: Option<[u8; KEY_ID_LEN]>,
390 has_extended_key_usage: bool,
391 seen: u64,
397}
398
399impl Extensions {
400 fn absorb(&mut self, extension: &mut DerReader<'_>) -> Result<()> {
403 let oid = extension.expect(TAG_OID)?.content;
404 let critical = match extension.take_if(TAG_BOOLEAN)? {
406 Some(element) => element.content == [0xFF],
407 None => false,
408 };
409 let value = extension.expect(TAG_OCTET_STRING)?.content;
410 extension.finish()?;
411
412 let Some([arc]) = oid.strip_prefix(crate::der::OID_CE_PREFIX) else {
414 return Ok(());
417 };
418 if let Some(bit) = 1u64.checked_shl(u32::from(*arc)) {
419 if self.seen & bit != 0 {
420 return Err(invalid());
421 }
422 self.seen |= bit;
423 }
424
425 let mut reader = DerReader::new(value);
426 match *arc {
427 14 => {
428 self.subject_key_id = Some(key_id(&reader.expect(TAG_OCTET_STRING)?)?);
430 }
431 15 => {
432 if !critical {
434 return Err(invalid());
435 }
436 self.key_usage = Some(read_key_usage(&reader.expect(TAG_BIT_STRING)?)?);
437 }
438 19 => {
439 if !critical {
441 return Err(invalid());
442 }
443 let mut seq = reader.expect_sequence()?;
444 let is_ca = match seq.take_if(TAG_BOOLEAN)? {
445 Some(element) => element.content == [0xFF],
446 None => false,
447 };
448 let path_len = match seq.take_if(TAG_INTEGER)? {
449 Some(element) => match element.content {
452 [len] if *len < 0x80 => Some(*len),
453 _ => return Err(malformed()),
454 },
455 None => None,
456 };
457 seq.finish()?;
458 if !is_ca && path_len.is_some() {
462 return Err(invalid());
463 }
464 self.basic_constraints = Some(BasicConstraints { is_ca, path_len });
465 }
466 35 => {
467 let mut seq = reader.expect_sequence()?;
469 if let Some(element) = seq.take_if(crate::der::context_primitive(0))? {
470 self.authority_key_id = Some(key_id(&element)?);
471 }
472 }
475 37 => self.has_extended_key_usage = true,
476 _ => {}
477 }
478 Ok(())
479 }
480}
481
482fn key_id(element: &Element<'_>) -> Result<[u8; KEY_ID_LEN]> {
483 <[u8; KEY_ID_LEN]>::try_from(element.content).map_err(|_| invalid())
485}
486
487fn read_key_usage(element: &Element<'_>) -> Result<KeyUsage> {
493 let content = element.content;
494 let (unused, octets) = content.split_first().ok_or_else(malformed)?;
495 if *unused > 7 || octets.len() > 2 {
496 return Err(malformed());
497 }
498 if *unused > 0 {
502 let last = octets.last().copied().unwrap_or(0);
503 let mask = 0xFFu8
504 .checked_shr(8u32.saturating_sub(u32::from(*unused)))
505 .unwrap_or(0);
506 if last & mask != 0 {
507 return Err(malformed());
508 }
509 }
510 let mut bits = 0u16;
511 if let Some(first) = octets.first() {
512 bits |= u16::from(first.reverse_bits());
513 }
514 if let Some(second) = octets.get(1) {
515 bits |= u16::from(second.reverse_bits()) << 8;
516 }
517 KeyUsage::from_bits(bits).ok_or_else(invalid)
518}
519
520#[cfg(test)]
521mod tests {
522 use super::*;
523
524 fn key_usage_element(unused: u8, octets: &[u8]) -> heapless::Vec<u8, 8> {
526 let mut out = heapless::Vec::new();
527 let _ = out.push(TAG_BIT_STRING);
528 let _ = out.push(u8::try_from(octets.len().saturating_add(1)).unwrap_or(0));
529 let _ = out.push(unused);
530 let _ = out.extend_from_slice(octets);
531 out
532 }
533
534 fn read_usage(unused: u8, octets: &[u8]) -> Result<KeyUsage> {
535 let bytes = key_usage_element(unused, octets);
536 let element = DerReader::new(&bytes).next_element()?;
537 read_key_usage(&element)
538 }
539
540 #[test]
541 fn key_usage_bits_are_numbered_from_the_most_significant_bit() {
542 assert_eq!(
546 read_usage(7, &[0x80]).expect("ds"),
547 KeyUsage::DIGITAL_SIGNATURE
548 );
549 assert_eq!(
550 read_usage(1, &[0x06]).expect("ca"),
551 KeyUsage::KEY_CERT_SIGN | KeyUsage::CRL_SIGN
552 );
553 assert_eq!(
555 read_usage(7, &[0x00, 0x80]).expect("do"),
556 KeyUsage::DECIPHER_ONLY
557 );
558 }
559
560 #[test]
561 fn a_bit_string_with_non_zero_unused_bits_is_refused() {
562 assert!(
565 read_usage(7, &[0x81]).is_err(),
566 "bit 7 is not an unused zero"
567 );
568 assert!(read_usage(1, &[0x07]).is_err());
569 assert!(read_usage(0, &[0x81]).is_ok());
571 }
572
573 #[test]
574 fn an_over_wide_key_usage_is_refused() {
575 assert!(read_usage(0, &[0x00, 0x00, 0x00]).is_err());
577 assert!(
578 read_usage(8, &[0x00]).is_err(),
579 "8 unused bits is not a thing"
580 );
581 }
582
583 fn common_name(cn: &str) -> heapless::Vec<u8, 128> {
585 let mut atv = heapless::Vec::<u8, 128>::new();
586 let _ = atv.extend_from_slice(&[0x06, 0x03, 0x55, 0x04, 0x03, 0x0C]);
587 let _ = atv.push(u8::try_from(cn.len()).unwrap_or(0));
588 let _ = atv.extend_from_slice(cn.as_bytes());
589
590 let mut seq = heapless::Vec::<u8, 128>::new();
591 let _ = seq.push(TAG_SEQUENCE);
592 let _ = seq.push(u8::try_from(atv.len()).unwrap_or(0));
593 let _ = seq.extend_from_slice(&atv);
594
595 let mut set = heapless::Vec::<u8, 128>::new();
596 let _ = set.push(crate::der::TAG_SET);
597 let _ = set.push(u8::try_from(seq.len()).unwrap_or(0));
598 let _ = set.extend_from_slice(&seq);
599 set
600 }
601
602 #[test]
603 fn the_leftmost_correct_match_wins_and_earlier_malformed_ones_do_not_count() {
604 let name = common_name("Mvid:zzzz and Mvid:ABCD");
608 let parsed = VidPid::from_name(&name).expect("parse");
609 assert_eq!(parsed.vendor_id, Some(VendorId(0xABCD)));
610 }
611
612 #[test]
613 fn a_prefix_with_no_correct_match_anywhere_is_an_error_not_an_absence() {
614 let name = common_name("Mvid:zzzz");
619 assert_eq!(
620 VidPid::from_name(&name).map(|_| ()).unwrap_err().code(),
621 ErrorCode::CertInvalid
622 );
623 }
624
625 #[test]
626 fn hex_must_be_exactly_four_uppercase_digits() {
627 assert_eq!(parse_hex4(b"FFF1"), Some(0xFFF1));
628 assert_eq!(parse_hex4(b"002A"), Some(0x002A));
629 assert_eq!(parse_hex4(b"0000"), Some(0));
630 assert_eq!(parse_hex4(b"fff1"), None);
632 assert_eq!(parse_hex4(b"FFF"), None);
633 assert_eq!(parse_hex4(b"FFF12"), None);
634 assert_eq!(parse_hex4(b"FFG1"), None);
635 }
636
637 #[test]
638 fn the_matter_arc_is_matched_exactly() {
639 let mut vid = heapless::Vec::<u8, 16>::new();
642 let _ = vid.extend_from_slice(OID_MATTER_ATTESTATION_PREFIX);
643 let _ = vid.push(1);
644 assert_eq!(matter_attestation_arc(&vid), Some(OID_MATTER_VID_ARC));
645
646 let mut deeper = vid.clone();
648 let _ = deeper.push(9);
649 assert_eq!(matter_attestation_arc(&deeper), None);
650
651 assert_eq!(
653 matter_attestation_arc(crate::der::OID_MATTER_DN_PREFIX),
654 None
655 );
656 }
657
658 #[test]
659 fn a_field_using_the_matter_oids_ignores_a_common_name_fallback() {
660 let mut atv = heapless::Vec::<u8, 128>::new();
664 let _ = atv.push(TAG_OID);
665 let _ = atv
666 .push(u8::try_from(OID_MATTER_ATTESTATION_PREFIX.len().saturating_add(1)).unwrap_or(0));
667 let _ = atv.extend_from_slice(OID_MATTER_ATTESTATION_PREFIX);
668 let _ = atv.push(OID_MATTER_VID_ARC);
669 let _ = atv.extend_from_slice(&[0x0C, 0x04, b'F', b'F', b'F', b'1']);
670
671 let mut seq = heapless::Vec::<u8, 128>::new();
672 let _ = seq.push(TAG_SEQUENCE);
673 let _ = seq.push(u8::try_from(atv.len()).unwrap_or(0));
674 let _ = seq.extend_from_slice(&atv);
675 let mut rdn = heapless::Vec::<u8, 128>::new();
676 let _ = rdn.push(crate::der::TAG_SET);
677 let _ = rdn.push(u8::try_from(seq.len()).unwrap_or(0));
678 let _ = rdn.extend_from_slice(&seq);
679
680 let cn = common_name("Matter Test Mpid:8000");
682 let mut name = heapless::Vec::<u8, 256>::new();
683 let _ = name.extend_from_slice(&rdn);
684 let _ = name.extend_from_slice(&cn);
685
686 let parsed = VidPid::from_name(&name).expect("parse");
687 assert_eq!(parsed.vendor_id, Some(VendorId(0xFFF1)));
688 assert_eq!(
689 parsed.product_id, None,
690 "the fallback is skipped for this field"
691 );
692 }
693}