1use proof_core::{
7 model::{
8 AttestationContent, Claim, EventContent, EventType, Evidence, EvidenceKind, MetaValue,
9 Proof, Proposition, RelType, Relationship, StoredAttestation,
10 },
11 ErrorCode, HashAlgorithm, HashRef, Limits, ProofError,
12};
13
14use crate::cbor::CborValue;
15use std::collections::HashSet;
16
17fn text_field(map: &[(CborValue, CborValue)], key: &str) -> Result<String, ProofError> {
18 for (k, v) in map {
19 if let CborValue::Text(kk) = k {
20 if kk == key {
21 if let CborValue::Text(s) = v {
22 if s.is_empty() || s.len() > 1024 {
23 return Err(ErrorCode::SchemaViolation
24 .err(format!("field {key} length out of bounds")));
25 }
26 return Ok(s.clone());
27 }
28 return Err(ErrorCode::SchemaViolation.err(format!("field {key} must be text")));
29 }
30 }
31 }
32 Err(ErrorCode::SchemaViolation.err(format!("missing field {key}")))
33}
34
35fn uint_field(map: &[(CborValue, CborValue)], key: &str) -> Result<u64, ProofError> {
36 for (k, v) in map {
37 if let CborValue::Text(kk) = k {
38 if kk == key {
39 if let CborValue::Uint(n) = v {
40 return Ok(*n);
41 }
42 return Err(ErrorCode::SchemaViolation.err(format!("field {key} must be uint")));
43 }
44 }
45 }
46 Err(ErrorCode::SchemaViolation.err(format!("missing field {key}")))
47}
48
49fn opt_text_or_nil(
50 map: &[(CborValue, CborValue)],
51 key: &str,
52) -> Result<Option<String>, ProofError> {
53 for (k, v) in map {
54 if let CborValue::Text(kk) = k {
55 if kk == key {
56 match v {
57 CborValue::Null => return Ok(None),
58 CborValue::Text(s) => {
59 if s.is_empty() || s.len() > 1024 {
60 return Err(
61 ErrorCode::SchemaViolation.err(format!("field {key} too long"))
62 );
63 }
64 return Ok(Some(s.clone()));
65 }
66 _ => {
67 return Err(
68 ErrorCode::SchemaViolation.err(format!("field {key} must be text|nil"))
69 )
70 }
71 }
72 }
73 }
74 }
75 Err(ErrorCode::SchemaViolation.err(format!("missing field {key}")))
76}
77
78fn opt_uint_or_nil(map: &[(CborValue, CborValue)], key: &str) -> Result<Option<u64>, ProofError> {
79 for (k, v) in map {
80 if let CborValue::Text(kk) = k {
81 if kk == key {
82 match v {
83 CborValue::Null => return Ok(None),
84 CborValue::Uint(n) => return Ok(Some(*n)),
85 _ => {
86 return Err(
87 ErrorCode::SchemaViolation.err(format!("field {key} must be uint|nil"))
88 )
89 }
90 }
91 }
92 }
93 }
94 Err(ErrorCode::SchemaViolation.err(format!("missing field {key}")))
95}
96
97fn check_version(map: &[(CborValue, CborValue)]) -> Result<(), ProofError> {
98 for (k, v) in map {
99 if let CborValue::Text(kk) = k {
100 if kk == "v" {
101 if let CborValue::Uint(1) = v {
102 return Ok(());
103 }
104 return Err(ErrorCode::UnsupportedVersion.err("only v=1 supported"));
105 }
106 }
107 }
108 Err(ErrorCode::SchemaViolation.err("missing field v"))
109}
110
111fn check_closed(
113 map: &[(CborValue, CborValue)],
114 allowed: &[&str],
115 what: &str,
116) -> Result<(), ProofError> {
117 for (k, _) in map {
118 if let CborValue::Text(kk) = k {
119 if !allowed.contains(&kk.as_str()) {
120 return Err(ErrorCode::SchemaViolation.err(format!("{what}: unknown field {kk}")));
121 }
122 } else {
123 return Err(ErrorCode::SchemaViolation.err(format!("{what}: non-text map key")));
124 }
125 }
126 Ok(())
127}
128
129fn meta_value_from_cbor(v: &CborValue) -> Result<MetaValue, ProofError> {
130 match v {
131 CborValue::Text(s) => {
132 if s.len() > 1024 {
133 return Err(ErrorCode::SchemaViolation.err("meta text too long"));
134 }
135 Ok(MetaValue::Text(s.clone()))
136 }
137 CborValue::Uint(n) => Ok(MetaValue::Uint(*n)),
138 CborValue::Bool(b) => Ok(MetaValue::Bool(*b)),
139 _ => Err(ErrorCode::SchemaViolation.err("meta value must be text|uint|bool")),
140 }
141}
142
143fn meta_value_to_cbor(m: &MetaValue) -> CborValue {
144 match m {
145 MetaValue::Text(s) => CborValue::Text(s.clone()),
146 MetaValue::Uint(n) => CborValue::Uint(*n),
147 MetaValue::Bool(b) => CborValue::Bool(*b),
148 }
149}
150
151fn hashref_to_cbor(h: &HashRef) -> CborValue {
152 CborValue::Map(vec![
153 (
154 CborValue::Text("alg".into()),
155 CborValue::Uint(h.alg.cbor_enum()),
156 ),
157 (
158 CborValue::Text("digest".into()),
159 CborValue::Bytes(h.digest.clone()),
160 ),
161 (CborValue::Text("v".into()), CborValue::Uint(h.v as u64)),
162 ])
163}
164
165fn hashref_from_cbor(v: &CborValue) -> Result<HashRef, ProofError> {
166 let map = match v {
167 CborValue::Map(p) => p,
168 _ => return Err(ErrorCode::SchemaViolation.err("payload_ref must be map")),
169 };
170 check_closed(map, &["v", "alg", "digest"], "HashRef")?;
171 check_version(map)?;
172 let alg_n = uint_field(map, "alg")?;
173 let alg = HashAlgorithm::from_cbor_enum(alg_n)?;
174 let digest = map
175 .iter()
176 .find_map(|(k, val)| match k {
177 CborValue::Text(kk) if kk == "digest" => match val {
178 CborValue::Bytes(b) => Some(b.clone()),
179 _ => None,
180 },
181 _ => None,
182 })
183 .ok_or_else(|| ErrorCode::SchemaViolation.err("HashRef.digest must be bytes"))?;
184 HashRef::new(alg, digest)
185}
186
187const EVENT_FIELDS: &[&str] = &[
190 "effective_at",
191 "metadata",
192 "payload_ref",
193 "subject",
194 "type",
195 "v",
196];
197
198pub fn event_to_cbor(e: &EventContent) -> Result<CborValue, ProofError> {
200 if e.v != 1 {
202 return Err(ErrorCode::UnsupportedVersion.err("only v=1 encodable"));
203 }
204 let meta: Vec<(CborValue, CborValue)> = e
205 .metadata
206 .iter()
207 .map(|(k, v)| (CborValue::Text(k.clone()), meta_value_to_cbor(v)))
208 .collect();
209 Ok(CborValue::Map(vec![
210 (
211 CborValue::Text("effective_at".into()),
212 CborValue::Uint(e.effective_at),
213 ),
214 (CborValue::Text("metadata".into()), CborValue::Map(meta)),
215 (
216 CborValue::Text("payload_ref".into()),
217 hashref_to_cbor(&e.payload_ref),
218 ),
219 (
220 CborValue::Text("subject".into()),
221 CborValue::Text(e.subject.clone()),
222 ),
223 (
224 CborValue::Text("type".into()),
225 CborValue::Text(e.event_type.as_str().into()),
226 ),
227 (CborValue::Text("v".into()), CborValue::Uint(1)),
228 ]))
229}
230
231pub fn cbor_to_event(v: &CborValue, limits: &Limits) -> Result<EventContent, ProofError> {
233 let map = match v {
234 CborValue::Map(p) => p,
235 _ => return Err(ErrorCode::SchemaViolation.err("Event must be map")),
236 };
237 if map.len() > limits.max_map_entries {
238 return Err(ErrorCode::LimitExceeded.err("Event map too large"));
239 }
240 check_closed(map, EVENT_FIELDS, "Event")?;
241 check_version(map)?;
242 let t = text_field(map, "type")?;
243 let event_type = EventType::new(t);
245 let subject = text_field(map, "subject")?;
246 let effective_at = uint_field(map, "effective_at")?;
247 let pref = map
248 .iter()
249 .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "payload_ref"))
250 .map(|(_, v)| v)
251 .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field payload_ref"))?;
252 let payload_ref = hashref_from_cbor(pref)?;
253 let meta_cbor = map
254 .iter()
255 .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "metadata"))
256 .map(|(_, v)| v)
257 .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field metadata"))?;
258 let meta_pairs = match meta_cbor {
259 CborValue::Map(p) => p,
260 _ => return Err(ErrorCode::SchemaViolation.err("metadata must be map")),
261 };
262 if meta_pairs.len() > 16 {
263 return Err(ErrorCode::LimitExceeded.err("metadata too many entries"));
264 }
265 let mut seen = HashSet::new();
266 let mut metadata = Vec::with_capacity(meta_pairs.len());
267 for (k, val) in meta_pairs {
268 let ks = match k {
269 CborValue::Text(s) => s,
270 _ => return Err(ErrorCode::SchemaViolation.err("metadata key must be text")),
271 };
272 if ks.len() > 64 || !seen.insert(ks.clone()) {
273 return Err(ErrorCode::SchemaViolation.err("bad metadata key"));
274 }
275 metadata.push((ks.clone(), meta_value_from_cbor(val)?));
276 }
277 Ok(EventContent {
278 v: 1,
279 event_type,
280 subject,
281 effective_at,
282 payload_ref,
283 metadata,
284 })
285}
286
287const ATT_FIELDS: &[&str] = &[
290 "claim",
291 "evidence_ref",
292 "expires_at",
293 "issued_at",
294 "issuer",
295 "subject",
296 "v",
297];
298
299pub fn attestation_to_cbor(a: &AttestationContent) -> CborValue {
300 let mut claim_pairs = vec![(
301 CborValue::Text("type".into()),
302 CborValue::Text(a.claim.claim_type.clone()),
303 )];
304 for (k, v) in &a.claim.fields {
305 claim_pairs.push((CborValue::Text(k.clone()), meta_value_to_cbor(v)));
306 }
307 CborValue::Map(vec![
308 (CborValue::Text("claim".into()), CborValue::Map(claim_pairs)),
309 (
310 CborValue::Text("evidence_ref".into()),
311 match &a.evidence_ref {
312 Some(s) => CborValue::Text(s.clone()),
313 None => CborValue::Null,
314 },
315 ),
316 (
317 CborValue::Text("expires_at".into()),
318 match a.expires_at {
319 Some(n) => CborValue::Uint(n),
320 None => CborValue::Null,
321 },
322 ),
323 (
324 CborValue::Text("issued_at".into()),
325 CborValue::Uint(a.issued_at),
326 ),
327 (
328 CborValue::Text("issuer".into()),
329 CborValue::Text(a.issuer.clone()),
330 ),
331 (
332 CborValue::Text("subject".into()),
333 CborValue::Text(a.subject.clone()),
334 ),
335 (CborValue::Text("v".into()), CborValue::Uint(1)),
336 ])
337}
338
339pub fn cbor_to_attestation(
340 v: &CborValue,
341 limits: &Limits,
342) -> Result<AttestationContent, ProofError> {
343 let map = match v {
344 CborValue::Map(p) => p,
345 _ => return Err(ErrorCode::SchemaViolation.err("Attestation must be map")),
346 };
347 if map.len() > limits.max_map_entries {
348 return Err(ErrorCode::LimitExceeded.err("Attestation map too large"));
349 }
350 check_closed(map, ATT_FIELDS, "Attestation")?;
351 check_version(map)?;
352 let issuer = text_field(map, "issuer")?;
353 let subject = text_field(map, "subject")?;
354 let issued_at = uint_field(map, "issued_at")?;
355 let expires_at = opt_uint_or_nil(map, "expires_at")?;
356 let evidence_ref = opt_text_or_nil(map, "evidence_ref")?;
357 if let (Some(e), _) = (expires_at, issued_at) {
358 if e < issued_at {
359 return Err(ErrorCode::SchemaViolation.err("expires_at < issued_at"));
360 }
361 }
362 let claim_cbor = map
363 .iter()
364 .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "claim"))
365 .map(|(_, v)| v)
366 .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field claim"))?;
367 let claim_pairs = match claim_cbor {
368 CborValue::Map(p) => p,
369 _ => return Err(ErrorCode::SchemaViolation.err("claim must be map")),
370 };
371 if claim_pairs.len() > 16 || claim_pairs.is_empty() {
372 return Err(ErrorCode::SchemaViolation.err("claim size out of bounds"));
373 }
374 let mut claim_type: Option<String> = None;
375 let mut fields = Vec::new();
376 let mut seen = HashSet::new();
377 for (k, val) in claim_pairs {
378 let ks = match k {
379 CborValue::Text(s) => s,
380 _ => return Err(ErrorCode::SchemaViolation.err("claim key must be text")),
381 };
382 if !seen.insert(ks.clone()) {
383 return Err(ErrorCode::SchemaViolation.err("duplicate claim key"));
384 }
385 if ks == "type" {
386 match val {
387 CborValue::Text(s) => {
388 if s.is_empty() || s.len() > 128 {
389 return Err(ErrorCode::SchemaViolation.err("bad claim type"));
390 }
391 claim_type = Some(s.clone());
392 }
393 _ => return Err(ErrorCode::SchemaViolation.err("claim.type must be text")),
394 }
395 } else {
396 fields.push((ks.clone(), meta_value_from_cbor(val)?));
397 }
398 }
399 let claim_type =
400 claim_type.ok_or_else(|| ErrorCode::SchemaViolation.err("missing claim.type"))?;
401 void_limits(limits)?;
402 Ok(AttestationContent {
403 v: 1,
404 issuer,
405 subject,
406 claim: Claim { claim_type, fields },
407 issued_at,
408 expires_at,
409 evidence_ref,
410 })
411}
412
413const EVIDENCE_FIELDS: &[&str] = &["attestation_ref", "digest", "hint", "kind", "v"];
416
417pub fn evidence_to_cbor(e: &Evidence) -> CborValue {
418 CborValue::Map(vec![
419 (
420 CborValue::Text("attestation_ref".into()),
421 match &e.attestation_ref {
422 Some(s) => CborValue::Text(s.clone()),
423 None => CborValue::Null,
424 },
425 ),
426 (CborValue::Text("digest".into()), hashref_to_cbor(&e.digest)),
427 (
428 CborValue::Text("hint".into()),
429 match &e.hint {
430 Some(s) => CborValue::Text(s.clone()),
431 None => CborValue::Null,
432 },
433 ),
434 (
435 CborValue::Text("kind".into()),
436 CborValue::Text(e.kind.as_str().into()),
437 ),
438 (CborValue::Text("v".into()), CborValue::Uint(1)),
439 ])
440}
441
442pub fn cbor_to_evidence(v: &CborValue, limits: &Limits) -> Result<Evidence, ProofError> {
443 let map = match v {
444 CborValue::Map(p) => p,
445 _ => return Err(ErrorCode::SchemaViolation.err("Evidence must be map")),
446 };
447 if map.len() > limits.max_map_entries {
448 return Err(ErrorCode::LimitExceeded.err("Evidence map too large"));
449 }
450 check_closed(map, EVIDENCE_FIELDS, "Evidence")?;
451 check_version(map)?;
452 let k = text_field(map, "kind")?;
453 let kind = EvidenceKind::new(k);
455 let digest_cbor = map
456 .iter()
457 .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "digest"))
458 .map(|(_, v)| v)
459 .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field digest"))?;
460 let digest = hashref_from_cbor(digest_cbor)?;
461 let attestation_ref = opt_text_or_nil(map, "attestation_ref")?;
462 let hint = opt_text_or_nil(map, "hint")?;
463 if hint.as_deref().is_some_and(|s| s.len() > 256) {
464 return Err(ErrorCode::SchemaViolation.err("hint too long"));
465 }
466 void_limits(limits)?;
467 Ok(Evidence {
468 v: 1,
469 kind,
470 digest,
471 attestation_ref,
472 hint,
473 })
474}
475
476fn void_limits(_: &Limits) -> Result<(), ProofError> {
477 Ok(())
478}
479
480const REL_FIELDS: &[&str] = &["attestation_ref", "evidence_ref", "from", "to", "type", "v"];
483
484pub fn relationship_to_cbor(r: &Relationship) -> CborValue {
485 CborValue::Map(vec![
486 (
487 CborValue::Text("attestation_ref".into()),
488 match &r.attestation_ref {
489 Some(s) => CborValue::Text(s.clone()),
490 None => CborValue::Null,
491 },
492 ),
493 (
494 CborValue::Text("evidence_ref".into()),
495 match &r.evidence_ref {
496 Some(s) => CborValue::Text(s.clone()),
497 None => CborValue::Null,
498 },
499 ),
500 (
501 CborValue::Text("from".into()),
502 CborValue::Text(r.from.clone()),
503 ),
504 (CborValue::Text("to".into()), CborValue::Text(r.to.clone())),
505 (
506 CborValue::Text("type".into()),
507 CborValue::Text(r.rel_type.as_str().into()),
508 ),
509 (CborValue::Text("v".into()), CborValue::Uint(1)),
510 ])
511}
512
513pub fn cbor_to_relationship(v: &CborValue, limits: &Limits) -> Result<Relationship, ProofError> {
514 let map = match v {
515 CborValue::Map(p) => p,
516 _ => return Err(ErrorCode::SchemaViolation.err("Relationship must be map")),
517 };
518 if map.len() > limits.max_map_entries {
519 return Err(ErrorCode::LimitExceeded.err("Relationship map too large"));
520 }
521 check_closed(map, REL_FIELDS, "Relationship")?;
522 check_version(map)?;
523 let from = text_field(map, "from")?;
524 let to = text_field(map, "to")?;
525 if from == to {
526 return Err(ErrorCode::SchemaViolation.err("self-edge forbidden in V0.1"));
527 }
528 let t = text_field(map, "type")?;
529 let rel_type = RelType::new(t);
531 let evidence_ref = opt_text_or_nil(map, "evidence_ref")?;
532 let attestation_ref = opt_text_or_nil(map, "attestation_ref")?;
533 void_limits(limits)?;
534 Ok(Relationship {
535 v: 1,
536 from,
537 rel_type,
538 to,
539 evidence_ref,
540 attestation_ref,
541 })
542}
543
544const PROP_FIELDS: &[&str] = &[
547 "at_time",
548 "context",
549 "kind",
550 "object",
551 "predicate",
552 "subject",
553 "v",
554];
555
556pub fn proposition_to_cbor(p: &Proposition) -> CborValue {
557 let ctx: Vec<(CborValue, CborValue)> = p
558 .context
559 .iter()
560 .map(|(k, v)| (CborValue::Text(k.clone()), meta_value_to_cbor(v)))
561 .collect();
562 CborValue::Map(vec![
563 (
564 CborValue::Text("at_time".into()),
565 match p.at_time {
566 Some(n) => CborValue::Uint(n),
567 None => CborValue::Null,
568 },
569 ),
570 (CborValue::Text("context".into()), CborValue::Map(ctx)),
571 (
572 CborValue::Text("kind".into()),
573 CborValue::Text(p.kind.clone()),
574 ),
575 (
576 CborValue::Text("object".into()),
577 match &p.object {
578 Some(s) => CborValue::Text(s.clone()),
579 None => CborValue::Null,
580 },
581 ),
582 (
583 CborValue::Text("predicate".into()),
584 CborValue::Text(p.predicate.clone()),
585 ),
586 (
587 CborValue::Text("subject".into()),
588 CborValue::Text(p.subject.clone()),
589 ),
590 (CborValue::Text("v".into()), CborValue::Uint(1)),
591 ])
592}
593
594pub fn cbor_to_proposition(v: &CborValue, limits: &Limits) -> Result<Proposition, ProofError> {
595 let map = match v {
596 CborValue::Map(p) => p,
597 _ => return Err(ErrorCode::SchemaViolation.err("Proposition must be map")),
598 };
599 if map.len() > limits.max_map_entries {
600 return Err(ErrorCode::LimitExceeded.err("Proposition map too large"));
601 }
602 check_closed(map, PROP_FIELDS, "Proposition")?;
603 check_version(map)?;
604 let kind = text_field(map, "kind")?;
605 let subject = text_field(map, "subject")?;
606 let predicate = text_field(map, "predicate")?;
607 let object = opt_text_or_nil(map, "object")?;
608 let at_time = opt_uint_or_nil(map, "at_time")?;
609 let ctx_cbor = map
610 .iter()
611 .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "context"))
612 .map(|(_, v)| v)
613 .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field context"))?;
614 let ctx_pairs = match ctx_cbor {
615 CborValue::Map(p) => p,
616 _ => return Err(ErrorCode::SchemaViolation.err("context must be map")),
617 };
618 if ctx_pairs.len() > 16 {
619 return Err(ErrorCode::LimitExceeded.err("context too many entries"));
620 }
621 let mut seen = HashSet::new();
622 let mut context = Vec::with_capacity(ctx_pairs.len());
623 for (k, val) in ctx_pairs {
624 let ks = match k {
625 CborValue::Text(s) => s,
626 _ => return Err(ErrorCode::SchemaViolation.err("context key must be text")),
627 };
628 if ks.len() > 64 || !seen.insert(ks.clone()) {
629 return Err(ErrorCode::SchemaViolation.err("bad context key"));
630 }
631 context.push((ks.clone(), meta_value_from_cbor(val)?));
632 }
633 void_limits(limits)?;
634 Ok(Proposition {
635 v: 1,
636 kind,
637 subject,
638 predicate,
639 object,
640 at_time,
641 context,
642 })
643}
644
645const PROOF_FIELDS: &[&str] = &[
648 "attestations",
649 "created_at",
650 "events",
651 "evidence",
652 "proof_id",
653 "proposition",
654 "relationships",
655 "v",
656];
657
658fn attestation_entry_to_cbor(a: &StoredAttestation) -> CborValue {
659 CborValue::Map(vec![
660 (
661 CborValue::Text("content".into()),
662 attestation_to_cbor(&a.content),
663 ),
664 (
665 CborValue::Text("sign1".into()),
666 CborValue::Bytes(a.sign1.clone()),
667 ),
668 ])
669}
670
671fn cbor_to_attestation_entry(
672 v: &CborValue,
673 limits: &Limits,
674) -> Result<StoredAttestation, ProofError> {
675 let map = match v {
676 CborValue::Map(p) => p,
677 _ => return Err(ErrorCode::SchemaViolation.err("attestation entry must be map")),
678 };
679 check_closed(map, &["content", "sign1"], "AttestationEntry")?;
680 let content_cbor = map
681 .iter()
682 .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "content"))
683 .map(|(_, v)| v)
684 .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field content"))?;
685 let content = cbor_to_attestation(content_cbor, limits)?;
686 let sign1 = map
687 .iter()
688 .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "sign1"))
689 .map(|(_, v)| v)
690 .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field sign1"))?;
691 let sign1 = match sign1 {
692 CborValue::Bytes(b) => {
693 if b.is_empty() || b.len() > limits.max_proof_size {
694 return Err(ErrorCode::LimitExceeded.err("sign1 size out of bounds"));
695 }
696 b.clone()
697 }
698 _ => return Err(ErrorCode::SchemaViolation.err("sign1 must be bytes")),
699 };
700 Ok(StoredAttestation { content, sign1 })
701}
702
703pub fn proof_to_cbor(p: &Proof) -> Result<CborValue, ProofError> {
704 let mut events = Vec::with_capacity(p.events.len());
705 for e in &p.events {
706 events.push(event_to_cbor(e)?);
707 }
708 Ok(CborValue::Map(vec![
709 (
710 CborValue::Text("attestations".into()),
711 CborValue::Array(
712 p.attestations
713 .iter()
714 .map(attestation_entry_to_cbor)
715 .collect(),
716 ),
717 ),
718 (
719 CborValue::Text("created_at".into()),
720 CborValue::Uint(p.created_at),
721 ),
722 (CborValue::Text("events".into()), CborValue::Array(events)),
723 (
724 CborValue::Text("evidence".into()),
725 CborValue::Array(p.evidence.iter().map(evidence_to_cbor).collect()),
726 ),
727 (
728 CborValue::Text("proof_id".into()),
729 CborValue::Text(p.proof_id.clone()),
730 ),
731 (
732 CborValue::Text("proposition".into()),
733 proposition_to_cbor(&p.proposition),
734 ),
735 (
736 CborValue::Text("relationships".into()),
737 CborValue::Array(p.relationships.iter().map(relationship_to_cbor).collect()),
738 ),
739 (CborValue::Text("v".into()), CborValue::Uint(1)),
740 ]))
741}
742
743fn cbor_array<'a>(
744 map: &'a [(CborValue, CborValue)],
745 key: &str,
746) -> Result<&'a Vec<CborValue>, ProofError> {
747 map.iter()
748 .find(|(k, _)| matches!(k, CborValue::Text(s) if s == key))
749 .map(|(_, v)| v)
750 .ok_or_else(|| ErrorCode::SchemaViolation.err(format!("missing field {key}")))
751 .and_then(|v| match v {
752 CborValue::Array(a) => Ok(a),
753 _ => Err(ErrorCode::SchemaViolation.err(format!("field {key} must be array"))),
754 })
755}
756
757pub fn cbor_to_proof(v: &CborValue, limits: &Limits) -> Result<Proof, ProofError> {
760 let map = match v {
761 CborValue::Map(p) => p,
762 _ => return Err(ErrorCode::SchemaViolation.err("Proof must be map")),
763 };
764 check_closed(map, PROOF_FIELDS, "Proof")?;
765 check_version(map)?;
766 let proof_id = text_field(map, "proof_id")?;
767 if !proof_id.starts_with("prf:v1:") {
768 return Err(ErrorCode::SchemaViolation.err("proof_id must start with prf:v1:"));
769 }
770 let prop_cbor = map
771 .iter()
772 .find(|(k, _)| matches!(k, CborValue::Text(s) if s == "proposition"))
773 .map(|(_, v)| v)
774 .ok_or_else(|| ErrorCode::SchemaViolation.err("missing field proposition"))?;
775 let proposition = cbor_to_proposition(prop_cbor, limits)?;
776 let created_at = uint_field(map, "created_at")?;
777
778 let mut events = vec![];
779 for item in cbor_array(map, "events")? {
780 events.push(cbor_to_event(item, limits)?);
781 }
782 let mut attestations = vec![];
783 for item in cbor_array(map, "attestations")? {
784 attestations.push(cbor_to_attestation_entry(item, limits)?);
785 }
786 let mut evidence = vec![];
787 for item in cbor_array(map, "evidence")? {
788 evidence.push(cbor_to_evidence(item, limits)?);
789 }
790 let mut relationships = vec![];
791 for item in cbor_array(map, "relationships")? {
792 relationships.push(cbor_to_relationship(item, limits)?);
793 }
794 if relationships.len() > limits.max_edges {
796 return Err(ErrorCode::LimitExceeded.err("too many relationships"));
797 }
798 if events.len() + attestations.len() + evidence.len() > limits.max_nodes {
799 return Err(ErrorCode::LimitExceeded.err("too many artifact members"));
800 }
801 void_limits(limits)?;
802 Ok(Proof {
803 v: 1,
804 proof_id,
805 proposition,
806 events,
807 attestations,
808 evidence,
809 relationships,
810 created_at,
811 })
812}
813
814#[cfg(test)]
815mod tests {
816 use super::*;
817 use proof_core::model::{Claim, EventType, EvidenceKind, MetaValue, RelType, Relationship};
818
819 pub fn event_fixture() -> EventContent {
820 EventContent {
821 v: 1,
822 event_type: EventType::new(EventType::PAYMENT_CREATED),
823 subject: "acct:merchant-01".into(),
824 effective_at: 1_700_000_000,
825 payload_ref: HashRef::new(HashAlgorithm::Sha256, vec![0xABu8; 32]).unwrap(),
826 metadata: vec![("order".into(), MetaValue::Text("ord-1".into()))],
827 }
828 }
829
830 #[test]
834 fn event_v2_refuses_to_encode() {
835 let mut e = event_fixture();
836 e.v = 2;
837 let err = event_to_cbor(&e).unwrap_err();
838 assert_eq!(err.code, ErrorCode::UnsupportedVersion);
839 }
840
841 #[test]
844 fn event_round_trip() {
845 let lim = Limits::default();
846 let e = event_fixture();
847 let v = event_to_cbor(&e).unwrap();
848 let bytes = crate::encode_canonical(&v);
849 let back = crate::decode_strict(&bytes, &lim).unwrap();
850 assert_eq!(crate::encode_canonical(&back), bytes);
852 let e2 = cbor_to_event(&back, &lim).unwrap();
853 assert_eq!(e2, e);
854 }
855
856 #[test]
857 fn unknown_event_type_accepted() {
858 let lim = Limits::default();
860 let v = CborValue::Map(vec![
861 (CborValue::Text("effective_at".into()), CborValue::Uint(1)),
862 (CborValue::Text("metadata".into()), CborValue::Map(vec![])),
863 (
864 CborValue::Text("payload_ref".into()),
865 CborValue::Map(vec![
866 (CborValue::Text("alg".into()), CborValue::Uint(0)),
867 (
868 CborValue::Text("digest".into()),
869 CborValue::Bytes(vec![0u8; 32]),
870 ),
871 (CborValue::Text("v".into()), CborValue::Uint(1)),
872 ]),
873 ),
874 (
875 CborValue::Text("subject".into()),
876 CborValue::Text("s".into()),
877 ),
878 (
879 CborValue::Text("type".into()),
880 CborValue::Text("healthcare.patient.admitted".into()),
881 ),
882 (CborValue::Text("v".into()), CborValue::Uint(1)),
883 ]);
884 let evt = cbor_to_event(&v, &lim).unwrap();
885 assert_eq!(evt.event_type.as_str(), "healthcare.patient.admitted");
886 assert!(!evt.event_type.is_well_known());
887 }
888
889 #[test]
890 fn unknown_field_rejected() {
891 let lim = Limits::default();
892 let mut e = event_fixture();
893 e.subject = "s".into();
894 let mut v = event_to_cbor(&e).unwrap();
895 if let CborValue::Map(p) = &mut v {
896 p.push((CborValue::Text("evil".into()), CborValue::Uint(1)));
897 }
898 assert_eq!(
899 cbor_to_event(&v, &lim).unwrap_err().code,
900 ErrorCode::SchemaViolation
901 );
902 }
903
904 #[test]
905 fn attestation_expires_before_issued_rejected() {
906 let lim = Limits::default();
907 let a = AttestationContent {
908 v: 1,
909 issuer: "key:ed25519:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".into(),
910 subject: "s".into(),
911 claim: Claim {
912 claim_type: "t".into(),
913 fields: vec![],
914 },
915 issued_at: 200,
916 expires_at: Some(100),
917 evidence_ref: None,
918 };
919 let v = attestation_to_cbor(&a);
920 assert_eq!(
921 cbor_to_attestation(&v, &lim).unwrap_err().code,
922 ErrorCode::SchemaViolation
923 );
924 }
925
926 #[test]
927 fn metadata_value_types_restricted() {
928 let lim = Limits::default();
929 let v = CborValue::Map(vec![
930 (CborValue::Text("effective_at".into()), CborValue::Uint(1)),
931 (
932 CborValue::Text("metadata".into()),
933 CborValue::Map(vec![(
934 CborValue::Text("k".into()),
935 CborValue::Array(vec![]),
936 )]),
937 ),
938 (
939 CborValue::Text("payload_ref".into()),
940 CborValue::Map(vec![
941 (CborValue::Text("alg".into()), CborValue::Uint(0)),
942 (
943 CborValue::Text("digest".into()),
944 CborValue::Bytes(vec![0u8; 32]),
945 ),
946 (CborValue::Text("v".into()), CborValue::Uint(1)),
947 ]),
948 ),
949 (
950 CborValue::Text("subject".into()),
951 CborValue::Text("s".into()),
952 ),
953 (
954 CborValue::Text("type".into()),
955 CborValue::Text("payment.created".into()),
956 ),
957 (CborValue::Text("v".into()), CborValue::Uint(1)),
958 ]);
959 assert_eq!(
960 cbor_to_event(&v, &lim).unwrap_err().code,
961 ErrorCode::SchemaViolation
962 );
963 }
964
965 #[test]
966 fn evidence_round_trip() {
967 let lim = Limits::default();
968 let e = Evidence {
969 v: 1,
970 kind: EvidenceKind::new(EvidenceKind::TRANSACTION_RECORD),
971 digest: HashRef::new(HashAlgorithm::Sha256, vec![0xCDu8; 32]).unwrap(),
972 attestation_ref: Some("att:v1:placeholder".into()),
973 hint: Some("invoice-I-9 settlement".into()),
974 };
975 let v = evidence_to_cbor(&e);
976 let bytes = crate::encode_canonical(&v);
977 let back = crate::decode_strict(&bytes, &lim).unwrap();
978 assert_eq!(crate::encode_canonical(&back), bytes);
979 assert_eq!(cbor_to_evidence(&back, &lim).unwrap(), e);
980 }
981
982 #[test]
983 fn unknown_evidence_kind_accepted() {
984 let lim = Limits::default();
986 let v = CborValue::Map(vec![
987 (CborValue::Text("attestation_ref".into()), CborValue::Null),
988 (
989 CborValue::Text("digest".into()),
990 CborValue::Map(vec![
991 (CborValue::Text("alg".into()), CborValue::Uint(0)),
992 (
993 CborValue::Text("digest".into()),
994 CborValue::Bytes(vec![0u8; 32]),
995 ),
996 (CborValue::Text("v".into()), CborValue::Uint(1)),
997 ]),
998 ),
999 (CborValue::Text("hint".into()), CborValue::Null),
1000 (
1001 CborValue::Text("kind".into()),
1002 CborValue::Text("medical_imaging".into()),
1003 ),
1004 (CborValue::Text("v".into()), CborValue::Uint(1)),
1005 ]);
1006 let evd = cbor_to_evidence(&v, &lim).unwrap();
1007 assert_eq!(evd.kind.as_str(), "medical_imaging");
1008 assert!(!evd.kind.is_well_known());
1009 }
1010
1011 #[test]
1012 fn relationship_round_trip() {
1013 let lim = Limits::default();
1014 let r = Relationship {
1015 v: 1,
1016 from: "evt:v1:aaa".into(),
1017 rel_type: RelType::new(RelType::SETTLES),
1018 to: "evt:v1:bbb".into(),
1019 evidence_ref: Some("evd:v1:ccc".into()),
1020 attestation_ref: None,
1021 };
1022 let v = relationship_to_cbor(&r);
1023 let bytes = crate::encode_canonical(&v);
1024 let back = crate::decode_strict(&bytes, &lim).unwrap();
1025 assert_eq!(crate::encode_canonical(&back), bytes);
1026 assert_eq!(cbor_to_relationship(&back, &lim).unwrap(), r);
1027 }
1028
1029 #[test]
1030 fn relationship_rejects_self_edge_and_accepts_unknown_type() {
1031 let lim = Limits::default();
1032 let base = Relationship {
1033 v: 1,
1034 from: "evt:v1:aaa".into(),
1035 rel_type: RelType::new(RelType::REFERENCES),
1036 to: "evt:v1:bbb".into(),
1037 evidence_ref: None,
1038 attestation_ref: None,
1039 };
1040 let mut v = relationship_to_cbor(&base);
1042 if let CborValue::Map(p) = &mut v {
1043 for (k, val) in p.iter_mut() {
1044 if matches!(k, CborValue::Text(s) if s == "type") {
1045 *val = CborValue::Text("CUSTOM_RELATIONSHIP".into());
1046 }
1047 }
1048 }
1049 let rel = cbor_to_relationship(&v, &lim).unwrap();
1050 assert_eq!(rel.rel_type.as_str(), "CUSTOM_RELATIONSHIP");
1051 assert!(!rel.rel_type.is_well_known());
1052
1053 let mut selfy = base.clone();
1055 selfy.to = selfy.from.clone();
1056 let v2 = relationship_to_cbor(&selfy);
1057 assert_eq!(
1058 cbor_to_relationship(&v2, &lim).unwrap_err().code,
1059 ErrorCode::SchemaViolation
1060 );
1061 }
1062
1063 #[test]
1064 fn proposition_round_trip() {
1065 use proof_core::model::Proposition;
1066 let lim = Limits::default();
1067 let p = Proposition {
1068 v: 1,
1069 kind: "payment.settles-invoice".into(),
1070 subject: "payment:p9".into(),
1071 predicate: "settles".into(),
1072 object: Some("invoice:i9".into()),
1073 at_time: Some(1_700_000_000),
1074 context: vec![(
1075 "policy".into(),
1076 MetaValue::Text("merchant_payment_v1".into()),
1077 )],
1078 };
1079 let v = proposition_to_cbor(&p);
1080 let bytes = crate::encode_canonical(&v);
1081 let back = crate::decode_strict(&bytes, &lim).unwrap();
1082 assert_eq!(crate::encode_canonical(&back), bytes);
1083 assert_eq!(cbor_to_proposition(&back, &lim).unwrap(), p);
1084 }
1085
1086 #[test]
1087 fn proof_envelope_round_trip_and_bounds() {
1088 use proof_core::model::{AttestationContent, Claim, Proof, StoredAttestation};
1089 let lim = Limits::default();
1090 let p = Proof {
1091 v: 1,
1092 proof_id: "prf:v1:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".into(),
1093 proposition: Proposition {
1094 v: 1,
1095 kind: "k".into(),
1096 subject: "s".into(),
1097 predicate: "p".into(),
1098 object: None,
1099 at_time: None,
1100 context: vec![],
1101 },
1102 events: vec![],
1103 attestations: vec![StoredAttestation {
1104 content: AttestationContent {
1105 v: 1,
1106 issuer: "key:ed25519:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".into(),
1107 subject: "s".into(),
1108 claim: Claim {
1109 claim_type: "t".into(),
1110 fields: vec![],
1111 },
1112 issued_at: 1,
1113 expires_at: None,
1114 evidence_ref: None,
1115 },
1116 sign1: vec![0u8; 64],
1117 }],
1118 evidence: vec![],
1119 relationships: vec![],
1120 created_at: 1_700_000_000,
1121 };
1122 let v = proof_to_cbor(&p).unwrap();
1123 let bytes = crate::encode_canonical(&v);
1124 let back = crate::decode_strict(&bytes, &lim).unwrap();
1125 assert_eq!(crate::encode_canonical(&back), bytes);
1126 assert_eq!(cbor_to_proof(&back, &lim).unwrap(), p);
1127 let mut bad = p.clone();
1129 bad.proof_id = "evt:v1:xxx".into();
1130 let vb = proof_to_cbor(&bad).unwrap();
1131 assert_eq!(
1132 cbor_to_proof(&vb, &lim).unwrap_err().code,
1133 ErrorCode::SchemaViolation
1134 );
1135 }
1136}