qualia_core_db/net/qdnf/evidence/
seal.rs1use crate::crypto::network::aead::{decrypt_in_place, encrypt_in_place};
8use crate::crypto::network::digest::sha384;
9use crate::crypto::network::types::{AEAD_KEY_LEN, AEAD_NONCE_LEN, AEAD_TAG_LEN};
10use crate::net::qdnf::errors::QdnfError;
11use crate::net::qdnf::types::StrongDigest;
12
13use super::promote::{admit_clock, EvidenceStore, MAX_ORIGINAL};
14
15#[repr(u8)]
17#[derive(Clone, Copy, Debug, PartialEq, Eq)]
18pub enum EvidenceView {
19 HashOnly = 1,
20 Original = 2,
21 Ciphertext = 3,
22}
23
24pub fn examinable(view: EvidenceView) -> bool {
26 match view {
27 EvidenceView::HashOnly => false,
28 EvidenceView::Original | EvidenceView::Ciphertext => true,
29 }
30}
31
32pub fn seal(
34 store: &mut EvidenceStore,
35 digest: StrongDigest,
36 key: &[u8; AEAD_KEY_LEN],
37 nonce: &[u8; AEAD_NONCE_LEN],
38 now: u64,
39) -> Result<(), QdnfError> {
40 admit_clock(store, now)?;
41 if key == &[0u8; AEAD_KEY_LEN] {
42 return Err(QdnfError::Malformed);
43 }
44 let idx = store.find(digest).ok_or(QdnfError::Incomplete)?;
45 if store.slots[idx].sealed {
46 return Err(QdnfError::Conflict);
47 }
48 if !store.slots[idx].plaintext_present {
49 return Err(QdnfError::Incomplete);
50 }
51 let len = store.slots[idx].record.byte_len as usize;
52 let mut buf = [0u8; MAX_ORIGINAL];
53 buf[..len].copy_from_slice(&store.slots[idx].original[..len]);
54 let mut tag = [0u8; AEAD_TAG_LEN];
55 encrypt_in_place(key, nonce, digest.as_bytes(), &mut buf[..len], &mut tag)?;
56 store.slots[idx].ct[..len].copy_from_slice(&buf[..len]);
57 store.slots[idx].nonce = *nonce;
58 store.slots[idx].tag = tag;
59 store.slots[idx].original_ct_digest = sha384(&buf[..len]);
60 store.slots[idx].wrap_epoch = 1;
61 store.slots[idx].sealed = true;
62 store.slots[idx].plaintext_present = false;
63 store.slots[idx].original = [0u8; MAX_ORIGINAL];
64 Ok(())
65}
66
67pub fn decrypt_sealed(
69 store: &EvidenceStore,
70 digest: StrongDigest,
71 key: &[u8; AEAD_KEY_LEN],
72 out: &mut [u8],
73) -> Result<usize, QdnfError> {
74 let idx = store.find(digest).ok_or(QdnfError::Incomplete)?;
75 if !store.slots[idx].sealed {
76 return Err(QdnfError::Incomplete);
77 }
78 let len = store.slots[idx].record.byte_len as usize;
79 if out.len() < len {
80 return Err(QdnfError::Capacity);
81 }
82 let mut buf = [0u8; MAX_ORIGINAL];
83 buf[..len].copy_from_slice(&store.slots[idx].ct[..len]);
84 decrypt_in_place(
85 key,
86 &store.slots[idx].nonce,
87 digest.as_bytes(),
88 &mut buf[..len],
89 &store.slots[idx].tag,
90 )?;
91 out[..len].copy_from_slice(&buf[..len]);
92 Ok(len)
93}
94
95pub fn custodian_plaintext<'a>(
97 store: &'a EvidenceStore,
98 digest: StrongDigest,
99) -> Result<&'a [u8], QdnfError> {
100 let idx = store.find(digest).ok_or(QdnfError::Incomplete)?;
101 if store.slots[idx].sealed || !store.slots[idx].plaintext_present {
102 return Err(QdnfError::Denied);
103 }
104 let len = store.slots[idx].record.byte_len as usize;
105 Ok(&store.slots[idx].original[..len])
106}
107
108#[cfg(test)]
109mod tests {
110 use super::*;
111 use crate::crypto::network::digest::sha384;
112 use crate::net::qdnf::authority::ObservationQuality;
113 use crate::net::qdnf::evidence::classes::{classify, EvidenceClass};
114 use crate::net::qdnf::evidence::promote::{
115 hash_preserves_content, promote, AuthorityAtTime, CustodyBind, EvidenceStore, MAX_ORIGINAL,
116 };
117 use crate::net::qdnf::policy_labels::{
118 encode_label_into, verify_label, Confidentiality, LabelFields,
119 };
120 use crate::net::qdnf::types::Generation;
121 use crate::wal_intent::{IntentTable, TxId};
122
123 fn tx(n: u8) -> TxId {
124 let mut bytes = [0u8; 16];
125 bytes[15] = n;
126 TxId { bytes }
127 }
128
129 fn seed(store: &mut EvidenceStore) -> StrongDigest {
130 let issuer = sha384(b"e19-issuer");
131 let mut fields = LabelFields::request(Confidentiality::C2Sensitive, issuer);
132 fields.audience = issuer;
133 fields.purpose_count = 1;
134 fields.purposes[0] = sha384(b"purpose");
135 let mut buf = [0u8; 256];
136 let n = encode_label_into(&fields, &mut buf).unwrap();
137 let v = verify_label(fields, &buf[..n]).unwrap();
138 let classified = classify(EvidenceClass::SelectedIncident, &v).unwrap();
139 let mut out = [0u8; MAX_ORIGINAL];
140 let rec = promote(
141 store,
142 &mut IntentTable::new(),
143 tx(1),
144 classified,
145 b"sealed-original",
146 AuthorityAtTime {
147 writer_id: 1,
148 generation: Generation(1),
149 unix_secs: 50,
150 },
151 1,
152 ObservationQuality::Measured,
153 CustodyBind {
154 from: sha384(b"from"),
155 to: sha384(b"to"),
156 },
157 Some(sha384(b"ctx")),
158 400,
159 50,
160 &mut out,
161 )
162 .unwrap();
163 rec.original_digest
164 }
165
166 #[test]
167 fn hashes_alone_are_not_examinable() {
168 assert!(!examinable(EvidenceView::HashOnly));
169 assert!(examinable(EvidenceView::Original));
170 assert!(examinable(EvidenceView::Ciphertext));
171 assert!(!hash_preserves_content());
172 }
173
174 #[test]
175 fn seal_zeros_plaintext_and_custodian_is_denied() {
176 let mut store = EvidenceStore::new();
177 let digest = seed(&mut store);
178 let key = [7u8; AEAD_KEY_LEN];
179 let nonce = [9u8; AEAD_NONCE_LEN];
180 seal(&mut store, digest, &key, &nonce, 60).unwrap();
181 assert_eq!(custodian_plaintext(&store, digest), Err(QdnfError::Denied));
182 let mut out = [0u8; MAX_ORIGINAL];
183 let n = decrypt_sealed(&store, digest, &key, &mut out).unwrap();
184 assert_eq!(&out[..n], b"sealed-original");
185 assert!(examinable(EvidenceView::Ciphertext));
186 }
187
188 #[test]
189 fn compromised_custodian_cannot_read_without_grant() {
190 let mut store = EvidenceStore::new();
191 let digest = seed(&mut store);
192 let examiner_key = [3u8; AEAD_KEY_LEN];
193 seal(
194 &mut store,
195 digest,
196 &examiner_key,
197 &[1u8; AEAD_NONCE_LEN],
198 60,
199 )
200 .unwrap();
201 assert_eq!(custodian_plaintext(&store, digest), Err(QdnfError::Denied));
202 let mut out = [0u8; MAX_ORIGINAL];
203 let wrong = [9u8; AEAD_KEY_LEN];
204 assert!(decrypt_sealed(&store, digest, &wrong, &mut out).is_err());
205 assert_ne!(&out[..15], b"sealed-original");
206 }
207}