1use anyhow::{ensure, Context, Result};
38use ed25519_dalek::{SigningKey, VerifyingKey};
39
40use hyprstream_crypto::cose_sign::{
41 assemble_composite_nested, inner_tbs, outer_tbs, sign_composite, split_composite,
42 verify_composite,
43};
44use hyprstream_crypto::pq::{
45 ml_dsa_sign, ml_dsa_sk_to_vk_bytes, ml_dsa_vk_bytes, ml_dsa_vk_from_bytes, MlDsaSigningKey,
46 MlDsaVerifyingKey,
47};
48
49use crate::at9p::{
50 Capsule, CapsuleBody, CoseCompositeSignature, HybridKeyPair, UpdateRecord,
51 CAPSULE_SIGNATURE_CONTEXT, ED25519_PUBLIC_KEY_LEN, UPDATE_SIGNATURE_CONTEXT,
52};
53use crate::dag_cbor::DagCbor;
54
55const AT9P_COMPOSITE_ALG_ID: &str = "id-MLDSA65-Ed25519";
61
62fn context_protected_header(context: &str) -> Vec<u8> {
71 DagCbor::str_map([
72 ("alg", DagCbor::Text(AT9P_COMPOSITE_ALG_ID.to_owned())),
73 ("context", DagCbor::Text(context.to_owned())),
74 ])
75 .encode()
76}
77
78fn verifying_keys(keypair: &HybridKeyPair) -> Result<(VerifyingKey, MlDsaVerifyingKey)> {
80 keypair.validate()?;
81 let ed_bytes: [u8; ED25519_PUBLIC_KEY_LEN] = keypair
82 .ed25519_pub
83 .as_slice()
84 .try_into()
85 .context("ed25519 subject key must be 32 bytes")?;
86 let ed_vk = VerifyingKey::from_bytes(&ed_bytes)
87 .context("declared ed25519 subject key is not a valid point")?;
88 let pq_vk = ml_dsa_vk_from_bytes(&keypair.mldsa65_pub)
89 .context("declared ML-DSA-65 subject key is invalid")?;
90 Ok((ed_vk, pq_vk))
91}
92
93fn sign_record(
98 payload: &[u8],
99 context: &str,
100 ed_sk: &SigningKey,
101 pq_sk: &MlDsaSigningKey,
102) -> Result<CoseCompositeSignature> {
103 let protected = context_protected_header(context);
104 let composite = sign_composite(ed_sk, Some(pq_sk), payload, &protected)
108 .context("at9p composite signing failed")?;
109
110 let (ed_sig, pq_sig) = split_composite(&composite)?;
111 let pq_sig = pq_sig
112 .ok_or_else(|| anyhow::anyhow!("at9p composite signing produced no ML-DSA-65 layer"))?;
113
114 CoseCompositeSignature::new(context, protected, ed_sig, pq_sig)
115}
116
117fn verify_record(
126 payload: &[u8],
127 sig: &CoseCompositeSignature,
128 expected_context: &str,
129 ed_vk: &VerifyingKey,
130 pq_vk: &MlDsaVerifyingKey,
131) -> Result<()> {
132 ensure!(
134 sig.context == expected_context,
135 "at9p signature context mismatch: expected {expected_context:?}, got {:?}",
136 sig.context
137 );
138
139 let expected_protected = context_protected_header(expected_context);
144 ensure!(
145 sig.protected == expected_protected,
146 "at9p signature protected header does not match the canonical binding for {expected_context:?}"
147 );
148
149 let ed_kid = ed_vk.to_bytes().to_vec();
153 let pq_kid = ml_dsa_vk_bytes(pq_vk);
154 let composite = assemble_composite_nested(
155 (ed_kid, sig.ed25519_signature.clone()),
156 Some((pq_kid, sig.mldsa65_signature.clone())),
157 )
158 .context("failed to reassemble at9p composite for verification")?;
159
160 let verified = verify_composite(
163 &composite,
164 ed_vk,
165 Some(pq_vk),
166 payload,
167 &expected_protected,
168 true,
169 )
170 .context("at9p composite verification failed")?;
171
172 ensure!(
175 verified.eddsa && verified.ml_dsa,
176 "at9p verification did not confirm both composite layers (eddsa={}, ml_dsa={})",
177 verified.eddsa,
178 verified.ml_dsa
179 );
180 Ok(())
181}
182
183pub trait CapsuleEd25519Signer {
192 fn verifying_key(&self) -> VerifyingKey;
194
195 fn sign_detached(&self, tbs: &[u8]) -> Result<[u8; 64]>;
197}
198
199impl CapsuleEd25519Signer for SigningKey {
200 fn verifying_key(&self) -> VerifyingKey {
201 SigningKey::verifying_key(self)
202 }
203
204 fn sign_detached(&self, tbs: &[u8]) -> Result<[u8; 64]> {
205 use ed25519_dalek::Signer as _;
206 Ok(self.sign(tbs).to_bytes())
207 }
208}
209
210fn sign_record_detached(
219 payload: &[u8],
220 context: &str,
221 ed: &dyn CapsuleEd25519Signer,
222 pq_sk: &MlDsaSigningKey,
223) -> Result<CoseCompositeSignature> {
224 let protected = context_protected_header(context);
225 let ed_kid = ed.verifying_key().to_bytes().to_vec();
226 let ed_sig = ed.sign_detached(&inner_tbs(ed_kid.clone(), payload, &protected, true))?;
227 let pq_kid = ml_dsa_sk_to_vk_bytes(pq_sk);
228 let pq_sig = ml_dsa_sign(
229 pq_sk,
230 &outer_tbs(pq_kid.clone(), payload, &ed_sig, &protected),
231 );
232 let composite = assemble_composite_nested((ed_kid, ed_sig.to_vec()), Some((pq_kid, pq_sig)))
236 .context("at9p detached composite assembly failed")?;
237 let (ed_sig, pq_sig) = split_composite(&composite)?;
238 let pq_sig = pq_sig
239 .ok_or_else(|| anyhow::anyhow!("at9p detached signing produced no ML-DSA-65 layer"))?;
240 CoseCompositeSignature::new(context, protected, ed_sig, pq_sig)
241}
242
243pub fn sign_capsule(
248 body: CapsuleBody,
249 ed_sk: &SigningKey,
250 pq_sk: &MlDsaSigningKey,
251) -> Result<Capsule> {
252 sign_capsule_detached(body, ed_sk, pq_sk)
253}
254
255pub fn sign_capsule_detached(
259 body: CapsuleBody,
260 ed: &dyn CapsuleEd25519Signer,
261 pq_sk: &MlDsaSigningKey,
262) -> Result<Capsule> {
263 body.validate()?;
264 let signer_ed = ed.verifying_key().to_bytes();
269 let entry = body.subject_key_for_ed25519(&signer_ed).ok_or_else(|| {
270 anyhow::anyhow!("signing ed25519 key is not a published capsule subject key")
271 })?;
272 ensure!(
273 entry.mldsa65_pub == ml_dsa_sk_to_vk_bytes(pq_sk),
274 "signing ML-DSA-65 key does not match the atomically-bound subject key"
275 );
276
277 let payload = body.to_dag_cbor()?;
278 let signatures = sign_record_detached(&payload, CAPSULE_SIGNATURE_CONTEXT, ed, pq_sk)?;
279 Capsule::new(body, signatures)
280}
281
282pub fn verify_capsule(capsule: &Capsule) -> Result<()> {
291 capsule.body.validate()?;
292 let payload = capsule.body.to_dag_cbor()?;
293 let mut last_err = None;
294 for subject in &capsule.body.subject_keys {
295 let (ed_vk, pq_vk) = match verifying_keys(subject) {
296 Ok(keys) => keys,
297 Err(e) => {
298 last_err = Some(e);
299 continue;
300 }
301 };
302 match verify_record(
303 &payload,
304 &capsule.signatures,
305 CAPSULE_SIGNATURE_CONTEXT,
306 &ed_vk,
307 &pq_vk,
308 ) {
309 Ok(()) => return Ok(()),
310 Err(e) => last_err = Some(e),
311 }
312 }
313 Err(last_err.unwrap_or_else(|| {
314 anyhow::anyhow!("capsule self-signature verified under no published subject key")
315 }))
316}
317
318#[allow(clippy::too_many_arguments)]
326pub fn sign_update_record(
327 subject_cid512: String,
328 epoch: u64,
329 prev_record_digest: [u8; crate::at9p::H512_LEN],
330 new_capsule_body: CapsuleBody,
331 expires_at: String,
332 ed_sk: &SigningKey,
333 pq_sk: &MlDsaSigningKey,
334) -> Result<UpdateRecord> {
335 new_capsule_body.validate()?;
336 let placeholder = CoseCompositeSignature::new(
339 UPDATE_SIGNATURE_CONTEXT,
340 context_protected_header(UPDATE_SIGNATURE_CONTEXT),
341 vec![0u8; crate::at9p::ED25519_SIGNATURE_LEN],
342 vec![0u8; crate::at9p::ML_DSA65_SIGNATURE_LEN],
343 )?;
344 let mut record = UpdateRecord {
345 subject_cid512,
346 epoch,
347 prev_record_digest,
348 new_capsule_body,
349 expires_at,
350 signatures: placeholder,
351 };
352 let payload = record.signable_bytes()?;
353 record.signatures = sign_record(&payload, UPDATE_SIGNATURE_CONTEXT, ed_sk, pq_sk)?;
354 UpdateRecord::from_dag_cbor(&record.to_dag_cbor()?)
356}
357
358pub fn verify_update_record(record: &UpdateRecord, signer: &HybridKeyPair) -> Result<()> {
362 let (ed_vk, pq_vk) = verifying_keys(signer)?;
363 let payload = record.signable_bytes()?;
364 verify_record(
365 &payload,
366 &record.signatures,
367 UPDATE_SIGNATURE_CONTEXT,
368 &ed_vk,
369 &pq_vk,
370 )
371}
372
373#[cfg(test)]
374#[allow(clippy::unwrap_used, clippy::expect_used, clippy::indexing_slicing)]
375mod tests {
376 use super::*;
377 use crate::at9p::{
378 ServiceEndpoint, ServiceEntry, ServiceType, Transport, ML_DSA65_SIGNATURE_LEN,
379 };
380 use ed25519_dalek::SigningKey;
381 use hyprstream_crypto::pq::ml_dsa_generate_keypair;
382 use rand::rngs::OsRng;
383
384 struct Signer {
385 ed_sk: SigningKey,
386 pq_sk: MlDsaSigningKey,
387 keypair: HybridKeyPair,
388 }
389
390 fn signer() -> Signer {
391 let ed_sk = SigningKey::generate(&mut OsRng);
392 let (pq_sk, pq_vk) = ml_dsa_generate_keypair();
393 let keypair = HybridKeyPair::new(
394 ed_sk.verifying_key().to_bytes().to_vec(),
395 ml_dsa_vk_bytes(&pq_vk),
396 )
397 .unwrap();
398 Signer {
399 ed_sk,
400 pq_sk,
401 keypair,
402 }
403 }
404
405 fn capsule_body(keypair: HybridKeyPair) -> CapsuleBody {
406 let endpoint = ServiceEndpoint::new(Transport::Iroh, "iroh://node0").unwrap();
407 let service = ServiceEntry::new("#ns", ServiceType::NinePExport, endpoint).unwrap();
408 CapsuleBody::new(vec![keypair], vec![service]).unwrap()
409 }
410
411 fn signed_capsule() -> (Signer, Capsule) {
412 let s = signer();
413 let body = capsule_body(s.keypair.clone());
414 let capsule = sign_capsule(body, &s.ed_sk, &s.pq_sk).unwrap();
415 (s, capsule)
416 }
417
418 fn signed_update(s: &Signer) -> UpdateRecord {
419 let body = capsule_body(s.keypair.clone());
420 let subject_cid512 = Capsule::new(
421 body.clone(),
422 sign_record(
424 &body.to_dag_cbor().unwrap(),
425 CAPSULE_SIGNATURE_CONTEXT,
426 &s.ed_sk,
427 &s.pq_sk,
428 )
429 .unwrap(),
430 )
431 .unwrap()
432 .cid512()
433 .unwrap();
434 sign_update_record(
435 subject_cid512,
436 7,
437 [9u8; crate::at9p::H512_LEN],
438 body,
439 "2026-07-09T00:00:00Z".to_owned(),
440 &s.ed_sk,
441 &s.pq_sk,
442 )
443 .unwrap()
444 }
445
446 #[test]
447 fn capsule_sign_verify_round_trip() {
448 let (_s, capsule) = signed_capsule();
449 verify_capsule(&capsule).expect("capsule must verify");
450 let bytes = capsule.to_dag_cbor().unwrap();
452 let decoded = Capsule::from_dag_cbor(&bytes).unwrap();
453 verify_capsule(&decoded).expect("decoded capsule must verify");
454 }
455
456 #[test]
457 fn update_record_sign_verify_round_trip() {
458 let s = signer();
459 let record = signed_update(&s);
460 verify_update_record(&record, &s.keypair).expect("update must verify");
461 let bytes = record.to_dag_cbor().unwrap();
462 let decoded = UpdateRecord::from_dag_cbor(&bytes).unwrap();
463 verify_update_record(&decoded, &s.keypair).expect("decoded update must verify");
464 }
465
466 #[test]
469 fn cross_type_replay_rejected() {
470 let (s, capsule) = signed_capsule();
471 let mut forged = capsule.signatures.clone();
474 forged.context = UPDATE_SIGNATURE_CONTEXT.to_owned();
477 forged.protected = context_protected_header(UPDATE_SIGNATURE_CONTEXT);
478 let (ed_vk, pq_vk) = verifying_keys(&s.keypair).unwrap();
479 let res = verify_record(
480 &capsule.body.to_dag_cbor().unwrap(),
481 &forged,
482 UPDATE_SIGNATURE_CONTEXT,
483 &ed_vk,
484 &pq_vk,
485 );
486 assert!(
487 res.is_err(),
488 "cross-context signature reuse must be rejected"
489 );
490
491 let res2 = verify_record(
494 &capsule.body.to_dag_cbor().unwrap(),
495 &capsule.signatures,
496 UPDATE_SIGNATURE_CONTEXT,
497 &ed_vk,
498 &pq_vk,
499 );
500 assert!(res2.is_err(), "wrong expected context must be rejected");
501 }
502
503 #[test]
508 fn classical_only_signature_rejected_under_classical_policy() {
509 let s = signer();
510 let body = capsule_body(s.keypair.clone());
511 let payload = body.to_dag_cbor().unwrap();
512 let protected = context_protected_header(CAPSULE_SIGNATURE_CONTEXT);
513
514 let classical = sign_composite(&s.ed_sk, None, &payload, &protected).unwrap();
521 let (ed_sig, pq_sig) = split_composite(&classical).unwrap();
522 assert!(pq_sig.is_none(), "classical composite has no ML-DSA layer");
523
524 let forged = CoseCompositeSignature::new(
525 CAPSULE_SIGNATURE_CONTEXT,
526 protected,
527 ed_sig,
528 vec![0u8; ML_DSA65_SIGNATURE_LEN],
529 )
530 .unwrap();
531 let capsule = Capsule::new(body, forged).unwrap();
532
533 let res = verify_capsule(&capsule);
535 assert!(
536 res.is_err(),
537 "classical-only / missing-PQ capsule must be rejected under pinned Hybrid"
538 );
539 }
540
541 #[test]
543 fn tampered_payload_rejected() {
544 let (s, capsule) = signed_capsule();
545 let (ed_vk, pq_vk) = verifying_keys(&s.keypair).unwrap();
546 let mut tampered = capsule.body.to_dag_cbor().unwrap();
547 let last = tampered.len() - 1;
549 tampered[last] ^= 0x01;
550 let res = verify_record(
551 &tampered,
552 &capsule.signatures,
553 CAPSULE_SIGNATURE_CONTEXT,
554 &ed_vk,
555 &pq_vk,
556 );
557 assert!(res.is_err(), "tampered payload must fail verification");
558 }
559
560 #[test]
563 fn wrong_key_rejected() {
564 let (_s, capsule) = signed_capsule();
565 let other = signer();
566 let res = verify_update_record(
567 &UpdateRecord {
568 subject_cid512: capsule.cid512().unwrap(),
569 epoch: 0,
570 prev_record_digest: [0u8; crate::at9p::H512_LEN],
571 new_capsule_body: capsule.body.clone(),
572 expires_at: "2026-07-09T00:00:00Z".to_owned(),
573 signatures: capsule.signatures.clone(),
574 },
575 &other.keypair,
576 );
577 assert!(res.is_err(), "verification under the wrong key must fail");
578 }
579
580 #[test]
585 fn signing_always_hybrid() {
586 let (_s, capsule) = signed_capsule();
587 assert_eq!(
588 capsule.signatures.mldsa65_signature.len(),
589 ML_DSA65_SIGNATURE_LEN
590 );
591 assert!(
592 capsule.signatures.mldsa65_signature.iter().any(|&b| b != 0),
593 "ML-DSA-65 signature must be a real signature, not a placeholder"
594 );
595 verify_capsule(&capsule).unwrap();
596 }
597
598 fn two_key_body(first: &Signer, second: &Signer) -> CapsuleBody {
603 let endpoint = ServiceEndpoint::new(Transport::Iroh, "iroh://node0").unwrap();
604 let service = ServiceEntry::new("#ns", ServiceType::NinePExport, endpoint).unwrap();
605 CapsuleBody::new(
606 vec![first.keypair.clone(), second.keypair.clone()],
607 vec![service],
608 )
609 .unwrap()
610 }
611
612 #[test]
617 fn capsule_signed_by_non_first_subject_key_verifies() {
618 let (k1, k2) = (signer(), signer());
619 let body = two_key_body(&k1, &k2);
620 let capsule = sign_capsule(body, &k2.ed_sk, &k2.pq_sk)
622 .expect("any published subject key may self-certify the capsule");
623 verify_capsule(&capsule).expect("capsule signed by a published key must verify");
624 let decoded = Capsule::from_dag_cbor(&capsule.to_dag_cbor().unwrap()).unwrap();
626 verify_capsule(&decoded).expect("decoded two-key capsule must verify");
627 }
628
629 #[test]
632 fn capsule_signed_by_unpublished_key_rejected() {
633 let (k1, k2, outsider) = (signer(), signer(), signer());
634 let body = two_key_body(&k1, &k2);
635 let capsule = sign_capsule(body.clone(), &k1.ed_sk, &k1.pq_sk).unwrap();
638 let payload = capsule.body.to_dag_cbor().unwrap();
639 let forged = sign_record(
640 &payload,
641 CAPSULE_SIGNATURE_CONTEXT,
642 &outsider.ed_sk,
643 &outsider.pq_sk,
644 )
645 .unwrap();
646 let spliced = Capsule::new(capsule.body, forged).unwrap();
647 assert!(
648 verify_capsule(&spliced).is_err(),
649 "a capsule signed by an unpublished key must fail closed"
650 );
651 }
652
653 #[test]
656 fn duplicate_ed25519_subject_key_rejected() {
657 let k = signer();
658 let endpoint = ServiceEndpoint::new(Transport::Iroh, "iroh://node0").unwrap();
659 let service = ServiceEntry::new("#ns", ServiceType::NinePExport, endpoint).unwrap();
660 let err = CapsuleBody::new(vec![k.keypair.clone(), k.keypair.clone()], vec![service])
661 .expect_err("a duplicate subject key must be rejected");
662 assert!(
663 err.to_string().contains("subjectKeys") || err.to_string().contains("subject"),
664 "unexpected error: {err}"
665 );
666 }
667}