1#[cfg(not(target_arch = "wasm32"))]
5use crate::envelope::MAX_MEDIATED_EVIDENCE_BYTES;
6use crate::envelope::{RequestEnvelope, MAX_TIMESTAMP_AGE_MS};
7use crate::transport_traits::Signer;
8#[cfg(not(target_arch = "wasm32"))]
9use crate::{FromCapnp, ToCapnp};
10use anyhow::{anyhow, ensure, Result};
11use sha2::{Digest, Sha256};
12
13pub const MAX_WITNESS_BYTES: usize = 16 * 1024;
14const AAD: &[u8] = b"hyprstream:mediated-authorization-witness:v1";
15const PURPOSE: &[u8] = b"authorization-query\0v1\0";
16const PURPOSE_V2: &[u8] = b"authorization-query\0v2\0";
17#[cfg(not(target_arch = "wasm32"))]
18const EVIDENCE_MAGIC: &[u8; 8] = b"HAQW1\0\0\0";
19#[cfg(not(target_arch = "wasm32"))]
20const EVIDENCE_V2_MAGIC: &[u8; 8] = b"HAQW2\0\0\0";
21const WITNESS_V2_MAGIC: &[u8; 8] = b"HAQS2\0\0\0";
22
23fn transcript(request: &RequestEnvelope, signer: &[u8; 32], expires: i64) -> Result<Vec<u8>> {
26 transcript_with_operation(request, signer, expires, None)
27}
28
29fn transcript_with_operation(
33 request: &RequestEnvelope,
34 signer: &[u8; 32],
35 expires: i64,
36 operation: Option<&str>,
37) -> Result<Vec<u8>> {
38 ensure!(
39 request.delegation_token.is_none(),
40 "nested delegated witness denied"
41 );
42 let target = request
43 .service_domain
44 .as_deref()
45 .ok_or_else(|| anyhow!("witness target missing"))?;
46 crate::envelope::validate_service_domain(target)?;
47 let credential = request
48 .jwt_token()
49 .ok_or_else(|| anyhow!("witness credential missing"))?;
50 transcript_from_parts(
51 target,
52 credential,
53 Sha256::digest(&request.payload).into(),
54 request.request_id,
55 request.nonce,
56 request.iat,
57 signer,
58 expires,
59 operation,
60 )
61}
62
63#[allow(clippy::too_many_arguments)]
64fn transcript_from_parts(
65 target: &str,
66 credential: &str,
67 payload_hash: [u8; 32],
68 request_id: u64,
69 nonce: [u8; 16],
70 iat: i64,
71 signer: &[u8; 32],
72 expires: i64,
73 operation: Option<&str>,
74) -> Result<Vec<u8>> {
75 crate::envelope::validate_service_domain(target)?;
76 let target_len = u16::try_from(target.len())?;
77 let operation_len = operation.map_or(0, str::len);
78 let mut bytes = Vec::with_capacity(160 + target.len() + operation_len);
79 bytes.extend_from_slice(if operation.is_some() {
80 PURPOSE_V2
81 } else {
82 PURPOSE
83 });
84 bytes.extend_from_slice(signer);
85 bytes.extend_from_slice(&target_len.to_be_bytes());
86 bytes.extend_from_slice(target.as_bytes());
87 bytes.extend_from_slice(&Sha256::digest(credential.as_bytes()));
88 bytes.extend_from_slice(&payload_hash);
89 bytes.extend_from_slice(&request_id.to_be_bytes());
90 bytes.extend_from_slice(&nonce);
91 bytes.extend_from_slice(&iat.to_be_bytes());
92 bytes.extend_from_slice(&expires.to_be_bytes());
93 if let Some(operation) = operation {
94 let operation_len = u16::try_from(operation.len())?;
95 bytes.extend_from_slice(&operation_len.to_be_bytes());
96 bytes.extend_from_slice(operation.as_bytes());
97 }
98 Ok(bytes)
99}
100
101pub async fn sign<S: Signer>(
104 request: &RequestEnvelope,
105 signer: &S,
106) -> Result<crate::sensitive::SensitiveBytes> {
107 use crate::crypto::cose_sign::{
108 assemble_composite_nested_pq_bound, inner_tbs_pq_bound, outer_tbs,
109 };
110 let expires = request
111 .iat
112 .checked_add(MAX_TIMESTAMP_AGE_MS)
113 .ok_or_else(|| anyhow!("witness expiry overflow"))?;
114 let ed = signer.pubkey();
115 let pq = signer
116 .pq_pubkey()
117 .ok_or_else(|| anyhow!("hybrid witness signer required"))?;
118 #[cfg(not(target_arch = "wasm32"))]
119 let operation = request.service_domain.as_deref().and_then(|service| {
120 crate::proof::policy::mediated_operation_for_request(service, &request.payload).ok()
121 });
122 #[cfg(target_arch = "wasm32")]
123 let operation: Option<String> = None;
124 let payload = transcript_with_operation(request, &ed, expires, operation.as_deref())?;
125 let ed_sig = signer
126 .sign(&inner_tbs_pq_bound(ed.to_vec(), &pq, &payload, AAD))
127 .await?
128 .to_vec();
129 let pq_sig = signer
130 .pq_sign(&outer_tbs(pq.clone(), &payload, &ed_sig, AAD))
131 .await?
132 .ok_or_else(|| anyhow!("hybrid witness signature required"))?;
133 let cose = assemble_composite_nested_pq_bound((ed.to_vec(), ed_sig), (pq, pq_sig))?;
134 let mut witness = if operation.is_some() {
135 WITNESS_V2_MAGIC.to_vec()
136 } else {
137 Vec::new()
138 };
139 witness.extend_from_slice(&expires.to_be_bytes());
140 witness.extend_from_slice(&cose);
141 ensure!(
142 witness.len() <= MAX_WITNESS_BYTES,
143 "authorization witness too large"
144 );
145 Ok(witness.into())
146}
147
148#[cfg(not(target_arch = "wasm32"))]
151pub fn package(request: &RequestEnvelope, signer: &[u8; 32]) -> Option<Vec<u8>> {
152 let witness = request.authorization_witness.as_ref()?;
153 if witness.starts_with(WITNESS_V2_MAGIC) {
154 return package_v2(request, signer);
155 }
156 if !crate::envelope::mediated_request_fits(request) {
157 return None;
158 }
159 let mut message = capnp::message::Builder::new_default();
160 let mut root =
161 message.init_root::<crate::common_capnp::authorization_query_evidence::Builder>();
162 root.set_signer(signer);
163 request.write_to(&mut root.init_request());
164 let mut bytes = EVIDENCE_MAGIC.to_vec();
165 bytes.extend_from_slice(&capnp::serialize::write_message_to_words(&message));
166 (bytes.len() <= MAX_MEDIATED_EVIDENCE_BYTES).then_some(bytes)
167}
168
169#[cfg(not(target_arch = "wasm32"))]
173fn package_v2(request: &RequestEnvelope, signer: &[u8; 32]) -> Option<Vec<u8>> {
174 let target = request.service_domain.as_deref()?;
175 let operation =
176 crate::proof::policy::mediated_operation_for_request(target, &request.payload).ok()?;
177 package_v2_for_operation(request, signer, &operation)
178}
179
180#[cfg(not(target_arch = "wasm32"))]
181fn package_v2_for_operation(
182 request: &RequestEnvelope,
183 signer: &[u8; 32],
184 operation: &str,
185) -> Option<Vec<u8>> {
186 let target = request.service_domain.as_deref()?;
187 crate::envelope::validate_service_domain(target).ok()?;
188 let credential = request.jwt_token()?;
189 let witness = request.authorization_witness.as_ref()?;
190 if request.delegation_token.is_some()
191 || !witness.starts_with(WITNESS_V2_MAGIC)
192 || target.len() > u16::MAX as usize
193 || credential.len() > u32::MAX as usize
194 || operation.len() > u16::MAX as usize
195 || witness.len() > u16::MAX as usize
196 {
197 return None;
198 }
199
200 let mut bytes = Vec::with_capacity(
201 EVIDENCE_V2_MAGIC.len()
202 + signer.len()
203 + 2
204 + target.len()
205 + 4
206 + credential.len()
207 + 32
208 + 8
209 + 16
210 + 8
211 + 2
212 + operation.len()
213 + 2
214 + witness.len(),
215 );
216 bytes.extend_from_slice(EVIDENCE_V2_MAGIC);
217 bytes.extend_from_slice(signer);
218 bytes.extend_from_slice(&(target.len() as u16).to_be_bytes());
219 bytes.extend_from_slice(target.as_bytes());
220 bytes.extend_from_slice(&(credential.len() as u32).to_be_bytes());
221 bytes.extend_from_slice(credential.as_bytes());
222 bytes.extend_from_slice(&Sha256::digest(&request.payload));
223 bytes.extend_from_slice(&request.request_id.to_be_bytes());
224 bytes.extend_from_slice(&request.nonce);
225 bytes.extend_from_slice(&request.iat.to_be_bytes());
226 bytes.extend_from_slice(&(operation.len() as u16).to_be_bytes());
227 bytes.extend_from_slice(operation.as_bytes());
228 bytes.extend_from_slice(&(witness.len() as u16).to_be_bytes());
229 bytes.extend_from_slice(witness);
230 (bytes.len() <= MAX_MEDIATED_EVIDENCE_BYTES).then_some(bytes)
231}
232
233#[cfg(not(target_arch = "wasm32"))]
234pub(crate) fn is_witness_evidence(bytes: &[u8]) -> bool {
235 bytes.starts_with(EVIDENCE_MAGIC) || bytes.starts_with(EVIDENCE_V2_MAGIC)
236}
237
238#[cfg(not(target_arch = "wasm32"))]
241pub(crate) struct VerifiedWitness {
242 pub(crate) request: RequestEnvelope,
243 pub(crate) signer: [u8; 32],
244 pub(crate) operation: Option<String>,
247}
248
249#[cfg(not(target_arch = "wasm32"))]
250pub(crate) fn verify(bytes: &[u8], mediator: &str) -> Result<VerifiedWitness> {
251 if bytes.starts_with(EVIDENCE_V2_MAGIC) {
252 return verify_v2(bytes, mediator);
253 }
254 verify_v1(bytes, mediator)
255}
256
257#[cfg(not(target_arch = "wasm32"))]
258fn verify_v1(bytes: &[u8], mediator: &str) -> Result<VerifiedWitness> {
259 let store = crate::envelope::global_pq_store();
260 verify_with_store(bytes, mediator, store.as_deref())
261}
262
263#[cfg(not(target_arch = "wasm32"))]
264fn verify_with_store(
265 bytes: &[u8],
266 mediator: &str,
267 store: Option<&dyn crate::envelope::PqTrustStore>,
268) -> Result<VerifiedWitness> {
269 ensure!(
270 bytes.len() <= MAX_MEDIATED_EVIDENCE_BYTES,
271 "mediated evidence too large"
272 );
273 let mut remaining = bytes
274 .strip_prefix(EVIDENCE_MAGIC)
275 .ok_or_else(|| anyhow!("wrong witness evidence type"))?;
276 let mut options = capnp::message::ReaderOptions::new();
277 options.traversal_limit_in_words(Some(MAX_MEDIATED_EVIDENCE_BYTES / 8));
278 options.nesting_limit(16);
279 let message = capnp::serialize::read_message_from_flat_slice(&mut remaining, options)?;
280 ensure!(remaining.is_empty(), "trailing witness evidence");
281 let root = message.get_root::<crate::common_capnp::authorization_query_evidence::Reader>()?;
282 let signer: [u8; 32] = root.get_signer()?.try_into()?;
283 let request = RequestEnvelope::read_from(root.get_request()?)?;
284 ensure!(
285 request.service_domain.as_deref() == Some(mediator),
286 "witness target mismatch"
287 );
288 let witness = request
289 .authorization_witness
290 .as_ref()
291 .ok_or_else(|| anyhow!("authorization witness missing"))?;
292 ensure!(
293 witness.len() > 8 && witness.len() <= MAX_WITNESS_BYTES,
294 "invalid authorization witness size"
295 );
296 let expires = i64::from_be_bytes(witness[..8].try_into()?);
297 let now = crate::envelope::current_timestamp();
298 ensure!(
299 expires
300 == request
301 .iat
302 .checked_add(MAX_TIMESTAMP_AGE_MS)
303 .ok_or_else(|| anyhow!("witness expiry overflow"))?
304 && now <= expires
305 && i128::from(request.iat) - i128::from(now) <= 30_000,
306 "authorization witness expired or outside freshness window"
307 );
308 let payload = transcript(&request, &signer, expires)?;
309 let store = store.ok_or_else(|| anyhow!("witness PQ anchors missing"))?;
310 let pq = store
311 .ml_dsa_key_for(&signer)
312 .ok_or_else(|| anyhow!("witness holder PQ anchor missing"))?;
313 let ed = ed25519_dalek::VerifyingKey::from_bytes(&signer)?;
314 crate::crypto::cose_sign::verify_composite(&witness[8..], &ed, Some(&pq), &payload, AAD, true)?;
315 Ok(VerifiedWitness {
316 request,
317 signer,
318 operation: None,
319 })
320}
321
322#[cfg(not(target_arch = "wasm32"))]
323fn take_bytes<'a>(remaining: &mut &'a [u8], length: usize) -> Result<&'a [u8]> {
324 ensure!(
325 length <= remaining.len(),
326 "truncated compact witness evidence"
327 );
328 let (value, rest) = remaining.split_at(length);
329 *remaining = rest;
330 Ok(value)
331}
332
333#[cfg(not(target_arch = "wasm32"))]
334fn verify_v2(bytes: &[u8], mediator: &str) -> Result<VerifiedWitness> {
335 let store =
336 crate::envelope::global_pq_store().ok_or_else(|| anyhow!("witness PQ anchors missing"))?;
337 verify_v2_with_store(bytes, mediator, Some(store.as_ref()))
338}
339
340#[cfg(not(target_arch = "wasm32"))]
341fn verify_v2_with_store(
342 bytes: &[u8],
343 mediator: &str,
344 store: Option<&dyn crate::envelope::PqTrustStore>,
345) -> Result<VerifiedWitness> {
346 ensure!(
347 bytes.len() <= MAX_MEDIATED_EVIDENCE_BYTES,
348 "mediated evidence too large"
349 );
350 let mut remaining = bytes
351 .strip_prefix(EVIDENCE_V2_MAGIC)
352 .ok_or_else(|| anyhow!("wrong compact witness evidence type"))?;
353 let signer: [u8; 32] = take_bytes(&mut remaining, 32)?.try_into()?;
354 let target_len = u16::from_be_bytes(take_bytes(&mut remaining, 2)?.try_into()?) as usize;
355 let target = std::str::from_utf8(take_bytes(&mut remaining, target_len)?)?;
356 crate::envelope::validate_service_domain(target)?;
357 ensure!(target == mediator, "witness target mismatch");
358 let credential_len = u32::from_be_bytes(take_bytes(&mut remaining, 4)?.try_into()?) as usize;
359 let credential = std::str::from_utf8(take_bytes(&mut remaining, credential_len)?)?;
360 ensure!(!credential.is_empty(), "witness credential missing");
361 let payload_hash: [u8; 32] = take_bytes(&mut remaining, 32)?.try_into()?;
362 let request_id = u64::from_be_bytes(take_bytes(&mut remaining, 8)?.try_into()?);
363 let nonce: [u8; 16] = take_bytes(&mut remaining, 16)?.try_into()?;
364 let iat = i64::from_be_bytes(take_bytes(&mut remaining, 8)?.try_into()?);
365 let operation_len = u16::from_be_bytes(take_bytes(&mut remaining, 2)?.try_into()?) as usize;
366 let operation = std::str::from_utf8(take_bytes(&mut remaining, operation_len)?)?;
367 ensure!(
368 !operation.is_empty() && operation.len() <= 128,
369 "invalid mediated operation"
370 );
371 let witness_len = u16::from_be_bytes(take_bytes(&mut remaining, 2)?.try_into()?) as usize;
372 let witness = take_bytes(&mut remaining, witness_len)?;
373 ensure!(remaining.is_empty(), "trailing compact witness evidence");
374 ensure!(
375 witness.starts_with(WITNESS_V2_MAGIC)
376 && witness.len() > WITNESS_V2_MAGIC.len() + 8
377 && witness.len() <= MAX_WITNESS_BYTES,
378 "invalid compact authorization witness size"
379 );
380 let expires =
381 i64::from_be_bytes(witness[WITNESS_V2_MAGIC.len()..WITNESS_V2_MAGIC.len() + 8].try_into()?);
382 let now = crate::envelope::current_timestamp();
383 ensure!(
384 expires
385 == iat
386 .checked_add(MAX_TIMESTAMP_AGE_MS)
387 .ok_or_else(|| anyhow!("witness expiry overflow"))?
388 && now <= expires
389 && i128::from(iat) - i128::from(now) <= 30_000,
390 "authorization witness expired or outside freshness window"
391 );
392 let payload = transcript_from_parts(
393 target,
394 credential,
395 payload_hash,
396 request_id,
397 nonce,
398 iat,
399 &signer,
400 expires,
401 Some(operation),
402 )?;
403 let store = store.ok_or_else(|| anyhow!("witness PQ anchors missing"))?;
404 let pq = store
405 .ml_dsa_key_for(&signer)
406 .ok_or_else(|| anyhow!("witness holder PQ anchor missing"))?;
407 let ed = ed25519_dalek::VerifyingKey::from_bytes(&signer)?;
408 crate::crypto::cose_sign::verify_composite(
409 &witness[WITNESS_V2_MAGIC.len() + 8..],
410 &ed,
411 Some(&pq),
412 &payload,
413 AAD,
414 true,
415 )?;
416 let mut request = RequestEnvelope::new(Vec::new())
417 .with_jwt_token(credential.to_owned())
418 .with_service_domain(target.to_owned())?;
419 request.request_id = request_id;
420 request.nonce = nonce;
421 request.iat = iat;
422 request.authorization_witness = Some(witness.to_vec().into());
423 Ok(VerifiedWitness {
424 request,
425 signer,
426 operation: Some(operation.to_owned()),
427 })
428}
429
430#[cfg(all(test, not(target_arch = "wasm32")))]
431mod tests {
432 use super::*;
433 use crate::envelope::{KeyedPqTrustStore, SignedEnvelope};
434 use crate::node_identity::derive_mesh_mldsa_key;
435 use crate::signer::LocalSigner;
436
437 #[tokio::test]
438 async fn witness_binds_holder_target_body_credential_freshness_and_protocol() -> Result<()> {
439 let key = ed25519_dalek::SigningKey::from_bytes(&[0x91; 32]);
440 let other = ed25519_dalek::SigningKey::from_bytes(&[0x92; 32]);
441 let signer = LocalSigner::new(key.clone());
442 let mut store = KeyedPqTrustStore::new();
443 for key in [&key, &other] {
444 let pq = crate::crypto::pq::ml_dsa_vk_from_bytes(
445 &crate::crypto::pq::ml_dsa_sk_to_vk_bytes(&derive_mesh_mldsa_key(key)),
446 )?;
447 store.bind(key.verifying_key().to_bytes(), &pq);
448 }
449 let mut request = RequestEnvelope::new(b"exact dispatched body".to_vec())
450 .with_jwt_token("credential-placeholder".to_owned())
451 .with_service_domain("registry")?;
452 request.authorization_witness = Some(sign(&request, &signer).await?);
453 let encode = |request: &RequestEnvelope, signer: &[u8; 32]| {
454 let mut message = capnp::message::Builder::new_default();
455 let mut root =
456 message.init_root::<crate::common_capnp::authorization_query_evidence::Builder>();
457 root.set_signer(signer);
458 request.write_to(&mut root.init_request());
459 let mut bytes = EVIDENCE_MAGIC.to_vec();
460 bytes.extend_from_slice(&capnp::serialize::write_message_to_words(&message));
461 bytes
462 };
463 let holder = signer.pubkey();
464 let bytes =
465 package(&request, &holder).ok_or_else(|| anyhow!("fixture evidence missing"))?;
466 assert_eq!(
467 verify_with_store(&bytes, "registry", Some(&store))?
468 .request
469 .payload,
470 request.payload
471 );
472 assert!(verify_with_store(&bytes, "model", Some(&store)).is_err());
473 assert!(verify_with_store(&bytes, "registry", None).is_err());
474 assert!(verify_with_store(&bytes, "registry", Some(&KeyedPqTrustStore::new())).is_err());
475 assert!(verify_with_store(
476 &encode(&request, &other.verifying_key().to_bytes()),
477 "registry",
478 Some(&store)
479 )
480 .is_err());
481
482 let mut changed = request.clone();
483 changed.payload.push(0);
484 assert!(verify_with_store(&encode(&changed, &holder), "registry", Some(&store)).is_err());
485 changed = request
486 .clone()
487 .with_jwt_token("another-credential".to_owned());
488 assert!(verify_with_store(&encode(&changed, &holder), "registry", Some(&store)).is_err());
489 changed = request.clone().with_service_domain("model")?;
490 assert!(verify_with_store(&encode(&changed, &holder), "model", Some(&store)).is_err());
493 changed = request.clone();
494 changed.nonce[0] ^= 1;
495 assert!(verify_with_store(&encode(&changed, &holder), "registry", Some(&store)).is_err());
496 changed = request.clone();
497 changed.request_id += 1;
498 assert!(verify_with_store(&encode(&changed, &holder), "registry", Some(&store)).is_err());
499 changed = request.clone();
500 let mut corrupted = changed
501 .authorization_witness
502 .as_ref()
503 .ok_or_else(|| anyhow!("fixture witness missing"))?
504 .to_vec();
505 let last = corrupted
506 .last_mut()
507 .ok_or_else(|| anyhow!("empty witness"))?;
508 *last ^= 1;
509 changed.authorization_witness = Some(corrupted.into());
510 assert!(verify_with_store(&encode(&changed, &holder), "registry", Some(&store)).is_err());
511 changed = request.clone();
512 changed.iat += 60_000;
513 changed.authorization_witness = Some(sign(&changed, &signer).await?);
514 assert!(verify_with_store(&encode(&changed, &holder), "registry", Some(&store)).is_err());
515 changed = request.clone();
516 changed.iat -= MAX_TIMESTAMP_AGE_MS + 60_000;
517 changed.authorization_witness = Some(sign(&changed, &signer).await?);
518 assert!(verify_with_store(&encode(&changed, &holder), "registry", Some(&store)).is_err());
519 changed = request.clone();
520 changed.authorization_witness = None;
521 assert!(package(&changed, &holder).is_none());
522 assert!(verify_with_store(&encode(&changed, &holder), "registry", Some(&store)).is_err());
523 let mut trailing = bytes.clone();
524 trailing.extend_from_slice(&[0; 8]);
525 assert!(verify_with_store(&trailing, "registry", Some(&store)).is_err());
526 assert!(verify_with_store(
527 &vec![0; MAX_MEDIATED_EVIDENCE_BYTES + 1],
528 "registry",
529 Some(&store)
530 )
531 .is_err());
532
533 let witness = request
536 .authorization_witness
537 .as_ref()
538 .ok_or_else(|| anyhow!("fixture witness missing"))?;
539 let mut envelope =
540 SignedEnvelope::new_signed_hybrid(request.clone(), &key, &derive_mesh_mldsa_key(&key));
541 envelope.cose = witness[8..].to_vec();
542 assert!(envelope
543 .verify_signature_only_with(
544 &key.verifying_key(),
545 Some(&store),
546 crate::crypto::CryptoPolicy::Hybrid
547 )
548 .is_err());
549 assert!(crate::proof::parser::ParsedProof::parse(witness).is_err());
550 assert!(crate::auth::decode_unverified(&String::from_utf8_lossy(witness)).is_err());
551 Ok(())
552 }
553
554 #[tokio::test]
555 async fn compact_witness_keeps_large_body_holder_and_operation_bindings() -> Result<()> {
556 use crate::crypto::cose_sign::{
557 assemble_composite_nested_pq_bound, inner_tbs_pq_bound, outer_tbs,
558 };
559
560 let key = ed25519_dalek::SigningKey::from_bytes(&[0x93; 32]);
561 let signer = LocalSigner::new(key.clone());
562 let mut store = KeyedPqTrustStore::new();
563 let pq = crate::crypto::pq::ml_dsa_vk_from_bytes(
564 &crate::crypto::pq::ml_dsa_sk_to_vk_bytes(&derive_mesh_mldsa_key(&key)),
565 )?;
566 store.bind(key.verifying_key().to_bytes(), &pq);
567
568 let mut request = RequestEnvelope::new(vec![0xA5; MAX_MEDIATED_EVIDENCE_BYTES + 1])
569 .with_jwt_token("credential-placeholder".to_owned())
570 .with_service_domain("registry")?;
571 let operation = "query";
572 let expires = request
573 .iat
574 .checked_add(MAX_TIMESTAMP_AGE_MS)
575 .ok_or_else(|| anyhow!("fixture expiry overflow"))?;
576 let ed = signer.pubkey();
577 let pq = signer
578 .pq_pubkey()
579 .ok_or_else(|| anyhow!("fixture PQ key missing"))?;
580 let payload = transcript_with_operation(&request, &ed, expires, Some(operation))?;
581 let ed_sig = signer
582 .sign(&inner_tbs_pq_bound(ed.to_vec(), &pq, &payload, AAD))
583 .await?
584 .to_vec();
585 let pq_sig = signer
586 .pq_sign(&outer_tbs(pq.clone(), &payload, &ed_sig, AAD))
587 .await?
588 .ok_or_else(|| anyhow!("fixture PQ signature missing"))?;
589 let cose = assemble_composite_nested_pq_bound((ed.to_vec(), ed_sig), (pq, pq_sig))?;
590 let mut witness = WITNESS_V2_MAGIC.to_vec();
591 witness.extend_from_slice(&expires.to_be_bytes());
592 witness.extend_from_slice(&cose);
593 request.authorization_witness = Some(witness.into());
594
595 let evidence = package_v2_for_operation(&request, &ed, operation)
596 .ok_or_else(|| anyhow!("large compact witness was not retained"))?;
597 assert!(evidence.len() <= MAX_MEDIATED_EVIDENCE_BYTES);
598 let verified = verify_v2_with_store(&evidence, "registry", Some(&store))?;
599 assert_eq!(verified.operation.as_deref(), Some(operation));
600 assert_eq!(
601 verified.request.payload,
602 Vec::<u8>::new(),
603 "the large body is never copied into mediation evidence"
604 );
605 assert_eq!(verified.request.request_id, request.request_id);
606
607 let payload_hash_offset = EVIDENCE_V2_MAGIC.len()
608 + 32
609 + 2
610 + "registry".len()
611 + 4
612 + "credential-placeholder".len();
613 let mut changed_hash = evidence.clone();
614 changed_hash[payload_hash_offset] ^= 1;
615 assert!(verify_v2_with_store(&changed_hash, "registry", Some(&store)).is_err());
616 let operation_offset = payload_hash_offset + 32 + 8 + 16 + 8 + 2;
617 let mut changed_operation = evidence;
618 changed_operation[operation_offset] = b'w';
619 assert!(verify_v2_with_store(&changed_operation, "registry", Some(&store)).is_err());
620 Ok(())
621 }
622}