qualia_core_db/net/qdnf/policy_labels/
lattice.rs1#[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
10pub 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}