qualia_core_db/net/qdnf/contracts/
evaluate.rs1use 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#[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
28pub 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#[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}