Skip to main content

qualia_core_db/net/qdnf/profiles/
negotiate.rs

1//! Profile negotiation: compatible control sets only. Never downgrade for cost.
2
3use crate::crypto::network::transcript::Transcript;
4use crate::net::peer::runtime::{ReservationHandle, ReservationLedger};
5use crate::net::qdnf::errors::QdnfError;
6use crate::net::qdnf::types::StrongDigest;
7
8use super::budget::{estimate_overhead, OverheadBudget};
9use super::catalog::{catalog_entry, ControlId, ControlPredicate, ControlSet, ProtectionProfile};
10
11const CANDIDATES: [ProtectionProfile; 5] = [
12    ProtectionProfile::P0,
13    ProtectionProfile::P1,
14    ProtectionProfile::P2,
15    ProtectionProfile::P3,
16    ProtectionProfile::P4,
17];
18
19const DEFAULT_APP_BYTES_PRIVATE: u64 = 1;
20const DEFAULT_DURATION_MS: u64 = 1000;
21const DEFAULT_RETRIES: u64 = 0;
22
23/// Organisational cost ranking among *feasible* configs. Cannot lower the
24/// required floor. `PaidTier` is the S13 case: same feasible set as `LeastCost`.
25#[repr(u8)]
26#[derive(Clone, Copy, Debug, PartialEq, Eq)]
27pub enum CostPreference {
28    LeastCost = 0,
29    PaidTier = 1,
30}
31
32#[derive(Debug)]
33pub enum NegotiateOutcome {
34    Selected(SelectedProfile),
35    Unavailable,
36}
37
38#[derive(Debug)]
39pub struct SelectedProfile {
40    pub profile: ProtectionProfile,
41    pub controls: ControlSet,
42    pub overhead: OverheadBudget,
43    pub version_digest: StrongDigest,
44    pub reservation: ReservationHandle,
45}
46
47struct Candidate {
48    profile: ProtectionProfile,
49    controls: ControlSet,
50    overhead: OverheadBudget,
51}
52
53fn approved_relay_id() -> ControlId {
54    ControlId::from_predicate(ControlPredicate::ApprovedRelay)
55}
56
57fn isolated_bearer_id() -> ControlId {
58    ControlId::from_predicate(ControlPredicate::IsolatedBearer)
59}
60
61/// `IsolatedBearer` may replace `ApprovedRelay` (P4 isolated local bearer).
62fn control_satisfied(available: &ControlSet, need: ControlId) -> bool {
63    if available.contains(need) {
64        return true;
65    }
66    need == approved_relay_id() && available.contains(isolated_bearer_id())
67}
68
69fn satisfies(available: &ControlSet, required: &ControlSet) -> bool {
70    let mut i = 0usize;
71    while i < required.control_count as usize {
72        if !control_satisfied(available, required.controls[i]) {
73            return false;
74        }
75        i += 1;
76    }
77    true
78}
79
80fn union_required_onto_catalog(
81    catalog: &ControlSet,
82    required: &ControlSet,
83) -> Result<ControlSet, QdnfError> {
84    let mut out = *catalog;
85    let mut i = 0usize;
86    while i < required.control_count as usize {
87        let id = required.controls[i];
88        if id == approved_relay_id() && catalog.contains(isolated_bearer_id()) {
89            i += 1;
90            continue;
91        }
92        out.try_push(id)?;
93        i += 1;
94    }
95    Ok(out)
96}
97
98/// SHA-384 transcript of selected profile id + control-set digest.
99pub fn bind_version_digest(
100    profile: ProtectionProfile,
101    controls_digest: StrongDigest,
102) -> Result<StrongDigest, QdnfError> {
103    let mut t = Transcript::new();
104    t.append(b"profile", &[profile.to_u8()])?;
105    t.append(b"controls", controls_digest.as_bytes())?;
106    Ok(t.digest())
107}
108
109fn application_bytes(profile: ProtectionProfile) -> u64 {
110    match profile {
111        ProtectionProfile::P0 => 0,
112        _ => DEFAULT_APP_BYTES_PRIVATE,
113    }
114}
115
116fn collect_feasible(
117    required: &ControlSet,
118    peer_available: &ControlSet,
119    local_available: &ControlSet,
120    out: &mut [Option<Candidate>; 5],
121) -> Result<usize, QdnfError> {
122    if !satisfies(peer_available, required) || !satisfies(local_available, required) {
123        return Err(QdnfError::UnknownProfile);
124    }
125    let floor = required.profile.floor_rank();
126    let mut n = 0usize;
127    let mut i = 0usize;
128    while i < CANDIDATES.len() {
129        let profile = CANDIDATES[i];
130        if profile.floor_rank() < floor {
131            i += 1;
132            continue;
133        }
134        let catalog = catalog_entry(profile);
135        if !peer_available.contains_all(&catalog) || !local_available.contains_all(&catalog) {
136            i += 1;
137            continue;
138        }
139        let controls = if profile == required.profile {
140            *required
141        } else {
142            union_required_onto_catalog(&catalog, required)?
143        };
144        if !satisfies(peer_available, &controls) || !satisfies(local_available, &controls) {
145            i += 1;
146            continue;
147        }
148        let overhead = estimate_overhead(
149            profile,
150            &controls,
151            application_bytes(profile),
152            DEFAULT_DURATION_MS,
153            DEFAULT_RETRIES,
154            false,
155        )?;
156        out[n] = Some(Candidate {
157            profile,
158            controls,
159            overhead,
160        });
161        n += 1;
162        i += 1;
163    }
164    if n == 0 {
165        return Err(QdnfError::UnknownProfile);
166    }
167    Ok(n)
168}
169
170fn pick_candidate(
171    slots: &[Option<Candidate>; 5],
172    count: usize,
173    extra_protection: bool,
174) -> Result<usize, QdnfError> {
175    if count == 0 {
176        return Err(QdnfError::UnknownProfile);
177    }
178    if extra_protection {
179        return Ok(count - 1);
180    }
181    let mut best = 0usize;
182    let mut best_bytes = slots[0]
183        .as_ref()
184        .ok_or(QdnfError::UnknownProfile)?
185        .overhead
186        .total_bytes()?;
187    let mut i = 1usize;
188    while i < count {
189        let bytes = slots[i]
190            .as_ref()
191            .ok_or(QdnfError::UnknownProfile)?
192            .overhead
193            .total_bytes()?;
194        if bytes < best_bytes {
195            best = i;
196            best_bytes = bytes;
197        }
198        i += 1;
199    }
200    Ok(best)
201}
202
203/// Negotiates a profile.
204pub fn negotiate(
205    required: &ControlSet,
206    peer_available: &ControlSet,
207    local_available: &ControlSet,
208    cost_preference: CostPreference,
209    extra_protection: bool,
210    ledger: &mut ReservationLedger,
211) -> Result<SelectedProfile, QdnfError> {
212    let _ = cost_preference;
213    let mut slots: [Option<Candidate>; 5] = [None, None, None, None, None];
214    let count = collect_feasible(required, peer_available, local_available, &mut slots)?;
215    let idx = pick_candidate(&slots, count, extra_protection)?;
216    let chosen = slots[idx].take().ok_or(QdnfError::UnknownProfile)?;
217    let resource = chosen.overhead.to_resource_budget()?;
218    let reservation = match ledger.reserve(resource, true) {
219        Ok(handle) => handle,
220        Err(QdnfError::BudgetExhausted) => return Err(QdnfError::BudgetExhausted),
221        Err(e) => return Err(e),
222    };
223    let version_digest = bind_version_digest(chosen.profile, chosen.controls.digest)?;
224    Ok(SelectedProfile {
225        profile: chosen.profile,
226        controls: chosen.controls,
227        overhead: chosen.overhead,
228        version_digest,
229        reservation,
230    })
231}
232
233/// Maps profile-incompatibility to [`NegotiateOutcome::Unavailable`].
234/// Budget and other failures stay typed on [`negotiate`].
235pub fn negotiate_outcome(
236    required: &ControlSet,
237    peer_available: &ControlSet,
238    local_available: &ControlSet,
239    cost_preference: CostPreference,
240    extra_protection: bool,
241    ledger: &mut ReservationLedger,
242) -> Result<NegotiateOutcome, QdnfError> {
243    match negotiate(
244        required,
245        peer_available,
246        local_available,
247        cost_preference,
248        extra_protection,
249        ledger,
250    ) {
251        Ok(selected) => Ok(NegotiateOutcome::Selected(selected)),
252        Err(QdnfError::UnknownProfile) | Err(QdnfError::Denied) => {
253            Ok(NegotiateOutcome::Unavailable)
254        }
255        Err(e) => Err(e),
256    }
257}
258
259#[cfg(test)]
260mod tests {
261    use super::*;
262    use crate::net::peer::runtime::{ReservationLedger, ResourceBudget};
263    use crate::net::qdnf::policy_labels::Confidentiality;
264    use crate::net::qdnf::profiles::catalog::catalog_entry;
265    use crate::net::qdnf::profiles::requirements::{
266        required_control_set, AssessedEnvironment, RequirementContext, TaskClass,
267    };
268
269    fn fat_ledger() -> ReservationLedger {
270        let cap = ResourceBudget {
271            bytes: 1 << 20,
272            work: 1 << 20,
273            io: 1 << 10,
274        };
275        ReservationLedger::new(cap, cap, cap, cap, cap)
276    }
277
278    fn tight_ledger() -> ReservationLedger {
279        let cap = ResourceBudget {
280            bytes: 1,
281            work: 1,
282            io: 1,
283        };
284        ReservationLedger::new(cap, cap, cap, cap, cap)
285    }
286
287    #[test]
288    fn p3_required_only_p1_available_is_unknown_profile() {
289        let required = catalog_entry(ProtectionProfile::P3);
290        let available = catalog_entry(ProtectionProfile::P1);
291        let mut ledger = fat_ledger();
292        assert_eq!(
293            negotiate(
294                &required,
295                &available,
296                &available,
297                CostPreference::LeastCost,
298                false,
299                &mut ledger
300            )
301            .unwrap_err(),
302            QdnfError::UnknownProfile
303        );
304        assert_eq!(ledger.used().host.bytes, 0);
305        match negotiate_outcome(
306            &required,
307            &available,
308            &available,
309            CostPreference::LeastCost,
310            false,
311            &mut ledger,
312        )
313        .unwrap()
314        {
315            NegotiateOutcome::Unavailable => {}
316            NegotiateOutcome::Selected(_) => panic!("downgraded to P1"),
317        }
318    }
319
320    #[test]
321    fn cost_preference_cannot_select_p1_when_c2_requires_p2() {
322        let ctx = RequirementContext::new(
323            Confidentiality::C2Sensitive,
324            TaskClass::KnownPeerMessage,
325            AssessedEnvironment::Friendly,
326        );
327        let required = required_control_set(&ctx).unwrap();
328        assert_eq!(required.profile, ProtectionProfile::P2);
329        let available = catalog_entry(ProtectionProfile::P2);
330        let mut ledger = fat_ledger();
331        let selected = negotiate(
332            &required,
333            &available,
334            &available,
335            CostPreference::PaidTier,
336            false,
337            &mut ledger,
338        )
339        .unwrap();
340        assert_eq!(selected.profile, ProtectionProfile::P2);
341        assert!(selected
342            .controls
343            .contains_predicate(ControlPredicate::ProtectedEndpoint));
344        assert_ne!(selected.profile, ProtectionProfile::P1);
345    }
346
347    #[test]
348    fn extra_protection_raises_p1_to_p2_when_both_available() {
349        let required = catalog_entry(ProtectionProfile::P1);
350        let available = catalog_entry(ProtectionProfile::P2);
351        let mut ledger = fat_ledger();
352        let plain = negotiate(
353            &required,
354            &available,
355            &available,
356            CostPreference::LeastCost,
357            false,
358            &mut ledger,
359        )
360        .unwrap();
361        assert_eq!(plain.profile, ProtectionProfile::P1);
362        let raised = negotiate(
363            &required,
364            &available,
365            &available,
366            CostPreference::LeastCost,
367            true,
368            &mut ledger,
369        )
370        .unwrap();
371        assert_eq!(raised.profile, ProtectionProfile::P2);
372        assert!(raised
373            .controls
374            .contains_predicate(ControlPredicate::ProtectedEndpoint));
375    }
376
377    #[test]
378    fn missing_approved_relay_when_p3_required_fails_closed() {
379        let required = catalog_entry(ProtectionProfile::P3);
380        let available = catalog_entry(ProtectionProfile::P2);
381        assert!(!available.contains_predicate(ControlPredicate::ApprovedRelay));
382        let mut ledger = fat_ledger();
383        let err = negotiate(
384            &required,
385            &available,
386            &available,
387            CostPreference::LeastCost,
388            false,
389            &mut ledger,
390        )
391        .unwrap_err();
392        assert!(err == QdnfError::UnknownProfile || err == QdnfError::Denied);
393        assert_eq!(ledger.used().host.bytes, 0);
394    }
395
396    #[test]
397    fn budget_exhausted_does_not_select_anyway() {
398        let required = catalog_entry(ProtectionProfile::P1);
399        let available = catalog_entry(ProtectionProfile::P1);
400        let mut ledger = tight_ledger();
401        assert_eq!(
402            negotiate(
403                &required,
404                &available,
405                &available,
406                CostPreference::LeastCost,
407                false,
408                &mut ledger
409            )
410            .unwrap_err(),
411            QdnfError::BudgetExhausted
412        );
413        assert_eq!(ledger.used().host.bytes, 0);
414        assert_eq!(ledger.used().host.work, 0);
415    }
416
417    #[test]
418    fn selected_digest_binds_profile_id_and_controls() {
419        let required = catalog_entry(ProtectionProfile::P1);
420        let available = catalog_entry(ProtectionProfile::P1);
421        let mut ledger = fat_ledger();
422        let selected = negotiate(
423            &required,
424            &available,
425            &available,
426            CostPreference::LeastCost,
427            false,
428            &mut ledger,
429        )
430        .unwrap();
431        let expected = bind_version_digest(selected.profile, selected.controls.digest).unwrap();
432        assert_eq!(selected.version_digest, expected);
433        let other = bind_version_digest(ProtectionProfile::P2, selected.controls.digest).unwrap();
434        assert_ne!(selected.version_digest, other);
435        let other_controls = catalog_entry(ProtectionProfile::P2);
436        let other_bind = bind_version_digest(selected.profile, other_controls.digest).unwrap();
437        assert_ne!(selected.version_digest, other_bind);
438    }
439
440    #[test]
441    fn no_feasible_config_does_not_fall_back_to_p0() {
442        let required = catalog_entry(ProtectionProfile::P2);
443        let available = catalog_entry(ProtectionProfile::P0);
444        let mut ledger = fat_ledger();
445        assert_eq!(
446            negotiate(
447                &required,
448                &available,
449                &available,
450                CostPreference::LeastCost,
451                true,
452                &mut ledger
453            )
454            .unwrap_err(),
455            QdnfError::UnknownProfile
456        );
457    }
458}