Skip to main content

qualia_core_db/net/qdnf/contracts/
evaluate.rs

1//! Separate contract evaluator. Calls the public compile_decision API only.
2//!
3//! Does not pass signed/supported booleans into compile internals.
4
5use super::compile::{compile_decision, ContractBundle};
6use super::generations::{recheck_permit, BoundGenerations, LiveGenerations};
7use super::identity::{
8    consume_authority, refuse_alias_merge, same_as_transfers_authority, ReferentKind,
9};
10use super::provenance::{admit_claim, contradicting_claims, ClaimRecord};
11use crate::net::qdnf::authority::{PolicyOutcome, TemporalGrant};
12use crate::net::qdnf::errors::QdnfError;
13
14/// Inputs for one evaluation. Digests and generations, not booleans.
15#[derive(Clone, Copy, Debug)]
16pub struct EvaluationView<'a> {
17    pub bundle: &'a ContractBundle,
18    pub expected: &'a ContractBundle,
19    pub original_bytes: &'a [u8],
20    pub bound: BoundGenerations,
21    pub live: LiveGenerations,
22    pub referent: ReferentKind,
23    pub claims: &'a [ClaimRecord],
24    pub delegation: Option<&'a TemporalGrant>,
25    pub now_unix: u64,
26}
27
28/// Evaluate a pinned contract at a consumption boundary.
29///
30/// Order: referent authority, alias/person merge guard, claim provenance,
31/// generation recheck, delegation freshness, then [`compile_decision`].
32pub fn evaluate(view: &EvaluationView<'_>) -> Result<PolicyOutcome, QdnfError> {
33    consume_authority(view.referent)?;
34    if same_as_transfers_authority() {
35        return Err(QdnfError::Unauthorized);
36    }
37    let mut i = 0usize;
38    while i < view.claims.len() {
39        admit_claim(&view.claims[i])?;
40        if i > 0 {
41            contradicting_claims(&view.claims[0], &view.claims[i])?;
42        }
43        i += 1;
44    }
45    recheck_permit(view.bound, view.live)?;
46    if let Some(grant) = view.delegation {
47        grant.current_at(view.now_unix)?;
48    }
49    compile_decision(view.bundle, view.expected, view.original_bytes)
50}
51
52/// Alias collision is never a person merge.
53#[inline]
54pub fn evaluate_alias(
55    left: ReferentKind,
56    right: ReferentKind,
57    left_id: crate::net::qdnf::types::StrongDigest,
58    right_id: crate::net::qdnf::types::StrongDigest,
59) -> Result<(), QdnfError> {
60    refuse_alias_merge(left, right, left_id, right_id)
61}
62
63#[cfg(test)]
64mod tests {
65    use super::*;
66    use crate::crypto::network::digest::sha384;
67    use crate::net::qdnf::types::{Generation, ProfileId, StrongDigest};
68
69    const BYTES: &[u8] = b"qdnf-eval-artifact-v1";
70
71    fn vocab() -> StrongDigest {
72        StrongDigest([0x31; 48])
73    }
74
75    fn pinned() -> ContractBundle {
76        ContractBundle {
77            exact_bytes_digest: sha384(BYTES),
78            context_digest: StrongDigest([0xB1; 48]),
79            ontology_digest: StrongDigest([0xB2; 48]),
80            shape_digest: StrongDigest([0xB3; 48]),
81            rules_digest: StrongDigest([0xB4; 48]),
82            required_vocab_digest: vocab(),
83            known_vocab_digest: vocab(),
84        }
85    }
86
87    fn gens() -> BoundGenerations {
88        BoundGenerations::new(Generation(1), Generation(1), Generation(1))
89    }
90
91    fn view<'a>(
92        bundle: &'a ContractBundle,
93        expected: &'a ContractBundle,
94        claims: &'a [ClaimRecord],
95        delegation: Option<&'a TemporalGrant>,
96        now: u64,
97    ) -> EvaluationView<'a> {
98        EvaluationView {
99            bundle,
100            expected,
101            original_bytes: BYTES,
102            bound: gens(),
103            live: gens().as_live(),
104            referent: ReferentKind::Entity,
105            claims,
106            delegation,
107            now_unix: now,
108        }
109    }
110
111    fn grant_until(expires: u64) -> TemporalGrant {
112        TemporalGrant {
113            purpose_digest: StrongDigest([0x51; 48]),
114            audience_digest: StrongDigest([0x52; 48]),
115            authority_generation: 1,
116            not_before_unix: 0,
117            expires_unix: expires,
118            profile: ProfileId::QDNF_CRYPTO_1,
119        }
120    }
121
122    #[test]
123    fn matching_view_allows() {
124        let bundle = pinned();
125        let v = view(&bundle, &bundle, &[], None, 1);
126        assert_eq!(evaluate(&v).unwrap(), PolicyOutcome::Allow);
127    }
128
129    #[test]
130    fn wrong_context_digest_is_conflict() {
131        let bundle = pinned();
132        let mut expected = bundle;
133        expected.context_digest = StrongDigest([0x99; 48]);
134        let v = view(&bundle, &expected, &[], None, 1);
135        assert_eq!(evaluate(&v), Err(QdnfError::Conflict));
136    }
137
138    #[test]
139    fn ontology_digest_change_invalidates() {
140        let bundle = pinned();
141        let mut expected = bundle;
142        expected.ontology_digest = StrongDigest([0x77; 48]);
143        let v = view(&bundle, &expected, &[], None, 1);
144        assert_eq!(evaluate(&v), Err(QdnfError::Conflict));
145        assert_ne!(evaluate(&v), Ok(PolicyOutcome::Allow));
146    }
147
148    #[test]
149    fn expired_delegation_is_not_allow() {
150        let bundle = pinned();
151        let grant = grant_until(10);
152        let v = view(&bundle, &bundle, &[], Some(&grant), 10);
153        assert_eq!(evaluate(&v), Err(QdnfError::Expired));
154    }
155
156    #[test]
157    fn current_delegation_still_requires_pinned_bytes() {
158        let bundle = pinned();
159        let grant = grant_until(10);
160        let v = view(&bundle, &bundle, &[], Some(&grant), 9);
161        assert_eq!(evaluate(&v).unwrap(), PolicyOutcome::Allow);
162    }
163
164    #[test]
165    fn alias_collision_does_not_merge_persons() {
166        assert_eq!(
167            evaluate_alias(
168                ReferentKind::Handle,
169                ReferentKind::NaturalPerson,
170                StrongDigest([1u8; 48]),
171                StrongDigest([2u8; 48]),
172            ),
173            Err(QdnfError::Unauthorized)
174        );
175        assert!(!same_as_transfers_authority());
176    }
177
178    #[test]
179    fn contradictory_claims_are_conflict() {
180        let bundle = pinned();
181        let claims = [
182            ClaimRecord {
183                issuer: StrongDigest([1u8; 48]),
184                scope: 4,
185                disagreement: false,
186                confidence: 200,
187            },
188            ClaimRecord {
189                issuer: StrongDigest([2u8; 48]),
190                scope: 4,
191                disagreement: false,
192                confidence: 200,
193            },
194        ];
195        let v = view(&bundle, &bundle, &claims, None, 1);
196        assert_eq!(evaluate(&v), Err(QdnfError::Conflict));
197    }
198
199    #[test]
200    fn flagged_disagreement_is_conflict() {
201        let bundle = pinned();
202        let mut rec = ClaimRecord {
203            issuer: StrongDigest([3u8; 48]),
204            scope: 8,
205            disagreement: true,
206            confidence: 1,
207        };
208        rec.disagreement = true;
209        let claims = [rec];
210        let v = view(&bundle, &bundle, &claims, None, 1);
211        assert_eq!(evaluate(&v), Err(QdnfError::Conflict));
212    }
213
214    #[test]
215    fn handle_referent_cannot_evaluate_as_authority() {
216        let bundle = pinned();
217        let mut v = view(&bundle, &bundle, &[], None, 1);
218        v.referent = ReferentKind::Handle;
219        assert_eq!(evaluate(&v), Err(QdnfError::Unauthorized));
220        v.referent = ReferentKind::Instrument;
221        assert_eq!(evaluate(&v), Err(QdnfError::Unauthorized));
222    }
223
224    #[test]
225    fn stale_generation_at_evaluate_is_not_allow() {
226        let bundle = pinned();
227        let mut v = view(&bundle, &bundle, &[], None, 1);
228        v.live.policy = Generation(9);
229        assert_eq!(evaluate(&v), Err(QdnfError::StaleGeneration));
230    }
231}