1use 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
15pub 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
41pub fn sig_structure(protected: &[u8], payload: &[u8]) -> Vec<u8> {
44 sig_structure_with_aad(protected, EXTERNAL_AAD, payload)
45}
46
47pub fn sign_ed25519(payload_canonical: &[u8], key: &crate::keys::Ed25519Key) -> Vec<u8> {
52 sign_ed25519_with_aad(payload_canonical, key, EXTERNAL_AAD)
53}
54
55pub 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
75pub 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
85pub 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#[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
116pub 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 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 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 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
219pub 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
232pub 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 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 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 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 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 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 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 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 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 #[test]
468 fn signing_is_deterministic_ed25519_and_esp256() {
469 let seed = [3u8; 32];
470 let msg = b"deterministic-vector-payload";
471 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 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 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 let e = verify_sign1(&bytes, &key.key_ref(), &AllowedAlgs::strict(), &lim()).unwrap_err();
562 assert_eq!(e.code, ErrorCode::UnexpectedHeaderParam);
563 verify_sign1(
565 &bytes,
566 &key.key_ref(),
567 &AllowedAlgs::strict().with_esp256(),
568 &lim(),
569 )
570 .unwrap();
571 }
572
573 const COSE_ML_DSA_44: i64 = -45;
587 const COSE_SLH_DSA_128S: i64 = -18;
589
590 #[test]
591 fn pq_mldsa44_unknown_alg_rejected() {
592 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 assert!(e.message.contains("-45"));
618 }
619
620 #[test]
621 fn pq_slhdsa128s_unknown_alg_rejected() {
622 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 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 assert_eq!(p.alg, COSE_ML_DSA_44);
668 assert_eq!(p.kid, kid.to_vec());
669 assert_eq!(p.payload, payload());
670 assert_eq!(p.signature.len(), 64);
672 }
673
674 #[test]
675 fn pq_and_classical_same_structure() {
676 let kid = Ed25519Key::from_seed(&TEST_SEED).pubkey_bytes();
685
686 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 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 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 assert_eq!(p1.alg, COSE_ED25519);
726 assert_eq!(p2.alg, COSE_ML_DSA_44);
727 assert_eq!(p1.kid, p2.kid); assert_eq!(p1.payload, p2.payload);
729 }
730}