use core::marker::PhantomData;
use heapless::Vec;
use crate::config::{AssertValid, Config};
use crate::dm::{Node, Privilege};
use crate::error::{Error, ErrorCode, Result, bail};
use crate::im::{ClusterId, EndpointId};
use crate::msg::{CaseAuthenticatedTag, FabricIndex, NodeId};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum AuthMode {
Pase = 1,
Case = 2,
Group = 3,
}
impl AuthMode {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
1 => Some(Self::Pase),
2 => Some(Self::Case),
3 => Some(Self::Group),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Target {
pub cluster: Option<ClusterId>,
pub endpoint: Option<EndpointId>,
pub device_type: Option<u32>,
}
impl Target {
#[must_use]
pub const fn cluster(cluster: ClusterId) -> Self {
Self {
cluster: Some(cluster),
endpoint: None,
device_type: None,
}
}
#[must_use]
pub const fn endpoint(endpoint: EndpointId) -> Self {
Self {
cluster: None,
endpoint: Some(endpoint),
device_type: None,
}
}
#[must_use]
pub const fn device_type(device_type: u32) -> Self {
Self {
cluster: None,
endpoint: None,
device_type: Some(device_type),
}
}
#[must_use]
pub const fn and_cluster(mut self, cluster: ClusterId) -> Self {
self.cluster = Some(cluster);
self
}
#[must_use]
pub const fn is_valid(&self) -> bool {
let named = self.cluster.is_some() || self.endpoint.is_some() || self.device_type.is_some();
let both_places = self.endpoint.is_some() && self.device_type.is_some();
if !named || both_places {
return false;
}
if let Some(cluster) = self.cluster
&& !crate::dm::mei::cluster_is_valid(cluster)
{
return false;
}
if let Some(device_type) = self.device_type
&& !crate::dm::mei::device_type_is_valid(device_type)
{
return false;
}
if let Some(endpoint) = self.endpoint
&& endpoint == 0xFFFF
{
return false;
}
true
}
fn matches(&self, node: &Node<'_>, endpoint: EndpointId, cluster: ClusterId) -> bool {
if self.cluster.is_some_and(|wanted| wanted != cluster) {
return false;
}
if self.endpoint.is_some_and(|wanted| wanted != endpoint) {
return false;
}
if let Some(wanted) = self.device_type {
let Some(endpoint) = node.endpoint(endpoint) else {
return false;
};
if !endpoint.has_device_type(wanted) {
return false;
}
}
true
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Entry<const S: usize, const T: usize> {
pub fabric_index: FabricIndex,
pub privilege: Privilege,
pub auth_mode: AuthMode,
pub subjects: Vec<NodeId, S>,
pub targets: Vec<Target, T>,
}
impl<const S: usize, const T: usize> Entry<S, T> {
#[must_use]
pub fn case(fabric_index: FabricIndex, privilege: Privilege) -> Self {
Self {
fabric_index,
privilege,
auth_mode: AuthMode::Case,
subjects: Vec::new(),
targets: Vec::new(),
}
}
pub fn with_subject(mut self, subject: NodeId) -> Result<Self> {
self.subjects
.push(subject)
.map_err(|_| Error::new(ErrorCode::NoSpace))?;
Ok(self)
}
pub fn with_target(mut self, target: Target) -> Result<Self> {
if !target.is_valid() {
bail!(InvalidArgument)
}
self.targets
.push(target)
.map_err(|_| Error::new(ErrorCode::NoSpace))?;
Ok(self)
}
fn is_well_formed(&self) -> bool {
if matches!(self.auth_mode, AuthMode::Pase) {
return false;
}
if matches!(self.privilege, Privilege::Administer)
&& !matches!(self.auth_mode, AuthMode::Case)
{
return false;
}
if self.subjects.is_empty() && !matches!(self.auth_mode, AuthMode::Case | AuthMode::Group) {
return false;
}
if self.fabric_index.0 == 0 {
return false;
}
if !self.subjects.iter().all(|s| self.subject_is_valid(*s)) {
return false;
}
self.targets.iter().all(Target::is_valid)
}
fn subject_is_valid(&self, subject: NodeId) -> bool {
match self.auth_mode {
AuthMode::Case => match subject.kind() {
crate::msg::NodeIdKind::Operational => true,
crate::msg::NodeIdKind::CaseAuthenticatedTag => {
CaseAuthenticatedTag::from_node_id(subject).is_some_and(|cat| cat.is_valid())
}
_ => false,
},
AuthMode::Group => subject.0 != 0 && subject.0 <= u64::from(u16::MAX),
AuthMode::Pase => false,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Granted(u8);
impl Granted {
pub const NONE: Self = Self(0);
const fn bit(privilege: Privilege) -> u8 {
1u8 << (privilege as u8)
}
fn add(&mut self, privilege: Privilege) {
self.0 |= Self::bit(privilege);
match privilege {
Privilege::Operate => self.0 |= Self::bit(Privilege::View),
Privilege::Manage => {
self.0 |= Self::bit(Privilege::Operate) | Self::bit(Privilege::View);
}
Privilege::Administer => {
self.0 |= Self::bit(Privilege::Manage)
| Self::bit(Privilege::Operate)
| Self::bit(Privilege::View);
}
Privilege::ProxyView | Privilege::View => {}
}
}
#[must_use]
pub const fn has(self, privilege: Privilege) -> bool {
self.0 & Self::bit(privilege) != 0
}
#[must_use]
pub const fn is_empty(self) -> bool {
self.0 == 0
}
#[must_use]
pub const fn highest(self) -> Option<Privilege> {
if self.has(Privilege::Administer) {
Some(Privilege::Administer)
} else if self.has(Privilege::Manage) {
Some(Privilege::Manage)
} else if self.has(Privilege::Operate) {
Some(Privilege::Operate)
} else if self.has(Privilege::View) {
Some(Privilege::View)
} else {
None
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SubjectDescriptor {
pub is_commissioning: bool,
pub auth_mode: Option<AuthMode>,
pub subjects: Vec<NodeId, 4>,
pub fabric_index: FabricIndex,
}
pub const DEFAULT_COMMISSIONING_PASSCODE: u64 = 0;
impl SubjectDescriptor {
#[must_use]
pub fn unauthenticated() -> Self {
Self {
is_commissioning: false,
auth_mode: None,
subjects: Vec::new(),
fabric_index: FabricIndex(0),
}
}
#[must_use]
pub fn pase(fabric_index: FabricIndex) -> Self {
let mut subjects = Vec::new();
let _ = subjects.push(NodeId(DEFAULT_COMMISSIONING_PASSCODE));
Self {
is_commissioning: true,
auth_mode: Some(AuthMode::Pase),
subjects,
fabric_index,
}
}
#[must_use]
pub fn commissioning() -> Self {
Self::pase(FabricIndex(0))
}
#[must_use]
pub fn case(fabric_index: FabricIndex, node_id: NodeId) -> Self {
let mut subjects = Vec::new();
let _ = subjects.push(node_id);
Self {
is_commissioning: false,
auth_mode: Some(AuthMode::Case),
subjects,
fabric_index,
}
}
#[must_use]
pub fn group(fabric_index: FabricIndex, group_id: crate::msg::GroupId) -> Self {
let mut subjects = Vec::new();
let _ = subjects.push(NodeId(u64::from(group_id.0)));
Self {
is_commissioning: false,
auth_mode: Some(AuthMode::Group),
subjects,
fabric_index,
}
}
pub fn with_cat(mut self, cat: CaseAuthenticatedTag) -> Result<Self> {
self.subjects
.push(cat.to_node_id())
.map_err(|_| Error::new(ErrorCode::NoSpace))?;
Ok(self)
}
#[cfg(feature = "rustcrypto")]
#[cfg_attr(docsrs, doc(cfg(feature = "rustcrypto")))]
#[must_use]
pub fn from_session(
session: &crate::session::SecureSession,
pending_fabric: Option<FabricIndex>,
) -> Self {
match session.kind {
crate::session::SessionKind::Pase => Self::pase(session.fabric_index),
crate::session::SessionKind::Case => {
if session.fabric_index.0 == 0 {
return Self::unauthenticated();
}
let mut descriptor = Self::case(session.fabric_index, session.peer_node_id);
descriptor.is_commissioning =
pending_fabric.is_some_and(|pending| pending == session.fabric_index);
for cat in &session.peer_cats {
let _ = descriptor.subjects.push(cat.to_node_id());
}
descriptor
}
}
}
}
fn subject_matches(acl_subject: NodeId, isd_subject: NodeId) -> bool {
if acl_subject == isd_subject {
return true;
}
match (
CaseAuthenticatedTag::from_node_id(acl_subject),
CaseAuthenticatedTag::from_node_id(isd_subject),
) {
(Some(acl), Some(isd)) => {
acl.identifier() == isd.identifier() && isd.version() >= acl.version()
}
_ => false,
}
}
#[derive(Debug)]
pub struct Acl<C: Config, const N: usize = 20, const S: usize = 4, const T: usize = 3> {
entries: Vec<Entry<S, T>, N>,
_config: PhantomData<C>,
}
impl<C: Config, const N: usize, const S: usize, const T: usize> crate::config::Capacity
for Acl<C, N, S, T>
{
const TOTAL: usize = N;
const PER_FABRIC: usize = C::ACL_ENTRIES_PER_FABRIC;
}
impl<C: Config, const N: usize, const S: usize, const T: usize> Acl<C, N, S, T> {
pub const CHECK: () = {
let () = AssertValid::<C>::CHECK;
assert!(
N >= C::ACL_ENTRIES_PER_FABRIC * C::FABRICS,
"Acl: Core §2.11.1.1 promises ACL_ENTRIES_PER_FABRIC to every fabric, so the list \
must hold FABRICS × that many"
);
assert!(
S >= 4,
"Acl: §9.10.6.5 constrains SubjectsPerAccessControlEntry to 4..=65534"
);
assert!(
T >= 3,
"Acl: §9.10.6.6 constrains TargetsPerAccessControlEntry to 3..=65534"
);
};
}
impl<C: Config, const N: usize, const S: usize, const T: usize> Default for Acl<C, N, S, T> {
fn default() -> Self {
Self::new()
}
}
impl<C: Config, const N: usize, const S: usize, const T: usize> Acl<C, N, S, T> {
#[must_use]
pub fn new() -> Self {
let () = Self::CHECK;
Self {
entries: Vec::new(),
_config: PhantomData,
}
}
#[must_use]
pub fn len(&self) -> usize {
self.entries.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn entries(&self) -> impl Iterator<Item = &Entry<S, T>> {
self.entries.iter()
}
pub fn of_fabric(&self, fabric: FabricIndex) -> impl Iterator<Item = &Entry<S, T>> {
self.entries
.iter()
.filter(move |entry| entry.fabric_index == fabric)
}
#[must_use]
pub fn len_of_fabric(&self, fabric: FabricIndex) -> usize {
self.of_fabric(fabric).count()
}
pub fn add(&mut self, entry: Entry<S, T>) -> Result<()> {
if !entry.is_well_formed() {
bail!(InvalidArgument)
}
if self.len_of_fabric(entry.fabric_index) >= <Self as crate::config::Capacity>::PER_FABRIC {
bail!(NoSpace)
}
self.entries
.push(entry)
.map_err(|_| Error::new(ErrorCode::NoSpace))
}
pub fn add_admin_for_fabric(&mut self, fabric: FabricIndex, subject: NodeId) -> Result<()> {
if !matches!(
subject.kind(),
crate::msg::NodeIdKind::Operational | crate::msg::NodeIdKind::CaseAuthenticatedTag
) {
bail!(InvalidArgument)
}
let entry = Entry::<S, T>::case(fabric, Privilege::Administer).with_subject(subject)?;
self.add(entry)
}
pub fn remove_fabric(&mut self, fabric: FabricIndex) {
self.entries.retain(|entry| entry.fabric_index != fabric);
}
pub fn replace_fabric(
&mut self,
fabric: FabricIndex,
entries: impl IntoIterator<Item = Entry<S, T>>,
) -> Result<()> {
self.entries.retain(|entry| entry.fabric_index != fabric);
for entry in entries {
self.add(entry)?;
}
Ok(())
}
#[must_use]
pub fn granted(
&self,
node: &Node<'_>,
subject: &SubjectDescriptor,
endpoint: EndpointId,
cluster: ClusterId,
) -> Granted {
let mut granted = Granted::NONE;
if subject.auth_mode == Some(AuthMode::Pase) && subject.is_commissioning {
granted.add(Privilege::Administer);
}
for entry in &self.entries {
if granted.has(Privilege::Administer) {
break;
}
if entry.fabric_index.0 == 0 || entry.fabric_index != subject.fabric_index {
continue;
}
if Some(entry.auth_mode) != subject.auth_mode {
continue;
}
if !entry.subjects.is_empty() {
let matched = entry.subjects.iter().any(|acl_subject| {
subject
.subjects
.iter()
.any(|isd| subject_matches(*acl_subject, *isd))
});
if !matched {
continue;
}
}
if entry.targets.is_empty() {
if matches!(entry.auth_mode, AuthMode::Group) && C::ACL_AUXILIARY && endpoint == 0 {
continue;
}
} else {
let matched = entry
.targets
.iter()
.any(|target| target.matches(node, endpoint, cluster));
if !matched {
continue;
}
}
granted.add(entry.privilege);
}
if subject.auth_mode == Some(AuthMode::Group) && granted.has(Privilege::Administer) {
return Granted::NONE;
}
granted
}
#[must_use]
pub fn allows(
&self,
node: &Node<'_>,
subject: &SubjectDescriptor,
endpoint: EndpointId,
cluster: ClusterId,
required: Privilege,
) -> crate::im::Outcome {
if self.granted(node, subject, endpoint, cluster).has(required) {
crate::im::Outcome::Granted
} else {
crate::im::Outcome::Denied
}
}
}
#[derive(Debug)]
pub struct AclAccess<'a, C: Config, const N: usize, const S: usize, const T: usize> {
acl: &'a core::cell::RefCell<Acl<C, N, S, T>>,
node: Node<'a>,
subject: &'a SubjectDescriptor,
}
impl<'a, C: Config, const N: usize, const S: usize, const T: usize> AclAccess<'a, C, N, S, T> {
#[must_use]
pub const fn new(
acl: &'a core::cell::RefCell<Acl<C, N, S, T>>,
node: Node<'a>,
subject: &'a SubjectDescriptor,
) -> Self {
Self { acl, node, subject }
}
}
impl<C: Config, const N: usize, const S: usize, const T: usize> crate::im::AccessControl
for AclAccess<'_, C, N, S, T>
{
fn allows(&self, path: &crate::im::AttributePath, required: Privilege) -> crate::im::Outcome {
let (Some(endpoint), Some(cluster)) = (path.endpoint, path.cluster) else {
return crate::im::Outcome::Denied;
};
self.acl
.borrow()
.allows(&self.node, self.subject, endpoint, cluster, required)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::DefaultConfig;
use crate::dm::{
AttributeDescriptor, ClusterDescriptor, CommandDescriptor, DeviceType, Endpoint,
};
type TestAcl = Acl<DefaultConfig>;
type TestEntry = Entry<4, 3>;
const ATTRS: &[AttributeDescriptor] = &[AttributeDescriptor::read_only(0)];
const NO_CMDS: &[CommandDescriptor] = &[];
const fn cluster(id: ClusterId) -> ClusterDescriptor<'static> {
ClusterDescriptor {
id,
revision: 1,
feature_map: 0,
attributes: ATTRS,
accepted_commands: NO_CMDS,
generated_commands: &[],
events: &[],
}
}
const ON_OFF: ClusterId = 0x0006;
const LEVEL: ClusterId = 0x0008;
const ROOT: &[ClusterDescriptor<'static>] = &[cluster(0x001D)];
const APP: &[ClusterDescriptor<'static>] = &[cluster(ON_OFF), cluster(LEVEL)];
const LIGHT: &[DeviceType] = &[DeviceType::new(0x0100, 1)];
const ENDPOINTS: &[Endpoint<'static>] = &[
Endpoint::new(0, ROOT),
Endpoint::new(1, APP).with_device_types(LIGHT),
];
fn node() -> Node<'static> {
Node::new(ENDPOINTS)
}
const F1: FabricIndex = FabricIndex(1);
const F2: FabricIndex = FabricIndex(2);
const ALICE: NodeId = NodeId(0x0000_0000_0000_1111);
const BOB: NodeId = NodeId(0x0000_0000_0000_2222);
#[test]
fn an_empty_list_grants_nothing() {
let acl = TestAcl::new();
let subject = SubjectDescriptor::case(F1, ALICE);
assert!(acl.granted(&node(), &subject, 1, ON_OFF).is_empty());
}
#[test]
fn a_pase_commissioner_is_an_administrator_without_an_entry() {
let acl = TestAcl::new();
let granted = acl.granted(&node(), &SubjectDescriptor::commissioning(), 0, 0x001D);
assert!(granted.has(Privilege::Administer));
assert!(granted.has(Privilege::View), "and everything it subsumes");
}
#[test]
fn a_pase_session_that_is_not_commissioning_grants_nothing() {
let acl = TestAcl::new();
let mut subject = SubjectDescriptor::commissioning();
subject.is_commissioning = false;
assert!(acl.granted(&node(), &subject, 0, 0x001D).is_empty());
}
#[test]
fn an_empty_subject_list_is_a_wildcard_not_an_empty_set() {
let mut acl = TestAcl::new();
acl.add(TestEntry::case(F1, Privilege::Operate))
.expect("add");
let granted = acl.granted(&node(), &SubjectDescriptor::case(F1, ALICE), 1, ON_OFF);
assert!(granted.has(Privilege::Operate));
assert!(granted.has(Privilege::View), "Operate subsumes View");
assert!(!granted.has(Privilege::Manage));
}
#[test]
fn a_named_subject_excludes_every_other() {
let mut acl = TestAcl::new();
acl.add(
TestEntry::case(F1, Privilege::Manage)
.with_subject(ALICE)
.expect("subject"),
)
.expect("add");
assert!(
acl.granted(&node(), &SubjectDescriptor::case(F1, ALICE), 1, ON_OFF)
.has(Privilege::Manage)
);
assert!(
acl.granted(&node(), &SubjectDescriptor::case(F1, BOB), 1, ON_OFF)
.is_empty()
);
}
#[test]
fn another_fabrics_entry_is_invisible() {
let mut acl = TestAcl::new();
acl.add(TestEntry::case(F2, Privilege::Administer))
.expect("add");
assert!(
acl.granted(&node(), &SubjectDescriptor::case(F1, ALICE), 1, ON_OFF)
.is_empty()
);
assert!(
acl.granted(&node(), &SubjectDescriptor::case(F2, ALICE), 1, ON_OFF)
.has(Privilege::Administer)
);
}
#[test]
fn an_auth_mode_never_subsumes_another() {
let mut acl = TestAcl::new();
acl.add(TestEntry::case(F1, Privilege::Operate))
.expect("add");
let mut group = SubjectDescriptor::case(F1, ALICE);
group.auth_mode = Some(AuthMode::Group);
assert!(acl.granted(&node(), &group, 1, ON_OFF).is_empty());
}
#[test]
fn a_target_narrows_to_one_cluster() {
let mut acl = TestAcl::new();
acl.add(
TestEntry::case(F1, Privilege::Operate)
.with_target(Target::cluster(ON_OFF))
.expect("target"),
)
.expect("add");
let subject = SubjectDescriptor::case(F1, ALICE);
assert!(
acl.granted(&node(), &subject, 1, ON_OFF)
.has(Privilege::Operate)
);
assert!(acl.granted(&node(), &subject, 1, LEVEL).is_empty());
}
#[test]
fn a_target_may_name_an_endpoint_by_its_device_type() {
let mut acl = TestAcl::new();
acl.add(
TestEntry::case(F1, Privilege::Operate)
.with_target(Target::device_type(0x0100))
.expect("target"),
)
.expect("add");
let subject = SubjectDescriptor::case(F1, ALICE);
assert!(
acl.granted(&node(), &subject, 1, ON_OFF)
.has(Privilege::Operate),
"endpoint 1 is an On/Off Light"
);
assert!(
acl.granted(&node(), &subject, 0, 0x001D).is_empty(),
"endpoint 0 is not"
);
}
#[test]
fn a_cat_matches_at_or_above_the_entrys_version() {
let tag = CaseAuthenticatedTag::new(0xABCD, 3);
let mut acl = TestAcl::new();
acl.add(
TestEntry::case(F1, Privilege::Manage)
.with_subject(tag.to_node_id())
.expect("subject"),
)
.expect("add");
for (version, expected) in [(2u16, false), (3, true), (4, true)] {
let subject = SubjectDescriptor::case(F1, ALICE)
.with_cat(CaseAuthenticatedTag::new(0xABCD, version))
.expect("cat");
assert_eq!(
acl.granted(&node(), &subject, 1, ON_OFF)
.has(Privilege::Manage),
expected,
"version {version} against an entry naming 3"
);
}
}
#[test]
fn a_cat_with_another_identifier_never_matches() {
let mut acl = TestAcl::new();
acl.add(
TestEntry::case(F1, Privilege::Manage)
.with_subject(CaseAuthenticatedTag::new(0xABCD, 1).to_node_id())
.expect("subject"),
)
.expect("add");
let subject = SubjectDescriptor::case(F1, ALICE)
.with_cat(CaseAuthenticatedTag::new(0x1234, 9))
.expect("cat");
assert!(acl.granted(&node(), &subject, 1, ON_OFF).is_empty());
}
#[test]
fn a_pase_entry_cannot_be_written() {
let mut acl = TestAcl::new();
let mut entry = TestEntry::case(F1, Privilege::Administer);
entry.auth_mode = AuthMode::Pase;
assert_eq!(
acl.add(entry).map_err(|e| e.code()),
Err(ErrorCode::InvalidArgument)
);
}
#[test]
fn a_group_entry_may_not_administer() {
let mut acl = TestAcl::new();
let mut entry = TestEntry::case(F1, Privilege::Administer);
entry.auth_mode = AuthMode::Group;
assert_eq!(
acl.add(entry).map_err(|e| e.code()),
Err(ErrorCode::InvalidArgument)
);
}
#[test]
fn a_target_naming_both_an_endpoint_and_a_device_type_is_refused() {
let target = Target {
cluster: None,
endpoint: Some(1),
device_type: Some(0x0100),
};
assert!(!target.is_valid());
assert!(
TestEntry::case(F1, Privilege::View)
.with_target(target)
.is_err()
);
}
#[test]
fn an_empty_target_is_refused() {
assert!(!Target::default().is_valid());
}
#[test]
fn proxy_view_is_not_subsumed_by_anything() {
let mut acl = TestAcl::new();
acl.add(TestEntry::case(F1, Privilege::Administer))
.expect("add");
let granted = acl.granted(&node(), &SubjectDescriptor::case(F1, ALICE), 1, ON_OFF);
assert!(granted.has(Privilege::Administer));
assert!(granted.has(Privilege::View));
assert!(
!granted.has(Privilege::ProxyView),
"ProxyView is not in the chain"
);
}
#[test]
fn removing_a_fabric_takes_its_entries() {
let mut acl = TestAcl::new();
acl.add(TestEntry::case(F1, Privilege::Operate))
.expect("add");
acl.add(TestEntry::case(F2, Privilege::Operate))
.expect("add");
acl.remove_fabric(F1);
assert_eq!(acl.len(), 1);
assert!(
acl.granted(&node(), &SubjectDescriptor::case(F1, ALICE), 1, ON_OFF)
.is_empty()
);
assert!(
acl.granted(&node(), &SubjectDescriptor::case(F2, ALICE), 1, ON_OFF)
.has(Privilege::Operate)
);
}
#[test]
fn the_add_noc_administrator_entry_has_the_shape_11_18_6_8_fixes() {
let mut acl = TestAcl::new();
acl.add_admin_for_fabric(F1, ALICE).expect("bootstrap");
let entry = acl.of_fabric(F1).next().expect("one entry");
assert_eq!(entry.privilege, Privilege::Administer);
assert_eq!(entry.auth_mode, AuthMode::Case);
assert_eq!(entry.subjects.as_slice(), &[ALICE]);
assert!(
entry.targets.is_empty(),
"Targets: [] means the entire node"
);
let subject = SubjectDescriptor::case(F1, ALICE);
assert!(
acl.granted(&node(), &subject, 0, 0x001D)
.has(Privilege::Administer)
);
}
#[test]
fn a_target_naming_an_identifier_that_cannot_exist_is_refused() {
for bad in [
Target {
cluster: Some(0xFFFF_FFFF),
..Target::default()
},
Target {
cluster: Some(0x0000_8000),
..Target::default()
},
Target {
device_type: Some(0xFFFF_FFFF),
..Target::default()
},
Target {
device_type: Some(0x0000_C000),
..Target::default()
},
Target {
endpoint: Some(0xFFFF),
..Target::default()
},
] {
assert!(!bad.is_valid(), "{bad:?} was accepted");
let entry = TestEntry::case(F1, Privilege::Operate)
.with_target(bad)
.map_err(|e| e.code());
assert_eq!(entry.err(), Some(ErrorCode::InvalidArgument));
}
for good in [
Target {
cluster: Some(0x0000_0006),
..Target::default()
},
Target {
cluster: Some(0xFFF1_FC00),
..Target::default()
},
Target {
endpoint: Some(1),
..Target::default()
},
Target {
device_type: Some(0x0000_0100),
..Target::default()
},
] {
assert!(good.is_valid(), "{good:?} was refused");
}
}
#[test]
fn a_subject_outside_its_auth_modes_shape_is_refused() {
for bad in [
NodeId(0),
NodeId(0xFFFF_FFFF_FFFF_FFFF),
NodeId(0xFFFF_FFFF_FFFF_0000),
NodeId(0xFFFF_FFFD_0000_0000),
NodeId(0xFFFF_FFFD_ABCD_0000),
NodeId(0xFFFF_FFFB_0000_0001),
NodeId(0xFFFF_FFFE_0000_0001),
] {
let mut acl = TestAcl::new();
let entry = TestEntry::case(F1, Privilege::Operate)
.with_subject(bad)
.expect("the list has room");
assert_eq!(
acl.add(entry).map_err(|e| e.code()),
Err(ErrorCode::InvalidArgument),
"{bad:?} was accepted as a CASE subject"
);
}
for good in [ALICE, CaseAuthenticatedTag::new(0xABCD, 2).to_node_id()] {
let mut acl = TestAcl::new();
let entry = TestEntry::case(F1, Privilege::Operate)
.with_subject(good)
.expect("the list has room");
acl.add(entry).expect("a legal CASE subject");
}
}
#[test]
fn a_group_subject_is_a_group_id_and_nothing_else() {
let mut acl = TestAcl::new();
let mut entry = TestEntry::case(F1, Privilege::Operate);
entry.auth_mode = AuthMode::Group;
for bad in [NodeId(0), NodeId(0x0001_0000), NodeId(0x1234_5678)] {
let candidate = entry.clone().with_subject(bad).expect("the list has room");
assert_eq!(
acl.add(candidate).map_err(|e| e.code()),
Err(ErrorCode::InvalidArgument),
"{bad:?} was accepted as a Group subject"
);
}
let good = entry.with_subject(NodeId(0x1234)).expect("room");
acl.add(good).expect("a group id is a group subject");
}
#[test]
fn a_case_admin_subject_outside_the_two_legal_ranges_is_refused() {
let mut acl = TestAcl::new();
for bad in [NodeId(0), NodeId(0xFFFF_FFFF_FFFF_0001)] {
assert_eq!(
acl.add_admin_for_fabric(F1, bad).map_err(|e| e.code()),
Err(ErrorCode::InvalidArgument),
"{bad:?}"
);
}
acl.add_admin_for_fabric(F1, CaseAuthenticatedTag::new(0xFFF1, 1).to_node_id())
.expect("a CAT is a valid admin subject");
}
#[test]
fn administer_requires_case_whichever_way_it_is_asked_for() {
let mut acl = TestAcl::new();
for mode in [AuthMode::Group, AuthMode::Pase] {
let mut entry = TestEntry::case(F1, Privilege::Administer);
entry.auth_mode = mode;
assert_eq!(
acl.add(entry).map_err(|e| e.code()),
Err(ErrorCode::InvalidArgument),
"{mode:?} at Administer"
);
}
for privilege in [Privilege::View, Privilege::Operate, Privilege::Manage] {
let mut entry = TestEntry::case(F1, privilege);
entry.auth_mode = AuthMode::Group;
acl.add(entry)
.expect("a group entry below Administer is legal");
}
}
#[test]
fn a_fabrics_quota_is_its_own() {
let mut acl = TestAcl::new();
for _ in 0..DefaultConfig::ACL_ENTRIES_PER_FABRIC {
acl.add(TestEntry::case(F1, Privilege::View)).expect("fits");
}
assert_eq!(
acl.add(TestEntry::case(F1, Privilege::View))
.map_err(|e| e.code()),
Err(ErrorCode::NoSpace)
);
acl.add(TestEntry::case(F2, Privilege::View))
.expect("another fabric has its own quota");
}
#[cfg(feature = "rustcrypto")]
fn session(kind: crate::session::SessionKind) -> crate::session::SecureSession {
use crate::msg::SessionId;
use crate::platform::Instant;
use crate::session::{EstablishedKeys, Role, SecureSession};
SecureSession::new(
SessionId(1),
SessionId(2),
kind,
Role::Responder,
EstablishedKeys::derive(b"shared secret", &[]).expect("derive"),
1,
Instant::ZERO,
)
}
#[cfg(feature = "rustcrypto")]
#[test]
fn a_pase_session_derives_the_commissioning_subject() {
let s = session(crate::session::SessionKind::Pase);
let isd = SubjectDescriptor::from_session(&s, None);
assert_eq!(isd.auth_mode, Some(AuthMode::Pase));
assert!(isd.is_commissioning);
assert_eq!(
isd.subjects.as_slice(),
&[NodeId(DEFAULT_COMMISSIONING_PASSCODE)]
);
assert_eq!(isd.fabric_index, FabricIndex(0), "PASE has no fabric yet");
}
#[cfg(feature = "rustcrypto")]
#[test]
fn a_case_session_presents_its_node_id_and_every_cat() {
let mut s = session(crate::session::SessionKind::Case);
s.fabric_index = F1;
s.peer_node_id = ALICE;
let tags = [
CaseAuthenticatedTag::new(0xAAAA, 1),
CaseAuthenticatedTag::new(0xBBBB, 2),
CaseAuthenticatedTag::new(0xCCCC, 3),
];
for tag in tags {
s.peer_cats.push(tag).expect("three fit");
}
let isd = SubjectDescriptor::from_session(&s, None);
assert_eq!(isd.auth_mode, Some(AuthMode::Case));
assert!(!isd.is_commissioning);
assert_eq!(isd.fabric_index, F1);
assert_eq!(
isd.subjects.len(),
4,
"the node id plus §6.5.6's three CATs"
);
assert_eq!(isd.subjects[0], ALICE);
for (index, tag) in tags.iter().enumerate() {
assert_eq!(isd.subjects[index + 1], tag.to_node_id());
}
}
#[cfg(feature = "rustcrypto")]
#[test]
fn a_case_session_on_the_pending_fabric_is_still_commissioning() {
let mut s = session(crate::session::SessionKind::Case);
s.fabric_index = F1;
s.peer_node_id = ALICE;
assert!(SubjectDescriptor::from_session(&s, Some(F1)).is_commissioning);
assert!(!SubjectDescriptor::from_session(&s, Some(F2)).is_commissioning);
assert!(!SubjectDescriptor::from_session(&s, None).is_commissioning);
}
#[cfg(feature = "rustcrypto")]
#[test]
fn a_case_session_without_a_fabric_authenticates_nobody() {
let s = session(crate::session::SessionKind::Case);
assert_eq!(s.fabric_index.0, 0);
let isd = SubjectDescriptor::from_session(&s, None);
assert_eq!(isd.auth_mode, None);
assert!(isd.subjects.is_empty());
}
#[test]
fn an_unauthenticated_subject_matches_no_entry_at_all() {
let mut acl = TestAcl::new();
acl.add(TestEntry::case(F1, Privilege::Administer))
.expect("add");
let mut isd = SubjectDescriptor::unauthenticated();
isd.fabric_index = F1;
assert!(acl.granted(&node(), &isd, 1, ON_OFF).is_empty());
}
#[test]
fn a_group_subject_presents_its_group_id() {
let isd = SubjectDescriptor::group(F1, crate::msg::GroupId(7));
assert_eq!(isd.auth_mode, Some(AuthMode::Group));
assert_eq!(isd.subjects.as_slice(), &[NodeId(7)]);
assert!(!isd.is_commissioning);
}
#[test]
fn a_read_of_the_attribute_sees_only_its_own_fabric() {
let mut acl = TestAcl::new();
acl.add(TestEntry::case(F1, Privilege::Operate))
.expect("add");
acl.add(TestEntry::case(F2, Privilege::Manage))
.expect("add");
assert_eq!(acl.len_of_fabric(F1), 1);
assert!(
acl.of_fabric(F1)
.all(|entry| entry.privilege == Privilege::Operate)
);
}
}