spodes_rs/security/
access_rights.rs1#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15pub enum AttributeAccessMode {
16 NoAccess = 0,
18 ReadOnly = 1,
20 WriteOnly = 2,
22 ReadWrite = 3,
24 AuthenticatedReadOnly = 4,
26 AuthenticatedWriteOnly = 5,
28 AuthenticatedReadWrite = 6,
30}
31
32impl AttributeAccessMode {
33 pub fn from_u8(v: u8) -> Option<Self> {
35 match v {
36 0 => Some(Self::NoAccess),
37 1 => Some(Self::ReadOnly),
38 2 => Some(Self::WriteOnly),
39 3 => Some(Self::ReadWrite),
40 4 => Some(Self::AuthenticatedReadOnly),
41 5 => Some(Self::AuthenticatedWriteOnly),
42 6 => Some(Self::AuthenticatedReadWrite),
43 _ => None,
44 }
45 }
46
47 pub fn allows_read(&self) -> bool {
49 matches!(self, Self::ReadOnly | Self::ReadWrite | Self::AuthenticatedReadOnly | Self::AuthenticatedReadWrite)
50 }
51
52 pub fn allows_write(&self) -> bool {
54 matches!(self, Self::WriteOnly | Self::ReadWrite | Self::AuthenticatedWriteOnly | Self::AuthenticatedReadWrite)
55 }
56
57 pub fn requires_auth(&self) -> bool {
59 matches!(self, Self::AuthenticatedReadOnly | Self::AuthenticatedWriteOnly | Self::AuthenticatedReadWrite)
60 }
61}
62
63#[derive(Debug, Clone, Copy, PartialEq, Eq)]
65pub enum MethodAccessMode {
66 NoAccess = 0,
68 Access = 1,
70 AuthenticatedAccess = 2,
72}
73
74impl MethodAccessMode {
75 pub fn from_u8(v: u8) -> Option<Self> {
77 match v {
78 0 => Some(Self::NoAccess),
79 1 => Some(Self::Access),
80 2 => Some(Self::AuthenticatedAccess),
81 _ => None,
82 }
83 }
84
85 pub fn allows_access(&self) -> bool {
87 !matches!(self, Self::NoAccess)
88 }
89
90 pub fn requires_auth(&self) -> bool {
92 matches!(self, Self::AuthenticatedAccess)
93 }
94}
95
96#[derive(Debug, Clone)]
98pub struct AttributeAccessItem {
99 pub attribute_id: i8,
101 pub access_mode: AttributeAccessMode,
103 pub access_selectors: Option<Vec<i8>>,
105}
106
107#[derive(Debug, Clone)]
109pub struct MethodAccessItem {
110 pub method_id: i8,
112 pub access_mode: MethodAccessMode,
114}
115
116#[derive(Debug, Clone)]
118pub struct AccessRights {
119 pub attribute_access: Vec<AttributeAccessItem>,
121 pub method_access: Vec<MethodAccessItem>,
123}
124
125#[derive(Debug, Clone)]
127pub struct ObjectListEntry {
128 pub class_id: u16,
130 pub version: u8,
132 pub logical_name: Vec<u8>, pub access_rights: AccessRights,
136}
137
138impl ObjectListEntry {
139 pub fn can_read(&self, attribute_id: i8) -> bool {
141 self.access_rights
142 .attribute_access
143 .iter()
144 .any(|item| item.attribute_id == attribute_id && item.access_mode.allows_read())
145 }
146
147 pub fn can_write(&self, attribute_id: i8) -> bool {
149 self.access_rights
150 .attribute_access
151 .iter()
152 .any(|item| item.attribute_id == attribute_id && item.access_mode.allows_write())
153 }
154
155 pub fn can_invoke(&self, method_id: i8) -> bool {
157 self.access_rights
158 .method_access
159 .iter()
160 .any(|item| item.method_id == method_id && item.access_mode.allows_access())
161 }
162
163 pub fn auth_required_read(&self, attribute_id: i8) -> bool {
165 self.access_rights
166 .attribute_access
167 .iter()
168 .any(|item| item.attribute_id == attribute_id && item.access_mode.requires_auth())
169 }
170
171 pub fn auth_required_write(&self, attribute_id: i8) -> bool {
173 self.access_rights
174 .attribute_access
175 .iter()
176 .any(|item| item.attribute_id == attribute_id && item.access_mode.requires_auth())
177 }
178}
179
180#[allow(clippy::cast_possible_wrap)]
183pub fn full_access_entry(class_id: u16, version: u8, obis: &[u8], attr_count: u8, method_count: u8) -> ObjectListEntry {
184 let attribute_access = (1..=attr_count)
185 .map(|id| AttributeAccessItem {
186 attribute_id: id as i8,
187 access_mode: AttributeAccessMode::ReadWrite,
188 access_selectors: None,
189 })
190 .collect();
191
192 let method_access = (1..=method_count)
193 .map(|id| MethodAccessItem { method_id: id as i8, access_mode: MethodAccessMode::Access })
194 .collect();
195
196 ObjectListEntry {
197 class_id,
198 version,
199 logical_name: obis.to_vec(),
200 access_rights: AccessRights { attribute_access, method_access },
201 }
202}
203
204#[allow(clippy::cast_possible_wrap)]
207pub fn read_only_entry(class_id: u16, version: u8, obis: &[u8], attr_count: u8, method_count: u8) -> ObjectListEntry {
208 let attribute_access = (1..=attr_count)
209 .map(|id| AttributeAccessItem {
210 attribute_id: id as i8,
211 access_mode: AttributeAccessMode::ReadOnly,
212 access_selectors: None,
213 })
214 .collect();
215
216 let method_access = (1..=method_count)
217 .map(|id| MethodAccessItem { method_id: id as i8, access_mode: MethodAccessMode::NoAccess })
218 .collect();
219
220 ObjectListEntry {
221 class_id,
222 version,
223 logical_name: obis.to_vec(),
224 access_rights: AccessRights { attribute_access, method_access },
225 }
226}