Skip to main content

qualia_core_db/net/qdnf/evidence/
seal.rs

1//! Separate AEAD wrap for sealed evidence (E19.4).
2//!
3//! Sealed ciphertext is stored independently of examiner plaintext. Hashes
4//! alone are not examinable. A custodian without an examiner wrap key cannot
5//! read originals.
6
7use 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/// What an examiner can actually inspect.
16#[repr(u8)]
17#[derive(Clone, Copy, Debug, PartialEq, Eq)]
18pub enum EvidenceView {
19    HashOnly = 1,
20    Original = 2,
21    Ciphertext = 3,
22}
23
24/// Hashes alone do not satisfy examinable content.
25pub fn examinable(view: EvidenceView) -> bool {
26    match view {
27        EvidenceView::HashOnly => false,
28        EvidenceView::Original | EvidenceView::Ciphertext => true,
29    }
30}
31
32/// Encrypt originals separately. Plaintext in the owner is zeroed after seal.
33pub 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
67/// Decrypt into `out` with the examiner wrap key. Wrong key is CryptoFailure.
68pub 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
95/// Custodian path: sealed evidence is never returned as plaintext.
96pub 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}