Skip to main content

qualia_core_db/net/qdnf/profiles/
requirements.rs

1//! Required control set from label confidentiality, task, sender policy and
2//! environment. Cost preference is not an input and cannot reduce protection.
3
4use 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/// Application task. Raises the *minimum* named profile; catalog predicates
12/// still have to be present at negotiation.
13#[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/// Assessed network/endpoint environment.
24#[repr(u8)]
25#[derive(Clone, Copy, Debug, PartialEq, Eq)]
26pub enum AssessedEnvironment {
27    Friendly = 0,
28    Observed = 1,
29    Hostile = 2,
30}
31
32/// Sender constraints that may only add controls or raise the floor.
33#[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/// Inputs for [`required_control_set`]. No cost/paid-tier field exists.
52#[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    /// Creates a requirement context.
66    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    /// Extra controls beyond the profile baseline.
83    pub fn extra_controls(&self) -> &[ControlId] {
84        &self.extra_controls[..self.extra_control_count as usize]
85    }
86
87    /// Adds an extra control; error at capacity.
88    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
105/// Minimum profile covering a confidentiality level.
106pub 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
151/// Computed required control set for `ctx`.
152pub 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}