use core::cell::RefCell;
use crate::commissioning::window::{
CommissioningWindow, EphemeralVerifier, OpenWindow, PAKE_VERIFIER_LEN, WindowStatus,
};
use crate::crypto::Spake2pVerifierData;
use crate::dm::access::{Access, AccessQualities, Privilege};
use crate::dm::meta::{AttributeDescriptor, ClusterDescriptor, CommandDescriptor};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{
AttributeId, ClusterHandler, ClusterId, CommandId, InteractionContext, Status, StatusIb,
};
use crate::msg::{FabricIndex, VendorId};
use crate::platform::{Duration, Instant};
use crate::sc::PbkdfParameters;
use crate::tlv::{ContainerKind, Tag, TlvReader, TlvWriter, set_once};
use super::Cluster;
pub const ID: ClusterId = 0x003C;
pub const REVISION: u16 = 1;
pub const FEATURE_BASIC: u32 = 1 << 0;
pub const WINDOW_STATUS: AttributeId = 0x0000;
pub const ADMIN_FABRIC_INDEX: AttributeId = 0x0001;
pub const ADMIN_VENDOR_ID: AttributeId = 0x0002;
pub const OPEN_COMMISSIONING_WINDOW: CommandId = 0x00;
pub const OPEN_BASIC_COMMISSIONING_WINDOW: CommandId = 0x01;
pub const REVOKE_COMMISSIONING: CommandId = 0x02;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum AdminStatus {
Busy = 0x02,
PakeParameterError = 0x03,
WindowNotOpen = 0x04,
}
impl AdminStatus {
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
#[must_use]
pub const fn as_status(self) -> StatusIb {
StatusIb::cluster_failure(self.value())
}
}
pub const COMMISSIONING_TIMEOUT_MIN_SECONDS: u16 = 180;
pub const COMMISSIONING_TIMEOUT_MAX_SECONDS: u16 = 900;
const ATTRIBUTES: &[AttributeDescriptor] = &[
AttributeDescriptor::read_only(WINDOW_STATUS),
AttributeDescriptor::read_only(ADMIN_FABRIC_INDEX)
.with_qualities(crate::dm::meta::AttributeQualities::NULLABLE),
AttributeDescriptor::read_only(ADMIN_VENDOR_ID)
.with_qualities(crate::dm::meta::AttributeQualities::NULLABLE),
];
const fn timed_admin(id: CommandId) -> CommandDescriptor {
CommandDescriptor::new(id)
.with_access(Access::invoke(Privilege::Administer).with_qualities(AccessQualities::TIMED))
}
const ENHANCED_COMMANDS: &[CommandDescriptor] = &[
timed_admin(OPEN_COMMISSIONING_WINDOW),
timed_admin(REVOKE_COMMISSIONING),
];
const ALL_COMMANDS: &[CommandDescriptor] = &[
timed_admin(OPEN_COMMISSIONING_WINDOW),
timed_admin(OPEN_BASIC_COMMISSIONING_WINDOW),
timed_admin(REVOKE_COMMISSIONING),
];
#[must_use]
pub const fn cluster() -> ClusterDescriptor<'static> {
ClusterDescriptor {
id: ID,
revision: REVISION,
feature_map: 0,
attributes: ATTRIBUTES,
accepted_commands: ENHANCED_COMMANDS,
generated_commands: &[],
events: &[],
}
}
#[must_use]
pub const fn cluster_with_basic() -> ClusterDescriptor<'static> {
ClusterDescriptor {
id: ID,
revision: REVISION,
feature_map: FEATURE_BASIC,
attributes: ATTRIBUTES,
accepted_commands: ALL_COMMANDS,
generated_commands: &[],
events: &[],
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Revoked {
pub close_pase_sessions: bool,
pub fail_safe_cleanup: Option<crate::commissioning::failsafe::Cleanup>,
pub stop_advertising: bool,
}
pub struct AdministratorCommissioning<'a> {
pub window: &'a RefCell<CommissioningWindow>,
pub fail_safe: &'a RefCell<crate::commissioning::failsafe::FailSafe>,
pub basic_supported: bool,
vendor_of_fabric: &'a dyn Fn(FabricIndex) -> Option<VendorId>,
}
impl<'a> AdministratorCommissioning<'a> {
#[must_use]
pub fn new(
window: &'a RefCell<CommissioningWindow>,
fail_safe: &'a RefCell<crate::commissioning::failsafe::FailSafe>,
vendor_of_fabric: &'a dyn Fn(FabricIndex) -> Option<VendorId>,
) -> Self {
Self {
window,
fail_safe,
basic_supported: false,
vendor_of_fabric,
}
}
#[must_use]
pub fn with_basic(mut self) -> Self {
self.basic_supported = true;
self
}
#[must_use]
pub fn descriptor(&self) -> ClusterDescriptor<'static> {
if self.basic_supported {
cluster_with_basic()
} else {
cluster()
}
}
fn may_open(&self, ctx: &InteractionContext<'_>) -> Result<(), StatusIb> {
if self.window.borrow().open(ctx.now).is_some() {
return Err(AdminStatus::Busy.as_status());
}
if self.fail_safe.borrow().is_armed(ctx.now) {
return Err(AdminStatus::Busy.as_status());
}
Ok(())
}
pub fn open_commissioning_window(
&self,
request: &OpenWindowRequest<'_>,
ctx: &InteractionContext<'_>,
) -> Result<(), StatusIb> {
self.may_open(ctx)?;
Spake2pVerifierData::from_bytes(request.verifier)
.map_err(|_| AdminStatus::PakeParameterError.as_status())?;
let parameters = PbkdfParameters::new(request.iterations, request.salt)
.map_err(|_| AdminStatus::PakeParameterError.as_status())?;
let mut verifier = [0u8; PAKE_VERIFIER_LEN];
verifier.copy_from_slice(request.verifier);
self.install(
WindowStatus::EnhancedOpen,
request.timeout_seconds,
request.discriminator,
Some(EphemeralVerifier {
verifier,
iterations: parameters.iterations,
salt: parameters.salt,
}),
ctx,
)
}
pub fn open_basic_commissioning_window(
&self,
timeout_seconds: u16,
discriminator: u16,
ctx: &InteractionContext<'_>,
) -> Result<(), StatusIb> {
if !self.basic_supported {
return Err(Status::UnsupportedCommand.into());
}
self.may_open(ctx)?;
self.install(
WindowStatus::BasicOpen,
timeout_seconds,
discriminator,
None,
ctx,
)
}
fn install(
&self,
status: WindowStatus,
timeout_seconds: u16,
discriminator: u16,
ephemeral: Option<EphemeralVerifier>,
ctx: &InteractionContext<'_>,
) -> Result<(), StatusIb> {
if !(COMMISSIONING_TIMEOUT_MIN_SECONDS..=COMMISSIONING_TIMEOUT_MAX_SECONDS)
.contains(&timeout_seconds)
{
return Err(Status::InvalidCommand.into());
}
if discriminator > 0x0FFF {
return Err(Status::ConstraintError.into());
}
let admin_fabric = ctx.fabric_index;
let admin_vendor = admin_fabric.and_then(|fabric| (self.vendor_of_fabric)(fabric));
let expires_at = ctx
.now
.saturating_add(Duration::from_secs(u64::from(timeout_seconds)));
self.window.borrow_mut().install(OpenWindow {
status,
expires_at,
admin_fabric,
admin_vendor,
discriminator,
ephemeral,
});
Ok(())
}
pub fn revoke_commissioning(
&self,
ctx: &InteractionContext<'_>,
) -> (Revoked, Result<(), StatusIb>) {
let was_open = self.window.borrow().open(ctx.now).is_some();
self.window.borrow_mut().close();
let mut fail_safe = self.fail_safe.borrow_mut();
let pase_held = fail_safe
.armed(ctx.now)
.is_some_and(|armed| armed.fabric_index.is_none());
let cleanup = pase_held.then(|| fail_safe.expire(Instant::MAX)).flatten();
drop(fail_safe);
let revoked = Revoked {
close_pase_sessions: true,
fail_safe_cleanup: cleanup,
stop_advertising: was_open,
};
let status = if was_open {
Ok(())
} else {
Err(AdminStatus::WindowNotOpen.as_status())
};
(revoked, status)
}
}
#[derive(Debug, Clone, Copy)]
pub struct OpenWindowRequest<'a> {
pub timeout_seconds: u16,
pub verifier: &'a [u8],
pub discriminator: u16,
pub iterations: u32,
pub salt: &'a [u8],
}
impl ClusterHandler for AdministratorCommissioning<'_> {
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);
let window = self.window.borrow();
let open = window.open(ctx.now);
match resolved.attribute {
WINDOW_STATUS => full(w.unsigned(tag, u64::from(window.status(ctx.now).value()))),
ADMIN_FABRIC_INDEX => match open.and_then(|window| window.admin_fabric) {
Some(fabric) => full(w.unsigned(tag, u64::from(fabric.0))),
None => full(w.null(tag)),
},
ADMIN_VENDOR_ID => match open.and_then(|window| window.admin_vendor) {
Some(vendor) => full(w.unsigned(tag, u64::from(vendor.0))),
None => full(w.null(tag)),
},
_ => Err(Status::UnsupportedAttribute),
}
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
_w: &mut TlvWriter<'_>,
_tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
match resolved.command.id {
OPEN_COMMISSIONING_WINDOW => {
let request = decode_open_window(fields)?;
self.open_commissioning_window(&request, ctx)?;
Ok(None)
}
OPEN_BASIC_COMMISSIONING_WINDOW => {
let timeout = decode_basic_window(fields)?;
let discriminator = self
.window
.borrow()
.open(ctx.now)
.map_or(0, |window| window.discriminator);
self.open_basic_commissioning_window(timeout, discriminator, ctx)?;
Ok(None)
}
REVOKE_COMMISSIONING => {
let (_, status) = self.revoke_commissioning(ctx);
status?;
Ok(None)
}
_ => Err(Status::UnsupportedCommand.into()),
}
}
}
impl Cluster for AdministratorCommissioning<'_> {
const ID: ClusterId = ID;
}
fn walk_fields<'a>(
fields: Option<&'a [u8]>,
mut on_field: impl FnMut(u8, &crate::tlv::Element<'a>) -> Result<bool, StatusIb>,
) -> Result<(), StatusIb> {
let fields = fields.ok_or_else(|| StatusIb::new(Status::InvalidCommand))?;
let mut reader = TlvReader::new_in(fields, ContainerKind::Structure);
let element = reader
.next_element()
.map_err(|_| StatusIb::new(Status::InvalidCommand))?
.ok_or_else(|| StatusIb::new(Status::InvalidCommand))?;
if element.value.container() != Some(ContainerKind::Structure) {
return Err(Status::InvalidCommand.into());
}
let start_depth = reader.depth();
loop {
let Some(field) = reader
.next_element()
.map_err(|_| StatusIb::new(Status::InvalidCommand))?
else {
return Err(Status::InvalidCommand.into());
};
if reader.depth() < start_depth {
break;
}
let Tag::Context(number) = field.tag else {
reader
.skip_value(&field)
.map_err(|_| StatusIb::new(Status::InvalidCommand))?;
continue;
};
if !on_field(number, &field)? {
reader
.skip_value(&field)
.map_err(|_| StatusIb::new(Status::InvalidCommand))?;
}
}
Ok(())
}
fn decode_open_window(fields: Option<&[u8]>) -> Result<OpenWindowRequest<'_>, StatusIb> {
let invalid = || StatusIb::new(Status::InvalidCommand);
let mut timeout = None;
let mut verifier = None;
let mut discriminator = None;
let mut iterations = None;
let mut salt = None;
walk_fields(fields, |number, element| {
match number {
0 => {
let value = element.unsigned().map_err(|_| invalid())?;
set_once(
&mut timeout,
u16::try_from(value).map_err(|_| StatusIb::new(Status::ConstraintError))?,
)
}
1 => set_once(&mut verifier, element.octets().map_err(|_| invalid())?),
2 => {
let value = element.unsigned().map_err(|_| invalid())?;
set_once(
&mut discriminator,
u16::try_from(value).map_err(|_| StatusIb::new(Status::ConstraintError))?,
)
}
3 => {
let value = element.unsigned().map_err(|_| invalid())?;
set_once(
&mut iterations,
u32::try_from(value).map_err(|_| StatusIb::new(Status::ConstraintError))?,
)
}
4 => set_once(&mut salt, element.octets().map_err(|_| invalid())?),
_ => return Ok(false),
}
.map_err(|_| invalid())?;
Ok(true)
})?;
let verifier = verifier.ok_or_else(invalid)?;
if verifier.len() != PAKE_VERIFIER_LEN {
return Err(AdminStatus::PakeParameterError.as_status());
}
Ok(OpenWindowRequest {
timeout_seconds: timeout.ok_or_else(invalid)?,
verifier,
discriminator: discriminator.ok_or_else(invalid)?,
iterations: iterations.ok_or_else(invalid)?,
salt: salt.ok_or_else(invalid)?,
})
}
fn decode_basic_window(fields: Option<&[u8]>) -> Result<u16, StatusIb> {
let invalid = || StatusIb::new(Status::InvalidCommand);
let mut timeout = None;
walk_fields(fields, |number, element| {
match number {
0 => {
let value = element.unsigned().map_err(|_| invalid())?;
set_once(
&mut timeout,
u16::try_from(value).map_err(|_| StatusIb::new(Status::ConstraintError))?,
)
.map_err(|_| invalid())?;
}
_ => return Ok(false),
}
Ok(true)
})?;
timeout.ok_or_else(invalid)
}