Skip to main content

hyprstream_rpc/
authorization_witness.rs

1//! Purpose-bound hybrid holder evidence for read-only Policy queries.
2//! This is deliberately not a credential, envelope signature, or v16 proof.
3
4#[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
23// Fixed-width integers/hashes, and an explicitly length-prefixed target, give
24// one unambiguous transcript. The witness itself is excluded to avoid cycles.
25fn transcript(request: &RequestEnvelope, signer: &[u8; 32], expires: i64) -> Result<Vec<u8>> {
26    transcript_with_operation(request, signer, expires, None)
27}
28
29// The v2 operation is derived from the request leaf before the holder signs.
30// It is never accepted from the mediator, and lets compact evidence retain the
31// method binding without copying an arbitrarily large signed body.
32fn 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
101/// Sign after final payload mutation and before transport sealing. No new
102/// authority is issued; only Policy's boolean-query handler understands AAD.
103pub 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/// Retain a decrypted request only when it carries independently verifiable
149/// holder evidence. This packages bytes; Policy still verifies every binding.
150#[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/// Compact v2 evidence retains the holder-signed body digest and derived
170/// method action, rather than retaining the body itself. This is required for
171/// valid large requests while keeping the mediation frame bounded.
172#[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/// Verify the hybrid holder and all committed fields. Does not verify the
239/// credential, decide policy, grant local provenance, or consume replay state.
240#[cfg(not(target_arch = "wasm32"))]
241pub(crate) struct VerifiedWitness {
242    pub(crate) request: RequestEnvelope,
243    pub(crate) signer: [u8; 32],
244    /// A v2 action is holder-signed and derived from the original request
245    /// leaf. A v1 witness retains the original body and derives it on verify.
246    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        // Even a mediator whose identity matches the changed target cannot
491        // repurpose the original Registry witness.
492        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        // The purpose-separated signature cannot be transplanted into an
534        // ordinary RPC envelope or parsed as a v16 dispatch proof/credential.
535        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}