Skip to main content

qualia_core_db/net/qdnf/policy_labels/
mod.rs

1//! Bounded protection labels. Separate from NQuin sensitivity-byte cache.
2
3pub 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}