Skip to main content

proof_crypto/
cose.rs

1// Copyright 2026 Proof Engine Contributors
2// SPDX-License-Identifier: MIT OR Apache-2.0
3//! COSE_Sign1 (RFC 9052 §4.2) with fully-specified algs only.
4//! Protected header: {1: alg, 4: kid} — nothing else. Unprotected MUST be empty.
5//! external_aad defaults to h'504531' ("PE1") but is configurable per-verifier
6//! for cross-domain isolation (V1.1).
7
8use ed25519_dalek::{Signature as EdSig, Verifier, VerifyingKey};
9use proof_core::{ErrorCode, Limits, ProofError};
10use proof_format::{decode_strict, encode_canonical, CborValue};
11
12use crate::alg::{AllowedAlgs, COSE_ED25519, COSE_ESP256};
13use crate::keys::{parse_ed25519_keyref, parse_p256_keyref};
14
15/// Default domain separation ("PE1"). Used when no custom AAD is specified.
16pub const EXTERNAL_AAD: &[u8] = b"PE1";
17
18fn protected_bytes(alg: i64, kid_raw: &[u8]) -> Vec<u8> {
19    let alg_val = if alg >= 0 {
20        CborValue::Uint(alg as u64)
21    } else {
22        CborValue::Nint(alg)
23    };
24    let inner = CborValue::Map(vec![
25        (CborValue::Uint(1), alg_val),
26        (CborValue::Uint(4), CborValue::Bytes(kid_raw.to_vec())),
27    ]);
28    encode_canonical(&inner)
29}
30
31fn sig_structure_with_aad(protected: &[u8], aad: &[u8], payload: &[u8]) -> Vec<u8> {
32    let v = CborValue::Array(vec![
33        CborValue::Text("Signature1".into()),
34        CborValue::Bytes(protected.to_vec()),
35        CborValue::Bytes(aad.to_vec()),
36        CborValue::Bytes(payload.to_vec()),
37    ]);
38    encode_canonical(&v)
39}
40
41/// Build the Sig_structure with default domain separation ("PE1").
42/// This is the canonical signing input for ProofEngine V1.
43pub fn sig_structure(protected: &[u8], payload: &[u8]) -> Vec<u8> {
44    sig_structure_with_aad(protected, EXTERNAL_AAD, payload)
45}
46
47/// Build a COSE_Sign1 for `payload_canonical` with an Ed25519 key.
48/// Returns the outer COSE bytes (deterministically encoded).
49/// Uses the default domain separation ("PE1").
50// PE-CRYPTO-002 (header) · PE-CRYPTO-003 (aad) · PE-CRYPTO-004 (Sig_structure).
51pub fn sign_ed25519(payload_canonical: &[u8], key: &crate::keys::Ed25519Key) -> Vec<u8> {
52    sign_ed25519_with_aad(payload_canonical, key, EXTERNAL_AAD)
53}
54
55/// Build a COSE_Sign1 with custom domain separation.
56/// Use this for cross-domain isolation (different domains use different AAD).
57pub fn sign_ed25519_with_aad(
58    payload_canonical: &[u8],
59    key: &crate::keys::Ed25519Key,
60    external_aad: &[u8],
61) -> Vec<u8> {
62    let kid = key.pubkey_bytes();
63    let prot = protected_bytes(COSE_ED25519, &kid);
64    let tbs = sig_structure_with_aad(&prot, external_aad, payload_canonical);
65    let sig = key.sign(&tbs);
66    let outer = CborValue::Array(vec![
67        CborValue::Bytes(prot),
68        CborValue::Map(vec![]),
69        CborValue::Bytes(payload_canonical.to_vec()),
70        CborValue::Bytes(sig.to_vec()),
71    ]);
72    encode_canonical(&outer)
73}
74
75/// Build a COSE_Sign1 with ESP256 (P-256). Requires allow-list at verify time.
76/// Uses the default domain separation ("PE1").
77pub fn sign_esp256(
78    payload_canonical: &[u8],
79    key: &crate::keys::P256Key,
80    signing_key: &p256::ecdsa::SigningKey,
81) -> Vec<u8> {
82    sign_esp256_with_aad(payload_canonical, key, signing_key, EXTERNAL_AAD)
83}
84
85/// Build a COSE_Sign1 with ESP256 and custom domain separation.
86pub fn sign_esp256_with_aad(
87    payload_canonical: &[u8],
88    key: &crate::keys::P256Key,
89    signing_key: &p256::ecdsa::SigningKey,
90    external_aad: &[u8],
91) -> Vec<u8> {
92    use p256::ecdsa::signature::Signer as _;
93    let kid = key.pubkey_xy();
94    let prot = protected_bytes(COSE_ESP256, &kid);
95    let tbs = sig_structure_with_aad(&prot, external_aad, payload_canonical);
96    let sig: p256::ecdsa::Signature = signing_key.sign(&tbs);
97    let outer = CborValue::Array(vec![
98        CborValue::Bytes(prot),
99        CborValue::Map(vec![]),
100        CborValue::Bytes(payload_canonical.to_vec()),
101        CborValue::Bytes(sig.to_bytes().to_vec()),
102    ]);
103    encode_canonical(&outer)
104}
105
106/// Parsed (verified-shape) Sign1 components. Crypto verification is separate.
107#[derive(Debug, Clone)]
108pub struct ParsedSign1 {
109    pub alg: i64,
110    pub kid: Vec<u8>,
111    pub payload: Vec<u8>,
112    pub signature: Vec<u8>,
113    pub protected_raw: Vec<u8>,
114}
115
116/// Parse + shape-check a COSE_Sign1 (no crypto). Enforces canonical form,
117/// closed headers, empty unprotected, embedded payload.
118pub fn parse_sign1(bytes: &[u8], limits: &Limits) -> Result<ParsedSign1, ProofError> {
119    if bytes.len() > limits.max_proof_size {
120        return Err(ErrorCode::LimitExceeded.err("sign1 exceeds max_proof_size"));
121    }
122    let outer = decode_strict(bytes, limits)?;
123    // Outer must already be canonical.
124    if encode_canonical(&outer) != bytes {
125        return Err(ErrorCode::NonCanonical.err("COSE_Sign1 not deterministic"));
126    }
127    let items = match outer {
128        CborValue::Array(a) => a,
129        _ => return Err(ErrorCode::Malformed.err("COSE_Sign1 must be array")),
130    };
131    if items.len() != 4 {
132        return Err(ErrorCode::Malformed.err("COSE_Sign1 must have 4 elements"));
133    }
134    let protected_raw = match &items[0] {
135        CborValue::Bytes(b) => b.clone(),
136        _ => return Err(ErrorCode::Malformed.err("protected must be bstr")),
137    };
138    match &items[1] {
139        CborValue::Map(m) if m.is_empty() => {}
140        _ => {
141            return Err(
142                ErrorCode::UnexpectedHeaderParam.err("unprotected header must be empty in V0.1")
143            )
144        }
145    }
146    let payload = match &items[2] {
147        CborValue::Bytes(b) => b.clone(),
148        _ => return Err(ErrorCode::Malformed.err("detached payload (nil) not supported in V0.1")),
149    };
150    if payload.len() > limits.max_proof_size {
151        return Err(ErrorCode::LimitExceeded.err("payload too large"));
152    }
153    let signature = match &items[3] {
154        CborValue::Bytes(b) => b.clone(),
155        _ => return Err(ErrorCode::Malformed.err("signature must be bstr")),
156    };
157    if signature.len() > limits.max_sig_size {
158        return Err(ErrorCode::LimitExceeded.err("signature exceeds max_sig_size"));
159    }
160
161    // Inner protected header.
162    let inner = decode_strict(&protected_raw, limits)?;
163    if encode_canonical(&inner) != protected_raw {
164        return Err(ErrorCode::NonCanonical.err("protected header not deterministic"));
165    }
166    let pairs = match inner {
167        CborValue::Map(p) => p,
168        _ => return Err(ErrorCode::Malformed.err("protected must be map")),
169    };
170    if pairs.len() != 2 {
171        return Err(ErrorCode::UnexpectedHeaderParam.err("protected must have exactly {1,4}"));
172    }
173    let mut alg: Option<i64> = None;
174    let mut kid: Option<Vec<u8>> = None;
175    for (k, v) in &pairs {
176        match k {
177            CborValue::Uint(1) => match v {
178                CborValue::Nint(n) => alg = Some(*n),
179                CborValue::Uint(n) => {
180                    if *n > i64::MAX as u64 {
181                        return Err(ErrorCode::UnknownAlgorithm.err("alg out of range"));
182                    }
183                    alg = Some(*n as i64);
184                }
185                _ => return Err(ErrorCode::UnexpectedHeaderParam.err("alg must be int")),
186            },
187            CborValue::Uint(4) => match v {
188                CborValue::Bytes(b) => kid = Some(b.clone()),
189                _ => return Err(ErrorCode::UnexpectedHeaderParam.err("kid must be bstr")),
190            },
191            _ => {
192                return Err(
193                    ErrorCode::UnexpectedHeaderParam.err("only header labels 1 and 4 allowed")
194                )
195            }
196        }
197    }
198    let alg = alg.ok_or_else(|| ErrorCode::UnexpectedHeaderParam.err("missing alg (1)"))?;
199    let kid = kid.ok_or_else(|| ErrorCode::UnexpectedHeaderParam.err("missing kid (4)"))?;
200    // kid length must match a known alg shape, else confusion.
201    match alg {
202        x if x == COSE_ED25519 && kid.len() != 32 => {
203            return Err(ErrorCode::AlgorithmConfusion.err("Ed25519 kid must be 32 bytes"));
204        }
205        x if x == COSE_ESP256 && kid.len() != 64 => {
206            return Err(ErrorCode::AlgorithmConfusion.err("P-256 kid must be 64 bytes X||Y"));
207        }
208        _ => {}
209    }
210    Ok(ParsedSign1 {
211        alg,
212        kid,
213        payload,
214        signature,
215        protected_raw,
216    })
217}
218
219/// Full verification: shape + alg policy + key binding + crypto.
220/// `expected_issuer` (e.g. "key:ed25519:…") must correspond to `kid`.
221/// Uses the default domain separation ("PE1").
222// PE-CRYPTO-001 (closed algs) · PE-CRYPTO-005 (key binding) · PE-TRUST-002.
223pub fn verify_sign1(
224    bytes: &[u8],
225    expected_issuer: &str,
226    allowed: &AllowedAlgs,
227    limits: &Limits,
228) -> Result<ParsedSign1, ProofError> {
229    verify_sign1_with_aad(bytes, expected_issuer, allowed, limits, EXTERNAL_AAD)
230}
231
232/// Full verification with custom domain separation.
233/// Use this when the signature was created with a non-default AAD.
234pub fn verify_sign1_with_aad(
235    bytes: &[u8],
236    expected_issuer: &str,
237    allowed: &AllowedAlgs,
238    limits: &Limits,
239    external_aad: &[u8],
240) -> Result<ParsedSign1, ProofError> {
241    let p = parse_sign1(bytes, limits)?;
242
243    if crate::alg::AllowedAlgs::is_deprecated(p.alg) {
244        return Err(ErrorCode::DeprecatedAlgorithm
245            .err(format!("deprecated COSE alg {} (use -19/-9)", p.alg)));
246    }
247    if !allowed.is_allowed(p.alg) {
248        // Distinguish unknown vs known-but-disabled.
249        if p.alg == COSE_ED25519 || p.alg == COSE_ESP256 {
250            return Err(ErrorCode::UnexpectedHeaderParam
251                .err(format!("alg {} not allowed by verifier policy", p.alg)));
252        }
253        return Err(ErrorCode::UnknownAlgorithm.err(format!("unknown COSE alg {}", p.alg)));
254    }
255    if p.signature.len() != 64 {
256        return Err(ErrorCode::SignatureInvalid.err("signature must be 64 bytes"));
257    }
258
259    // Key binding: kid must equal the expected issuer pubkey.
260    match p.alg {
261        x if x == COSE_ED25519 => {
262            let expect = parse_ed25519_keyref(expected_issuer)?;
263            if expect.as_slice() != p.kid.as_slice() {
264                return Err(ErrorCode::SignatureInvalid.err("kid does not match issuer key"));
265            }
266            let vk = VerifyingKey::from_bytes(&expect)
267                .map_err(|e| ErrorCode::Malformed.err(format!("bad ed25519 key: {e}")))?;
268            let sig = EdSig::from_bytes(
269                &p.signature
270                    .clone()
271                    .try_into()
272                    .map_err(|_| ErrorCode::SignatureInvalid.err("bad ed25519 sig length"))?,
273            );
274            let tbs = sig_structure_with_aad(&p.protected_raw, external_aad, &p.payload);
275            vk.verify(&tbs, &sig)
276                .map_err(|_| ErrorCode::SignatureInvalid.err("Ed25519 verification failed"))?;
277        }
278        x if x == COSE_ESP256 => {
279            let expect = parse_p256_keyref(expected_issuer)?;
280            if expect.as_slice() != p.kid.as_slice() {
281                return Err(ErrorCode::SignatureInvalid.err("kid does not match issuer key"));
282            }
283            use p256::ecdsa::signature::Verifier as _;
284            let vk = p256_verify_key(&expect)?;
285            let sig = p256::ecdsa::Signature::from_slice(&p.signature)
286                .map_err(|e| ErrorCode::SignatureInvalid.err(format!("bad p256 signature: {e}")))?;
287            let tbs = sig_structure_with_aad(&p.protected_raw, external_aad, &p.payload);
288            vk.verify(&tbs, &sig)
289                .map_err(|_| ErrorCode::SignatureInvalid.err("ESP256 verification failed"))?;
290        }
291        _ => return Err(ErrorCode::UnknownAlgorithm.err("unreachable")),
292    }
293    Ok(p)
294}
295
296fn p256_verify_key(xy: &[u8; 64]) -> Result<p256::ecdsa::VerifyingKey, ProofError> {
297    use p256::EncodedPoint;
298    let mut unc = [0u8; 65];
299    unc[0] = 0x04;
300    unc[1..].copy_from_slice(xy);
301    let pt = EncodedPoint::from_bytes(&unc[..])
302        .map_err(|e| ErrorCode::Malformed.err(format!("bad p256 point: {e}")))?;
303    p256::ecdsa::VerifyingKey::from_encoded_point(&pt)
304        .map_err(|e| ErrorCode::Malformed.err(format!("bad p256 key: {e}")))
305}
306
307#[cfg(test)]
308mod tests {
309    use super::*;
310    use crate::keys::{Ed25519Key, P256Key};
311    use proof_core::Limits;
312
313    fn lim() -> Limits {
314        Limits::default()
315    }
316
317    /// Fixed test seed (NOT a production key). All vectors derive from it.
318    pub const TEST_SEED: [u8; 32] = [9u8; 32];
319
320    fn payload() -> Vec<u8> {
321        b"attestation-content-canonical-placeholder".to_vec()
322    }
323
324    #[test]
325    fn external_aad_is_pe1() {
326        assert_eq!(EXTERNAL_AAD, b"PE1");
327    }
328
329    #[test]
330    fn sign_verify_round_trip_ed25519() {
331        let key = Ed25519Key::from_seed(&TEST_SEED);
332        let issuer = key.key_ref();
333        let bytes = sign_ed25519(&payload(), &key);
334        let p = verify_sign1(&bytes, &issuer, &AllowedAlgs::strict(), &lim()).unwrap();
335        assert_eq!(p.alg, COSE_ED25519);
336        assert_eq!(p.kid, key.pubkey_bytes().to_vec());
337        assert_eq!(p.payload, payload());
338    }
339
340    #[test]
341    fn tampered_payload_fails() {
342        let key = Ed25519Key::from_seed(&TEST_SEED);
343        let issuer = key.key_ref();
344        let bytes = sign_ed25519(&payload(), &key);
345        // Flip one payload byte inside the outer encoding by re-parsing shapes:
346        // simplest robust tamper: flip last byte of the whole message (inside sig).
347        let mut bad = bytes.clone();
348        let n = bad.len();
349        bad[n - 1] ^= 0x01;
350        let e = verify_sign1(&bad, &issuer, &AllowedAlgs::strict(), &lim()).unwrap_err();
351        // Either canonical mismatch (if structure broke) or signature invalid.
352        assert!(matches!(
353            e.code,
354            ErrorCode::SignatureInvalid | ErrorCode::NonCanonical | ErrorCode::Malformed
355        ));
356    }
357
358    #[test]
359    fn wrong_key_fails() {
360        let key = Ed25519Key::from_seed(&TEST_SEED);
361        let other = Ed25519Key::from_seed(&[7u8; 32]);
362        let bytes = sign_ed25519(&payload(), &key);
363        let e = verify_sign1(&bytes, &other.key_ref(), &AllowedAlgs::strict(), &lim()).unwrap_err();
364        assert_eq!(e.code, ErrorCode::SignatureInvalid);
365    }
366
367    #[test]
368    fn deprecated_alg_8_rejected() {
369        // Hand-build outer with alg=-8 but a valid-shape 64B sig of zeros.
370        // Parser accepts shape; verifier must reject as deprecated before crypto.
371        let kid = Ed25519Key::from_seed(&TEST_SEED).pubkey_bytes();
372        let prot = {
373            let inner = CborValue::Map(vec![
374                (CborValue::Uint(1), CborValue::Nint(-8)),
375                (CborValue::Uint(4), CborValue::Bytes(kid.to_vec())),
376            ]);
377            encode_canonical(&inner)
378        };
379        let outer = CborValue::Array(vec![
380            CborValue::Bytes(prot),
381            CborValue::Map(vec![]),
382            CborValue::Bytes(payload()),
383            CborValue::Bytes(vec![0u8; 64]),
384        ]);
385        let bytes = encode_canonical(&outer);
386        let issuer = Ed25519Key::from_seed(&TEST_SEED).key_ref();
387        let e = verify_sign1(&bytes, &issuer, &AllowedAlgs::strict(), &lim()).unwrap_err();
388        assert_eq!(e.code, ErrorCode::DeprecatedAlgorithm);
389    }
390
391    #[test]
392    fn unknown_alg_rejected() {
393        let kid = Ed25519Key::from_seed(&TEST_SEED).pubkey_bytes();
394        let prot = {
395            let inner = CborValue::Map(vec![
396                (CborValue::Uint(1), CborValue::Nint(-999)),
397                (CborValue::Uint(4), CborValue::Bytes(kid.to_vec())),
398            ]);
399            encode_canonical(&inner)
400        };
401        let outer = CborValue::Array(vec![
402            CborValue::Bytes(prot),
403            CborValue::Map(vec![]),
404            CborValue::Bytes(payload()),
405            CborValue::Bytes(vec![0u8; 64]),
406        ]);
407        let bytes = encode_canonical(&outer);
408        let issuer = Ed25519Key::from_seed(&TEST_SEED).key_ref();
409        let e = verify_sign1(&bytes, &issuer, &AllowedAlgs::strict(), &lim()).unwrap_err();
410        assert_eq!(e.code, ErrorCode::UnknownAlgorithm);
411    }
412
413    #[test]
414    fn non_empty_unprotected_rejected() {
415        let key = Ed25519Key::from_seed(&TEST_SEED);
416        let kid = key.pubkey_bytes();
417        let prot = {
418            let inner = CborValue::Map(vec![
419                (CborValue::Uint(1), CborValue::Nint(COSE_ED25519)),
420                (CborValue::Uint(4), CborValue::Bytes(kid.to_vec())),
421            ]);
422            encode_canonical(&inner)
423        };
424        // Unprotected carries smuggled {0: 1}.
425        let outer = CborValue::Array(vec![
426            CborValue::Bytes(prot),
427            CborValue::Map(vec![(CborValue::Uint(0), CborValue::Uint(1))]),
428            CborValue::Bytes(payload()),
429            CborValue::Bytes(vec![0u8; 64]),
430        ]);
431        let bytes = encode_canonical(&outer);
432        let e = parse_sign1(&bytes, &lim()).unwrap_err();
433        assert_eq!(e.code, ErrorCode::UnexpectedHeaderParam);
434    }
435
436    #[test]
437    fn header_label_6_rejected() {
438        // Label 6 is Partial IV — must never appear in Sign1 protected header.
439        let kid = Ed25519Key::from_seed(&TEST_SEED).pubkey_bytes();
440        let prot = {
441            let inner = CborValue::Map(vec![
442                (CborValue::Uint(1), CborValue::Nint(COSE_ED25519)),
443                (CborValue::Uint(4), CborValue::Bytes(kid.to_vec())),
444                (
445                    CborValue::Uint(6),
446                    CborValue::Text("proof-engine/v1".into()),
447                ),
448            ]);
449            encode_canonical(&inner)
450        };
451        let outer = CborValue::Array(vec![
452            CborValue::Bytes(prot),
453            CborValue::Map(vec![]),
454            CborValue::Bytes(payload()),
455            CborValue::Bytes(vec![0u8; 64]),
456        ]);
457        let bytes = encode_canonical(&outer);
458        let e = parse_sign1(&bytes, &lim()).unwrap_err();
459        assert_eq!(e.code, ErrorCode::UnexpectedHeaderParam);
460    }
461
462    // PE-CRYPTO-010 (deterministic-signature contract — LONGEVITY.md §4):
463    // Ed25519 (RFC 8032) and ECDSA P-256 (RFC 6979 deterministic nonce) must
464    // sign byte-identically for the same key+message, so the same caller inputs
465    // reproduce the same report byte-for-byte. Cross-checked by the interop
466    // verifier (golden-21..23) and encode tests in `pengine.py`.
467    #[test]
468    fn signing_is_deterministic_ed25519_and_esp256() {
469        let seed = [3u8; 32];
470        let msg = b"deterministic-vector-payload";
471        // Ed25519 (RFC 8032 — deterministic by construction).
472        let ek = Ed25519Key::from_seed(&seed);
473        let a = sign_ed25519(msg, &ek);
474        let b = sign_ed25519(msg, &ek);
475        assert_eq!(a, b, "Ed25519 must be byte-deterministic (RFC 8032)");
476        // ECDSA P-256 (RFC 6979 nonce derivation — relies on the ecdsa crate).
477        let sk = p256::ecdsa::SigningKey::from_bytes(seed.as_slice().into()).unwrap();
478        let pk = P256Key::from_seed(&seed).unwrap();
479        let c = sign_esp256(msg, &pk, &sk);
480        let d = sign_esp256(msg, &pk, &sk);
481        assert_eq!(c, d, "ECDSA P-256 must be byte-deterministic (RFC 6979)");
482        // Determinism must not be monotonicity-with-structure: different payload
483        // -> different bytes.
484        let e = sign_esp256(b"other-payload", &pk, &sk);
485        assert_ne!(c, e);
486        assert_ne!(a, sign_ed25519(b"other-payload", &ek));
487    }
488
489    #[test]
490    fn esp256_tampered_payload_fails() {
491        let seed = [3u8; 32];
492        let sk = p256::ecdsa::SigningKey::from_bytes(seed.as_slice().into()).unwrap();
493        let pk = P256Key::from_seed(&seed).unwrap();
494        let bytes = sign_esp256(&payload(), &pk, &sk);
495        let mut bad = bytes.clone();
496        let n = bad.len();
497        bad[n - 1] ^= 0x01;
498        let e = verify_sign1(
499            &bad,
500            &pk.key_ref(),
501            &AllowedAlgs::strict().with_esp256(),
502            &lim(),
503        )
504        .unwrap_err();
505        assert!(matches!(
506            e.code,
507            ErrorCode::SignatureInvalid | ErrorCode::NonCanonical | ErrorCode::Malformed
508        ));
509    }
510
511    #[test]
512    fn esp256_wrong_key_fails() {
513        let seed = [3u8; 32];
514        let sk = p256::ecdsa::SigningKey::from_bytes(seed.as_slice().into()).unwrap();
515        let pk = P256Key::from_seed(&seed).unwrap();
516        let other = P256Key::from_seed(&[7u8; 32]).unwrap();
517        let bytes = sign_esp256(&payload(), &pk, &sk);
518        let e = verify_sign1(
519            &bytes,
520            &other.key_ref(),
521            &AllowedAlgs::strict().with_esp256(),
522            &lim(),
523        )
524        .unwrap_err();
525        assert_eq!(e.code, ErrorCode::SignatureInvalid);
526    }
527
528    #[test]
529    fn esp256_gated_by_policy() {
530        use p256::ecdsa::signature::Signer as _;
531        let seed = [3u8; 32];
532        let sk = p256::ecdsa::SigningKey::from_bytes(seed.as_slice().into()).unwrap();
533        let key = P256Key::from_seed(&seed).unwrap();
534        let payload = payload();
535        let kid = key.pubkey_xy();
536        let prot = {
537            let inner = CborValue::Map(vec![
538                (CborValue::Uint(1), CborValue::Nint(COSE_ESP256)),
539                (CborValue::Uint(4), CborValue::Bytes(kid.to_vec())),
540            ]);
541            encode_canonical(&inner)
542        };
543        let tbs = {
544            let v = CborValue::Array(vec![
545                CborValue::Text("Signature1".into()),
546                CborValue::Bytes(prot.clone()),
547                CborValue::Bytes(EXTERNAL_AAD.to_vec()),
548                CborValue::Bytes(payload.clone()),
549            ]);
550            encode_canonical(&v)
551        };
552        let sig: p256::ecdsa::Signature = sk.sign(&tbs);
553        let outer = CborValue::Array(vec![
554            CborValue::Bytes(prot),
555            CborValue::Map(vec![]),
556            CborValue::Bytes(payload),
557            CborValue::Bytes(sig.to_bytes().to_vec()),
558        ]);
559        let bytes = encode_canonical(&outer);
560        // Strict (default) policy rejects even a *valid* ESP256 sig.
561        let e = verify_sign1(&bytes, &key.key_ref(), &AllowedAlgs::strict(), &lim()).unwrap_err();
562        assert_eq!(e.code, ErrorCode::UnexpectedHeaderParam);
563        // Explicit opt-in verifies.
564        verify_sign1(
565            &bytes,
566            &key.key_ref(),
567            &AllowedAlgs::strict().with_esp256(),
568            &lim(),
569        )
570        .unwrap();
571    }
572
573    // --- Post-Quantum crypto-agility tests (LONGEVITY.md §4) ---
574    //
575    // These tests verify the architecture handles PQ algorithm numbers correctly.
576    // ML-DSA-44 (NIST FIPS 204) would use COSE alg -45; SLH-DSA-128s (FIPS 205)
577    // would use COSE alg -18. Neither is implemented yet. The architecture must:
578    //   1. Parse COSE_Sign1 with any valid alg number (shape-level)
579    //   2. Reject unknown algs with UNKNOWN_ALGORITHM (policy-level)
580    //   3. Accept known algs when explicitly allowed (policy-level)
581    // This proves crypto-agility: adding PQ = new alg entry + key prefix, not
582    // a core rewrite. See LONGEVITY.md §4 for the full migration contract.
583
584    /// ML-DSA-44 (NIST FIPS 204) — hypothetical COSE alg number.
585    /// IANA assignment may differ; this uses -45 as a placeholder for testing.
586    const COSE_ML_DSA_44: i64 = -45;
587    /// SLH-DSA-128s (NIST FIPS 205) — hypothetical COSE alg number.
588    const COSE_SLH_DSA_128S: i64 = -18;
589
590    #[test]
591    fn pq_mldsa44_unknown_alg_rejected() {
592        // Construct a COSE_Sign1 with alg=-45 (ML-DSA-44 placeholder).
593        // The shape is valid: protected header {1: -45, 4: kid}, empty
594        // unprotected, embedded payload, 64-byte signature placeholder.
595        // The verifier must reject with UNKNOWN_ALGORITHM because -45 is
596        // not in the AllowedAlgs registry — proving the architecture
597        // handles PQ algorithm numbers without crashing or misrouting.
598        let kid = Ed25519Key::from_seed(&TEST_SEED).pubkey_bytes();
599        let prot = {
600            let inner = CborValue::Map(vec![
601                (CborValue::Uint(1), CborValue::Nint(COSE_ML_DSA_44)),
602                (CborValue::Uint(4), CborValue::Bytes(kid.to_vec())),
603            ]);
604            encode_canonical(&inner)
605        };
606        let outer = CborValue::Array(vec![
607            CborValue::Bytes(prot),
608            CborValue::Map(vec![]),
609            CborValue::Bytes(payload()),
610            CborValue::Bytes(vec![0u8; 64]),
611        ]);
612        let bytes = encode_canonical(&outer);
613        let issuer = Ed25519Key::from_seed(&TEST_SEED).key_ref();
614        let e = verify_sign1(&bytes, &issuer, &AllowedAlgs::strict(), &lim()).unwrap_err();
615        assert_eq!(e.code, ErrorCode::UnknownAlgorithm);
616        // Error message identifies the algorithm number for debugging.
617        assert!(e.message.contains("-45"));
618    }
619
620    #[test]
621    fn pq_slhdsa128s_unknown_alg_rejected() {
622        // Same pattern for SLH-DSA-128s (alg=-18 placeholder).
623        // The parser accepts the shape; the verifier rejects the algorithm.
624        let kid = Ed25519Key::from_seed(&TEST_SEED).pubkey_bytes();
625        let prot = {
626            let inner = CborValue::Map(vec![
627                (CborValue::Uint(1), CborValue::Nint(COSE_SLH_DSA_128S)),
628                (CborValue::Uint(4), CborValue::Bytes(kid.to_vec())),
629            ]);
630            encode_canonical(&inner)
631        };
632        let outer = CborValue::Array(vec![
633            CborValue::Bytes(prot),
634            CborValue::Map(vec![]),
635            CborValue::Bytes(payload()),
636            CborValue::Bytes(vec![0u8; 64]),
637        ]);
638        let bytes = encode_canonical(&outer);
639        let issuer = Ed25519Key::from_seed(&TEST_SEED).key_ref();
640        let e = verify_sign1(&bytes, &issuer, &AllowedAlgs::strict(), &lim()).unwrap_err();
641        assert_eq!(e.code, ErrorCode::UnknownAlgorithm);
642        assert!(e.message.contains("-18"));
643    }
644
645    #[test]
646    fn pq_algorithm_header_is_parsed_correctly() {
647        // Verify that parse_sign1 correctly extracts the PQ algorithm number
648        // from the protected header. This proves the parser is algorithm-neutral:
649        // it doesn't care what the alg number is, only that the shape is valid.
650        let kid = Ed25519Key::from_seed(&TEST_SEED).pubkey_bytes();
651        let prot = {
652            let inner = CborValue::Map(vec![
653                (CborValue::Uint(1), CborValue::Nint(COSE_ML_DSA_44)),
654                (CborValue::Uint(4), CborValue::Bytes(kid.to_vec())),
655            ]);
656            encode_canonical(&inner)
657        };
658        let outer = CborValue::Array(vec![
659            CborValue::Bytes(prot),
660            CborValue::Map(vec![]),
661            CborValue::Bytes(payload()),
662            CborValue::Bytes(vec![0u8; 64]),
663        ]);
664        let bytes = encode_canonical(&outer);
665        let p = parse_sign1(&bytes, &lim()).unwrap();
666        // Parser correctly extracted the PQ algorithm number.
667        assert_eq!(p.alg, COSE_ML_DSA_44);
668        assert_eq!(p.kid, kid.to_vec());
669        assert_eq!(p.payload, payload());
670        // 64-byte signature placeholder passes shape check.
671        assert_eq!(p.signature.len(), 64);
672    }
673
674    #[test]
675    fn pq_and_classical_same_structure() {
676        // Both PQ and classical COSE_Sign1 use the same wire structure.
677        // This proves a future PQ implementation only needs to add:
678        //   1. A new COSE alg constant (e.g., const COSE_ML_DSA_44: i64 = -45)
679        //   2. A new key-ref prefix (e.g., "key:ml-dsa-44:")
680        //   3. A new entry in AllowedAlgs (e.g., mldsa44: bool)
681        //   4. Sign/verify functions for the new algorithm
682        // The proof format, ID construction, verification pipeline, and
683        // policy engine remain unchanged. This is crypto-agility by construction.
684        let kid = Ed25519Key::from_seed(&TEST_SEED).pubkey_bytes();
685
686        // Classical (Ed25519)
687        let prot_classical = {
688            let inner = CborValue::Map(vec![
689                (CborValue::Uint(1), CborValue::Nint(COSE_ED25519)),
690                (CborValue::Uint(4), CborValue::Bytes(kid.to_vec())),
691            ]);
692            encode_canonical(&inner)
693        };
694
695        // PQ (ML-DSA-44 placeholder)
696        let prot_pq = {
697            let inner = CborValue::Map(vec![
698                (CborValue::Uint(1), CborValue::Nint(COSE_ML_DSA_44)),
699                (CborValue::Uint(4), CborValue::Bytes(kid.to_vec())),
700            ]);
701            encode_canonical(&inner)
702        };
703
704        // Both parse successfully (same structure, different alg numbers).
705        let outer_classical = CborValue::Array(vec![
706            CborValue::Bytes(prot_classical),
707            CborValue::Map(vec![]),
708            CborValue::Bytes(payload()),
709            CborValue::Bytes(vec![0u8; 64]),
710        ]);
711        let outer_pq = CborValue::Array(vec![
712            CborValue::Bytes(prot_pq),
713            CborValue::Map(vec![]),
714            CborValue::Bytes(payload()),
715            CborValue::Bytes(vec![0u8; 64]),
716        ]);
717
718        let bytes_classical = encode_canonical(&outer_classical);
719        let bytes_pq = encode_canonical(&outer_pq);
720
721        let p1 = parse_sign1(&bytes_classical, &lim()).unwrap();
722        let p2 = parse_sign1(&bytes_pq, &lim()).unwrap();
723
724        // Same structure, different alg numbers.
725        assert_eq!(p1.alg, COSE_ED25519);
726        assert_eq!(p2.alg, COSE_ML_DSA_44);
727        assert_eq!(p1.kid, p2.kid); // Same key, different algorithm
728        assert_eq!(p1.payload, p2.payload);
729    }
730}