1use 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#[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
61fn 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
98pub 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
203pub 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
233pub 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}