qualia_core_db/net/qdnf/profiles/
requirements.rs1use crate::net::qdnf::errors::QdnfError;
5use crate::net::qdnf::policy_labels::Confidentiality;
6
7use super::catalog::{
8 catalog_entry, ControlId, ControlPredicate, ControlSet, ProtectionProfile, MAX_CONTROLS,
9};
10
11#[repr(u8)]
14#[derive(Clone, Copy, Debug, PartialEq, Eq)]
15pub enum TaskClass {
16 PublicDiscovery = 0,
17 KnownPeerMessage = 1,
18 ProfessionalRecord = 2,
19 HostileEnvironmentCare = 3,
20 CompartmentedMission = 4,
21}
22
23#[repr(u8)]
25#[derive(Clone, Copy, Debug, PartialEq, Eq)]
26pub enum AssessedEnvironment {
27 Friendly = 0,
28 Observed = 1,
29 Hostile = 2,
30}
31
32#[repr(C)]
34#[derive(Clone, Copy, Debug, PartialEq, Eq)]
35pub struct SenderPolicy {
36 pub extra_protection: bool,
37 pub require_isolated_bearer: bool,
38 pub require_cover_traffic: bool,
39 pub require_short_capabilities: bool,
40}
41
42impl SenderPolicy {
43 pub const DEFAULT: Self = Self {
44 extra_protection: false,
45 require_isolated_bearer: false,
46 require_cover_traffic: false,
47 require_short_capabilities: false,
48 };
49}
50
51#[repr(C)]
53#[derive(Clone, Copy, Debug, PartialEq, Eq)]
54pub struct RequirementContext {
55 pub confidentiality: Confidentiality,
56 pub compartment_count: u8,
57 pub extra_controls: [ControlId; MAX_CONTROLS],
58 pub extra_control_count: u8,
59 pub task: TaskClass,
60 pub environment: AssessedEnvironment,
61 pub sender: SenderPolicy,
62}
63
64impl RequirementContext {
65 pub fn new(
67 confidentiality: Confidentiality,
68 task: TaskClass,
69 environment: AssessedEnvironment,
70 ) -> Self {
71 Self {
72 confidentiality,
73 compartment_count: 0,
74 extra_controls: [ControlId::ZERO; MAX_CONTROLS],
75 extra_control_count: 0,
76 task,
77 environment,
78 sender: SenderPolicy::DEFAULT,
79 }
80 }
81
82 pub fn extra_controls(&self) -> &[ControlId] {
84 &self.extra_controls[..self.extra_control_count as usize]
85 }
86
87 pub fn push_extra(&mut self, id: ControlId) -> Result<(), QdnfError> {
89 let mut i = 0usize;
90 while i < self.extra_control_count as usize {
91 if self.extra_controls[i] == id {
92 return Ok(());
93 }
94 i += 1;
95 }
96 if self.extra_control_count as usize >= MAX_CONTROLS {
97 return Err(QdnfError::Capacity);
98 }
99 self.extra_controls[self.extra_control_count as usize] = id;
100 self.extra_control_count += 1;
101 Ok(())
102 }
103}
104
105pub fn min_profile_for_confidentiality(
107 confidentiality: Confidentiality,
108 compartment_count: u8,
109) -> Result<ProtectionProfile, QdnfError> {
110 match confidentiality {
111 Confidentiality::C0Public => Ok(ProtectionProfile::P0),
112 Confidentiality::C1Private => Ok(ProtectionProfile::P1),
113 Confidentiality::C2Sensitive => Ok(ProtectionProfile::P2),
114 Confidentiality::C3Compartmented => {
115 if compartment_count > 0 {
116 Ok(ProtectionProfile::P4)
117 } else {
118 Ok(ProtectionProfile::P3)
119 }
120 }
121 Confidentiality::Unknown => Err(QdnfError::Conflict),
122 }
123}
124
125fn task_floor(task: TaskClass) -> ProtectionProfile {
126 match task {
127 TaskClass::PublicDiscovery => ProtectionProfile::P0,
128 TaskClass::KnownPeerMessage => ProtectionProfile::P1,
129 TaskClass::ProfessionalRecord => ProtectionProfile::P2,
130 TaskClass::HostileEnvironmentCare => ProtectionProfile::P3,
131 TaskClass::CompartmentedMission => ProtectionProfile::P4,
132 }
133}
134
135fn environment_floor(
136 environment: AssessedEnvironment,
137 confidentiality: Confidentiality,
138) -> ProtectionProfile {
139 match environment {
140 AssessedEnvironment::Friendly => ProtectionProfile::P0,
141 AssessedEnvironment::Observed | AssessedEnvironment::Hostile => {
142 if matches!(confidentiality, Confidentiality::C0Public) {
143 ProtectionProfile::P0
144 } else {
145 ProtectionProfile::P3
146 }
147 }
148 }
149}
150
151pub fn required_control_set(ctx: &RequirementContext) -> Result<ControlSet, QdnfError> {
153 let conf_floor = min_profile_for_confidentiality(ctx.confidentiality, ctx.compartment_count)?;
154 let mut floor = conf_floor
155 .raise_floor(task_floor(ctx.task))
156 .raise_floor(environment_floor(ctx.environment, ctx.confidentiality));
157 if ctx.sender.require_isolated_bearer {
158 floor = floor.raise_floor(ProtectionProfile::P4);
159 }
160 if ctx.sender.extra_protection {
161 floor = floor.one_stronger();
162 }
163 let mut set = catalog_entry(floor);
164 if ctx.sender.require_isolated_bearer {
165 set.try_push_predicate(ControlPredicate::IsolatedBearer)?;
166 }
167 if ctx.sender.require_cover_traffic {
168 set.try_push_predicate(ControlPredicate::CoverTraffic)?;
169 }
170 if ctx.sender.require_short_capabilities {
171 set.try_push_predicate(ControlPredicate::ShortCapabilities)?;
172 }
173 let mut i = 0usize;
174 while i < ctx.extra_control_count as usize {
175 set.try_push(ctx.extra_controls[i])?;
176 i += 1;
177 }
178 Ok(set)
179}
180
181#[cfg(test)]
182mod tests {
183 use super::*;
184 use crate::net::qdnf::profiles::catalog::catalog_entry;
185
186 #[test]
187 fn unknown_confidentiality_never_maps_to_p0() {
188 assert_eq!(
189 min_profile_for_confidentiality(Confidentiality::Unknown, 0),
190 Err(QdnfError::Conflict)
191 );
192 let ctx = RequirementContext::new(
193 Confidentiality::Unknown,
194 TaskClass::PublicDiscovery,
195 AssessedEnvironment::Friendly,
196 );
197 assert_eq!(required_control_set(&ctx), Err(QdnfError::Conflict));
198 assert_ne!(Confidentiality::Unknown, Confidentiality::C0Public);
199 let p0 = required_control_set(&RequirementContext::new(
200 Confidentiality::C0Public,
201 TaskClass::PublicDiscovery,
202 AssessedEnvironment::Friendly,
203 ))
204 .unwrap();
205 assert_eq!(p0.profile, ProtectionProfile::P0);
206 }
207
208 #[test]
209 fn confidentiality_floors() {
210 assert_eq!(
211 min_profile_for_confidentiality(Confidentiality::C0Public, 0).unwrap(),
212 ProtectionProfile::P0
213 );
214 assert_eq!(
215 min_profile_for_confidentiality(Confidentiality::C1Private, 0).unwrap(),
216 ProtectionProfile::P1
217 );
218 assert_eq!(
219 min_profile_for_confidentiality(Confidentiality::C2Sensitive, 0).unwrap(),
220 ProtectionProfile::P2
221 );
222 assert_eq!(
223 min_profile_for_confidentiality(Confidentiality::C3Compartmented, 0).unwrap(),
224 ProtectionProfile::P3
225 );
226 assert_eq!(
227 min_profile_for_confidentiality(Confidentiality::C3Compartmented, 1).unwrap(),
228 ProtectionProfile::P4
229 );
230 }
231
232 #[test]
233 fn c2_requires_p2_catalog() {
234 let ctx = RequirementContext::new(
235 Confidentiality::C2Sensitive,
236 TaskClass::KnownPeerMessage,
237 AssessedEnvironment::Friendly,
238 );
239 let set = required_control_set(&ctx).unwrap();
240 assert_eq!(set.profile, ProtectionProfile::P2);
241 assert!(set.contains_predicate(ControlPredicate::ProtectedEndpoint));
242 assert_eq!(set, catalog_entry(ProtectionProfile::P2));
243 }
244
245 #[test]
246 fn extra_label_controls_must_be_present() {
247 let mut ctx = RequirementContext::new(
248 Confidentiality::C1Private,
249 TaskClass::KnownPeerMessage,
250 AssessedEnvironment::Friendly,
251 );
252 ctx.push_extra(ControlId::from_predicate(ControlPredicate::ApprovedRelay))
253 .unwrap();
254 let set = required_control_set(&ctx).unwrap();
255 assert_eq!(set.profile, ProtectionProfile::P1);
256 assert!(set.contains_predicate(ControlPredicate::ApprovedRelay));
257 assert!(set.contains_all(&catalog_entry(ProtectionProfile::P1)));
258 }
259
260 #[test]
261 fn extra_protection_may_raise_floor() {
262 let mut ctx = RequirementContext::new(
263 Confidentiality::C1Private,
264 TaskClass::KnownPeerMessage,
265 AssessedEnvironment::Friendly,
266 );
267 ctx.sender.extra_protection = true;
268 let set = required_control_set(&ctx).unwrap();
269 assert_eq!(set.profile, ProtectionProfile::P2);
270 }
271
272 #[test]
273 fn hostile_environment_does_not_raise_public_c0() {
274 let ctx = RequirementContext::new(
275 Confidentiality::C0Public,
276 TaskClass::PublicDiscovery,
277 AssessedEnvironment::Hostile,
278 );
279 let set = required_control_set(&ctx).unwrap();
280 assert_eq!(set.profile, ProtectionProfile::P0);
281 }
282
283 #[test]
284 fn hostile_environment_raises_private_to_p3() {
285 let ctx = RequirementContext::new(
286 Confidentiality::C1Private,
287 TaskClass::KnownPeerMessage,
288 AssessedEnvironment::Hostile,
289 );
290 let set = required_control_set(&ctx).unwrap();
291 assert_eq!(set.profile, ProtectionProfile::P3);
292 assert!(set.contains_predicate(ControlPredicate::ApprovedRelay));
293 }
294}