qualia_core_db/net/qdnf/evidence/
export.rs1use 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#[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
50pub 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
96pub 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
128pub 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
181pub fn renewal_replaces_original() -> bool {
183 false
184}
185
186pub 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}