qualia_core_db/net/qdnf/profiles/
gateway.rs1use super::catalog::{catalog_entry, ControlPredicate, ProtectionProfile};
15use crate::net::qdnf::errors::QdnfError;
16use crate::net::qdnf::policy_labels::{join_one, release_derivation, LabelFields, VerifiedLabel};
17use crate::net::qdnf::types::StrongDigest;
18
19#[repr(u8)]
21#[derive(Clone, Copy, Debug, PartialEq, Eq)]
22pub enum GatewayMedia {
23 Network = 0,
24 Removable = 1,
25}
26
27fn map_denied<T>(r: Result<T, QdnfError>) -> Result<T, QdnfError> {
28 r.map_err(|_| QdnfError::Denied)
29}
30
31pub fn gateway_transfer(
36 source: &VerifiedLabel,
37 destination: &VerifiedLabel,
38 proposed: &LabelFields,
39 reviewer: StrongDigest,
40 media: GatewayMedia,
41 profile: ProtectionProfile,
42) -> Result<(), QdnfError> {
43 if media == GatewayMedia::Removable
44 && !catalog_entry(profile).contains_predicate(ControlPredicate::IsolatedBearer)
45 {
46 return Err(QdnfError::Denied);
47 }
48 let mut joined = *source.fields();
49 map_denied(join_one(&mut joined, destination.fields()))?;
50 map_denied(release_derivation(source, proposed, reviewer))?;
51 Ok(())
52}
53
54pub fn refuse_negotiated_downgrade(
56 negotiated: ProtectionProfile,
57 proposed: ProtectionProfile,
58) -> Result<(), QdnfError> {
59 if proposed.floor_rank() < negotiated.floor_rank() {
60 Err(QdnfError::Downgrade)
61 } else {
62 Ok(())
63 }
64}
65
66pub fn gateway_transfer_negotiated(
68 source: &VerifiedLabel,
69 destination: &VerifiedLabel,
70 proposed: &LabelFields,
71 reviewer: StrongDigest,
72 media: GatewayMedia,
73 negotiated: ProtectionProfile,
74 transfer_profile: ProtectionProfile,
75) -> Result<(), QdnfError> {
76 refuse_negotiated_downgrade(negotiated, transfer_profile)?;
77 gateway_transfer(
78 source,
79 destination,
80 proposed,
81 reviewer,
82 media,
83 transfer_profile,
84 )
85}
86
87#[cfg(test)]
88mod tests {
89 use super::*;
90 use crate::net::qdnf::policy_labels::{
91 encode_label_into, verify_label, Confidentiality, NO_TRAINING,
92 };
93
94 fn issuer(b: u8) -> StrongDigest {
95 let mut d = StrongDigest::ZERO;
96 d.0[0] = b;
97 d.0[47] = 1;
98 d
99 }
100
101 fn verified(conf: Confidentiality, iss: StrongDigest, restrictions: u16) -> VerifiedLabel {
102 let mut fields = LabelFields::request(conf, iss);
103 fields.restriction_bits = restrictions;
104 if conf.requires_audience() {
105 fields.audience = iss;
106 }
107 let mut buf = [0u8; 256];
108 let n = encode_label_into(&fields, &mut buf).unwrap();
109 verify_label(fields, &buf[..n]).unwrap()
110 }
111
112 #[test]
113 fn matching_issuer_same_label_transfers() {
114 let src = verified(Confidentiality::C2Sensitive, issuer(1), 0);
115 let dst = verified(Confidentiality::C2Sensitive, issuer(1), 0);
116 gateway_transfer(
117 &src,
118 &dst,
119 src.fields(),
120 issuer(1),
121 GatewayMedia::Network,
122 ProtectionProfile::P3,
123 )
124 .unwrap();
125 }
126
127 #[test]
128 fn failed_join_is_denied() {
129 let mut a_fields = LabelFields::request(Confidentiality::C2Sensitive, issuer(1));
130 a_fields.audience = issuer(1);
131 a_fields.purpose_count = 1;
132 a_fields.purposes[0] = issuer(9);
133 let mut buf = [0u8; 256];
134 let n = encode_label_into(&a_fields, &mut buf).unwrap();
135 let src = verify_label(a_fields, &buf[..n]).unwrap();
136 let mut b_fields = LabelFields::request(Confidentiality::C2Sensitive, issuer(2));
137 b_fields.audience = issuer(2);
138 b_fields.purpose_count = 1;
139 b_fields.purposes[0] = issuer(8);
140 let n = encode_label_into(&b_fields, &mut buf).unwrap();
141 let dst = verify_label(b_fields, &buf[..n]).unwrap();
142 assert_eq!(
143 gateway_transfer(
144 &src,
145 &dst,
146 src.fields(),
147 issuer(1),
148 GatewayMedia::Network,
149 ProtectionProfile::P3,
150 ),
151 Err(QdnfError::Denied)
152 );
153 }
154
155 #[test]
156 fn failed_release_is_denied() {
157 let src = verified(Confidentiality::C2Sensitive, issuer(1), NO_TRAINING);
158 let dst = verified(Confidentiality::C2Sensitive, issuer(1), NO_TRAINING);
159 let mut proposed = *src.fields();
160 proposed.restriction_bits = 0;
161 proposed.confidentiality = Confidentiality::C0Public;
162 assert_eq!(
163 gateway_transfer(
164 &src,
165 &dst,
166 &proposed,
167 issuer(1),
168 GatewayMedia::Network,
169 ProtectionProfile::P3,
170 ),
171 Err(QdnfError::Denied)
172 );
173 }
174
175 #[test]
176 fn removable_media_requires_isolated_bearer() {
177 let src = verified(Confidentiality::C3Compartmented, issuer(1), 0);
178 let dst = verified(Confidentiality::C3Compartmented, issuer(1), 0);
179 assert_eq!(
180 gateway_transfer(
181 &src,
182 &dst,
183 src.fields(),
184 issuer(1),
185 GatewayMedia::Removable,
186 ProtectionProfile::P3,
187 ),
188 Err(QdnfError::Denied)
189 );
190 gateway_transfer(
191 &src,
192 &dst,
193 src.fields(),
194 issuer(1),
195 GatewayMedia::Removable,
196 ProtectionProfile::P4,
197 )
198 .unwrap();
199 }
200
201 #[test]
202 fn foreign_reviewer_denied() {
203 let src = verified(Confidentiality::C2Sensitive, issuer(1), 0);
204 let dst = verified(Confidentiality::C2Sensitive, issuer(1), 0);
205 assert_eq!(
206 gateway_transfer(
207 &src,
208 &dst,
209 src.fields(),
210 issuer(2),
211 GatewayMedia::Network,
212 ProtectionProfile::P2,
213 ),
214 Err(QdnfError::Denied)
215 );
216 }
217
218 #[test]
219 fn cannot_downgrade_negotiated_profile() {
220 let src = verified(Confidentiality::C2Sensitive, issuer(1), 0);
221 let dst = verified(Confidentiality::C2Sensitive, issuer(1), 0);
222 assert_eq!(
223 refuse_negotiated_downgrade(ProtectionProfile::P3, ProtectionProfile::P1),
224 Err(QdnfError::Downgrade)
225 );
226 assert_eq!(
227 gateway_transfer_negotiated(
228 &src,
229 &dst,
230 src.fields(),
231 issuer(1),
232 GatewayMedia::Network,
233 ProtectionProfile::P3,
234 ProtectionProfile::P1,
235 ),
236 Err(QdnfError::Downgrade)
237 );
238 gateway_transfer_negotiated(
239 &src,
240 &dst,
241 src.fields(),
242 issuer(1),
243 GatewayMedia::Network,
244 ProtectionProfile::P2,
245 ProtectionProfile::P2,
246 )
247 .unwrap();
248 }
249}