Skip to main content

qualia_core_db/net/qdnf/policy_labels/
lattice.rs

1//! Confidentiality lattice properties over [`join_one`].
2
3#[cfg(test)]
4use super::join::{join_labels_into, join_one};
5use super::types::Confidentiality;
6#[cfg(test)]
7use super::types::LabelFields;
8use crate::net::qdnf::errors::QdnfError;
9
10/// Lattice join of two confidentiality ranks. Unknown cannot join.
11pub fn join_confidentiality(
12    a: Confidentiality,
13    b: Confidentiality,
14) -> Result<Confidentiality, QdnfError> {
15    let ra = a.lattice_rank()?;
16    let rb = b.lattice_rank()?;
17    if rb > ra {
18        Ok(b)
19    } else {
20        Ok(a)
21    }
22}
23
24#[cfg(test)]
25mod tests {
26    use super::*;
27    use crate::net::qdnf::policy_labels::decode::encode_label_into;
28    use crate::net::qdnf::policy_labels::egress::{
29        admit_cache_insert, admit_caller_egress, EgressCaller,
30    };
31    use crate::net::qdnf::policy_labels::flow::JobLabelContext;
32    use crate::net::qdnf::policy_labels::projection::{project_sink, DerivedSink};
33    use crate::net::qdnf::policy_labels::release::release_derivation;
34    use crate::net::qdnf::policy_labels::types::{VerifiedLabel, NO_TRAINING};
35    use crate::net::qdnf::policy_labels::verify::verify_label;
36    use crate::net::qdnf::types::StrongDigest;
37
38    fn issuer(b: u8) -> StrongDigest {
39        let mut d = StrongDigest::ZERO;
40        d.0[0] = b;
41        d.0[47] = 1;
42        d
43    }
44
45    fn fields(conf: Confidentiality, iss: u8) -> LabelFields {
46        LabelFields::request(conf, issuer(iss))
47    }
48
49    fn verified(conf: Confidentiality, iss: StrongDigest, restrictions: u16) -> VerifiedLabel {
50        let mut f = LabelFields::request(conf, iss);
51        f.restriction_bits = restrictions;
52        if conf.requires_audience() {
53            f.audience = iss;
54        }
55        let mut buf = [0u8; 256];
56        let n = encode_label_into(&f, &mut buf).unwrap();
57        verify_label(f, &buf[..n]).unwrap()
58    }
59
60    #[test]
61    fn join_is_idempotent() {
62        for conf in [
63            Confidentiality::C0Public,
64            Confidentiality::C1Private,
65            Confidentiality::C2Sensitive,
66            Confidentiality::C3Compartmented,
67        ] {
68            assert_eq!(join_confidentiality(conf, conf).unwrap(), conf);
69            let mut acc = fields(conf, 1);
70            if conf.requires_audience() {
71                acc.audience = issuer(1);
72            }
73            let dep = acc;
74            join_one(&mut acc, &dep).unwrap();
75            assert_eq!(acc.confidentiality, conf);
76        }
77    }
78
79    #[test]
80    fn join_is_commutative() {
81        let pairs = [
82            (Confidentiality::C0Public, Confidentiality::C1Private),
83            (Confidentiality::C1Private, Confidentiality::C2Sensitive),
84            (
85                Confidentiality::C2Sensitive,
86                Confidentiality::C3Compartmented,
87            ),
88            (Confidentiality::C0Public, Confidentiality::C3Compartmented),
89        ];
90        for (a, b) in pairs {
91            assert_eq!(
92                join_confidentiality(a, b).unwrap(),
93                join_confidentiality(b, a).unwrap()
94            );
95            let mut left = fields(a, 1);
96            let mut right = fields(b, 1);
97            if a.requires_audience() || b.requires_audience() {
98                left.audience = issuer(1);
99                right.audience = issuer(1);
100            }
101            let mut ab = left;
102            join_one(&mut ab, &right).unwrap();
103            let mut ba = right;
104            join_one(&mut ba, &left).unwrap();
105            assert_eq!(ab.confidentiality, ba.confidentiality);
106        }
107    }
108
109    #[test]
110    fn join_is_monotonic_max_confidentiality() {
111        let mut acc = fields(Confidentiality::C0Public, 1);
112        acc.audience = issuer(1);
113        let mut dep = fields(Confidentiality::C2Sensitive, 1);
114        dep.audience = issuer(1);
115        let before = acc.confidentiality.lattice_rank().unwrap();
116        join_one(&mut acc, &dep).unwrap();
117        let after = acc.confidentiality.lattice_rank().unwrap();
118        assert!(after >= before);
119        assert_eq!(acc.confidentiality, Confidentiality::C2Sensitive);
120        assert_eq!(
121            join_confidentiality(Confidentiality::C1Private, Confidentiality::C3Compartmented)
122                .unwrap(),
123            Confidentiality::C3Compartmented
124        );
125    }
126
127    #[test]
128    fn multi_input_disjoint_purposes_conflict() {
129        let mut a = fields(Confidentiality::C1Private, 1);
130        a.purpose_count = 1;
131        a.purposes[0] = issuer(9);
132        let mut b = fields(Confidentiality::C1Private, 2);
133        b.purpose_count = 1;
134        b.purposes[0] = issuer(8);
135        let mut out = LabelFields::blank();
136        assert_eq!(
137            join_labels_into(&a, &[b], &mut out),
138            Err(QdnfError::Conflict)
139        );
140        let mut c = fields(Confidentiality::C1Private, 3);
141        c.purpose_count = 1;
142        c.purposes[0] = issuer(7);
143        assert_eq!(
144            join_labels_into(&a, &[b, c], &mut out),
145            Err(QdnfError::Conflict)
146        );
147    }
148
149    #[test]
150    fn covert_metadata_output_inherits() {
151        let mut req = fields(Confidentiality::C2Sensitive, 1);
152        req.audience = issuer(1);
153        let ctx = JobLabelContext::new(req).unwrap();
154        for sink in [DerivedSink::Log, DerivedSink::Receipt, DerivedSink::Backup] {
155            let projected = project_sink(&ctx, sink).unwrap();
156            assert_eq!(projected.confidentiality, Confidentiality::C2Sensitive);
157        }
158    }
159
160    #[test]
161    fn forged_release_is_denied() {
162        let original = verified(Confidentiality::C2Sensitive, issuer(1), NO_TRAINING);
163        let mut proposed = *original.fields();
164        proposed.confidentiality = Confidentiality::C0Public;
165        proposed.restriction_bits = 0;
166        assert_eq!(
167            release_derivation(&original, &proposed, issuer(2)),
168            Err(QdnfError::Denied)
169        );
170        assert_eq!(
171            release_derivation(&original, &proposed, issuer(1)),
172            Err(QdnfError::Denied)
173        );
174    }
175
176    #[test]
177    fn cache_contamination_c2_under_c0_denied() {
178        assert_eq!(
179            admit_cache_insert(Confidentiality::C0Public, Confidentiality::C2Sensitive),
180            Err(QdnfError::Denied)
181        );
182    }
183
184    #[test]
185    fn delegated_tool_egress_uses_admit_egress() {
186        let mut req = fields(Confidentiality::C2Sensitive, 1);
187        req.audience = issuer(1);
188        req.purpose_count = 1;
189        req.purposes[0] = issuer(5);
190        req.compartment_count = 1;
191        req.compartments[0] = issuer(4);
192        let ctx = JobLabelContext::new(req).unwrap();
193        assert!(admit_caller_egress(
194            &ctx,
195            EgressCaller::DelegatedTool,
196            DerivedSink::Export,
197            issuer(1),
198            issuer(4),
199            issuer(5),
200            2,
201        )
202        .is_ok());
203        assert_eq!(
204            admit_caller_egress(
205                &ctx,
206                EgressCaller::DelegatedTool,
207                DerivedSink::Export,
208                issuer(1),
209                issuer(4),
210                issuer(5),
211                0,
212            ),
213            Err(QdnfError::Denied)
214        );
215    }
216}