use crate::cert::{
CERT_DER_MAX, DistinguishedName, DnAttributeKind, DnValue, Extension, KeyUsage,
MatterCertificate, NOT_AFTER_NEVER, SERIAL_MAX,
};
use crate::error::{Error, ErrorCode, Result};
use crate::der::{
DerWriter, OID_CE_PREFIX, OID_DOMAIN_COMPONENT, OID_ECDSA_WITH_SHA256, OID_KP_PREFIX,
OID_MATTER_DN_PREFIX, TAG_BIT_STRING, TAG_BOOLEAN, TAG_GENERALIZED_TIME, TAG_IA5_STRING,
TAG_INTEGER, TAG_OCTET_STRING, TAG_OID, TAG_PRINTABLE_STRING, TAG_SEQUENCE, TAG_SET,
TAG_UTF8_STRING, context_constructed, context_primitive, write_time,
};
const TAG_VERSION: u8 = context_constructed(0);
const TAG_EXTENSIONS: u8 = context_constructed(3);
const TAG_KEY_IDENTIFIER: u8 = context_primitive(0);
const OID_X520_PREFIX: &[u8] = &[0x55, 0x04];
const CE_SUBJECT_KEY_IDENTIFIER: u8 = 14;
const CE_KEY_USAGE: u8 = 15;
const CE_BASIC_CONSTRAINTS: u8 = 19;
const CE_AUTHORITY_KEY_IDENTIFIER: u8 = 35;
const CE_EXTENDED_KEY_USAGE: u8 = 37;
const X520_ARCS: [u8; 15] = [3, 4, 5, 6, 7, 8, 10, 11, 12, 41, 42, 43, 44, 46, 65];
fn invalid() -> Error {
Error::new(ErrorCode::CertInvalid)
}
pub fn tbs_certificate<'b>(cert: &MatterCertificate<'_>, buf: &'b mut [u8]) -> Result<&'b [u8]> {
let mut writer = DerWriter::new(buf);
write_tbs(&mut writer, cert)?;
Ok(writer.finish())
}
pub fn certificate<'b>(cert: &MatterCertificate<'_>, buf: &'b mut [u8]) -> Result<&'b [u8]> {
let mut writer = DerWriter::new(buf);
let mark = writer.mark();
write_signature_value(&mut writer, cert)?;
write_algorithm_identifier(&mut writer)?;
write_tbs(&mut writer, cert)?;
writer.header(TAG_SEQUENCE, mark)?;
if writer.len() > CERT_DER_MAX {
return Err(invalid());
}
Ok(writer.finish())
}
fn write_tbs(writer: &mut DerWriter<'_>, cert: &MatterCertificate<'_>) -> Result<()> {
let mark = writer.mark();
write_extensions(writer, cert)?;
write_subject_public_key_info(writer, cert)?;
write_name(writer, &cert.subject)?;
write_validity(writer, cert)?;
write_name(writer, &cert.issuer)?;
write_algorithm_identifier(writer)?;
write_serial_number(writer, cert.serial_number)?;
write_version(writer)?;
writer.header(TAG_SEQUENCE, mark)
}
fn write_version(writer: &mut DerWriter<'_>) -> Result<()> {
let mark = writer.mark();
writer.primitive(TAG_INTEGER, &[2])?;
writer.header(TAG_VERSION, mark)
}
fn write_serial_number(writer: &mut DerWriter<'_>, serial: &[u8]) -> Result<()> {
if serial.is_empty() || serial.len() > SERIAL_MAX {
return Err(invalid());
}
if let ([first, second, ..], _) = (serial, ()) {
let redundant_zero = *first == 0x00 && *second < 0x80;
let redundant_ones = *first == 0xFF && *second >= 0x80;
if redundant_zero || redundant_ones {
return Err(invalid());
}
}
writer.primitive(TAG_INTEGER, serial)
}
fn write_algorithm_identifier(writer: &mut DerWriter<'_>) -> Result<()> {
writer.algorithm_identifier(OID_ECDSA_WITH_SHA256)
}
fn write_name(writer: &mut DerWriter<'_>, dn: &DistinguishedName<'_>) -> Result<()> {
if dn.is_empty() {
return Err(invalid());
}
let mark = writer.mark();
for attribute in dn.attributes().iter().rev() {
let set_mark = writer.mark();
let seq_mark = writer.mark();
match attribute.value {
DnValue::Str(text) => {
let tag = if attribute.printable_string {
TAG_PRINTABLE_STRING
} else if attribute.kind == DnAttributeKind::DomainComponent {
TAG_IA5_STRING
} else {
TAG_UTF8_STRING
};
writer.primitive(tag, text.as_bytes())?;
}
DnValue::Uint(value) => {
let octets = attribute.kind.scalar_octets().ok_or_else(invalid)?;
let mut hex = [0u8; 16];
let width = octets.checked_mul(2).ok_or_else(invalid)?;
let digits = hex.get_mut(..width).ok_or_else(invalid)?;
write_uppercase_hex(digits, value)?;
writer.primitive(TAG_UTF8_STRING, digits)?;
}
}
write_attribute_type_oid(writer, attribute.kind)?;
writer.header(TAG_SEQUENCE, seq_mark)?;
writer.header(TAG_SET, set_mark)?;
}
writer.header(TAG_SEQUENCE, mark)
}
fn write_attribute_type_oid(writer: &mut DerWriter<'_>, kind: DnAttributeKind) -> Result<()> {
if kind == DnAttributeKind::DomainComponent {
return writer.primitive(TAG_OID, OID_DOMAIN_COMPONENT);
}
if kind.is_matter_specific() {
let arc = kind.tag().checked_sub(16).ok_or_else(invalid)?;
return writer.oid_with_arc(OID_MATTER_DN_PREFIX, arc);
}
let index = usize::from(kind.tag()).checked_sub(1).ok_or_else(invalid)?;
let arc = X520_ARCS.get(index).copied().ok_or_else(invalid)?;
writer.oid_with_arc(OID_X520_PREFIX, arc)
}
fn write_uppercase_hex(out: &mut [u8], value: u64) -> Result<()> {
const DIGITS: &[u8; 16] = b"0123456789ABCDEF";
let width = out.len();
if width < 16 {
let bits = u32::try_from(width).ok().and_then(|w| w.checked_mul(4));
let limit = bits.and_then(|b| 1u64.checked_shl(b));
if limit.is_some_and(|limit| value >= limit) {
return Err(invalid());
}
}
for (index, slot) in out.iter_mut().enumerate() {
let from_end = width
.checked_sub(index)
.and_then(|n| n.checked_sub(1))
.ok_or_else(invalid)?;
let shift = u32::try_from(from_end)
.ok()
.and_then(|n| n.checked_mul(4))
.ok_or_else(invalid)?;
let nibble = usize::try_from((value >> shift) & 0x0F).map_err(|_| invalid())?;
*slot = DIGITS.get(nibble).copied().ok_or_else(invalid)?;
}
Ok(())
}
fn write_validity(writer: &mut DerWriter<'_>, cert: &MatterCertificate<'_>) -> Result<()> {
let mark = writer.mark();
if cert.not_after == NOT_AFTER_NEVER {
writer.primitive(TAG_GENERALIZED_TIME, b"99991231235959Z")?;
} else {
write_time(writer, cert.not_after)?;
}
write_time(writer, cert.not_before)?;
writer.header(TAG_SEQUENCE, mark)
}
fn write_subject_public_key_info(
writer: &mut DerWriter<'_>,
cert: &MatterCertificate<'_>,
) -> Result<()> {
writer.subject_public_key_info(cert.public_key.as_bytes())
}
fn write_extensions(writer: &mut DerWriter<'_>, cert: &MatterCertificate<'_>) -> Result<()> {
let entries = cert.extensions.entries();
if entries.is_empty() {
return Err(invalid());
}
let outer = writer.mark();
let seq = writer.mark();
for extension in entries.iter().rev() {
write_extension(writer, extension)?;
}
writer.header(TAG_SEQUENCE, seq)?;
writer.header(TAG_EXTENSIONS, outer)
}
fn write_extension(writer: &mut DerWriter<'_>, extension: &Extension<'_>) -> Result<()> {
let mark = writer.mark();
let (arc, critical) = match extension {
Extension::BasicConstraints(basic) => {
let value = writer.mark();
let inner = writer.mark();
if let Some(path_len) = basic.path_len_constraint {
writer.primitive(TAG_INTEGER, &[path_len])?;
}
if basic.is_ca {
writer.primitive(TAG_BOOLEAN, &[0xFF])?;
}
writer.header(TAG_SEQUENCE, inner)?;
writer.header(TAG_OCTET_STRING, value)?;
(CE_BASIC_CONSTRAINTS, true)
}
Extension::KeyUsage(usage) => {
let value = writer.mark();
write_key_usage_bit_string(writer, *usage)?;
writer.header(TAG_OCTET_STRING, value)?;
(CE_KEY_USAGE, true)
}
Extension::ExtendedKeyUsage(purposes) => {
if purposes.is_empty() {
return Err(invalid());
}
let value = writer.mark();
let inner = writer.mark();
for purpose in purposes.iter().rev() {
writer.oid_with_arc(OID_KP_PREFIX, *purpose as u8)?;
}
writer.header(TAG_SEQUENCE, inner)?;
writer.header(TAG_OCTET_STRING, value)?;
(CE_EXTENDED_KEY_USAGE, true)
}
Extension::SubjectKeyId(id) => {
let value = writer.mark();
writer.primitive(TAG_OCTET_STRING, id)?;
writer.header(TAG_OCTET_STRING, value)?;
(CE_SUBJECT_KEY_IDENTIFIER, false)
}
Extension::AuthorityKeyId(id) => {
let value = writer.mark();
let inner = writer.mark();
writer.primitive(TAG_KEY_IDENTIFIER, id)?;
writer.header(TAG_SEQUENCE, inner)?;
writer.header(TAG_OCTET_STRING, value)?;
(CE_AUTHORITY_KEY_IDENTIFIER, false)
}
Extension::Future(der) => {
return writer.slice(der);
}
};
if critical {
writer.primitive(TAG_BOOLEAN, &[0xFF])?;
}
writer.oid_with_arc(OID_CE_PREFIX, arc)?;
writer.header(TAG_SEQUENCE, mark)
}
#[expect(
clippy::cast_possible_truncation,
reason = "a KeyUsage bit string is nine bits; §6.5.11.2 puts the low eight in one octet"
)]
fn write_key_usage_bit_string(writer: &mut DerWriter<'_>, usage: KeyUsage) -> Result<()> {
let bits = usage.bits();
if bits == 0 {
return Err(invalid());
}
let octets = [
(bits as u8).reverse_bits(),
((bits >> 8) as u8).reverse_bits(),
];
let highest = 15u32.saturating_sub(bits.leading_zeros());
let used = highest.saturating_add(1);
let significant = used.div_ceil(8) as usize;
let unused = u8::try_from(significant.saturating_mul(8))
.ok()
.and_then(|total| u8::try_from(used).ok().map(|u| total.wrapping_sub(u)))
.ok_or_else(invalid)?;
let mark = writer.mark();
writer.slice(octets.get(..significant).ok_or_else(invalid)?)?;
writer.byte(unused)?;
writer.header(TAG_BIT_STRING, mark)
}
fn write_signature_value(writer: &mut DerWriter<'_>, cert: &MatterCertificate<'_>) -> Result<()> {
let mark = writer.mark();
writer.ecdsa_sig_value(cert.signature.as_bytes())?;
writer.byte(0)?;
writer.header(TAG_BIT_STRING, mark)
}