use crate::cert::dn::{DistinguishedName, DnAttribute, DnAttributeKind};
use crate::cert::{
BasicConstraints, CERT_DER_MAX, EllipticCurveId, Extension, Extensions, KEY_ID_LEN,
KeyPurposeId, KeyUsage, MatterCertificate, PublicKeyAlgorithm, SignatureAlgorithm, der,
};
use crate::crypto::{KeyHandle, KeyStore, PublicKey};
use crate::error::{Error, ErrorCode, Result};
use crate::msg::{CaseAuthenticatedTag, FabricId, NodeId};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Validity {
pub not_before: u32,
pub not_after: u32,
}
impl Validity {
#[must_use]
pub const fn years(from: u32, years: u32) -> Self {
Self {
not_before: from,
not_after: from.saturating_add(years.saturating_mul(31_557_600)),
}
}
#[must_use]
pub const fn forever(from: u32) -> Self {
Self {
not_before: from,
not_after: 0,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Identity {
pub fabric_id: FabricId,
pub node_id: NodeId,
pub cats: [Option<CaseAuthenticatedTag>; MAX_CATS],
}
pub const MAX_CATS: usize = 3;
impl Identity {
#[must_use]
pub const fn new(fabric_id: FabricId, node_id: NodeId) -> Self {
Self {
fabric_id,
node_id,
cats: [None; MAX_CATS],
}
}
pub fn with_cats(mut self, cats: &[CaseAuthenticatedTag]) -> Result<Self> {
if cats.len() > MAX_CATS {
return Err(Error::new(ErrorCode::InvalidArgument));
}
for (index, tag) in cats.iter().enumerate() {
if cats
.iter()
.skip(index.saturating_add(1))
.any(|other| other.identifier() == tag.identifier())
{
return Err(Error::new(ErrorCode::InvalidArgument));
}
if let Some(slot) = self.cats.get_mut(index) {
*slot = Some(*tag);
}
}
Ok(self)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Authority {
Root,
Intermediate,
}
#[derive(Debug, Clone, Copy)]
pub struct CertAuthority {
key: KeyHandle,
kind: Authority,
rcac_id: u64,
fabric_id: Option<FabricId>,
}
impl CertAuthority {
#[must_use]
pub const fn new(key: KeyHandle, rcac_id: u64) -> Self {
Self {
key,
kind: Authority::Root,
rcac_id,
fabric_id: None,
}
}
#[must_use]
pub const fn intermediate(key: KeyHandle, icac_id: u64) -> Self {
Self {
key,
kind: Authority::Intermediate,
rcac_id: icac_id,
fabric_id: None,
}
}
#[must_use]
pub const fn kind(&self) -> Authority {
self.kind
}
#[must_use]
pub const fn for_fabric(mut self, fabric_id: FabricId) -> Self {
self.fabric_id = Some(fabric_id);
self
}
#[must_use]
pub const fn key(&self) -> KeyHandle {
self.key
}
pub fn self_signed_root<'b, K: KeyStore>(
&self,
keys: &K,
buf: &'b mut [u8],
validity: Validity,
) -> Result<&'b [u8]> {
if self.kind != Authority::Root {
return Err(Error::new(ErrorCode::InvalidArgument));
}
let public_key = keys.public_key(self.key)?;
let mut subject = DistinguishedName::new();
subject.push(DnAttribute::uint(
DnAttributeKind::MatterRcacId,
self.rcac_id,
))?;
if let Some(fabric_id) = self.fabric_id {
subject.push(DnAttribute::uint(
DnAttributeKind::MatterFabricId,
fabric_id.0,
))?;
}
self.sign_into(
keys,
buf,
&subject.clone(),
&subject,
&public_key,
validity,
Extension::BasicConstraints(BasicConstraints {
is_ca: true,
path_len_constraint: None,
}),
KeyUsage::KEY_CERT_SIGN | KeyUsage::CRL_SIGN,
&[],
&public_key,
)
}
pub fn issue_icac<'b, K: KeyStore>(
&self,
keys: &K,
buf: &'b mut [u8],
icac_id: u64,
public_key: &PublicKey,
validity: Validity,
) -> Result<&'b [u8]> {
if self.kind != Authority::Root {
return Err(Error::new(ErrorCode::InvalidArgument));
}
let root_key = keys.public_key(self.key)?;
let mut subject = DistinguishedName::new();
subject.push(DnAttribute::uint(DnAttributeKind::MatterIcacId, icac_id))?;
if let Some(fabric_id) = self.fabric_id {
subject.push(DnAttribute::uint(
DnAttributeKind::MatterFabricId,
fabric_id.0,
))?;
}
self.sign_into(
keys,
buf,
&self.issuer()?,
&subject,
public_key,
validity,
Extension::BasicConstraints(BasicConstraints {
is_ca: true,
path_len_constraint: Some(0),
}),
KeyUsage::KEY_CERT_SIGN | KeyUsage::CRL_SIGN,
&[],
&root_key,
)
}
pub fn issue_noc<'b, K: KeyStore>(
&self,
keys: &K,
buf: &'b mut [u8],
identity: &Identity,
public_key: &PublicKey,
validity: Validity,
) -> Result<&'b [u8]> {
if self
.fabric_id
.is_some_and(|pinned| pinned != identity.fabric_id)
{
return Err(Error::new(ErrorCode::InvalidArgument));
}
if !identity.node_id.is_operational() {
return Err(Error::new(ErrorCode::InvalidArgument));
}
let root_key = keys.public_key(self.key)?;
let mut subject = DistinguishedName::new();
subject.push(DnAttribute::uint(
DnAttributeKind::MatterFabricId,
identity.fabric_id.0,
))?;
subject.push(DnAttribute::uint(
DnAttributeKind::MatterNodeId,
identity.node_id.0,
))?;
for cat in identity.cats.iter().flatten() {
subject.push(DnAttribute::uint(
DnAttributeKind::MatterNocCat,
u64::from(cat.0),
))?;
}
self.sign_into(
keys,
buf,
&self.issuer()?,
&subject,
public_key,
validity,
Extension::BasicConstraints(BasicConstraints {
is_ca: false,
path_len_constraint: None,
}),
KeyUsage::DIGITAL_SIGNATURE,
&[KeyPurposeId::ServerAuth, KeyPurposeId::ClientAuth],
&root_key,
)
}
fn issuer(&self) -> Result<DistinguishedName<'static>> {
let mut issuer = DistinguishedName::new();
issuer.push(DnAttribute::uint(
match self.kind {
Authority::Root => DnAttributeKind::MatterRcacId,
Authority::Intermediate => DnAttributeKind::MatterIcacId,
},
self.rcac_id,
))?;
if let Some(fabric_id) = self.fabric_id {
issuer.push(DnAttribute::uint(
DnAttributeKind::MatterFabricId,
fabric_id.0,
))?;
}
Ok(issuer)
}
#[allow(clippy::too_many_arguments)]
fn sign_into<'b, K: KeyStore>(
&self,
keys: &K,
buf: &'b mut [u8],
issuer: &DistinguishedName<'_>,
subject: &DistinguishedName<'_>,
public_key: &PublicKey,
validity: Validity,
constraints: Extension<'static>,
key_usage: KeyUsage,
extended_key_usage: &[KeyPurposeId],
authority_key: &PublicKey,
) -> Result<&'b [u8]> {
let mut extensions = Extensions::new();
extensions.push(constraints)?;
extensions.push(Extension::KeyUsage(key_usage))?;
if !extended_key_usage.is_empty() {
let purposes = heapless::Vec::from_slice(extended_key_usage)
.map_err(|_| Error::new(ErrorCode::InvalidArgument))?;
extensions.push(Extension::ExtendedKeyUsage(purposes))?;
}
extensions.push(Extension::SubjectKeyId(key_id(public_key)?))?;
extensions.push(Extension::AuthorityKeyId(key_id(authority_key)?))?;
let serial = crate::cert::positive_serial(key_id(public_key)?);
let mut cert = MatterCertificate {
serial_number: &serial,
signature_algorithm: SignatureAlgorithm::EcdsaWithSha256,
issuer: issuer.clone(),
not_before: validity.not_before,
not_after: validity.not_after,
subject: subject.clone(),
public_key_algorithm: PublicKeyAlgorithm::EcPubKey,
elliptic_curve_id: EllipticCurveId::Prime256V1,
public_key: *public_key,
extensions,
signature: crate::crypto::Signature::from_bytes([0u8; 64]),
};
let mut der_buf = [0u8; CERT_DER_MAX];
let tbs = der::tbs_certificate(&cert, &mut der_buf)?;
cert.signature = keys.sign(self.key, tbs)?;
cert.encode(buf)
}
}
fn key_id(public_key: &PublicKey) -> Result<[u8; KEY_ID_LEN]> {
let digest = crate::crypto::hash(public_key.as_bytes());
let prefix = digest
.get(..KEY_ID_LEN)
.ok_or_else(|| Error::new(ErrorCode::InvalidState))?;
<[u8; KEY_ID_LEN]>::try_from(prefix).map_err(|_| Error::new(ErrorCode::InvalidState))
}