qualia_core_db/net/qdnf/policy_labels/
mod.rs1pub mod declassify;
4pub mod decode;
5pub mod egress;
6pub mod flow;
7pub mod join;
8pub mod lattice;
9pub mod projection;
10pub mod release;
11pub mod types;
12pub mod verify;
13
14pub use declassify::{declassify, declassify_record, declassify_to, DeclassifyRecord};
15pub use decode::{decode_label_into, encode_label_into};
16pub use egress::{admit_cache_insert, admit_caller_egress, admit_egress, EgressCaller};
17pub use flow::{protected_read, JobLabelContext};
18pub use join::{join_labels_into, join_one};
19pub use lattice::join_confidentiality;
20pub use projection::{
21 project_sensitivity, project_sink, require_labelled, require_labelled_content, DerivedSink,
22};
23pub use release::release_derivation;
24pub use types::{
25 Confidentiality, LabelFields, VerifiedLabel, MAX_COMPARTMENTS, MAX_JOIN_INPUTS,
26 MAX_LABEL_BYTES, MAX_PURPOSES, NO_BIOMETRIC_REUSE, NO_EXTERNAL_AI, NO_PUBLIC_INDEX,
27 NO_REDISTRIBUTE, NO_TRAINING,
28};
29pub use verify::{verify_label, verify_label_digest};
30
31#[cfg(test)]
32mod tests {
33 use super::*;
34 use crate::net::qdnf::errors::QdnfError;
35 use crate::net::qdnf::types::StrongDigest;
36
37 fn issuer(b: u8) -> StrongDigest {
38 let mut d = StrongDigest::ZERO;
39 d.0[0] = b;
40 d.0[47] = 1;
41 d
42 }
43
44 fn verified(conf: Confidentiality, iss: StrongDigest, restrictions: u16) -> VerifiedLabel {
45 let mut fields = LabelFields::request(conf, iss);
46 fields.restriction_bits = restrictions;
47 if conf.requires_audience() {
48 fields.audience = iss;
49 }
50 let mut buf = [0u8; 256];
51 let n = encode_label_into(&fields, &mut buf).unwrap();
52 verify_label(fields, &buf[..n]).unwrap()
53 }
54
55 #[test]
56 fn join_c1_and_c2_is_c2() {
57 let req = LabelFields::request(Confidentiality::C1Private, issuer(1));
58 let dep = verified(Confidentiality::C2Sensitive, issuer(2), 0);
59 let mut acc = req;
60 join_one(&mut acc, dep.fields()).unwrap();
61 assert_eq!(acc.confidentiality, Confidentiality::C2Sensitive);
62 }
63
64 #[test]
65 fn disjoint_purposes_conflict() {
66 let mut a = LabelFields::request(Confidentiality::C1Private, issuer(1));
67 a.purpose_count = 1;
68 a.purposes[0] = issuer(9);
69 let mut b = LabelFields::request(Confidentiality::C1Private, issuer(2));
70 b.purpose_count = 1;
71 b.purposes[0] = issuer(8);
72 let mut acc = a;
73 assert_eq!(join_one(&mut acc, &b), Err(QdnfError::Conflict));
74 }
75
76 #[test]
77 fn protected_read_joins_c2_even_if_request_was_c0() {
78 let req = LabelFields::request(Confidentiality::C0Public, issuer(1));
79 let mut ctx = JobLabelContext::new(req).unwrap();
80 let object = verified(Confidentiality::C2Sensitive, issuer(3), NO_TRAINING);
81 let src = b"patient";
82 let mut dst = [0u8; 8];
83 let n = protected_read(&mut ctx, &object, src, &mut dst).unwrap();
84 assert_eq!(n, 7);
85 assert_eq!(&dst[..7], src);
86 assert_eq!(ctx.current().confidentiality, Confidentiality::C2Sensitive);
87 assert_eq!(ctx.current().restriction_bits & NO_TRAINING, NO_TRAINING);
88 }
89
90 #[test]
91 fn unknown_confidentiality_does_not_become_public() {
92 assert_eq!(
93 JobLabelContext::new(LabelFields::blank()).err(),
94 Some(QdnfError::Conflict)
95 );
96 assert_ne!(Confidentiality::Unknown, Confidentiality::C0Public);
97 }
98
99 #[test]
100 fn restrictions_union() {
101 let mut a = LabelFields::request(Confidentiality::C1Private, issuer(1));
102 a.restriction_bits = NO_TRAINING;
103 let mut b = LabelFields::request(Confidentiality::C1Private, issuer(2));
104 b.restriction_bits = NO_EXTERNAL_AI;
105 join_one(&mut a, &b).unwrap();
106 assert_eq!(a.restriction_bits, NO_TRAINING | NO_EXTERNAL_AI);
107 }
108
109 #[test]
110 fn foreign_issuer_cannot_relax_confidentiality() {
111 let original = verified(Confidentiality::C2Sensitive, issuer(1), NO_TRAINING);
112 let mut proposed = *original.fields();
113 proposed.confidentiality = Confidentiality::C0Public;
114 proposed.restriction_bits = 0;
115 assert_eq!(
116 release_derivation(&original, &proposed, issuer(2)),
117 Err(QdnfError::Denied)
118 );
119 }
120
121 #[test]
122 fn matching_issuer_cannot_drop_restrictions() {
123 let original = verified(Confidentiality::C2Sensitive, issuer(1), NO_TRAINING);
124 let mut proposed = *original.fields();
125 proposed.confidentiality = Confidentiality::C1Private;
126 proposed.restriction_bits = 0;
127 assert_eq!(
128 release_derivation(&original, &proposed, issuer(1)),
129 Err(QdnfError::Denied)
130 );
131 }
132
133 #[test]
134 fn failed_join_copies_zero_bytes() {
135 let mut object_fields = LabelFields::request(Confidentiality::C1Private, issuer(2));
136 object_fields.purpose_count = 1;
137 object_fields.purposes[0] = issuer(9);
138 let mut buf = [0u8; 256];
139 let n = encode_label_into(&object_fields, &mut buf).unwrap();
140 let object = verify_label(object_fields, &buf[..n]).unwrap();
141 let mut request = LabelFields::request(Confidentiality::C1Private, issuer(1));
142 request.purpose_count = 1;
143 request.purposes[0] = issuer(8);
144 let mut ctx = JobLabelContext::new(request).unwrap();
145 let src = b"secret";
146 let mut dst = [0xFFu8; 8];
147 assert_eq!(
148 protected_read(&mut ctx, &object, src, &mut dst),
149 Err(QdnfError::Conflict)
150 );
151 assert_eq!(dst, [0xFFu8; 8]);
152 }
153
154 #[test]
155 fn missing_label_on_protected_content_fails_closed() {
156 assert_eq!(
157 require_labelled_content(true, None),
158 Err(QdnfError::Incomplete)
159 );
160 assert_eq!(
161 require_labelled_content(false, None).unwrap(),
162 Confidentiality::C0Public
163 );
164 }
165
166 #[test]
167 fn sinks_inherit_and_cannot_lower() {
168 let req = LabelFields::request(Confidentiality::C2Sensitive, issuer(1));
169 let mut fields = req;
170 fields.audience = issuer(1);
171 let ctx = JobLabelContext::new(fields).unwrap();
172 for sink in [
173 DerivedSink::Reply,
174 DerivedSink::Summary,
175 DerivedSink::Translation,
176 DerivedSink::Embedding,
177 DerivedSink::ModelContext,
178 DerivedSink::QueryResult,
179 DerivedSink::Export,
180 DerivedSink::Log,
181 DerivedSink::Receipt,
182 DerivedSink::Backup,
183 ] {
184 let projected = project_sink(&ctx, sink).unwrap();
185 assert_eq!(projected.confidentiality, Confidentiality::C2Sensitive);
186 }
187 }
188
189 #[test]
190 fn joined_distinct_issuers_cannot_release() {
191 let req = LabelFields::request(Confidentiality::C1Private, issuer(1));
192 let dep = verified(Confidentiality::C2Sensitive, issuer(2), NO_TRAINING);
193 let mut acc = req;
194 join_one(&mut acc, dep.fields()).unwrap();
195 assert!(acc.issuer.is_zero());
196 let joined = VerifiedLabel::from_verified(acc, issuer(9));
197 let mut proposed = acc;
198 proposed.confidentiality = Confidentiality::C0Public;
199 assert_eq!(
200 release_derivation(&joined, &proposed, issuer(1)),
201 Err(QdnfError::Unauthorized)
202 );
203 assert_eq!(
204 release_derivation(&joined, &proposed, issuer(2)),
205 Err(QdnfError::Unauthorized)
206 );
207 }
208}