use core::cell::{Cell, RefCell};
use crate::attestation::{self, AttestationElements};
use crate::cert::MatterCertificate;
use crate::config::Config;
use crate::crypto::{KeyHandle, KeyStore, PublicKey, SymmetricKey};
use crate::dm::access::{Access, AccessQualities, Privilege};
use crate::dm::meta::{
AttributeDescriptor, AttributeQualities, ClusterDescriptor, CommandDescriptor, Reporting,
};
use crate::dm::{Resolved, ResolvedCommand};
use crate::fabric::{
Credentials, Fabric, FabricIdentity, FabricTable, OPERATIONAL_CERT_MAX,
VENDOR_ID_VERIFICATION_TBS_MAX, VID_VERIFICATION_STATEMENT_LEN,
};
use crate::im::{
AttributeId, ClusterHandler, ClusterId, CommandId, InteractionContext, Status, StatusIb,
};
use crate::msg::{FabricIndex, NodeId, SessionId, VendorId};
use crate::platform::Rng;
use crate::tlv::{ContainerKind, Tag, TlvReader, TlvWriter, set_once};
use super::Cluster;
pub const ID: ClusterId = 0x003E;
pub const REVISION: u16 = 2;
#[must_use]
pub const fn max_nocs_len(fabrics: usize) -> usize {
let per_fabric = OPERATIONAL_CERT_MAX.saturating_mul(2).saturating_add(16);
per_fabric.saturating_mul(fabrics).saturating_add(8)
}
pub const RESP_MAX: usize = 900;
pub const NOCS: AttributeId = 0x0000;
pub const FABRICS: AttributeId = 0x0001;
pub const SUPPORTED_FABRICS: AttributeId = 0x0002;
pub const COMMISSIONED_FABRICS: AttributeId = 0x0003;
pub const TRUSTED_ROOT_CERTIFICATES: AttributeId = 0x0004;
pub const CURRENT_FABRIC_INDEX: AttributeId = 0x0005;
pub const ATTESTATION_REQUEST: CommandId = 0x00;
pub const ATTESTATION_RESPONSE: CommandId = 0x01;
pub const CERTIFICATE_CHAIN_REQUEST: CommandId = 0x02;
pub const CERTIFICATE_CHAIN_RESPONSE: CommandId = 0x03;
pub const CSR_REQUEST: CommandId = 0x04;
pub const CSR_RESPONSE: CommandId = 0x05;
pub const ADD_NOC: CommandId = 0x06;
pub const UPDATE_NOC: CommandId = 0x07;
pub const NOC_RESPONSE: CommandId = 0x08;
pub const UPDATE_FABRIC_LABEL: CommandId = 0x09;
pub const REMOVE_FABRIC: CommandId = 0x0A;
pub const ADD_TRUSTED_ROOT_CERTIFICATE: CommandId = 0x0B;
pub const SET_VID_VERIFICATION_STATEMENT: CommandId = 0x0C;
pub const SIGN_VID_VERIFICATION_REQUEST: CommandId = 0x0D;
pub const SIGN_VID_VERIFICATION_RESPONSE: CommandId = 0x0E;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum CertificateChainType {
Dac = 1,
Pai = 2,
}
impl CertificateChainType {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
1 => Some(Self::Dac),
2 => Some(Self::Pai),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
#[non_exhaustive]
pub enum NocStatus {
Ok = 0,
InvalidPublicKey = 1,
InvalidNodeOpId = 2,
InvalidNoc = 3,
MissingCsr = 4,
TableFull = 5,
InvalidAdminSubject = 6,
FabricConflict = 9,
LabelConflict = 10,
InvalidFabricIndex = 11,
}
impl NocStatus {
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
#[must_use]
pub const fn is_ok(self) -> bool {
matches!(self, Self::Ok)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DeviceAttestation<'a> {
pub dac: &'a [u8],
pub pai: &'a [u8],
pub certification_declaration: &'a [u8],
pub dac_key: KeyHandle,
pub firmware_information: Option<&'a [u8]>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FabricChange {
Added {
index: FabricIndex,
case_admin_subject: u64,
bind_pase_session: bool,
},
Updated {
index: FabricIndex,
},
Removed {
index: FabricIndex,
was_last: bool,
was_accessing: bool,
},
}
#[derive(Debug, Clone, Copy)]
struct PendingCsr {
session: Option<SessionId>,
key: KeyHandle,
public: PublicKey,
for_update: bool,
}
const fn fixed(id: AttributeId) -> AttributeDescriptor {
AttributeDescriptor::read_only(id).with_qualities(AttributeQualities::FIXED)
}
const ATTRIBUTES: &[AttributeDescriptor] = &[
AttributeDescriptor::read_only(NOCS)
.with_access(
Access::read_only(Privilege::Administer).with_qualities(AccessQualities::FABRIC_SCOPED),
)
.with_qualities(AttributeQualities::NON_VOLATILE)
.with_reporting(Reporting::ChangesOmitted),
AttributeDescriptor::read_only(FABRICS)
.with_access(
Access::read_only(Privilege::View).with_qualities(AccessQualities::FABRIC_SCOPED),
)
.with_qualities(AttributeQualities::NON_VOLATILE),
fixed(SUPPORTED_FABRICS),
AttributeDescriptor::read_only(COMMISSIONED_FABRICS)
.with_qualities(AttributeQualities::NON_VOLATILE),
AttributeDescriptor::read_only(TRUSTED_ROOT_CERTIFICATES)
.with_qualities(AttributeQualities::NON_VOLATILE)
.with_reporting(Reporting::ChangesOmitted),
AttributeDescriptor::read_only(CURRENT_FABRIC_INDEX),
];
const COMMANDS: &[CommandDescriptor] = &[
CommandDescriptor::new(ATTESTATION_REQUEST)
.with_access(Access::invoke(Privilege::Administer))
.with_response(ATTESTATION_RESPONSE),
CommandDescriptor::new(CERTIFICATE_CHAIN_REQUEST)
.with_access(Access::invoke(Privilege::Administer))
.with_response(CERTIFICATE_CHAIN_RESPONSE),
CommandDescriptor::new(CSR_REQUEST)
.with_access(Access::invoke(Privilege::Administer))
.with_response(CSR_RESPONSE),
CommandDescriptor::new(ADD_NOC)
.with_access(Access::invoke(Privilege::Administer))
.with_response(NOC_RESPONSE),
CommandDescriptor::new(UPDATE_NOC)
.with_access(
Access::invoke(Privilege::Administer).with_qualities(AccessQualities::FABRIC_SCOPED),
)
.with_response(NOC_RESPONSE),
CommandDescriptor::new(UPDATE_FABRIC_LABEL)
.with_access(
Access::invoke(Privilege::Administer).with_qualities(AccessQualities::FABRIC_SCOPED),
)
.with_response(NOC_RESPONSE),
CommandDescriptor::new(REMOVE_FABRIC)
.with_access(Access::invoke(Privilege::Administer))
.with_response(NOC_RESPONSE),
CommandDescriptor::new(ADD_TRUSTED_ROOT_CERTIFICATE)
.with_access(Access::invoke(Privilege::Administer)),
CommandDescriptor::new(SET_VID_VERIFICATION_STATEMENT).with_access(
Access::invoke(Privilege::Administer).with_qualities(AccessQualities::FABRIC_SCOPED),
),
CommandDescriptor::new(SIGN_VID_VERIFICATION_REQUEST)
.with_access(Access::invoke(Privilege::Administer))
.with_response(SIGN_VID_VERIFICATION_RESPONSE),
];
#[must_use]
pub const fn cluster() -> ClusterDescriptor<'static> {
ClusterDescriptor {
id: ID,
revision: REVISION,
feature_map: 0,
attributes: ATTRIBUTES,
accepted_commands: COMMANDS,
generated_commands: &[],
events: &[],
}
}
pub struct OperationalCredentials<'a, C: Config, K: KeyStore, R: Rng, const N: usize> {
pub fabrics: &'a RefCell<FabricTable<C, N>>,
pub keys: &'a RefCell<K>,
pub rng: &'a RefCell<R>,
pub fail_safe: &'a RefCell<crate::commissioning::failsafe::FailSafe>,
pub attestation: DeviceAttestation<'a>,
pending_root: RefCell<Option<heapless::Vec<u8, OPERATIONAL_CERT_MAX>>>,
pending_csr: Cell<Option<PendingCsr>>,
change: Cell<Option<FabricChange>>,
}
impl<'a, C: Config, K: KeyStore, R: Rng, const N: usize> OperationalCredentials<'a, C, K, R, N> {
#[must_use]
pub fn new(
fabrics: &'a RefCell<FabricTable<C, N>>,
keys: &'a RefCell<K>,
rng: &'a RefCell<R>,
fail_safe: &'a RefCell<crate::commissioning::failsafe::FailSafe>,
attestation: DeviceAttestation<'a>,
) -> Self {
Self {
fabrics,
keys,
rng,
fail_safe,
attestation,
pending_root: RefCell::new(None),
pending_csr: Cell::new(None),
change: Cell::new(None),
}
}
#[must_use]
pub fn take_change(&self) -> Option<FabricChange> {
self.change.take()
}
pub fn discard_pending(&self) {
*self.pending_root.borrow_mut() = None;
if let Some(pending) = self.pending_csr.take() {
let _ = self.keys.borrow_mut().remove(pending.key);
}
}
fn reap(&self, now: crate::platform::Instant) {
let progress = self
.fail_safe
.borrow()
.armed(now)
.map(|armed| armed.progress);
let Some(progress) = progress else {
self.discard_pending();
return;
};
if !progress.csr_requested
&& let Some(pending) = self.pending_csr.take()
{
let _ = self.keys.borrow_mut().remove(pending.key);
}
if !progress.added_trusted_root {
*self.pending_root.borrow_mut() = None;
}
}
fn require_fail_safe(
&self,
now: crate::platform::Instant,
) -> Result<crate::commissioning::failsafe::Progress, Status> {
self.fail_safe
.borrow()
.armed(now)
.map(|armed| armed.progress)
.ok_or(Status::FailsafeRequired)
}
}
impl<C: Config, K: KeyStore, R: Rng, const N: usize> OperationalCredentials<'_, C, K, R, N> {
pub fn attestation_response(
&self,
nonce: &[u8; attestation::ATTESTATION_NONCE_LEN],
timestamp: u32,
challenge: &SymmetricKey,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let elements = AttestationElements {
certification_declaration: self.attestation.certification_declaration,
attestation_nonce: *nonce,
timestamp,
firmware_information: self.attestation.firmware_information,
};
let mut buf = [0u8; RESP_MAX];
let encoded = elements.encode(&mut buf).map_err(|_| Status::Failure)?;
let signature = attestation::sign_attestation(
&*self.keys.borrow(),
self.attestation.dac_key,
encoded,
challenge,
)
.map_err(|_| Status::Failure)?;
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
full(w.start_structure(tag))?;
full(w.octets(Tag::Context(0), encoded))?;
full(w.octets(Tag::Context(1), signature.as_bytes()))?;
full(w.end_container())
}
pub fn csr_response(
&self,
nonce: &[u8; attestation::CSR_NONCE_LEN],
for_update: bool,
ctx: &InteractionContext<'_>,
random: &[u8; 32],
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let progress = self.require_fail_safe(ctx.now)?;
if progress.added_noc || progress.updated_noc {
return Err(Status::ConstraintError);
}
if for_update && ctx.fabric_index.is_none() {
return Err(Status::InvalidCommand);
}
let challenge = ctx.attestation_challenge.ok_or(Status::UnsupportedAccess)?;
if let Some(previous) = self.pending_csr.take() {
let _ = self.keys.borrow_mut().remove(previous.key);
}
let (key, public) = self
.keys
.borrow_mut()
.generate(crate::crypto::KeyPurpose::Operational, random)
.map_err(|_| Status::Failure)?;
let mut csr_buf = [0u8; attestation::nocsr::MAX_CSR_LEN];
let csr = crate::attestation::nocsr::build_csr(&*self.keys.borrow(), key, &mut csr_buf)
.map_err(|_| Status::Failure)?;
let elements = crate::attestation::nocsr::NocsrElements::new(csr, *nonce);
let mut elements_buf = [0u8; RESP_MAX];
let encoded = elements
.encode(&mut elements_buf)
.map_err(|_| Status::Failure)?;
let signature = crate::attestation::nocsr::sign_nocsr(
&*self.keys.borrow(),
self.attestation.dac_key,
encoded,
challenge,
)
.map_err(|_| Status::Failure)?;
self.pending_csr.set(Some(PendingCsr {
session: ctx.session,
key,
public,
for_update,
}));
self.fail_safe
.borrow_mut()
.record(ctx.now, |p| p.csr_requested = true)
.map_err(|_| Status::FailsafeRequired)?;
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
full(w.start_structure(tag))?;
full(w.octets(Tag::Context(0), encoded))?;
full(w.octets(Tag::Context(1), signature.as_bytes()))?;
full(w.end_container())
}
pub fn add_trusted_root(
&self,
rcac: &[u8],
ctx: &InteractionContext<'_>,
) -> Result<(), Status> {
let progress = self.require_fail_safe(ctx.now)?;
if progress.added_trusted_root {
return Err(Status::ConstraintError);
}
if progress.added_noc || progress.updated_noc {
return Err(Status::ConstraintError);
}
let parsed = MatterCertificate::decode(rcac).map_err(|_| Status::InvalidCommand)?;
parsed
.validate_as(crate::cert::CertType::Rcac)
.map_err(|_| Status::InvalidCommand)?;
if !crate::cert::verify_self_signed(&parsed).unwrap_or(false) {
return Err(Status::InvalidCommand);
}
let stored = heapless::Vec::from_slice(rcac).map_err(|_| Status::ResourceExhausted)?;
*self.pending_root.borrow_mut() = Some(stored);
self.fail_safe
.borrow_mut()
.record(ctx.now, |p| p.added_trusted_root = true)
.map_err(|_| Status::FailsafeRequired)?;
Ok(())
}
}
#[derive(Debug, Clone, Copy)]
pub struct AddNocRequest<'a> {
pub noc: &'a [u8],
pub icac: Option<&'a [u8]>,
pub ipk: [u8; crate::crypto::SYMMETRIC_KEY_LENGTH_BYTES],
pub case_admin_subject: u64,
pub admin_vendor_id: VendorId,
}
impl<C: Config, K: KeyStore, R: Rng, const N: usize> OperationalCredentials<'_, C, K, R, N> {
pub fn add_noc(
&self,
request: &AddNocRequest<'_>,
ctx: &InteractionContext<'_>,
) -> Result<NocStatus, Status> {
let progress = self.require_fail_safe(ctx.now)?;
if progress.added_noc || progress.updated_noc {
return Err(Status::ConstraintError);
}
let Some(pending) = self.pending_csr.get() else {
return Ok(NocStatus::MissingCsr);
};
if pending.session != ctx.session {
return Ok(NocStatus::MissingCsr);
}
if pending.for_update {
return Err(Status::ConstraintError);
}
let pending_root = self.pending_root.borrow();
let Some(rcac_bytes) = pending_root
.as_deref()
.filter(|_| progress.added_trusted_root)
else {
return Ok(NocStatus::InvalidNoc);
};
let identity = match validate_chain(request.noc, request.icac, rcac_bytes, &pending.public)
{
Ok(identity) => identity,
Err(status) => return Ok(status),
};
let mut table = self.fabrics.borrow_mut();
let compressed =
crate::fabric::compressed_fabric_id(&identity.root_public_key, identity.fabric_id)
.map_err(|_| Status::Failure)?;
if table.find_by_compressed(compressed).is_some() {
return Ok(NocStatus::FabricConflict);
}
if table.len() >= table.capacity() {
return Ok(NocStatus::TableFull);
}
if !is_case_subject(request.case_admin_subject) {
return Ok(NocStatus::InvalidAdminSubject);
}
let mut credentials = match Credentials::new(request.noc, rcac_bytes) {
Ok(credentials) => credentials,
Err(_) => return Ok(NocStatus::InvalidNoc),
};
if let Some(icac) = request.icac {
credentials = match credentials.with_icac(icac) {
Ok(credentials) => credentials,
Err(_) => return Ok(NocStatus::InvalidNoc),
};
}
let index = table.allocate_index().map_err(|_| Status::Failure)?;
let fabric = Fabric::new(
index,
FabricIdentity {
fabric_id: identity.fabric_id,
node_id: identity.node_id,
root_public_key: identity.root_public_key,
admin_vendor_id: request.admin_vendor_id,
},
&SymmetricKey::new(request.ipk),
pending.key,
credentials,
);
let Ok(fabric) = fabric else {
return Ok(NocStatus::InvalidNoc);
};
if table.insert(fabric).is_err() {
return Ok(NocStatus::FabricConflict);
}
drop(table);
drop(pending_root);
self.pending_csr.set(None);
*self.pending_root.borrow_mut() = None;
let mut fail_safe = self.fail_safe.borrow_mut();
fail_safe
.record(ctx.now, |p| p.added_noc = true)
.map_err(|_| Status::FailsafeRequired)?;
fail_safe
.adopt_fabric(index, ctx.now)
.map_err(|_| Status::FailsafeRequired)?;
drop(fail_safe);
self.change.set(Some(FabricChange::Added {
index,
case_admin_subject: request.case_admin_subject,
bind_pase_session: ctx.fabric_index.is_none(),
}));
Ok(NocStatus::Ok)
}
pub fn update_noc(
&self,
noc: &[u8],
icac: Option<&[u8]>,
ctx: &InteractionContext<'_>,
) -> Result<NocStatus, Status> {
let progress = self.require_fail_safe(ctx.now)?;
if progress.added_noc || progress.updated_noc {
return Err(Status::ConstraintError);
}
if progress.added_trusted_root {
return Err(Status::ConstraintError);
}
let Some(pending) = self.pending_csr.get() else {
return Ok(NocStatus::MissingCsr);
};
if pending.session != ctx.session {
return Ok(NocStatus::MissingCsr);
}
if !pending.for_update {
return Err(Status::ConstraintError);
}
let accessing = ctx.fabric_index.ok_or(Status::UnsupportedAccess)?;
let mut table = self.fabrics.borrow_mut();
let Some(existing) = table.find(accessing) else {
return Ok(NocStatus::InvalidFabricIndex);
};
let rcac = existing.credentials.rcac.clone();
let existing_fabric_id = existing.fabric_id;
let identity = match validate_chain(noc, icac, &rcac, &pending.public) {
Ok(identity) => identity,
Err(status) => return Ok(status),
};
if identity.fabric_id != existing_fabric_id {
return Ok(NocStatus::InvalidNoc);
}
let mut credentials = match Credentials::new(noc, &rcac) {
Ok(credentials) => credentials,
Err(_) => return Ok(NocStatus::InvalidNoc),
};
if let Some(icac) = icac {
credentials = match credentials.with_icac(icac) {
Ok(credentials) => credentials,
Err(_) => return Ok(NocStatus::InvalidNoc),
};
}
let Some(fabric) = table.find_mut(accessing) else {
return Ok(NocStatus::InvalidFabricIndex);
};
let previous_key = fabric.operational_key;
fabric.node_id = identity.node_id;
fabric.credentials = credentials;
fabric.operational_key = pending.key;
drop(table);
let _ = self.keys.borrow_mut().remove(previous_key);
self.pending_csr.set(None);
self.fail_safe
.borrow_mut()
.record(ctx.now, |p| p.updated_noc = true)
.map_err(|_| Status::FailsafeRequired)?;
self.change
.set(Some(FabricChange::Updated { index: accessing }));
Ok(NocStatus::Ok)
}
pub fn update_fabric_label(
&self,
label: &str,
ctx: &InteractionContext<'_>,
) -> Result<NocStatus, Status> {
let accessing = ctx.fabric_index.ok_or(Status::UnsupportedAccess)?;
let mut table = self.fabrics.borrow_mut();
if table
.iter()
.any(|f| f.index != accessing && f.label.as_str() == label && !label.is_empty())
{
return Ok(NocStatus::LabelConflict);
}
let Some(fabric) = table.find_mut(accessing) else {
return Ok(NocStatus::InvalidFabricIndex);
};
fabric
.set_label(label)
.map_err(|_| Status::ConstraintError)?;
Ok(NocStatus::Ok)
}
pub fn remove_fabric(
&self,
index: FabricIndex,
ctx: &InteractionContext<'_>,
) -> Result<NocStatus, Status> {
let mut table = self.fabrics.borrow_mut();
let Some(removed) = table.remove(index) else {
return Ok(NocStatus::InvalidFabricIndex);
};
let was_last = table.is_empty();
drop(table);
let _ = self.keys.borrow_mut().remove(removed.operational_key);
self.change.set(Some(FabricChange::Removed {
index,
was_last,
was_accessing: ctx.fabric_index == Some(index),
}));
Ok(NocStatus::Ok)
}
pub fn set_vid_verification_statement(
&self,
vendor_id: Option<VendorId>,
statement: Option<&[u8]>,
vvsc: Option<&[u8]>,
ctx: &InteractionContext<'_>,
) -> Result<(), Status> {
if vendor_id.is_none() && statement.is_none() && vvsc.is_none() {
return Err(Status::InvalidCommand);
}
let accessing = ctx.fabric_index.ok_or(Status::UnsupportedAccess)?;
let mut table = self.fabrics.borrow_mut();
let Some(fabric) = table.find_mut(accessing) else {
return Err(Status::ConstraintError);
};
if let Some(statement) = statement {
match statement.len() {
0 => fabric.vid_verification_statement = None,
VID_VERIFICATION_STATEMENT_LEN => {
let mut value = [0u8; VID_VERIFICATION_STATEMENT_LEN];
value.copy_from_slice(statement);
fabric.vid_verification_statement = Some(value);
}
_ => return Err(Status::ConstraintError),
}
}
if let Some(vvsc) = vvsc {
fabric
.credentials
.set_vvsc(vvsc)
.map_err(|_| Status::InvalidCommand)?;
}
if let Some(vendor_id) = vendor_id {
fabric.admin_vendor_id = vendor_id;
}
Ok(())
}
pub fn sign_vid_verification(
&self,
index: FabricIndex,
client_challenge: &[u8; 32],
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let challenge = ctx.attestation_challenge.ok_or(Status::UnsupportedAccess)?;
let table = self.fabrics.borrow();
let fabric = table.find(index).ok_or(Status::ConstraintError)?;
let mut tbs_buf = [0u8; VENDOR_ID_VERIFICATION_TBS_MAX];
let tbs = fabric.vendor_id_verification_tbs(&mut tbs_buf, client_challenge, challenge);
let signature = self
.keys
.borrow()
.sign(fabric.operational_key, tbs)
.map_err(|_| Status::Failure)?;
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
full(w.start_structure(tag))?;
full(w.unsigned(Tag::Context(0), u64::from(index.0)))?;
full(w.unsigned(
Tag::Context(1),
u64::from(crate::fabric::FABRIC_BINDING_VERSION),
))?;
full(w.octets(Tag::Context(2), signature.as_bytes()))?;
full(w.end_container())
}
}
fn is_case_subject(subject: u64) -> bool {
let node = NodeId(subject);
matches!(
node.kind(),
crate::msg::NodeIdKind::Operational | crate::msg::NodeIdKind::CaseAuthenticatedTag
)
}
struct ChainIdentity {
fabric_id: crate::msg::FabricId,
node_id: NodeId,
root_public_key: PublicKey,
}
fn validate_chain(
noc: &[u8],
icac: Option<&[u8]>,
rcac: &[u8],
expected_public_key: &PublicKey,
) -> Result<ChainIdentity, NocStatus> {
let noc_cert = MatterCertificate::decode(noc).map_err(|_| NocStatus::InvalidNoc)?;
let icac_cert = match icac {
Some(bytes) => Some(MatterCertificate::decode(bytes).map_err(|_| NocStatus::InvalidNoc)?),
None => None,
};
let root = MatterCertificate::decode(rcac).map_err(|_| NocStatus::InvalidNoc)?;
let node_id = noc_cert.node_id().ok_or(NocStatus::InvalidNodeOpId)?;
if !node_id.is_operational() {
return Err(NocStatus::InvalidNodeOpId);
}
let verified = crate::cert::verify_chain(&noc_cert, icac_cert.as_ref(), &root, None)
.map_err(|_| NocStatus::InvalidNoc)?;
if noc_cert.public_key.as_bytes() != expected_public_key.as_bytes() {
return Err(NocStatus::InvalidPublicKey);
}
Ok(ChainIdentity {
fabric_id: verified.fabric_id,
node_id,
root_public_key: root.public_key,
})
}
pub const FABRIC_INDEX_FIELD: u8 = 254;
impl<C: Config, K: KeyStore, R: Rng, const N: usize> OperationalCredentials<'_, C, K, R, N> {
fn visible(ctx: &InteractionContext<'_>, index: FabricIndex) -> bool {
!ctx.fabric_filtered || ctx.fabric_index == Some(index)
}
fn write_nocs(
&self,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
let table = self.fabrics.borrow();
full(w.start_array(tag))?;
for fabric in table.iter().filter(|f| Self::visible(ctx, f.index)) {
let credentials = &fabric.credentials;
full(w.start_structure(Tag::Anonymous))?;
full(w.octets(Tag::Context(1), &credentials.noc))?;
match &credentials.icac {
Some(icac) => full(w.octets(Tag::Context(2), icac))?,
None => full(w.null(Tag::Context(2)))?,
}
if let Some(vvsc) = &credentials.vvsc {
full(w.octets(Tag::Context(3), vvsc))?;
}
full(w.unsigned(Tag::Context(FABRIC_INDEX_FIELD), u64::from(fabric.index.0)))?;
full(w.end_container())?;
}
full(w.end_container())
}
fn write_fabrics(
&self,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
let table = self.fabrics.borrow();
full(w.start_array(tag))?;
for fabric in table.iter().filter(|f| Self::visible(ctx, f.index)) {
full(w.start_structure(Tag::Anonymous))?;
full(w.octets(Tag::Context(1), fabric.root_public_key.as_bytes()))?;
full(w.unsigned(Tag::Context(2), u64::from(fabric.admin_vendor_id.0)))?;
full(w.unsigned(Tag::Context(3), fabric.fabric_id.0))?;
full(w.unsigned(Tag::Context(4), fabric.node_id.0))?;
full(w.utf8(Tag::Context(5), fabric.label.as_str()))?;
if let Some(statement) = &fabric.vid_verification_statement {
full(w.octets(Tag::Context(6), statement))?;
}
full(w.unsigned(Tag::Context(FABRIC_INDEX_FIELD), u64::from(fabric.index.0)))?;
full(w.end_container())?;
}
full(w.end_container())
}
fn write_roots(
&self,
w: &mut TlvWriter<'_>,
tag: Tag,
now: crate::platform::Instant,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
let table = self.fabrics.borrow();
full(w.start_array(tag))?;
for fabric in table.iter() {
full(w.octets(Tag::Anonymous, &fabric.credentials.rcac))?;
}
if self
.fail_safe
.borrow()
.armed(now)
.is_some_and(|armed| armed.progress.added_trusted_root)
&& let Some(pending) = self.pending_root.borrow().as_ref()
{
full(w.octets(Tag::Anonymous, pending))?;
}
full(w.end_container())
}
}
impl<C: Config, K: KeyStore, R: Rng, const N: usize> ClusterHandler
for OperationalCredentials<'_, C, K, R, N>
{
fn read(
&self,
resolved: &Resolved<'_>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
match resolved.attribute {
NOCS => self.write_nocs(ctx, w, tag),
FABRICS => self.write_fabrics(ctx, w, tag),
SUPPORTED_FABRICS => {
let capacity = u8::try_from(self.fabrics.borrow().capacity()).unwrap_or(u8::MAX);
full(w.unsigned(tag, u64::from(capacity)))
}
COMMISSIONED_FABRICS => {
let len = u8::try_from(self.fabrics.borrow().len()).unwrap_or(u8::MAX);
full(w.unsigned(tag, u64::from(len)))
}
TRUSTED_ROOT_CERTIFICATES => self.write_roots(w, tag, ctx.now),
CURRENT_FABRIC_INDEX => {
full(w.unsigned(tag, u64::from(ctx.fabric_index.unwrap_or(FabricIndex(0)).0)))
}
_ => Err(Status::UnsupportedAttribute),
}
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
self.run(resolved.command.id, fields, ctx, w, tag)
.map_err(StatusIb::from)
}
}
impl<C: Config, K: KeyStore, R: Rng, const N: usize> Cluster
for OperationalCredentials<'_, C, K, R, N>
{
const ID: ClusterId = ID;
}
fn walk_fields<'a>(
fields: Option<&'a [u8]>,
mut on_field: impl FnMut(u8, &crate::tlv::Element<'a>) -> Result<bool, Status>,
) -> Result<(), Status> {
let fields = fields.ok_or(Status::InvalidCommand)?;
let mut reader = TlvReader::new_in(fields, ContainerKind::Structure);
let element = reader
.next_element()
.map_err(|_| Status::InvalidCommand)?
.ok_or(Status::InvalidCommand)?;
if element.value.container() != Some(ContainerKind::Structure) {
return Err(Status::InvalidCommand);
}
let start_depth = reader.depth();
loop {
let Some(field) = reader.next_element().map_err(|_| Status::InvalidCommand)? else {
return Err(Status::InvalidCommand);
};
if reader.depth() < start_depth {
break;
}
let number = match field.tag {
Tag::Context(number) => number,
_ => {
reader
.skip_value(&field)
.map_err(|_| Status::InvalidCommand)?;
continue;
}
};
if !on_field(number, &field)? {
reader
.skip_value(&field)
.map_err(|_| Status::InvalidCommand)?;
}
}
Ok(())
}
fn decode_nonce<const L: usize>(element: &crate::tlv::Element<'_>) -> Result<[u8; L], Status> {
let bytes = element.octets().map_err(|_| Status::InvalidCommand)?;
let mut out = [0u8; L];
if bytes.len() != L {
return Err(Status::InvalidCommand);
}
out.copy_from_slice(bytes);
Ok(out)
}
impl<C: Config, K: KeyStore, R: Rng, const N: usize> OperationalCredentials<'_, C, K, R, N> {
fn noc_response(
status: NocStatus,
index: Option<FabricIndex>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
full(w.start_structure(tag))?;
full(w.unsigned(Tag::Context(0), u64::from(status.value())))?;
if status.is_ok()
&& let Some(index) = index
{
full(w.unsigned(Tag::Context(1), u64::from(index.0)))?;
}
full(w.end_container())
}
}
impl<C: Config, K: KeyStore, R: Rng, const N: usize> OperationalCredentials<'_, C, K, R, N> {
pub fn run(
&self,
command: CommandId,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<Option<CommandId>, Status> {
self.reap(ctx.now);
match command {
ATTESTATION_REQUEST => {
let mut nonce = None;
walk_fields(fields, |number, element| match number {
0 => {
set_once(
&mut nonce,
decode_nonce::<{ attestation::ATTESTATION_NONCE_LEN }>(element)?,
)
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
}
_ => Ok(false),
})?;
let nonce = nonce.ok_or(Status::InvalidCommand)?;
let challenge = ctx.attestation_challenge.ok_or(Status::UnsupportedAccess)?;
self.attestation_response(&nonce, 0, challenge, w, tag)?;
Ok(Some(ATTESTATION_RESPONSE))
}
CERTIFICATE_CHAIN_REQUEST => {
let mut kind = None;
walk_fields(fields, |number, element| match number {
0 => {
let value = element.unsigned().map_err(|_| Status::InvalidCommand)?;
let value = u8::try_from(value).map_err(|_| Status::InvalidCommand)?;
let kind_value = CertificateChainType::from_value(value)
.ok_or(Status::InvalidCommand)?;
set_once(&mut kind, kind_value).map_err(|_| Status::InvalidCommand)?;
Ok(true)
}
_ => Ok(false),
})?;
let certificate = match kind.ok_or(Status::InvalidCommand)? {
CertificateChainType::Dac => self.attestation.dac,
CertificateChainType::Pai => self.attestation.pai,
};
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
full(w.start_structure(tag))?;
full(w.octets(Tag::Context(0), certificate))?;
full(w.end_container())?;
Ok(Some(CERTIFICATE_CHAIN_RESPONSE))
}
CSR_REQUEST => {
let mut nonce = None;
let mut for_update = None;
walk_fields(fields, |number, element| match number {
0 => {
set_once(
&mut nonce,
decode_nonce::<{ attestation::CSR_NONCE_LEN }>(element)?,
)
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
}
1 => {
let value = element.bool().map_err(|_| Status::InvalidCommand)?;
set_once(&mut for_update, value).map_err(|_| Status::InvalidCommand)?;
Ok(true)
}
_ => Ok(false),
})?;
let nonce = nonce.ok_or(Status::InvalidCommand)?;
let mut random = [0u8; 32];
self.rng
.borrow_mut()
.fill(&mut random)
.map_err(|_| Status::Failure)?;
self.csr_response(&nonce, for_update.unwrap_or(false), ctx, &random, w, tag)?;
Ok(Some(CSR_RESPONSE))
}
ADD_NOC => {
let mut noc = None;
let mut icac = None;
let mut ipk = None;
let mut subject = None;
let mut vendor = None;
walk_fields(fields, |number, element| {
match number {
0 => set_once(
&mut noc,
element.octets().map_err(|_| Status::InvalidCommand)?,
),
1 => set_once(
&mut icac,
element.octets().map_err(|_| Status::InvalidCommand)?,
),
2 => set_once(
&mut ipk,
decode_nonce::<{ crate::crypto::SYMMETRIC_KEY_LENGTH_BYTES }>(element)?,
),
3 => set_once(
&mut subject,
element.unsigned().map_err(|_| Status::InvalidCommand)?,
),
4 => {
let value = element.unsigned().map_err(|_| Status::InvalidCommand)?;
let value =
u16::try_from(value).map_err(|_| Status::ConstraintError)?;
set_once(&mut vendor, VendorId(value))
}
_ => return Ok(false),
}
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
})?;
let request = AddNocRequest {
noc: noc.ok_or(Status::InvalidCommand)?,
icac,
ipk: ipk.ok_or(Status::InvalidCommand)?,
case_admin_subject: subject.ok_or(Status::InvalidCommand)?,
admin_vendor_id: vendor.ok_or(Status::InvalidCommand)?,
};
let status = self.add_noc(&request, ctx)?;
Self::noc_response(status, self.changed_index(), w, tag)?;
Ok(Some(NOC_RESPONSE))
}
UPDATE_NOC => {
let mut noc = None;
let mut icac = None;
walk_fields(fields, |number, element| {
match number {
0 => set_once(
&mut noc,
element.octets().map_err(|_| Status::InvalidCommand)?,
),
1 => set_once(
&mut icac,
element.octets().map_err(|_| Status::InvalidCommand)?,
),
_ => return Ok(false),
}
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
})?;
let status = self.update_noc(noc.ok_or(Status::InvalidCommand)?, icac, ctx)?;
Self::noc_response(status, self.changed_index(), w, tag)?;
Ok(Some(NOC_RESPONSE))
}
UPDATE_FABRIC_LABEL => {
let mut label = None;
walk_fields(fields, |number, element| match number {
0 => {
set_once(
&mut label,
element.utf8().map_err(|_| Status::InvalidCommand)?,
)
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
}
_ => Ok(false),
})?;
let status = self.update_fabric_label(label.ok_or(Status::InvalidCommand)?, ctx)?;
Self::noc_response(status, ctx.fabric_index, w, tag)?;
Ok(Some(NOC_RESPONSE))
}
REMOVE_FABRIC => {
let mut index = None;
walk_fields(fields, |number, element| match number {
0 => {
let value = element.unsigned().map_err(|_| Status::InvalidCommand)?;
let value = u8::try_from(value).map_err(|_| Status::ConstraintError)?;
set_once(&mut index, FabricIndex(value))
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
}
_ => Ok(false),
})?;
let index = index.ok_or(Status::InvalidCommand)?;
let status = self.remove_fabric(index, ctx)?;
Self::noc_response(status, Some(index), w, tag)?;
Ok(Some(NOC_RESPONSE))
}
ADD_TRUSTED_ROOT_CERTIFICATE => {
let mut rcac = None;
walk_fields(fields, |number, element| match number {
0 => {
set_once(
&mut rcac,
element.octets().map_err(|_| Status::InvalidCommand)?,
)
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
}
_ => Ok(false),
})?;
self.add_trusted_root(rcac.ok_or(Status::InvalidCommand)?, ctx)?;
Ok(None)
}
SET_VID_VERIFICATION_STATEMENT => {
let mut vendor = None;
let mut statement = None;
let mut vvsc = None;
walk_fields(fields, |number, element| {
match number {
0 => {
let value = element.unsigned().map_err(|_| Status::InvalidCommand)?;
let value =
u16::try_from(value).map_err(|_| Status::ConstraintError)?;
set_once(&mut vendor, VendorId(value))
}
1 => set_once(
&mut statement,
element.octets().map_err(|_| Status::InvalidCommand)?,
),
2 => set_once(
&mut vvsc,
element.octets().map_err(|_| Status::InvalidCommand)?,
),
_ => return Ok(false),
}
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
})?;
self.set_vid_verification_statement(vendor, statement, vvsc, ctx)?;
Ok(None)
}
SIGN_VID_VERIFICATION_REQUEST => {
let mut index = None;
let mut challenge = None;
walk_fields(fields, |number, element| {
match number {
0 => {
let value = element.unsigned().map_err(|_| Status::InvalidCommand)?;
let value = u8::try_from(value).map_err(|_| Status::ConstraintError)?;
set_once(&mut index, FabricIndex(value))
}
1 => set_once(&mut challenge, decode_nonce::<32>(element)?),
_ => return Ok(false),
}
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
})?;
self.sign_vid_verification(
index.ok_or(Status::InvalidCommand)?,
&challenge.ok_or(Status::InvalidCommand)?,
ctx,
w,
tag,
)?;
Ok(Some(SIGN_VID_VERIFICATION_RESPONSE))
}
_ => Err(Status::UnsupportedCommand),
}
}
fn changed_index(&self) -> Option<FabricIndex> {
match self.change.get()? {
FabricChange::Added { index, .. }
| FabricChange::Updated { index }
| FabricChange::Removed { index, .. } => Some(index),
}
}
}