Skip to main content

qualia_core_db/net/qdnf/evidence/
export.rs

1//! Examiner export, offline verification and wrap renewal (E19.5).
2//!
3//! Completeness/gap reports never become empty success. Renewal uses a new
4//! wrap key and retains the original ciphertext.
5
6use crate::crypto::network::aead::{decrypt_in_place, encrypt_in_place};
7use crate::crypto::network::digest::sha384;
8use crate::crypto::network::types::{AEAD_KEY_LEN, AEAD_NONCE_LEN, AEAD_TAG_LEN};
9use crate::net::qdnf::errors::QdnfError;
10use crate::net::qdnf::types::StrongDigest;
11
12use super::promote::{admit_clock, EvidenceStore, MAX_EVIDENCE, MAX_ORIGINAL};
13use super::seal::decrypt_sealed;
14
15/// Recorded disclosed subset. Not a patient-record dump.
16#[repr(C)]
17#[derive(Clone, Copy, Debug, PartialEq, Eq)]
18pub struct ExportReceipt {
19    pub examiner: StrongDigest,
20    pub disclosed: u8,
21    pub omitted: u8,
22    pub disclosed_digests: [StrongDigest; MAX_EVIDENCE],
23}
24
25impl ExportReceipt {
26    pub const EMPTY: Self = Self {
27        examiner: StrongDigest::ZERO,
28        disclosed: 0,
29        omitted: 0,
30        disclosed_digests: [StrongDigest::ZERO; MAX_EVIDENCE],
31    };
32}
33
34#[repr(C)]
35#[derive(Clone, Copy, Debug, PartialEq, Eq)]
36pub struct CompletenessReport {
37    pub complete: bool,
38    pub matched: u8,
39    pub gaps: u8,
40}
41
42impl CompletenessReport {
43    pub const EMPTY: Self = Self {
44        complete: false,
45        matched: 0,
46        gaps: 0,
47    };
48}
49
50/// Export the granted subset. Missing examiner identity is Denied.
51pub fn export_examiner(
52    store: &EvidenceStore,
53    examiner: StrongDigest,
54    wrap_key: &[u8; AEAD_KEY_LEN],
55    selected: &[StrongDigest],
56    out_plain: &mut [u8],
57    receipt: &mut ExportReceipt,
58) -> Result<usize, QdnfError> {
59    if examiner.is_zero() {
60        return Err(QdnfError::Denied);
61    }
62    *receipt = ExportReceipt::EMPTY;
63    receipt.examiner = examiner;
64    if selected.is_empty() {
65        return Err(QdnfError::Incomplete);
66    }
67    let mut written = 0usize;
68    let mut i = 0usize;
69    while i < selected.len() {
70        if receipt.disclosed as usize >= MAX_EVIDENCE {
71            return Err(QdnfError::Capacity);
72        }
73        let digest = selected[i];
74        let idx = store.find(digest).ok_or(QdnfError::Incomplete)?;
75        let len = store.slots[idx].record.byte_len as usize;
76        if written.checked_add(len).ok_or(QdnfError::Range)? > out_plain.len() {
77            return Err(QdnfError::Capacity);
78        }
79        if store.slots[idx].sealed {
80            decrypt_sealed(store, digest, wrap_key, &mut out_plain[written..])?;
81        } else if store.slots[idx].plaintext_present {
82            out_plain[written..written + len].copy_from_slice(&store.slots[idx].original[..len]);
83        } else {
84            return Err(QdnfError::Incomplete);
85        }
86        receipt.disclosed_digests[receipt.disclosed as usize] = digest;
87        receipt.disclosed = receipt.disclosed.checked_add(1).ok_or(QdnfError::Range)?;
88        written += len;
89        i += 1;
90    }
91    let total = store.count();
92    receipt.omitted = (total.saturating_sub(receipt.disclosed as usize)) as u8;
93    Ok(written)
94}
95
96/// Re-hash originals against the manifest. Tamper is Conflict; missing is gap.
97pub fn verify_offline(
98    originals: &[&[u8]],
99    manifest: &[StrongDigest],
100) -> Result<CompletenessReport, QdnfError> {
101    if manifest.is_empty() {
102        return Err(QdnfError::Incomplete);
103    }
104    if originals.len() != manifest.len() {
105        return Err(QdnfError::Incomplete);
106    }
107    let mut report = CompletenessReport::EMPTY;
108    let mut i = 0usize;
109    while i < manifest.len() {
110        if originals[i].is_empty() {
111            report.gaps = report.gaps.saturating_add(1);
112            i += 1;
113            continue;
114        }
115        if sha384(originals[i]) != manifest[i] {
116            return Err(QdnfError::Conflict);
117        }
118        report.matched = report.matched.saturating_add(1);
119        i += 1;
120    }
121    if report.gaps > 0 {
122        return Err(QdnfError::Incomplete);
123    }
124    report.complete = true;
125    Ok(report)
126}
127
128/// New wrap key. Original sealed ciphertext is retained.
129pub fn renew_wrap(
130    store: &mut EvidenceStore,
131    digest: StrongDigest,
132    old_key: &[u8; AEAD_KEY_LEN],
133    new_key: &[u8; AEAD_KEY_LEN],
134    new_nonce: &[u8; AEAD_NONCE_LEN],
135    now: u64,
136) -> Result<(), QdnfError> {
137    admit_clock(store, now)?;
138    if new_key == &[0u8; AEAD_KEY_LEN] || old_key == new_key {
139        return Err(QdnfError::Malformed);
140    }
141    let idx = store.find(digest).ok_or(QdnfError::Incomplete)?;
142    if !store.slots[idx].sealed {
143        return Err(QdnfError::Incomplete);
144    }
145    let len = store.slots[idx].record.byte_len as usize;
146    let prior_digest = store.slots[idx].original_ct_digest;
147    let mut prior = [0u8; MAX_ORIGINAL];
148    prior[..len].copy_from_slice(&store.slots[idx].ct[..len]);
149    let mut plain = [0u8; MAX_ORIGINAL];
150    plain[..len].copy_from_slice(&store.slots[idx].ct[..len]);
151    decrypt_in_place(
152        old_key,
153        &store.slots[idx].nonce,
154        digest.as_bytes(),
155        &mut plain[..len],
156        &store.slots[idx].tag,
157    )?;
158    let mut fresh = [0u8; MAX_ORIGINAL];
159    fresh[..len].copy_from_slice(&plain[..len]);
160    let mut tag = [0u8; AEAD_TAG_LEN];
161    encrypt_in_place(
162        new_key,
163        new_nonce,
164        digest.as_bytes(),
165        &mut fresh[..len],
166        &mut tag,
167    )?;
168    store.slots[idx].renewed_ct[..len].copy_from_slice(&fresh[..len]);
169    store.slots[idx].renewed_nonce = *new_nonce;
170    store.slots[idx].renewed_tag = tag;
171    store.slots[idx].renewed = true;
172    store.slots[idx].wrap_epoch = store.slots[idx]
173        .wrap_epoch
174        .checked_add(1)
175        .ok_or(QdnfError::Range)?;
176    store.slots[idx].ct[..len].copy_from_slice(&prior[..len]);
177    store.slots[idx].original_ct_digest = prior_digest;
178    Ok(())
179}
180
181/// Renewal must not replace the original sealed ciphertext.
182pub fn renewal_replaces_original() -> bool {
183    false
184}
185
186/// Copy retained original ciphertext. Used after renewal.
187pub fn original_ciphertext(
188    store: &EvidenceStore,
189    digest: StrongDigest,
190    out: &mut [u8],
191) -> Result<usize, QdnfError> {
192    let idx = store.find(digest).ok_or(QdnfError::Incomplete)?;
193    if !store.slots[idx].sealed {
194        return Err(QdnfError::Incomplete);
195    }
196    let len = store.slots[idx].record.byte_len as usize;
197    if out.len() < len {
198        return Err(QdnfError::Capacity);
199    }
200    out[..len].copy_from_slice(&store.slots[idx].ct[..len]);
201    Ok(len)
202}
203
204#[cfg(test)]
205mod tests {
206    use super::*;
207    use crate::crypto::network::digest::sha384;
208    use crate::net::qdnf::authority::ObservationQuality;
209    use crate::net::qdnf::evidence::classes::{classify, EvidenceClass};
210    use crate::net::qdnf::evidence::promote::{
211        promote, AuthorityAtTime, CustodyBind, EvidenceStore, MAX_ORIGINAL,
212    };
213    use crate::net::qdnf::evidence::seal::{custodian_plaintext, seal};
214    use crate::net::qdnf::policy_labels::{
215        encode_label_into, verify_label, Confidentiality, LabelFields,
216    };
217    use crate::net::qdnf::types::Generation;
218    use crate::wal_intent::{IntentTable, TxId};
219
220    fn tx(n: u8) -> TxId {
221        let mut bytes = [0u8; 16];
222        bytes[15] = n;
223        TxId { bytes }
224    }
225
226    fn classified() -> crate::net::qdnf::evidence::classes::ClassifiedEvidence {
227        let issuer = sha384(b"e19-issuer");
228        let mut fields = LabelFields::request(Confidentiality::C1Private, issuer);
229        fields.purpose_count = 1;
230        fields.purposes[0] = sha384(b"purpose");
231        let mut buf = [0u8; 256];
232        let n = encode_label_into(&fields, &mut buf).unwrap();
233        classify(
234            EvidenceClass::Preserved,
235            &verify_label(fields, &buf[..n]).unwrap(),
236        )
237        .unwrap()
238    }
239
240    fn seed(store: &mut EvidenceStore, n: u8, bytes: &[u8], now: u64) -> StrongDigest {
241        let mut out = [0u8; MAX_ORIGINAL];
242        promote(
243            store,
244            &mut IntentTable::new(),
245            tx(n),
246            classified(),
247            bytes,
248            AuthorityAtTime {
249                writer_id: 1,
250                generation: Generation(1),
251                unix_secs: now,
252            },
253            n as u64,
254            ObservationQuality::Measured,
255            CustodyBind {
256                from: sha384(b"from"),
257                to: sha384(b"to"),
258            },
259            Some(sha384(b"ctx")),
260            now + 500,
261            now,
262            &mut out,
263        )
264        .unwrap()
265        .original_digest
266    }
267
268    #[test]
269    fn tampered_bundle_is_conflict() {
270        let original = b"bundle-bytes";
271        let manifest = [sha384(original)];
272        assert!(
273            verify_offline(&[original.as_slice()], &manifest)
274                .unwrap()
275                .complete
276        );
277        let mut bad = *original;
278        bad[0] ^= 0xFF;
279        assert_eq!(
280            verify_offline(&[bad.as_slice()], &manifest),
281            Err(QdnfError::Conflict)
282        );
283    }
284
285    #[test]
286    fn gap_is_incomplete_not_empty_success() {
287        let manifest = [sha384(b"present")];
288        assert_eq!(
289            verify_offline(&[b"".as_slice()], &manifest),
290            Err(QdnfError::Incomplete)
291        );
292        assert_eq!(verify_offline(&[], &[]), Err(QdnfError::Incomplete));
293    }
294
295    #[test]
296    fn examiner_export_records_disclosed_subset() {
297        let mut store = EvidenceStore::new();
298        let a = seed(&mut store, 1, b"alpha", 40);
299        let b = seed(&mut store, 2, b"beta-x", 50);
300        let key = [4u8; AEAD_KEY_LEN];
301        seal(&mut store, a, &key, &[1u8; AEAD_NONCE_LEN], 60).unwrap();
302        seal(&mut store, b, &key, &[2u8; AEAD_NONCE_LEN], 70).unwrap();
303        let mut out = [0u8; MAX_ORIGINAL];
304        let mut receipt = ExportReceipt::EMPTY;
305        let n = export_examiner(
306            &store,
307            sha384(b"examiner"),
308            &key,
309            &[a],
310            &mut out,
311            &mut receipt,
312        )
313        .unwrap();
314        assert_eq!(&out[..n], b"alpha");
315        assert_eq!(receipt.disclosed, 1);
316        assert_eq!(receipt.omitted, 1);
317        assert_eq!(receipt.disclosed_digests[0], a);
318        assert_eq!(custodian_plaintext(&store, a), Err(QdnfError::Denied));
319    }
320
321    #[test]
322    fn renewal_retains_original_ciphertext() {
323        assert!(!renewal_replaces_original());
324        let mut store = EvidenceStore::new();
325        let d = seed(&mut store, 1, b"renew-me", 40);
326        let old = [5u8; AEAD_KEY_LEN];
327        let new = [6u8; AEAD_KEY_LEN];
328        seal(&mut store, d, &old, &[3u8; AEAD_NONCE_LEN], 50).unwrap();
329        let mut before = [0u8; MAX_ORIGINAL];
330        let n = original_ciphertext(&store, d, &mut before).unwrap();
331        let prior = sha384(&before[..n]);
332        renew_wrap(&mut store, d, &old, &new, &[4u8; AEAD_NONCE_LEN], 80).unwrap();
333        let mut after = [0u8; MAX_ORIGINAL];
334        let m = original_ciphertext(&store, d, &mut after).unwrap();
335        assert_eq!(&before[..n], &after[..m]);
336        assert_eq!(sha384(&after[..m]), prior);
337        assert!(!renewal_replaces_original());
338        let idx = store.find(d).unwrap();
339        assert!(store.slots[idx].renewed);
340        assert_eq!(store.slots[idx].original_ct_digest, prior);
341    }
342
343    #[test]
344    fn zero_examiner_is_denied() {
345        let store = EvidenceStore::new();
346        let mut out = [0u8; 8];
347        let mut receipt = ExportReceipt::EMPTY;
348        assert_eq!(
349            export_examiner(
350                &store,
351                StrongDigest::ZERO,
352                &[1u8; AEAD_KEY_LEN],
353                &[sha384(b"x")],
354                &mut out,
355                &mut receipt,
356            ),
357            Err(QdnfError::Denied)
358        );
359    }
360}