Merge pull request #9 from project-chip/feature/multi-admin

Multi-Admin Support

Author: kedars

examples/onoff_light/src/main.rs

@@ -19,28 +19,27 @@ mod dev_att;
 use matter::core::{self, CommissioningData};
 use matter::data_model::cluster_basic_information::BasicInfoConfig;
 use matter::data_model::device_types::device_type_add_on_off_light;
-use rand::prelude::*;
+use matter::secure_channel::spake2p::VerifierData;
 
 fn main() {
     env_logger::init();
-    let mut comm_data = CommissioningData {
+    let comm_data = CommissioningData {
         // TODO: Hard-coded for now
-        passwd: 123456,
+        verifier: VerifierData::new_with_pw(123456),
         discriminator: 250,
-        ..Default::default()
     };
-    rand::thread_rng().fill_bytes(&mut comm_data.salt);
 
     // vid/pid should match those in the DAC
     let dev_info = BasicInfoConfig {
         vid: 0xFFF1,
         pid: 0x8002,
         hw_ver: 2,
         sw_ver: 1,
+        serial_no: "aabbccdd".to_string(),
     };
     let dev_att = Box::new(dev_att::HardCodedDevAtt::new());
 
-    let mut matter = core::Matter::new(&dev_info, dev_att, &comm_data).unwrap();
+    let mut matter = core::Matter::new(dev_info, dev_att, comm_data).unwrap();
     let dm = matter.get_data_model();
     {
         let mut node = dm.node.write().unwrap();

matter/src/core.rs

@@ -25,19 +25,15 @@ use crate::{
     fabric::FabricMgr,
     interaction_model::InteractionModel,
     mdns::Mdns,
-    secure_channel::core::SecureChannel,
+    secure_channel::{core::SecureChannel, pake::PaseMgr, spake2p::VerifierData},
     transport,
 };
 use std::sync::Arc;
 
-#[derive(Default)]
 /// Device Commissioning Data
 pub struct CommissioningData {
-    /// The commissioning salt
-    pub salt: [u8; 16],
-    /// The password for commissioning the device
-    // TODO: We should replace this with verifier instead of password
-    pub passwd: u32,
+    /// The data like password or verifier that is required to authenticate
+    pub verifier: VerifierData,
     /// The 12-bit discriminator used to differentiate between multiple devices
     pub discriminator: u16,
 }
@@ -57,17 +53,19 @@ impl Matter {
     /// requires a set of device attestation certificates and keys. It is the responsibility of
     /// this object to return the device attestation details when queried upon.
     pub fn new(
-        dev_det: &BasicInfoConfig,
+        dev_det: BasicInfoConfig,
         dev_att: Box<dyn DevAttDataFetcher>,
-        dev_comm: &CommissioningData,
+        dev_comm: CommissioningData,
     ) -> Result<Box<Matter>, Error> {
         let mdns = Mdns::get()?;
-        mdns.set_values(dev_det.vid, dev_det.pid, dev_comm.discriminator);
+        mdns.set_values(dev_det.vid, dev_det.pid);
 
         let fabric_mgr = Arc::new(FabricMgr::new()?);
         let acl_mgr = Arc::new(AclMgr::new()?);
+        let mut pase = PaseMgr::new();
         let open_comm_window = fabric_mgr.is_empty();
-        let data_model = DataModel::new(dev_det, dev_att, fabric_mgr.clone(), acl_mgr)?;
+        let data_model =
+            DataModel::new(dev_det, dev_att, fabric_mgr.clone(), acl_mgr, pase.clone())?;
         let mut matter = Box::new(Matter {
             transport_mgr: transport::mgr::Mgr::new()?,
             data_model,
@@ -76,11 +74,12 @@ impl Matter {
         let interaction_model =
             Box::new(InteractionModel::new(Box::new(matter.data_model.clone())));
         matter.transport_mgr.register_protocol(interaction_model)?;
-        let mut secure_channel = Box::new(SecureChannel::new(matter.fabric_mgr.clone()));
+
         if open_comm_window {
-            secure_channel.open_comm_window(&dev_comm.salt, dev_comm.passwd)?;
+            pase.enable_pase_session(dev_comm.verifier, dev_comm.discriminator)?;
         }
 
+        let secure_channel = Box::new(SecureChannel::new(pase, matter.fabric_mgr.clone()));
         matter.transport_mgr.register_protocol(secure_channel)?;
         Ok(matter)
     }

matter/src/data_model/cluster_basic_information.rs

@@ -17,20 +17,35 @@
 
 use super::objects::*;
 use crate::error::*;
+use num_derive::FromPrimitive;
 
 pub const ID: u32 = 0x0028;
+
+#[derive(FromPrimitive)]
 enum Attributes {
+    DMRevision = 0,
     VendorId = 2,
     ProductId = 4,
     HwVer = 7,
     SwVer = 9,
+    SerialNo = 0x0f,
 }
 
 pub struct BasicInfoConfig {
     pub vid: u16,
     pub pid: u16,
     pub hw_ver: u16,
     pub sw_ver: u32,
+    pub serial_no: String,
+}
+
+fn attr_dm_rev_new() -> Result<Attribute, Error> {
+    Attribute::new(
+        Attributes::DMRevision as u16,
+        AttrValue::Uint8(1),
+        Access::RV,
+        Quality::FIXED,
+    )
 }
 
 fn attr_vid_new(vid: u16) -> Result<Attribute, Error> {
@@ -69,19 +84,31 @@ fn attr_sw_ver_new(sw_ver: u32) -> Result<Attribute, Error> {
     )
 }
 
+fn attr_serial_no_new(label: String) -> Result<Attribute, Error> {
+    Attribute::new(
+        Attributes::SerialNo as u16,
+        AttrValue::Utf8(label),
+        Access::RV,
+        Quality::FIXED,
+    )
+}
 pub struct BasicInfoCluster {
     base: Cluster,
 }
 
 impl BasicInfoCluster {
-    pub fn new(cfg: &BasicInfoConfig) -> Result<Box<Self>, Error> {
+    pub fn new(cfg: BasicInfoConfig) -> Result<Box<Self>, Error> {
         let mut cluster = Box::new(BasicInfoCluster {
             base: Cluster::new(ID)?,
         });
+        cluster.base.add_attribute(attr_dm_rev_new()?)?;
         cluster.base.add_attribute(attr_vid_new(cfg.vid)?)?;
         cluster.base.add_attribute(attr_pid_new(cfg.pid)?)?;
         cluster.base.add_attribute(attr_hw_ver_new(cfg.hw_ver)?)?;
         cluster.base.add_attribute(attr_sw_ver_new(cfg.sw_ver)?)?;
+        cluster
+            .base
+            .add_attribute(attr_serial_no_new(cfg.serial_no)?)?;
         Ok(cluster)
     }
 }

matter/src/data_model/core.rs

@@ -36,6 +36,7 @@ use crate::{
         },
         InteractionConsumer, Transaction,
     },
+    secure_channel::pake::PaseMgr,
     tlv::{TLVArray, TLVWriter, TagType, ToTLV},
     transport::session::{Session, SessionMode},
 };
@@ -50,10 +51,11 @@ pub struct DataModel {
 
 impl DataModel {
     pub fn new(
-        dev_details: &BasicInfoConfig,
+        dev_details: BasicInfoConfig,
         dev_att: Box<dyn DevAttDataFetcher>,
         fabric_mgr: Arc<FabricMgr>,
         acl_mgr: Arc<AclMgr>,
+        pase_mgr: PaseMgr,
     ) -> Result<Self, Error> {
         let dm = DataModel {
             node: Arc::new(RwLock::new(Node::new()?)),
@@ -62,7 +64,14 @@ impl DataModel {
         {
             let mut node = dm.node.write()?;
             node.set_changes_cb(Box::new(dm.clone()));
-            device_type_add_root_node(&mut node, dev_details, dev_att, fabric_mgr, acl_mgr)?;
+            device_type_add_root_node(
+                &mut node,
+                dev_details,
+                dev_att,
+                fabric_mgr,
+                acl_mgr,
+                pase_mgr,
+            )?;
         }
         Ok(dm)
     }
@@ -75,7 +84,7 @@ impl DataModel {
     ) -> Result<AttrValue, IMStatusCode> {
         let node = self.node.read().unwrap();
         let cluster = node.get_cluster(endpoint, cluster)?;
-        cluster.base().read_attribute_raw(attr).map(|a| *a)
+        cluster.base().read_attribute_raw(attr).map(|a| a.clone())
     }
 
     // Encode a write attribute from a path that may or may not be wildcard

matter/src/data_model/device_types.rs

@@ -19,6 +19,7 @@ use super::cluster_basic_information::BasicInfoCluster;
 use super::cluster_basic_information::BasicInfoConfig;
 use super::cluster_on_off::OnOffCluster;
 use super::objects::*;
+use super::sdm::admin_commissioning::AdminCommCluster;
 use super::sdm::dev_att::DevAttDataFetcher;
 use super::sdm::general_commissioning::GenCommCluster;
 use super::sdm::noc::NocCluster;
@@ -27,20 +28,27 @@ use super::system_model::access_control::AccessControlCluster;
 use crate::acl::AclMgr;
 use crate::error::*;
 use crate::fabric::FabricMgr;
+use crate::secure_channel::pake::PaseMgr;
 use std::sync::Arc;
 use std::sync::RwLockWriteGuard;
 
+pub const DEV_TYPE_ROOT_NODE: DeviceType = DeviceType {
+    dtype: 0x0016,
+    drev: 1,
+};
+
 type WriteNode<'a> = RwLockWriteGuard<'a, Box<Node>>;
 
 pub fn device_type_add_root_node(
     node: &mut WriteNode,
-    dev_info: &BasicInfoConfig,
+    dev_info: BasicInfoConfig,
     dev_att: Box<dyn DevAttDataFetcher>,
     fabric_mgr: Arc<FabricMgr>,
     acl_mgr: Arc<AclMgr>,
+    pase_mgr: PaseMgr,
 ) -> Result<u32, Error> {
     // Add the root endpoint
-    let endpoint = node.add_endpoint()?;
+    let endpoint = node.add_endpoint(DEV_TYPE_ROOT_NODE)?;
     if endpoint != 0 {
         // Somehow endpoint 0 was already added, this shouldn't be the case
         return Err(Error::Invalid);
@@ -51,6 +59,7 @@ pub fn device_type_add_root_node(
     let failsafe = general_commissioning.failsafe();
     node.add_cluster(0, general_commissioning)?;
     node.add_cluster(0, NwCommCluster::new()?)?;
+    node.add_cluster(0, AdminCommCluster::new(pase_mgr)?)?;
     node.add_cluster(
         0,
         NocCluster::new(dev_att, fabric_mgr, acl_mgr.clone(), failsafe)?,
@@ -59,8 +68,13 @@ pub fn device_type_add_root_node(
     Ok(endpoint)
 }
 
+const DEV_TYPE_ON_OFF_LIGHT: DeviceType = DeviceType {
+    dtype: 0x0100,
+    drev: 2,
+};
+
 pub fn device_type_add_on_off_light(node: &mut WriteNode) -> Result<u32, Error> {
-    let endpoint = node.add_endpoint()?;
+    let endpoint = node.add_endpoint(DEV_TYPE_ON_OFF_LIGHT)?;
     node.add_cluster(endpoint, OnOffCluster::new()?)?;
     Ok(endpoint)
 }

matter/src/data_model/objects/attribute.rs

@@ -88,14 +88,15 @@ bitflags! {
  * - instead of arrays, can use linked-lists to conserve space and avoid the internal fragmentation
  */
 
-#[derive(PartialEq, Copy, Clone)]
+#[derive(PartialEq, Clone)]
 pub enum AttrValue {
     Int64(i64),
     Uint8(u8),
     Uint16(u16),
     Uint32(u32),
     Uint64(u64),
     Bool(bool),
+    Utf8(String),
     Custom,
 }
 
@@ -108,6 +109,7 @@ impl Debug for AttrValue {
             AttrValue::Uint32(v) => write!(f, "{:?}", *v),
             AttrValue::Uint64(v) => write!(f, "{:?}", *v),
             AttrValue::Bool(v) => write!(f, "{:?}", *v),
+            AttrValue::Utf8(v) => write!(f, "{:?}", *v),
             AttrValue::Custom => write!(f, "custom-attribute"),
         }?;
         Ok(())
@@ -123,6 +125,7 @@ impl ToTLV for AttrValue {
             AttrValue::Uint16(v) => tw.u16(tag_type, *v),
             AttrValue::Uint32(v) => tw.u32(tag_type, *v),
             AttrValue::Uint64(v) => tw.u64(tag_type, *v),
+            AttrValue::Utf8(v) => tw.utf8(tag_type, v.as_bytes()),
             _ => {
                 error!("Attribute type not yet supported");
                 Err(Error::AttributeNotFound)

matter/src/data_model/objects/cluster.rs

@@ -87,7 +87,6 @@ pub trait ClusterType {
 pub struct Cluster {
     pub(super) id: u32,
     attributes: Vec<Attribute>,
-    feature_map: Option<u32>,
     data_ver: u32,
 }
 
@@ -96,7 +95,6 @@ impl Cluster {
         let mut c = Cluster {
             id,
             attributes: Vec::with_capacity(ATTRS_PER_CLUSTER),
-            feature_map: None,
             data_ver: rand::thread_rng().gen_range(0..0xFFFFFFFF),
         };
         c.add_default_attributes()?;
@@ -112,22 +110,20 @@ impl Cluster {
     }
 
     pub fn set_feature_map(&mut self, map: u32) -> Result<(), Error> {
-        if self.feature_map.is_none() {
-            self.add_attribute(Attribute::new(
-                GlobalElements::FeatureMap as u16,
-                AttrValue::Uint32(map),
-                Access::RV,
-                Quality::NONE,
-            )?)?;
-        } else {
-            self.write_attribute_raw(GlobalElements::FeatureMap as u16, AttrValue::Uint32(map))
-                .map_err(|_| Error::Invalid)?;
-        }
-        self.feature_map = Some(map);
+        self.write_attribute_raw(GlobalElements::FeatureMap as u16, AttrValue::Uint32(map))
+            .map_err(|_| Error::Invalid)?;
         Ok(())
     }
 
     fn add_default_attributes(&mut self) -> Result<(), Error> {
+        // Default feature map is 0
+        self.add_attribute(Attribute::new(
+            GlobalElements::FeatureMap as u16,
+            AttrValue::Uint32(0),
+            Access::RV,
+            Quality::NONE,
+        )?)?;
+
         self.add_attribute(Attribute::new(
             GlobalElements::AttributeList as u16,
             AttrValue::Custom,
@@ -233,8 +229,7 @@ impl Cluster {
                     return;
                 }
                 GlobalElements::FeatureMap => {
-                    let val = if let Some(m) = self.feature_map { m } else { 0 };
-                    encoder.encode(EncodeValue::Value(&val));
+                    encoder.encode(EncodeValue::Value(&attr.value));
                     return;
                 }
                 _ => {
@@ -284,7 +279,7 @@ impl Cluster {
     ) -> Result<(), IMStatusCode> {
         let a = self.get_attribute_mut(attr_id)?;
         if a.value != AttrValue::Custom {
-            let mut value = a.value;
+            let mut value = a.value.clone();
             value
                 .update_from_tlv(data)
                 .map_err(|_| IMStatusCode::Failure)?;

matter/src/data_model/objects/encoder.rs

@@ -115,3 +115,9 @@ pub trait Encoder {
     /// Encode a status report
     fn encode_status(&mut self, status: IMStatusCode, cluster_status: u16);
 }
+
+#[derive(ToTLV, Copy, Clone)]
+pub struct DeviceType {
+    pub dtype: u16,
+    pub drev: u16,
+}