1use std::path::Path;
8
9use anyhow::Result;
10use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
11use ed25519_dalek::{SigningKey, VerifyingKey};
12
13const NEW_EXPIRY_TTL: i64 = 30 * 86_400;
14const RENEW_THRESHOLD: i64 = 7 * 86_400;
15
16pub fn issue_or_load_service_jwt(
26 credentials_dir: &Path,
27 service_name: &str,
28 ca_jwt_key: &SigningKey,
29 bootstrap: &super::identity_store::BootstrapPubkey,
30 local_issuer_url: &str,
31 now: i64,
32 target_clearance: Option<&hyprstream_rpc::auth::mac::SecurityLabel>,
33) -> Result<String> {
34 let service_vk = &bootstrap.ed25519;
35 let ml_dsa_bytes = bootstrap
41 .ml_dsa_65
42 .as_ref()
43 .map(hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes);
44 let expected_hs = hyprstream_rpc::auth::service_signer_suite_b64(
45 &service_vk.to_bytes(),
46 ml_dsa_bytes.as_deref(),
47 );
48 let existing = super::identity_store::load_service_jwt(credentials_dir, service_name)?;
49 let needs_issue = match existing {
50 None => true,
51 Some(ref jwt) => {
52 let exp = decode_jwt_exp(jwt).unwrap_or(0);
53 (exp - now) <= RENEW_THRESHOLD
64 || !claims_bind_local_issuer(jwt, local_issuer_url)
65 || !header_alg_covers_pq(jwt)
66 || !persisted_token_binds(jwt, ca_jwt_key, service_name, service_vk, &expected_hs)
71 || decode_jwt_clearance(jwt)
78 != target_clearance
79 .map(|c| hyprstream_rpc::auth::mac::CredentialClearance::from_label(*c))
80 }
81 };
82
83 if !needs_issue {
84 if let Some(jwt) = existing {
85 return Ok(jwt);
86 }
87 }
88
89 let expiry = now + NEW_EXPIRY_TTL;
90 let mut claims =
102 hyprstream_rpc::auth::Claims::new(format!("service:{service_name}"), now, expiry)
103 .with_cnf_jwk(service_vk.as_bytes())
106 .with_cnf_hs_signer_suite(expected_hs.clone());
107 if !local_issuer_url.is_empty() {
108 claims = claims
112 .with_issuer(local_issuer_url.to_owned())
113 .with_audience(Some(local_issuer_url.to_owned()));
114 }
115 if let Some(clearance) = target_clearance {
119 claims = claims.with_clearance(*clearance);
120 }
121
122 let ca_pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(ca_jwt_key);
130 let ca_pq_vk = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&ca_pq);
131 Ok(hyprstream_rpc::auth::jwt::encode_service_jwt_hybrid(
132 &claims, ca_jwt_key, &ca_pq, &ca_pq_vk,
133 ))
134}
135
136fn claims_bind_local_issuer(jwt: &str, local_issuer_url: &str) -> bool {
143 let iss = decode_jwt_iss(jwt);
144 if iss.as_deref().is_none_or(str::is_empty) {
145 return false;
146 }
147 if local_issuer_url.is_empty() {
148 return true;
149 }
150 iss.as_deref() == Some(local_issuer_url)
151 && decode_jwt_aud(jwt).as_deref() == Some(local_issuer_url)
152}
153
154fn header_alg_covers_pq(jwt: &str) -> bool {
158 matches!(
159 hyprstream_rpc::auth::jwt::header_alg(jwt)
160 .ok()
161 .flatten()
162 .as_deref(),
163 Some("ML-DSA-65" | "ML-DSA-65-Ed25519")
164 )
165}
166
167fn persisted_token_binds(
173 jwt: &str,
174 ca_jwt_key: &SigningKey,
175 service_name: &str,
176 service_vk: &VerifyingKey,
177 expected_hs: &str,
178) -> bool {
179 let ca_pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(ca_jwt_key);
180 let ca_pq_vk = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&ca_pq);
181 let Ok(dispatch) = hyprstream_rpc::auth::jwt::parse_composite_dispatch(jwt, &["wit+jwt"])
182 else {
183 return false;
184 };
185 let Ok(claims) = hyprstream_rpc::auth::jwt::decode_composite(
186 jwt,
187 &ca_pq_vk,
188 &ca_jwt_key.verifying_key(),
189 None,
190 &dispatch,
191 ) else {
192 return false;
193 };
194 let hs_binds = claims
199 .cnf
200 .as_ref()
201 .and_then(|c| c.hs_signer_suite.as_deref())
202 == Some(expected_hs);
203 claims.sub == format!("service:{service_name}")
204 && claims.cnf_key_bytes() == Some(service_vk.to_bytes())
205 && claims.jti.is_some()
206 && hs_binds
207}
208
209fn decode_jwt_clearance(jwt: &str) -> Option<hyprstream_rpc::auth::mac::CredentialClearance> {
216 let payload_b64 = jwt.split('.').nth(1)?;
217 let payload = URL_SAFE_NO_PAD.decode(payload_b64).ok()?;
218 let value: serde_json::Value = serde_json::from_slice(&payload).ok()?;
219 serde_json::from_value(value.get("clearance")?.clone()).ok()
220}
221
222fn decode_jwt_exp(jwt: &str) -> Option<i64> {
223 let payload_b64 = jwt.split('.').nth(1)?;
224 let payload = URL_SAFE_NO_PAD.decode(payload_b64).ok()?;
225 let value: serde_json::Value = serde_json::from_slice(&payload).ok()?;
226 value.get("exp")?.as_i64()
227}
228
229fn decode_jwt_iss(jwt: &str) -> Option<String> {
234 let payload_b64 = jwt.split('.').nth(1)?;
235 let payload = URL_SAFE_NO_PAD.decode(payload_b64).ok()?;
236 let value: serde_json::Value = serde_json::from_slice(&payload).ok()?;
237 value.get("iss")?.as_str().map(ToOwned::to_owned)
238}
239
240fn decode_jwt_aud(jwt: &str) -> Option<String> {
243 let payload_b64 = jwt.split('.').nth(1)?;
244 let payload = URL_SAFE_NO_PAD.decode(payload_b64).ok()?;
245 let value: serde_json::Value = serde_json::from_slice(&payload).ok()?;
246 value.get("aud")?.as_str().map(ToOwned::to_owned)
247}
248
249#[cfg(test)]
250#[allow(clippy::unwrap_used, clippy::expect_used)]
251mod tests {
252 use super::super::identity_store::BootstrapPubkey;
253 use super::*;
254 use ed25519_dalek::SigningKey;
255
256 fn bp(vk: ed25519_dalek::VerifyingKey) -> BootstrapPubkey {
258 BootstrapPubkey {
259 ed25519: vk,
260 ml_dsa_65: None,
261 }
262 }
263
264 #[test]
269 fn issued_service_jwt_carries_local_issuer() {
270 let dir = tempfile::tempdir().unwrap();
271 let ca = SigningKey::from_bytes(&[3u8; 32]);
272 let svc = SigningKey::from_bytes(&[4u8; 32]);
273 let issuer = "http://localhost:6791";
274
275 let jwt = issue_or_load_service_jwt(
276 dir.path(),
277 "model",
278 &ca,
279 &bp(svc.verifying_key()),
280 issuer,
281 1_000_000,
282 None,
283 )
284 .unwrap();
285
286 assert_eq!(decode_jwt_iss(&jwt).as_deref(), Some(issuer));
287 }
288
289 #[test]
298 fn policy_service_jwt_is_symmetric_and_binds_root_key() {
299 let dir = tempfile::tempdir().unwrap();
300 let root_key = SigningKey::from_bytes(&[7u8; 32]);
302 let ca_jwt_key =
305 hyprstream_rpc::node_identity::derive_purpose_key(&root_key, "hyprstream-jwt-v1");
306 let issuer = "http://localhost:6791";
307
308 let policy_key = root_key.clone();
311 let policy_vk = policy_key.verifying_key();
312 let jwt = issue_or_load_service_jwt(
313 dir.path(),
314 "policy",
315 &ca_jwt_key,
316 &bp(policy_vk),
317 issuer,
318 1_000_000,
319 None,
320 )
321 .unwrap();
322 super::super::identity_store::write_service_jwt(dir.path(), "policy", &jwt).unwrap();
323
324 let loaded = super::super::identity_store::load_service_jwt(dir.path(), "policy").unwrap();
326 assert_eq!(loaded.as_deref(), Some(jwt.as_str()));
327
328 let payload_b64 = jwt.split('.').nth(1).unwrap();
330 let payload = URL_SAFE_NO_PAD.decode(payload_b64).unwrap();
331 let value: serde_json::Value = serde_json::from_slice(&payload).unwrap();
332 assert_eq!(
333 value.get("sub").and_then(|v| v.as_str()),
334 Some("service:policy")
335 );
336
337 let cnf = value.get("cnf").and_then(|v| v.get("jwk"));
340 assert!(cnf.is_some(), "policy service JWT must carry a cnf.jwk");
341 let x = cnf
344 .and_then(|v| v.get("x"))
345 .and_then(|v| v.as_str())
346 .unwrap();
347 let x_bytes = URL_SAFE_NO_PAD.decode(x).unwrap();
348 assert_eq!(
349 x_bytes.as_slice(),
350 root_key.verifying_key().as_bytes(),
351 "cnf.jwk must bind root_key.verifying_key(), the key bootstrap registers for policy"
352 );
353
354 assert_eq!(root_key.verifying_key().as_bytes(), policy_vk.as_bytes());
356 }
357
358 #[test]
363 fn classical_persisted_jwt_is_reissued_hybrid() {
364 let dir = tempfile::tempdir().unwrap();
365 let ca = SigningKey::from_bytes(&[3u8; 32]);
366 let svc = SigningKey::from_bytes(&[4u8; 32]);
367 let issuer = "http://localhost:6791";
368 let now = chrono::Utc::now().timestamp();
371
372 let legacy_claims =
374 hyprstream_rpc::auth::Claims::new("service:model".to_owned(), now, now + 30 * 86_400)
375 .with_issuer(issuer.to_owned())
376 .with_cnf_jwk(svc.verifying_key().as_bytes());
377 let legacy = hyprstream_rpc::auth::jwt::encode_service_jwt(&legacy_claims, &ca);
378 super::super::identity_store::write_service_jwt(dir.path(), "model", &legacy).unwrap();
379
380 let jwt = issue_or_load_service_jwt(
381 dir.path(),
382 "model",
383 &ca,
384 &bp(svc.verifying_key()),
385 issuer,
386 now,
387 None,
388 )
389 .unwrap();
390 assert_ne!(jwt, legacy, "classical token must not be returned as-is");
391 assert_eq!(
392 hyprstream_rpc::auth::jwt::header_alg(&jwt)
393 .unwrap()
394 .as_deref(),
395 Some("ML-DSA-65-Ed25519"),
396 );
397
398 let ca_pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&ca);
401 let ca_pq_vk = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&ca_pq);
402 let dispatch =
403 hyprstream_rpc::auth::jwt::parse_composite_dispatch(&jwt, &["wit+jwt"]).unwrap();
404 let verified = hyprstream_rpc::auth::jwt::decode_composite(
405 &jwt,
406 &ca_pq_vk,
407 &ca.verifying_key(),
408 None,
409 &dispatch,
410 )
411 .unwrap();
412 assert_eq!(verified.sub, "service:model");
413 assert_eq!(verified.iss, issuer);
414 }
415
416 #[test]
421 fn audless_persisted_hybrid_jwt_is_reissued_with_audience() {
422 let dir = tempfile::tempdir().unwrap();
423 let ca = SigningKey::from_bytes(&[3u8; 32]);
424 let svc = SigningKey::from_bytes(&[4u8; 32]);
425 let issuer = "http://localhost:6791";
426 let now = chrono::Utc::now().timestamp();
427
428 let legacy_claims =
430 hyprstream_rpc::auth::Claims::new("service:model".to_owned(), now, now + 30 * 86_400)
431 .with_issuer(issuer.to_owned())
432 .with_cnf_jwk(svc.verifying_key().as_bytes());
433 let ca_pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&ca);
434 let ca_pq_vk = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&ca_pq);
435 let legacy = hyprstream_rpc::auth::jwt::encode_service_jwt_hybrid(
436 &legacy_claims,
437 &ca,
438 &ca_pq,
439 &ca_pq_vk,
440 );
441 assert!(decode_jwt_aud(&legacy).is_none());
442 super::super::identity_store::write_service_jwt(dir.path(), "model", &legacy).unwrap();
443
444 let jwt = issue_or_load_service_jwt(
445 dir.path(),
446 "model",
447 &ca,
448 &bp(svc.verifying_key()),
449 issuer,
450 now,
451 None,
452 )
453 .unwrap();
454 assert_ne!(jwt, legacy, "aud-less token must not be returned as-is");
455 assert_eq!(decode_jwt_iss(&jwt).as_deref(), Some(issuer));
456 assert_eq!(decode_jwt_aud(&jwt).as_deref(), Some(issuer));
457
458 let dispatch =
460 hyprstream_rpc::auth::jwt::parse_composite_dispatch(&jwt, &["wit+jwt"]).unwrap();
461 hyprstream_rpc::auth::jwt::decode_composite(
462 &jwt,
463 &ca_pq_vk,
464 &ca.verifying_key(),
465 Some(issuer),
466 &dispatch,
467 )
468 .unwrap();
469 }
470
471 #[test]
474 fn hybrid_persisted_jwt_is_returned_unchanged() {
475 let dir = tempfile::tempdir().unwrap();
476 let ca = SigningKey::from_bytes(&[3u8; 32]);
477 let svc = SigningKey::from_bytes(&[4u8; 32]);
478 let issuer = "http://localhost:6791";
479 let now = chrono::Utc::now().timestamp();
482
483 let first = issue_or_load_service_jwt(
484 dir.path(),
485 "model",
486 &ca,
487 &bp(svc.verifying_key()),
488 issuer,
489 now,
490 None,
491 )
492 .unwrap();
493 super::super::identity_store::write_service_jwt(dir.path(), "model", &first).unwrap();
494
495 let second = issue_or_load_service_jwt(
496 dir.path(),
497 "model",
498 &ca,
499 &bp(svc.verifying_key()),
500 issuer,
501 now,
502 None,
503 )
504 .unwrap();
505 assert_eq!(first, second);
506 }
507
508 #[test]
512 fn empty_issuer_legacy_jwt_is_reissued_with_issuer() {
513 let dir = tempfile::tempdir().unwrap();
514 let ca = SigningKey::from_bytes(&[3u8; 32]);
515 let svc = SigningKey::from_bytes(&[4u8; 32]);
516
517 let now = 1_000_000;
519 let legacy_claims =
520 hyprstream_rpc::auth::Claims::new("service:model".to_owned(), now, now + 30 * 86_400)
521 .with_cnf_jwk(svc.verifying_key().as_bytes());
522 let legacy = hyprstream_rpc::auth::jwt::encode_service_jwt(&legacy_claims, &ca);
523 assert!(decode_jwt_iss(&legacy).is_none_or(|s| s.is_empty()));
524 super::super::identity_store::write_service_jwt(dir.path(), "model", &legacy).unwrap();
525
526 let jwt = issue_or_load_service_jwt(
529 dir.path(),
530 "model",
531 &ca,
532 &bp(svc.verifying_key()),
533 "http://localhost:6791",
534 now,
535 None,
536 )
537 .unwrap();
538 assert_eq!(
539 decode_jwt_iss(&jwt).as_deref(),
540 Some("http://localhost:6791")
541 );
542 }
543
544 fn enrollment_label() -> hyprstream_rpc::auth::mac::SecurityLabel {
545 hyprstream_rpc::auth::mac::SecurityLabel::new(
546 hyprstream_rpc::auth::mac::Level::Internal,
547 hyprstream_rpc::auth::mac::Assurance::Classical,
548 hyprstream_rpc::auth::mac::CompartmentSet::EMPTY,
549 )
550 }
551
552 #[test]
557 fn clearance_is_stamped_and_stale_or_missing_clearance_reissued() {
558 let dir = tempfile::tempdir().unwrap();
559 let ca = SigningKey::from_bytes(&[3u8; 32]);
560 let svc = SigningKey::from_bytes(&[4u8; 32]);
561 let issuer = "http://localhost:6791";
562 let now = chrono::Utc::now().timestamp();
567 let target = enrollment_label();
568
569 let jwt = issue_or_load_service_jwt(
571 dir.path(),
572 "model",
573 &ca,
574 &bp(svc.verifying_key()),
575 issuer,
576 now,
577 Some(&target),
578 )
579 .unwrap();
580 assert_eq!(
581 decode_jwt_clearance(&jwt),
582 Some(hyprstream_rpc::auth::mac::CredentialClearance::from_label(
583 target
584 ))
585 );
586 super::super::identity_store::write_service_jwt(dir.path(), "model", &jwt).unwrap();
587
588 let second = issue_or_load_service_jwt(
590 dir.path(),
591 "model",
592 &ca,
593 &bp(svc.verifying_key()),
594 issuer,
595 now,
596 Some(&target),
597 )
598 .unwrap();
599 assert_eq!(jwt, second);
600
601 let narrowed = hyprstream_rpc::auth::mac::SecurityLabel::new(
604 hyprstream_rpc::auth::mac::Level::Secret,
605 hyprstream_rpc::auth::mac::Assurance::Classical,
606 hyprstream_rpc::auth::mac::CompartmentSet::EMPTY,
607 );
608 let reminted = issue_or_load_service_jwt(
609 dir.path(),
610 "model",
611 &ca,
612 &bp(svc.verifying_key()),
613 issuer,
614 now,
615 Some(&narrowed),
616 )
617 .unwrap();
618 assert_ne!(reminted, jwt, "stale-clearance token must not be reused");
619 assert_eq!(
620 decode_jwt_clearance(&reminted),
621 Some(hyprstream_rpc::auth::mac::CredentialClearance::from_label(
622 narrowed
623 ))
624 );
625
626 let legacy_claims =
629 hyprstream_rpc::auth::Claims::new("service:model".to_owned(), now, now + 30 * 86_400)
630 .with_issuer(issuer.to_owned())
631 .with_audience(Some(issuer.to_owned()))
632 .with_cnf_jwk(svc.verifying_key().as_bytes());
633 let ca_pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&ca);
634 let ca_pq_vk = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&ca_pq);
635 let legacy = hyprstream_rpc::auth::jwt::encode_service_jwt_hybrid(
636 &legacy_claims,
637 &ca,
638 &ca_pq,
639 &ca_pq_vk,
640 );
641 super::super::identity_store::write_service_jwt(dir.path(), "model", &legacy).unwrap();
642 let healed = issue_or_load_service_jwt(
643 dir.path(),
644 "model",
645 &ca,
646 &bp(svc.verifying_key()),
647 issuer,
648 now,
649 Some(&target),
650 )
651 .unwrap();
652 assert_ne!(healed, legacy, "clearance-less token must not be reused");
653 assert_eq!(
654 decode_jwt_clearance(&healed),
655 Some(hyprstream_rpc::auth::mac::CredentialClearance::from_label(
656 target
657 ))
658 );
659 }
660
661 #[test]
665 fn persisted_token_with_broken_binding_is_reissued() {
666 let dir = tempfile::tempdir().unwrap();
667 let ca = SigningKey::from_bytes(&[3u8; 32]);
668 let svc = SigningKey::from_bytes(&[4u8; 32]);
669 let issuer = "http://localhost:6791";
670 let now = chrono::Utc::now().timestamp();
671
672 let good = issue_or_load_service_jwt(
673 dir.path(),
674 "model",
675 &ca,
676 &bp(svc.verifying_key()),
677 issuer,
678 now,
679 None,
680 )
681 .unwrap();
682 super::super::identity_store::write_service_jwt(dir.path(), "model", &good).unwrap();
683
684 let reused = issue_or_load_service_jwt(
686 dir.path(),
687 "model",
688 &ca,
689 &bp(svc.verifying_key()),
690 issuer,
691 now,
692 None,
693 )
694 .unwrap();
695 assert_eq!(good, reused);
696
697 let parts: Vec<&str> = good.split('.').collect();
700 let mut sig = URL_SAFE_NO_PAD.decode(parts[2]).unwrap();
701 sig[0] ^= 0x01;
702 let tampered = format!("{}.{}.{}", parts[0], parts[1], URL_SAFE_NO_PAD.encode(sig));
703 super::super::identity_store::write_service_jwt(dir.path(), "model", &tampered).unwrap();
704 let reissued = issue_or_load_service_jwt(
705 dir.path(),
706 "model",
707 &ca,
708 &bp(svc.verifying_key()),
709 issuer,
710 now,
711 None,
712 )
713 .unwrap();
714 assert_ne!(
715 reissued, tampered,
716 "tampered-signature token must be reissued"
717 );
718
719 let other_svc = SigningKey::from_bytes(&[9u8; 32]);
722 let foreign_claims =
723 hyprstream_rpc::auth::Claims::new("service:model".to_owned(), now, now + 30 * 86_400)
724 .with_issuer(issuer.to_owned())
725 .with_audience(Some(issuer.to_owned()))
726 .with_cnf_jwk(other_svc.verifying_key().as_bytes());
727 let ca_pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&ca);
728 let ca_pq_vk = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&ca_pq);
729 let foreign = hyprstream_rpc::auth::jwt::encode_service_jwt_hybrid(
730 &foreign_claims,
731 &ca,
732 &ca_pq,
733 &ca_pq_vk,
734 );
735 super::super::identity_store::write_service_jwt(dir.path(), "model", &foreign).unwrap();
736 let reissued = issue_or_load_service_jwt(
737 dir.path(),
738 "model",
739 &ca,
740 &bp(svc.verifying_key()),
741 issuer,
742 now,
743 None,
744 )
745 .unwrap();
746 assert_ne!(reissued, foreign, "foreign-cnf token must be reissued");
747 let dispatch =
749 hyprstream_rpc::auth::jwt::parse_composite_dispatch(&reissued, &["wit+jwt"]).unwrap();
750 let verified = hyprstream_rpc::auth::jwt::decode_composite(
751 &reissued,
752 &ca_pq_vk,
753 &ca.verifying_key(),
754 None,
755 &dispatch,
756 )
757 .unwrap();
758 assert_eq!(
759 verified.cnf_key_bytes(),
760 Some(svc.verifying_key().to_bytes())
761 );
762 }
763
764 fn decode_cnf(jwt: &str) -> Option<serde_json::Value> {
766 let payload_b64 = jwt.split('.').nth(1)?;
767 let payload = URL_SAFE_NO_PAD.decode(payload_b64).ok()?;
768 let value: serde_json::Value = serde_json::from_slice(&payload).ok()?;
769 value.get("cnf").cloned()
770 }
771
772 #[test]
776 fn fresh_hybrid_service_jwt_stamps_authoritative_signer_suite() {
777 let dir = tempfile::tempdir().unwrap();
778 let ca = SigningKey::from_bytes(&[3u8; 32]);
779 let svc = SigningKey::from_bytes(&[4u8; 32]);
780 let (_svc_pq, svc_pq_vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
781 let issuer = "http://localhost:6791";
782 let now = chrono::Utc::now().timestamp();
783
784 let bootstrap = BootstrapPubkey {
785 ed25519: svc.verifying_key(),
786 ml_dsa_65: Some(svc_pq_vk.clone()),
787 };
788 let jwt =
789 issue_or_load_service_jwt(dir.path(), "model", &ca, &bootstrap, issuer, now, None)
790 .unwrap();
791
792 let expected = hyprstream_rpc::auth::service_signer_suite_b64(
793 &svc.verifying_key().to_bytes(),
794 Some(&hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes(&svc_pq_vk)),
795 );
796 let cnf = decode_cnf(&jwt).expect("minted JWT carries cnf");
797 assert_eq!(
798 cnf.get("hs_signer_suite").and_then(|v| v.as_str()),
799 Some(expected.as_str()),
800 "cnf.hs_signer_suite must equal the authoritative hybrid signer suite"
801 );
802 assert!(
804 cnf.get("jwk").and_then(|v| v.get("x")).is_some(),
805 "cnf.jwk must be preserved alongside hs_signer_suite"
806 );
807 }
808
809 fn write_persisted_token_with_hs(
815 dir: &Path,
816 ca: &SigningKey,
817 svc: &SigningKey,
818 issuer: &str,
819 now: i64,
820 hs: Option<&str>,
821 ) {
822 let mut claims =
823 hyprstream_rpc::auth::Claims::new("service:model".to_owned(), now, now + 30 * 86_400)
824 .with_issuer(issuer.to_owned())
825 .with_audience(Some(issuer.to_owned()))
826 .with_cnf_jwk(svc.verifying_key().as_bytes())
827 .with_jti();
828 if let Some(hs) = hs {
829 claims = claims.with_cnf_hs_signer_suite(hs.to_owned());
830 }
831 let ca_pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(ca);
832 let ca_pq_vk = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&ca_pq);
833 let jwt =
834 hyprstream_rpc::auth::jwt::encode_service_jwt_hybrid(&claims, ca, &ca_pq, &ca_pq_vk);
835 super::super::identity_store::write_service_jwt(dir, "model", &jwt).unwrap();
836 }
837
838 #[test]
842 fn persisted_token_missing_hs_signer_suite_is_reissued() {
843 let dir = tempfile::tempdir().unwrap();
844 let ca = SigningKey::from_bytes(&[3u8; 32]);
845 let svc = SigningKey::from_bytes(&[4u8; 32]);
846 let issuer = "http://localhost:6791";
847 let now = chrono::Utc::now().timestamp();
848
849 write_persisted_token_with_hs(dir.path(), &ca, &svc, issuer, now, None);
850 let existing = super::super::identity_store::load_service_jwt(dir.path(), "model")
851 .unwrap()
852 .unwrap();
853
854 let reissued = issue_or_load_service_jwt(
855 dir.path(),
856 "model",
857 &ca,
858 &bp(svc.verifying_key()),
859 issuer,
860 now,
861 None,
862 )
863 .unwrap();
864 assert_ne!(
865 reissued, existing,
866 "a legacy-only (no hs) token must be reissued"
867 );
868 let expected =
870 hyprstream_rpc::auth::service_signer_suite_b64(&svc.verifying_key().to_bytes(), None);
871 let cnf = decode_cnf(&reissued).unwrap();
872 assert_eq!(
873 cnf.get("hs_signer_suite").and_then(|v| v.as_str()),
874 Some(expected.as_str())
875 );
876 }
877
878 #[test]
881 fn persisted_token_stale_hs_signer_suite_is_reissued() {
882 let dir = tempfile::tempdir().unwrap();
883 let ca = SigningKey::from_bytes(&[3u8; 32]);
884 let svc = SigningKey::from_bytes(&[4u8; 32]);
885 let other = SigningKey::from_bytes(&[9u8; 32]);
886 let issuer = "http://localhost:6791";
887 let now = chrono::Utc::now().timestamp();
888
889 let wrong_hs =
891 hyprstream_rpc::auth::service_signer_suite_b64(&other.verifying_key().to_bytes(), None);
892 write_persisted_token_with_hs(dir.path(), &ca, &svc, issuer, now, Some(&wrong_hs));
893 let existing = super::super::identity_store::load_service_jwt(dir.path(), "model")
894 .unwrap()
895 .unwrap();
896
897 let reissued = issue_or_load_service_jwt(
898 dir.path(),
899 "model",
900 &ca,
901 &bp(svc.verifying_key()),
902 issuer,
903 now,
904 None,
905 )
906 .unwrap();
907 assert_ne!(reissued, existing, "a stale-hs token must be reissued");
908
909 let correct_hs =
913 hyprstream_rpc::auth::service_signer_suite_b64(&svc.verifying_key().to_bytes(), None);
914 write_persisted_token_with_hs(dir.path(), &ca, &svc, issuer, now, Some(&correct_hs));
915 let current = super::super::identity_store::load_service_jwt(dir.path(), "model")
916 .unwrap()
917 .unwrap();
918 let reused = issue_or_load_service_jwt(
919 dir.path(),
920 "model",
921 &ca,
922 &bp(svc.verifying_key()),
923 issuer,
924 now,
925 None,
926 )
927 .unwrap();
928 assert_eq!(reused, current, "a correct-hs current token must be reused");
929 }
930}