Skip to main content

qualia_core_db/net/qdnf/profiles/
gateway.rs

1//! Compartment gateways and removable-media transfer (E16.5).
2//!
3//! This module is a transfer gate, not a router: it does not call
4//! `plan_routes` and does not import `crate::net::qdnf::route`.
5//!
6//! Labels are [`VerifiedLabel`] handles. Join/release failures map to
7//! [`QdnfError::Denied`]. Removable media is [`GatewayMedia::Removable`] and
8//! is admitted only for profiles that list [`ControlPredicate::IsolatedBearer`]
9//! (P4). Counting boolean flags is not an approval instrument.
10//!
11//! Remote wipe and attestation cannot guarantee safety after endpoint
12//! compromise or seizure (E16.7).
13
14use 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/// Transfer media. Removable media is IsolatedBearer (P4) only.
20#[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
31/// Verify labels and releasability at every transfer.
32///
33/// `reviewer` is the release-issuer digest checked by
34/// [`release_derivation`]. Failed join or release is Denied.
35pub 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
54/// Negotiated floor cannot be lowered at a gateway.
55pub 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
66/// Transfer using a profile that must not sit below the negotiated floor.
67pub 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}