qualia_core_db/net/qdnf/evidence/
classes.rs1use crate::net::qdnf::errors::QdnfError;
7use crate::net::qdnf::policy_labels::{require_labelled, Confidentiality, VerifiedLabel};
8use crate::net::qdnf::types::StrongDigest;
9
10#[repr(u8)]
12#[derive(Clone, Copy, Debug, PartialEq, Eq)]
13pub enum EvidenceClass {
14 EphemeralDiagnostic = 1,
15 BoundedOperational = 2,
16 SelectedIncident = 3,
17 Obligation = 4,
18 Preserved = 5,
19}
20
21impl EvidenceClass {
22 pub fn from_wire(value: u8) -> Result<Self, QdnfError> {
24 match value {
25 1 => Ok(Self::EphemeralDiagnostic),
26 2 => Ok(Self::BoundedOperational),
27 3 => Ok(Self::SelectedIncident),
28 4 => Ok(Self::Obligation),
29 5 => Ok(Self::Preserved),
30 _ => Err(QdnfError::Malformed),
31 }
32 }
33
34 #[inline]
36 pub const fn requires_context(self) -> bool {
37 matches!(
38 self,
39 Self::SelectedIncident | Self::Obligation | Self::Preserved
40 )
41 }
42}
43
44#[repr(C)]
46#[derive(Clone, Copy, Debug, PartialEq, Eq)]
47pub struct ClassifiedEvidence {
48 pub class: EvidenceClass,
49 pub label_digest: StrongDigest,
50 pub purpose: StrongDigest,
51 pub confidentiality: Confidentiality,
52}
53
54pub fn classify(
56 class: EvidenceClass,
57 label: &VerifiedLabel,
58) -> Result<ClassifiedEvidence, QdnfError> {
59 require_labelled(label.fields())?;
60 if label.exact_bytes_digest().is_zero() {
61 return Err(QdnfError::Malformed);
62 }
63 let purpose = if label.fields().purpose_count == 0 {
64 StrongDigest::ZERO
65 } else {
66 label.fields().purposes[0]
67 };
68 Ok(ClassifiedEvidence {
69 class,
70 label_digest: label.exact_bytes_digest(),
71 purpose,
72 confidentiality: label.confidentiality(),
73 })
74}
75
76pub fn unrestricted_patient_export() -> bool {
78 false
79}
80
81pub fn claims_legal_admissibility() -> bool {
83 false
84}
85
86#[cfg(test)]
87mod tests {
88 use super::*;
89 use crate::crypto::network::digest::sha384;
90 use crate::net::qdnf::policy_labels::{encode_label_into, verify_label, LabelFields};
91
92 fn labelled(conf: Confidentiality, purpose: &[u8]) -> VerifiedLabel {
93 let issuer = sha384(b"e19-issuer");
94 let mut fields = LabelFields::request(conf, issuer);
95 if conf.requires_audience() {
96 fields.audience = issuer;
97 }
98 if !purpose.is_empty() {
99 fields.purpose_count = 1;
100 fields.purposes[0] = sha384(purpose);
101 }
102 let mut buf = [0u8; 256];
103 let n = encode_label_into(&fields, &mut buf).unwrap();
104 verify_label(fields, &buf[..n]).unwrap()
105 }
106
107 #[test]
108 fn every_class_carries_label_digest_and_purpose() {
109 let classes = [
110 EvidenceClass::EphemeralDiagnostic,
111 EvidenceClass::BoundedOperational,
112 EvidenceClass::SelectedIncident,
113 EvidenceClass::Obligation,
114 EvidenceClass::Preserved,
115 ];
116 let mut i = 0usize;
117 while i < classes.len() {
118 let label = labelled(Confidentiality::C1Private, b"incident-purpose");
119 let c = classify(classes[i], &label).unwrap();
120 assert_eq!(c.class, classes[i]);
121 assert_eq!(c.label_digest, label.exact_bytes_digest());
122 assert!(!c.label_digest.is_zero());
123 assert_eq!(c.purpose, sha384(b"incident-purpose"));
124 i += 1;
125 }
126 }
127
128 #[test]
129 fn patient_records_are_not_dumped() {
130 assert!(!unrestricted_patient_export());
131 assert!(!claims_legal_admissibility());
132 let clinical = labelled(Confidentiality::C3Compartmented, b"clinical");
133 let c = classify(EvidenceClass::SelectedIncident, &clinical).unwrap();
134 assert_eq!(c.confidentiality, Confidentiality::C3Compartmented);
135 assert!(!unrestricted_patient_export());
136 }
137
138 #[test]
139 fn unknown_wire_class_is_malformed() {
140 assert_eq!(EvidenceClass::from_wire(0), Err(QdnfError::Malformed));
141 assert_eq!(
142 EvidenceClass::from_wire(1).unwrap(),
143 EvidenceClass::EphemeralDiagnostic
144 );
145 }
146
147 #[test]
148 fn selected_classes_require_context() {
149 assert!(!EvidenceClass::EphemeralDiagnostic.requires_context());
150 assert!(!EvidenceClass::BoundedOperational.requires_context());
151 assert!(EvidenceClass::SelectedIncident.requires_context());
152 assert!(EvidenceClass::Obligation.requires_context());
153 assert!(EvidenceClass::Preserved.requires_context());
154 }
155}