1use qualia_core_db::crypto::sanctuary_audit::{
35 open_sealed, seal_to, unwrap_key, wrap_key, AuditKeypair,
36};
37use sha2::{Digest, Sha256};
38
39use crate::consent_credential::{EncryptedCommonsPayload, PayloadCommitment};
40
41const PAYLOAD_AAD: &[u8] = b"qualia:accountability:payload:v1";
43const DEK_AAD: &[u8] = b"qualia:accountability:dek:v1";
45
46pub type DataKey = [u8; 32];
48
49#[derive(Debug, Clone, PartialEq, Eq)]
52pub struct EnvelopeKeypair {
53 pub public: [u8; 32],
54 pub secret: [u8; 32],
55}
56
57impl EnvelopeKeypair {
58 pub fn generate() -> Result<Self, String> {
60 let kp = AuditKeypair::generate().map_err(|e| format!("keypair generate: {e:?}"))?;
61 Ok(Self {
62 public: kp.public,
63 secret: *kp.secret_bytes(),
64 })
65 }
66
67 pub fn public_hex(&self) -> String {
69 hex::encode(self.public)
70 }
71 pub fn secret_hex(&self) -> String {
73 hex::encode(self.secret)
74 }
75
76 pub fn from_hex(public_hex: &str, secret_hex: &str) -> Result<Self, String> {
78 Ok(Self {
79 public: parse_key_hex(public_hex, "public")?,
80 secret: parse_key_hex(secret_hex, "secret")?,
81 })
82 }
83
84 pub fn derive(root_secret: &[u8; 32], domain: &[u8]) -> Self {
89 let mut h = Sha256::new();
90 h.update(domain);
91 h.update(b"\x1f");
92 h.update(root_secret);
93 let derived: [u8; 32] = h.finalize().into();
94 let kp = AuditKeypair::from_secret(derived);
95 Self {
96 public: kp.public,
97 secret: *kp.secret_bytes(),
98 }
99 }
100}
101
102pub const OWNER_ENVELOPE_DOMAIN: &[u8] = b"qualia:accountability:envelope:owner:v1";
104
105pub const OWNER_PQ_KEM_DOMAIN: &[u8] = b"qualia:accountability:pq-kem:xwing-mlkem768:v1";
107pub const OWNER_PQ_DSA_DOMAIN: &[u8] = b"qualia:accountability:pq-dsa:mldsa65:v1";
109
110#[derive(Debug, Clone, PartialEq, Eq)]
114pub struct PostQuantumKeyMaterial {
115 pub xwing_seed: [u8; 64],
117 pub mldsa65_seed: [u8; 32],
119}
120
121impl PostQuantumKeyMaterial {
122 pub fn derive_from_root(root_secret: &[u8; 32]) -> Self {
125 let mut h_kem = Sha256::new();
127 h_kem.update(OWNER_PQ_KEM_DOMAIN);
128 h_kem.update(b"\x00");
129 h_kem.update(root_secret);
130 let kem_seed: [u8; 32] = h_kem.finalize().into();
131
132 let mut h_x25519 = Sha256::new();
134 h_x25519.update(OWNER_PQ_KEM_DOMAIN);
135 h_x25519.update(b"\x01");
136 h_x25519.update(root_secret);
137 let x25519_seed: [u8; 32] = h_x25519.finalize().into();
138
139 let mut xwing_seed = [0u8; 64];
140 xwing_seed[..32].copy_from_slice(&kem_seed);
141 xwing_seed[32..].copy_from_slice(&x25519_seed);
142
143 let mut h_dsa = Sha256::new();
145 h_dsa.update(OWNER_PQ_DSA_DOMAIN);
146 h_dsa.update(b"\x1f");
147 h_dsa.update(root_secret);
148 let mldsa65_seed: [u8; 32] = h_dsa.finalize().into();
149
150 Self {
151 xwing_seed,
152 mldsa65_seed,
153 }
154 }
155
156 pub fn key_id(&self) -> String {
158 let mut h = Sha256::new();
159 h.update(b"qualia:accountability:pq-key-id:v1\x1f");
160 h.update(&self.xwing_seed);
161 h.update(&self.mldsa65_seed);
162 let d = h.finalize();
163 format!("pq:{}", hex::encode(&d[..16]))
164 }
165}
166
167fn parse_key_hex(s: &str, which: &str) -> Result<[u8; 32], String> {
168 let bytes = hex::decode(s.trim()).map_err(|e| format!("{which} key not hex: {e}"))?;
169 bytes
170 .as_slice()
171 .try_into()
172 .map_err(|_| format!("{which} key must be 32 bytes, got {}", bytes.len()))
173}
174
175fn random_dek() -> DataKey {
177 let mut k = [0u8; 32];
178 for chunk in k.chunks_mut(8) {
179 let r = rand::random::<u64>().to_le_bytes();
180 chunk.copy_from_slice(&r[..chunk.len()]);
181 }
182 k
183}
184
185pub fn seal_payload(
189 plaintext: &[u8],
190 storers: Vec<String>,
191) -> Result<(EncryptedCommonsPayload, DataKey), String> {
192 let dek = random_dek();
193 let ciphertext =
194 wrap_key(&dek, plaintext, PAYLOAD_AAD).map_err(|e| format!("seal payload: {e:?}"))?;
195 let commitment: PayloadCommitment = Sha256::digest(&ciphertext).into();
196 Ok((
197 EncryptedCommonsPayload::new(commitment, ciphertext, storers),
198 dek,
199 ))
200}
201
202pub fn wrap_dek_to(recipient_public: &[u8; 32], dek: &DataKey) -> Result<Vec<u8>, String> {
205 seal_to(recipient_public, dek, DEK_AAD).map_err(|e| format!("wrap DEK: {e:?}"))
206}
207
208pub fn unwrap_dek(recipient_secret: &[u8; 32], wrapped: &[u8]) -> Result<DataKey, String> {
210 let opened = open_sealed(recipient_secret, wrapped, DEK_AAD)
211 .map_err(|e| format!("unwrap DEK: {e:?}"))?;
212 opened
213 .as_slice()
214 .try_into()
215 .map_err(|_| "unwrapped DEK was not 32 bytes".to_string())
216}
217
218pub fn open_payload(payload: &EncryptedCommonsPayload, dek: &DataKey) -> Result<Vec<u8>, String> {
221 let recomputed: PayloadCommitment = Sha256::digest(&payload.ciphertext).into();
222 if recomputed != payload.commitment {
223 return Err("commitment mismatch — ciphertext is not the committed bytes".into());
224 }
225 unwrap_key(dek, &payload.ciphertext, PAYLOAD_AAD).map_err(|e| format!("open payload: {e:?}"))
226}
227
228pub fn open_payload_with_wrapped(
232 payload: &EncryptedCommonsPayload,
233 recipient_secret: &[u8; 32],
234 wrapped_dek: &[u8],
235) -> Result<Vec<u8>, String> {
236 let dek = unwrap_dek(recipient_secret, wrapped_dek)?;
237 open_payload(payload, &dek)
238}
239
240#[cfg(test)]
241mod tests {
242 use super::*;
243
244 #[test]
245 fn seal_wrap_unwrap_open_round_trips() {
246 let owner = EnvelopeKeypair::generate().unwrap();
247 let agent = EnvelopeKeypair::generate().unwrap();
248 let plaintext = b"housing record: emergency placement requested 2026-07-06";
249
250 let (payload, dek) = seal_payload(plaintext, vec!["did:wf:person".into()]).unwrap();
252 assert_ne!(
253 payload.ciphertext.as_slice(),
254 plaintext,
255 "payload is really encrypted"
256 );
257 let wrapped = wrap_dek_to(&agent.public, &dek).unwrap();
258
259 let opened = open_payload_with_wrapped(&payload, &agent.secret, &wrapped).unwrap();
261 assert_eq!(
262 opened.as_slice(),
263 plaintext,
264 "agent decrypts the exact plaintext"
265 );
266
267 let wrapped_self = wrap_dek_to(&owner.public, &dek).unwrap();
269 assert_eq!(
270 open_payload_with_wrapped(&payload, &owner.secret, &wrapped_self)
271 .unwrap()
272 .as_slice(),
273 plaintext
274 );
275 }
276
277 #[test]
278 fn wrong_recipient_cannot_unwrap_the_dek() {
279 let agent = EnvelopeKeypair::generate().unwrap();
280 let attacker = EnvelopeKeypair::generate().unwrap();
281 let (_payload, dek) = seal_payload(b"secret", vec![]).unwrap();
282 let wrapped = wrap_dek_to(&agent.public, &dek).unwrap();
283 assert!(
285 unwrap_dek(&attacker.secret, &wrapped).is_err(),
286 "only the intended recipient unwraps"
287 );
288 }
289
290 #[test]
291 fn revocation_destroying_the_wrapped_dek_makes_the_payload_unrecoverable() {
292 let agent = EnvelopeKeypair::generate().unwrap();
295 let (payload, dek) = seal_payload(
296 b"the record",
297 vec!["did:wf:person".into(), "did:wf:archive".into()],
298 )
299 .unwrap();
300 let wrapped = Some(wrap_dek_to(&agent.public, &dek).unwrap());
301
302 assert!(
304 open_payload_with_wrapped(&payload, &agent.secret, wrapped.as_ref().unwrap()).is_ok()
305 );
306
307 let wrapped: Option<Vec<u8>> = None;
310 assert!(wrapped.is_none());
311 assert!(
312 payload.is_durable(),
313 "the commons bytes are NOT chased down — they survive"
314 );
315 assert!(
317 open_payload(&payload, &[0u8; 32]).is_err(),
318 "no key, no payload"
319 );
320 }
321
322 #[test]
323 fn a_tampered_ciphertext_is_rejected() {
324 let agent = EnvelopeKeypair::generate().unwrap();
325 let (mut payload, dek) = seal_payload(b"unaltered record", vec![]).unwrap();
326 let wrapped = wrap_dek_to(&agent.public, &dek).unwrap();
327 let mid = payload.ciphertext.len() / 2;
330 payload.ciphertext[mid] ^= 0xFF;
331 assert!(
332 open_payload_with_wrapped(&payload, &agent.secret, &wrapped).is_err(),
333 "tamper is detected"
334 );
335 }
336
337 #[test]
338 fn a_swapped_ciphertext_breaks_the_commitment() {
339 let (mut a, _dek_a) = seal_payload(b"record A", vec![]).unwrap();
340 let (b, _dek_b) = seal_payload(b"record B", vec![]).unwrap();
341 a.ciphertext = b.ciphertext;
343 assert!(
344 open_payload(&a, &[0u8; 32]).is_err(),
345 "commitment binds the ciphertext"
346 );
347 }
348
349 #[test]
350 fn derived_owner_keypair_is_deterministic_and_usable() {
351 let seed = [42u8; 32]; let a = EnvelopeKeypair::derive(&seed, OWNER_ENVELOPE_DOMAIN);
353 let b = EnvelopeKeypair::derive(&seed, OWNER_ENVELOPE_DOMAIN);
354 assert_eq!(
355 a, b,
356 "same seed + domain ⇒ same keypair (re-derivable, nothing stored)"
357 );
358 assert_ne!(a, EnvelopeKeypair::derive(&seed, b"other:domain"));
360 assert_ne!(
361 a,
362 EnvelopeKeypair::derive(&[7u8; 32], OWNER_ENVELOPE_DOMAIN)
363 );
364 let (payload, dek) = seal_payload(b"owner-held record", vec![]).unwrap();
366 let wrapped = wrap_dek_to(&a.public, &dek).unwrap();
367 let rederived = EnvelopeKeypair::derive(&seed, OWNER_ENVELOPE_DOMAIN);
368 assert_eq!(
369 open_payload_with_wrapped(&payload, &rederived.secret, &wrapped)
370 .unwrap()
371 .as_slice(),
372 b"owner-held record"
373 );
374 }
375
376 #[test]
377 fn keypair_hex_round_trips() {
378 let kp = EnvelopeKeypair::generate().unwrap();
379 let back = EnvelopeKeypair::from_hex(&kp.public_hex(), &kp.secret_hex()).unwrap();
380 assert_eq!(kp, back);
381 assert!(EnvelopeKeypair::from_hex("zz", &kp.secret_hex()).is_err());
382 }
383
384 #[test]
385 fn pq_key_material_deterministic_derivation() {
386 let root = [99u8; 32];
387 let pq1 = PostQuantumKeyMaterial::derive_from_root(&root);
388 let pq2 = PostQuantumKeyMaterial::derive_from_root(&root);
389 assert_eq!(pq1, pq2, "derivation must be deterministic");
390 assert_eq!(pq1.key_id(), pq2.key_id(), "key_id must be deterministic");
391
392 let root_other = [100u8; 32];
393 let pq_other = PostQuantumKeyMaterial::derive_from_root(&root_other);
394 assert_ne!(pq1, pq_other);
395 assert_ne!(pq1.key_id(), pq_other.key_id());
396 }
397
398 #[test]
399 fn pq_key_material_domain_separation() {
400 let root = [42u8; 32];
401 let pq = PostQuantumKeyMaterial::derive_from_root(&root);
402 let classical = EnvelopeKeypair::derive(&root, OWNER_ENVELOPE_DOMAIN);
403
404 assert_ne!(&pq.xwing_seed[..32], &pq.xwing_seed[32..]);
406 assert_ne!(&pq.xwing_seed[..32], &pq.mldsa65_seed[..]);
408 assert_ne!(&pq.xwing_seed[32..], &pq.mldsa65_seed[..]);
409 assert_ne!(&pq.xwing_seed[..32], &classical.secret[..]);
411 assert_ne!(&pq.xwing_seed[32..], &classical.secret[..]);
412 assert_ne!(&pq.mldsa65_seed[..], &classical.secret[..]);
413 }
414
415 #[test]
416 fn pq_key_material_key_id_stability() {
417 let root = [1u8; 32];
418 let pq = PostQuantumKeyMaterial::derive_from_root(&root);
419 let id = pq.key_id();
420 assert!(id.starts_with("pq:"));
421 assert_eq!(id.len(), 3 + 32); assert_eq!(id, pq.key_id());
424 }
425}