Skip to main content

qualia_core_db/net/qdnf/evidence/
classes.rs

1//! Evidence classes. Every class carries a verified label digest (E19.1).
2//!
3//! Patient records are never dumped into evidence. Technical classification is
4//! not a claim of legal admissibility.
5
6use crate::net::qdnf::errors::QdnfError;
7use crate::net::qdnf::policy_labels::{require_labelled, Confidentiality, VerifiedLabel};
8use crate::net::qdnf::types::StrongDigest;
9
10/// Capture class. Sensitivity and purpose live on the bound label digest.
11#[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    /// Builds `EvidenceClass` from `wire`.
23    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    /// Contrary/contextual material is required for these selections.
35    #[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/// Classified selection bound to exact label bytes via SHA-384 digest.
45#[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
54/// Bind class to a verified label. Missing/unknown labels fail closed.
55pub 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
76/// Patient records are not an unrestricted evidence dump.
77pub fn unrestricted_patient_export() -> bool {
78    false
79}
80
81/// Technical evidence support is not a guarantee of admissibility or prosecution.
82pub 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}