Skip to main content

qualia_core_db/bundle/stream/policy/remote/
decision.rs

1//! Private nonconstructible disclosure decision. Not PolicyOutcome::Allow or a bool.
2use super::codec::DecisionTicketFields;
3use super::recognition::RecognizedController;
4use super::PolicyError as E;
5use crate::crypto::network::object_stream::RecipientRecord;
6use crate::net::qdnf::authority::PolicyOutcome;
7use crate::net::qdnf::types::{Generation, StrongDigest};
8
9/// Independent admission facts. Check A against these, never against A itself.
10#[derive(Clone, Copy, Debug, PartialEq, Eq)]
11pub struct IndependentAdmission {
12    pub descriptor: StrongDigest,
13    pub context: StrongDigest,
14    pub recipient: StrongDigest,
15    pub publisher: StrongDigest,
16    pub service: StrongDigest,
17    pub purpose: StrongDigest,
18    pub instrument: StrongDigest,
19    pub scope: StrongDigest,
20    pub operation: [u8; 16],
21    pub closure: StrongDigest,
22    pub policy: StrongDigest,
23    pub consumer: StrongDigest,
24    pub source: StrongDigest,
25    pub source_length: u64,
26}
27
28/// Current remote decision. Fields are private; no public constructor exists.
29#[derive(Debug, PartialEq, Eq)]
30pub struct DisclosureDecision {
31    action: super::DisclosureAction,
32    policy: StrongDigest,
33    controller_generation: Generation,
34    decision_id: u64,
35    expires: u64,
36}
37
38impl DisclosureDecision {
39    pub const fn action(&self) -> super::DisclosureAction {
40        self.action
41    }
42    pub const fn policy(&self) -> StrongDigest {
43        self.policy
44    }
45    pub const fn controller_generation(&self) -> Generation {
46        self.controller_generation
47    }
48    pub const fn decision_id(&self) -> u64 {
49        self.decision_id
50    }
51    pub const fn expires(&self) -> u64 {
52        self.expires
53    }
54
55    pub fn refuse_policy_outcome(outcome: PolicyOutcome) -> E {
56        super::refuse_policy_outcome(outcome)
57    }
58
59    pub fn refuse_bool(allow: bool) -> E {
60        super::refuse_bool_authority(allow)
61    }
62
63    /// R2 mints this after paired verification. R1 only binds schema/recognition.
64    pub(super) fn bind(
65        recognized: &RecognizedController,
66        ticket: &DecisionTicketFields,
67        now: u64,
68    ) -> Result<Self, E> {
69        recognized.current_at(now)?;
70        ticket.valid_at(now)?;
71        if ticket.policy != recognized.policy()
72            || ticket.controller_generation != recognized.controller_generation()
73            || ticket.decision_id < recognized.decision_id_floor()
74            || !recognized.allowed_ops().contains(ticket.action)
75            || ticket.lease_secs()? > recognized.max_decision_lifetime()
76            || ticket.expires > recognized.expires_unix()
77        {
78            return Err(E::Reference);
79        }
80        Ok(Self {
81            action: ticket.action,
82            policy: ticket.policy,
83            controller_generation: ticket.controller_generation,
84            decision_id: ticket.decision_id,
85            expires: ticket.expires,
86        })
87    }
88}
89
90pub fn check_recipient_against_independent(
91    record: &RecipientRecord<'_>,
92    expected: &IndependentAdmission,
93) -> Result<(), E> {
94    let a = record.fields();
95    if a.descriptor != expected.descriptor
96        || a.context != expected.context
97        || a.recipient != expected.recipient
98        || a.publisher != expected.publisher
99        || a.service != expected.service
100        || a.purpose != expected.purpose
101        || a.instrument != expected.instrument
102        || a.scope != expected.scope
103        || a.operation != expected.operation
104        || a.closure != expected.closure
105        || a.policy != expected.policy
106        || a.consumer != expected.consumer
107        || a.source != expected.source
108        || a.source_length != expected.source_length
109    {
110        return Err(E::Reference);
111    }
112    Ok(())
113}