1pub use hyprstream_rpc::auth::{
6 decode, decode_with_any_key, decode_with_any_key_lenient, decode_with_federation_candidates,
7 decode_with_key, encode, encode_service_jwt, Claims, JwtError,
8};
9
10use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
11use p256::ecdsa::{signature::Signer, SigningKey as Es256SigningKey};
12
13pub fn encode_es256(claims: &Claims, signing_key: &Es256SigningKey) -> String {
19 let claims = if claims.jti.is_some() {
20 std::borrow::Cow::Borrowed(claims)
21 } else {
22 std::borrow::Cow::Owned(claims.clone().with_jti())
23 };
24 let kid = es256_kid(signing_key);
25 let header = format!(r#"{{"alg":"ES256","typ":"at+jwt","kid":"{}"}}"#, kid);
26 let header_b64 = URL_SAFE_NO_PAD.encode(header.as_bytes());
27 let payload_json = serde_json::to_string(claims.as_ref()).unwrap_or_else(|_e| {
28 tracing::error!("JWT claims serialization failed: {}", _e);
29 "{}".to_owned()
30 });
31 let payload_b64 = URL_SAFE_NO_PAD.encode(payload_json.as_bytes());
32 let signing_input = format!("{header_b64}.{payload_b64}");
33 let signature: p256::ecdsa::Signature = signing_key.sign(signing_input.as_bytes());
34 let sig_b64 = URL_SAFE_NO_PAD.encode(signature.to_bytes());
35 format!("{signing_input}.{sig_b64}")
36}
37
38fn es256_coordinates(signing_key: &Es256SigningKey) -> ([u8; 32], [u8; 32]) {
39 let vk = signing_key.verifying_key();
40 let point = vk.to_encoded_point(false);
41 let mut x = [0u8; 32];
43 let mut y = [0u8; 32];
44 x.copy_from_slice(point.x().map(AsRef::as_ref).unwrap_or(&[0u8; 32]));
45 y.copy_from_slice(point.y().map(AsRef::as_ref).unwrap_or(&[0u8; 32]));
46 (x, y)
47}
48
49pub fn es256_kid(signing_key: &Es256SigningKey) -> String {
51 let (x, y) = es256_coordinates(signing_key);
52 hyprstream_rpc::auth::jwk_thumbprint(&hyprstream_rpc::auth::JwkThumbprintInput::Es256 {
53 x: &x,
54 y: &y,
55 })
56}
57
58pub fn es256_jwk(signing_key: &Es256SigningKey) -> serde_json::Value {
60 let (x, y) = es256_coordinates(signing_key);
61 let kid = es256_kid(signing_key);
62 serde_json::json!({
63 "kty": "EC",
64 "crv": "P-256",
65 "use": "sig",
66 "alg": "ES256",
67 "kid": kid,
68 "x": URL_SAFE_NO_PAD.encode(x),
69 "y": URL_SAFE_NO_PAD.encode(y),
70 })
71}
72
73pub fn generate_es256_key() -> Es256SigningKey {
75 Es256SigningKey::random(&mut rand::rngs::OsRng)
76}
77
78pub fn encode_ml_dsa_65(
82 claims: &Claims,
83 signing_key: &hyprstream_rpc::crypto::pq::MlDsaSigningKey,
84) -> String {
85 let claims = if claims.jti.is_some() {
86 std::borrow::Cow::Borrowed(claims)
87 } else {
88 std::borrow::Cow::Owned(claims.clone().with_jti())
89 };
90 let vk = ml_dsa::Keypair::verifying_key(signing_key);
91 let vk_bytes = hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes(&vk);
92 let kid =
93 hyprstream_rpc::auth::jwk_thumbprint(&hyprstream_rpc::auth::JwkThumbprintInput::Akp {
94 alg: "ML-DSA-65",
95 pub_bytes: &vk_bytes,
96 });
97 let header = format!(r#"{{"alg":"ML-DSA-65","typ":"at+jwt","kid":"{}"}}"#, kid);
98 let header_b64 = URL_SAFE_NO_PAD.encode(header.as_bytes());
99 let payload_json = serde_json::to_string(claims.as_ref()).unwrap_or_else(|_e| {
100 tracing::error!("JWT claims serialization failed: {}", _e);
101 "{}".to_owned()
102 });
103 let payload_b64 = URL_SAFE_NO_PAD.encode(payload_json.as_bytes());
104 let signing_input = format!("{header_b64}.{payload_b64}");
105 let sig = hyprstream_rpc::crypto::pq::ml_dsa_sign(signing_key, signing_input.as_bytes());
106 let sig_b64 = URL_SAFE_NO_PAD.encode(&sig);
107 format!("{signing_input}.{sig_b64}")
108}
109
110pub fn encode_composite_ml_dsa_65_ed25519(
115 claims: &Claims,
116 ml_dsa_key: &hyprstream_rpc::crypto::pq::MlDsaSigningKey,
117 ed25519_key: &ed25519_dalek::SigningKey,
118) -> String {
119 use ed25519_dalek::Signer;
120
121 let claims = if claims.jti.is_some() {
122 std::borrow::Cow::Borrowed(claims)
123 } else {
124 std::borrow::Cow::Owned(claims.clone().with_jti())
125 };
126 let vk = ml_dsa::Keypair::verifying_key(ml_dsa_key);
127 let kid = composite_kid(&vk, &ed25519_key.verifying_key());
128 let header = format!(
129 r#"{{"alg":"ML-DSA-65-Ed25519","typ":"at+jwt","kid":"{}"}}"#,
130 kid
131 );
132 let header_b64 = URL_SAFE_NO_PAD.encode(header.as_bytes());
133 let payload_json = serde_json::to_string(claims.as_ref()).unwrap_or_else(|_e| {
134 tracing::error!("JWT claims serialization failed: {}", _e);
135 "{}".to_owned()
136 });
137 let payload_b64 = URL_SAFE_NO_PAD.encode(payload_json.as_bytes());
138 let signing_input = format!("{header_b64}.{payload_b64}");
139 let message = signing_input.as_bytes();
140
141 let ml_dsa_sig = hyprstream_rpc::crypto::pq::ml_dsa_sign(ml_dsa_key, message);
142 let ed25519_sig = ed25519_key.sign(message);
143
144 let mut composite_sig = Vec::with_capacity(ml_dsa_sig.len() + 64);
145 composite_sig.extend_from_slice(&ml_dsa_sig);
146 composite_sig.extend_from_slice(&ed25519_sig.to_bytes());
147 let sig_b64 = URL_SAFE_NO_PAD.encode(&composite_sig);
148 format!("{signing_input}.{sig_b64}")
149}
150
151pub fn encode_composite_service_jwt(
153 claims: &Claims,
154 ml_dsa_key: &hyprstream_rpc::crypto::pq::MlDsaSigningKey,
155 ed25519_key: &ed25519_dalek::SigningKey,
156) -> String {
157 use ed25519_dalek::Signer;
158
159 let claims = if claims.jti.is_some() {
160 std::borrow::Cow::Borrowed(claims)
161 } else {
162 std::borrow::Cow::Owned(claims.clone().with_jti())
163 };
164 let vk = ml_dsa::Keypair::verifying_key(ml_dsa_key);
165 let kid = composite_kid(&vk, &ed25519_key.verifying_key());
166 let header = format!(
167 r#"{{"alg":"ML-DSA-65-Ed25519","typ":"wit+jwt","kid":"{}"}}"#,
168 kid
169 );
170 let header_b64 = URL_SAFE_NO_PAD.encode(header.as_bytes());
171 let payload_json = serde_json::to_string(claims.as_ref()).unwrap_or_else(|_e| {
172 tracing::error!("JWT claims serialization failed: {}", _e);
173 "{}".to_owned()
174 });
175 let payload_b64 = URL_SAFE_NO_PAD.encode(payload_json.as_bytes());
176 let signing_input = format!("{header_b64}.{payload_b64}");
177 let message = signing_input.as_bytes();
178
179 let ml_dsa_sig = hyprstream_rpc::crypto::pq::ml_dsa_sign(ml_dsa_key, message);
180 let ed25519_sig = ed25519_key.sign(message);
181
182 let mut composite_sig = Vec::with_capacity(ml_dsa_sig.len() + 64);
183 composite_sig.extend_from_slice(&ml_dsa_sig);
184 composite_sig.extend_from_slice(&ed25519_sig.to_bytes());
185 let sig_b64 = URL_SAFE_NO_PAD.encode(&composite_sig);
186 format!("{signing_input}.{sig_b64}")
187}
188
189pub fn encode_service_jwt_hybrid_via_authority(
206 claims: &Claims,
207 fallback_ed: &ed25519_dalek::SigningKey,
208) -> anyhow::Result<String> {
209 encode_service_jwt_hybrid_with_key_set(
210 &hyprstream_rpc::auth::global_composite_key_set(),
211 claims,
212 fallback_ed,
213 )
214}
215
216fn encode_service_jwt_hybrid_with_key_set(
218 key_set: &hyprstream_rpc::auth::CompositeKeySet,
219 claims: &Claims,
220 fallback_ed: &ed25519_dalek::SigningKey,
221) -> anyhow::Result<String> {
222 if key_set.authority_configured() {
223 let snapshot = key_set
224 .mint_snapshot()
225 .map_err(|error| anyhow::anyhow!("composite authority unavailable: {error}"))?;
226 let (ml_key, ed_key) = snapshot
227 .active_signing_pair(hyprstream_rpc::auth::CompositePairRole::OAuth)
228 .and_then(hyprstream_rpc::auth::CompositeKeyPair::signing_keys)
229 .ok_or_else(|| {
230 anyhow::anyhow!("no active OAuth composite signing pair; refusing to mint")
231 })?;
232 return Ok(encode_composite_service_jwt(claims, &ml_key, &ed_key));
233 }
234 let pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(fallback_ed);
235 let pq_vk = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&pq);
236 Ok(hyprstream_rpc::auth::jwt::encode_service_jwt_hybrid(
237 claims,
238 fallback_ed,
239 &pq,
240 &pq_vk,
241 ))
242}
243
244pub fn ml_dsa_65_jwk(vk: &hyprstream_rpc::crypto::pq::MlDsaVerifyingKey) -> serde_json::Value {
246 let vk_bytes = hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes(vk);
247 let kid =
248 hyprstream_rpc::auth::jwk_thumbprint(&hyprstream_rpc::auth::JwkThumbprintInput::Akp {
249 alg: "ML-DSA-65",
250 pub_bytes: &vk_bytes,
251 });
252 serde_json::json!({
253 "kty": "AKP",
254 "alg": "ML-DSA-65",
255 "use": "sig",
256 "kid": kid,
257 "pub": URL_SAFE_NO_PAD.encode(&vk_bytes),
258 })
259}
260
261pub fn composite_kid(
263 ml_dsa_vk: &hyprstream_rpc::crypto::pq::MlDsaVerifyingKey,
264 ed25519_vk: &ed25519_dalek::VerifyingKey,
265) -> String {
266 hyprstream_rpc::auth::composite_kid(ml_dsa_vk, ed25519_vk)
267}
268
269pub fn composite_jwk(
271 ml_dsa_vk: &hyprstream_rpc::crypto::pq::MlDsaVerifyingKey,
272 ed25519_vk: &ed25519_dalek::VerifyingKey,
273) -> serde_json::Value {
274 let kid = composite_kid(ml_dsa_vk, ed25519_vk);
275 let ml_dsa_vk_bytes = hyprstream_rpc::crypto::pq::ml_dsa_vk_bytes(ml_dsa_vk);
276 let ed25519_vk_bytes = ed25519_vk.to_bytes();
277 let mut composite_pub = Vec::with_capacity(ml_dsa_vk_bytes.len() + 32);
278 composite_pub.extend_from_slice(&ml_dsa_vk_bytes);
279 composite_pub.extend_from_slice(&ed25519_vk_bytes);
280 serde_json::json!({
281 "kty": "AKP",
282 "alg": "ML-DSA-65-Ed25519",
283 "use": "sig",
284 "kid": kid,
285 "pub": URL_SAFE_NO_PAD.encode(&composite_pub),
286 })
287}
288
289#[cfg(test)]
290#[allow(clippy::unwrap_used, clippy::expect_used)]
291mod tests {
292 use super::*;
293
294 #[test]
298 fn hybrid_wit_falls_back_only_without_authority() {
299 let key_set = hyprstream_rpc::auth::CompositeKeySet::default();
300 let ed = ed25519_dalek::SigningKey::from_bytes(&[0x41; 32]);
301 let now = chrono::Utc::now().timestamp();
302 let claims = Claims::new("alice".to_owned(), now, now + 3600);
303
304 let wit = encode_service_jwt_hybrid_with_key_set(&key_set, &claims, &ed).unwrap();
305
306 let pq = hyprstream_rpc::node_identity::derive_mesh_mldsa_key(&ed);
307 let pq_vk = hyprstream_rpc::crypto::pq::ml_dsa_sk_to_vk(&pq);
308 let dispatch =
309 hyprstream_rpc::auth::jwt::parse_composite_dispatch(&wit, &["wit+jwt"]).unwrap();
310 assert_eq!(dispatch.kid(), composite_kid(&pq_vk, &ed.verifying_key()));
311 let verified = hyprstream_rpc::auth::jwt::decode_composite(
312 &wit,
313 &pq_vk,
314 &ed.verifying_key(),
315 None,
316 &dispatch,
317 )
318 .unwrap();
319 assert_eq!(verified.sub, "alice");
320 }
321
322 #[test]
327 fn hybrid_wit_mint_failure_propagates_instead_of_falling_back() {
328 let dir = tempfile::tempdir().unwrap();
329 let key_set = hyprstream_rpc::auth::CompositeKeySet::default();
330 key_set.configure_authority(
333 dir.path().join("ledger.json"),
334 dir.path().join("committed"),
335 dir.path().join("committed-ledger"),
336 dir.path().join("ledger.lock"),
337 );
338 let ed = ed25519_dalek::SigningKey::from_bytes(&[0x42; 32]);
339 let now = chrono::Utc::now().timestamp();
340 let claims = Claims::new("alice".to_owned(), now, now + 3600);
341
342 let result = encode_service_jwt_hybrid_with_key_set(&key_set, &claims, &ed);
343 assert!(
344 result.is_err(),
345 "mint-snapshot failure must propagate, not fall back to a derived pair"
346 );
347 }
348
349 #[test]
352 fn hybrid_wit_refuses_without_active_oauth_pair() {
353 use hyprstream_rpc::auth::{CompositeKeyPair, CompositePairRole, CompositePairState};
354 use std::sync::Arc;
355
356 let dir = tempfile::tempdir().unwrap();
357 let key_set = hyprstream_rpc::auth::CompositeKeySet::default();
358 let generation = br#"{"version":1,"component_digest":"g1"}"#;
359 std::fs::write(dir.path().join("ledger.json"), generation).unwrap();
360 std::fs::write(dir.path().join("committed"), generation).unwrap();
361 std::fs::write(dir.path().join("committed-ledger-1-g1.json"), generation).unwrap();
362 key_set.configure_authority(
363 dir.path().join("ledger.json"),
364 dir.path().join("committed"),
365 dir.path().join("committed-ledger"),
366 dir.path().join("ledger.lock"),
367 );
368 let (pq, pq_vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
370 let pair_ed = Arc::new(ed25519_dalek::SigningKey::from_bytes(&[0x43; 32]));
371 let kid = composite_kid(&pq_vk, &pair_ed.verifying_key());
372 key_set
373 .publish(
374 1,
375 "g1".to_owned(),
376 vec![CompositeKeyPair::signing(
377 kid,
378 Arc::new(pq),
379 pair_ed,
380 CompositePairRole::Policy,
381 CompositePairState::Active,
382 0,
383 i64::MAX,
384 )],
385 )
386 .unwrap();
387
388 let ed = ed25519_dalek::SigningKey::from_bytes(&[0x44; 32]);
389 let now = chrono::Utc::now().timestamp();
390 let claims = Claims::new("alice".to_owned(), now, now + 3600);
391 assert!(encode_service_jwt_hybrid_with_key_set(&key_set, &claims, &ed).is_err());
392 }
393
394 #[test]
395 fn es256_roundtrip() {
396 let key = generate_es256_key();
397 let claims = Claims::new("alice".to_owned(), 0, 9_999_999_999);
398 let token = encode_es256(&claims, &key);
399
400 let parts: Vec<&str> = token.split('.').collect();
401 assert_eq!(parts.len(), 3);
402
403 let header_bytes = URL_SAFE_NO_PAD.decode(parts[0]).unwrap();
404 let header: serde_json::Value = serde_json::from_slice(&header_bytes).unwrap();
405 assert_eq!(header["alg"], "ES256");
406 assert_eq!(header["typ"], "at+jwt");
407 assert!(header["kid"].as_str().unwrap().len() == 43);
408
409 let payload_bytes = URL_SAFE_NO_PAD.decode(parts[1]).unwrap();
410 let decoded: Claims = serde_json::from_slice(&payload_bytes).unwrap();
411 assert_eq!(decoded.sub, "alice");
412 assert!(decoded.jti.is_some());
413
414 use p256::ecdsa::{signature::Verifier, Signature};
416 let sig_bytes = URL_SAFE_NO_PAD.decode(parts[2]).unwrap();
417 let signature = Signature::from_slice(&sig_bytes).unwrap();
418 let signing_input = format!("{}.{}", parts[0], parts[1]);
419 key.verifying_key()
420 .verify(signing_input.as_bytes(), &signature)
421 .unwrap();
422 }
423
424 #[test]
425 fn es256_kid_deterministic() {
426 let key = generate_es256_key();
427 assert_eq!(es256_kid(&key), es256_kid(&key));
428 assert_eq!(es256_kid(&key).len(), 43);
429 }
430
431 #[test]
432 fn es256_jwk_structure() {
433 let key = generate_es256_key();
434 let jwk = es256_jwk(&key);
435 assert_eq!(jwk["kty"], "EC");
436 assert_eq!(jwk["crv"], "P-256");
437 assert_eq!(jwk["alg"], "ES256");
438 assert_eq!(jwk["use"], "sig");
439 assert!(jwk["kid"].as_str().unwrap().len() == 43);
440 assert!(jwk["x"].as_str().is_some());
441 assert!(jwk["y"].as_str().is_some());
442 }
443
444 #[test]
445 fn es256_auto_assigns_jti() {
446 let key = generate_es256_key();
447 let claims = Claims::new("bob".to_owned(), 0, 9_999_999_999);
448 assert!(claims.jti.is_none());
449 let token = encode_es256(&claims, &key);
450
451 let parts: Vec<&str> = token.split('.').collect();
452 let payload_bytes = URL_SAFE_NO_PAD.decode(parts[1]).unwrap();
453 let decoded: Claims = serde_json::from_slice(&payload_bytes).unwrap();
454 assert!(decoded.jti.is_some());
455 }
456
457 #[test]
458 fn ml_dsa_65_roundtrip() {
459 let (sk, vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
460 let claims = Claims::new("alice".to_owned(), 0, 9_999_999_999);
461 let token = encode_ml_dsa_65(&claims, &sk);
462
463 let parts: Vec<&str> = token.split('.').collect();
464 assert_eq!(parts.len(), 3);
465
466 let header_bytes = URL_SAFE_NO_PAD.decode(parts[0]).unwrap();
467 let header: serde_json::Value = serde_json::from_slice(&header_bytes).unwrap();
468 assert_eq!(header["alg"], "ML-DSA-65");
469 assert_eq!(header["typ"], "at+jwt");
470 assert!(header["kid"].as_str().unwrap().len() == 43);
471
472 let decoded = hyprstream_rpc::auth::jwt::decode_ml_dsa_65(&token, &vk, None).unwrap();
473 assert_eq!(decoded.sub, "alice");
474 assert!(decoded.jti.is_some());
475 }
476
477 #[test]
478 fn ml_dsa_65_jwk_structure() {
479 let (sk, _) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
480 let vk = ml_dsa::Keypair::verifying_key(&sk);
481 let jwk = ml_dsa_65_jwk(&vk);
482 assert_eq!(jwk["kty"], "AKP");
483 assert_eq!(jwk["alg"], "ML-DSA-65");
484 assert_eq!(jwk["use"], "sig");
485 assert!(jwk["kid"].as_str().unwrap().len() == 43);
486 assert!(jwk["pub"].as_str().is_some());
487 }
488
489 #[test]
490 fn composite_ml_dsa_65_ed25519_roundtrip() {
491 let (ml_dsa_sk, ml_dsa_vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
492 let ed25519_sk = ed25519_dalek::SigningKey::generate(&mut rand::rngs::OsRng);
493 let ed25519_vk = ed25519_sk.verifying_key();
494
495 let claims = Claims::new("bob".to_owned(), 0, 9_999_999_999);
496 let token = encode_composite_ml_dsa_65_ed25519(&claims, &ml_dsa_sk, &ed25519_sk);
497
498 let parts: Vec<&str> = token.split('.').collect();
499 assert_eq!(parts.len(), 3);
500
501 let header_bytes = URL_SAFE_NO_PAD.decode(parts[0]).unwrap();
502 let header: serde_json::Value = serde_json::from_slice(&header_bytes).unwrap();
503 assert_eq!(header["alg"], "ML-DSA-65-Ed25519");
504
505 let dispatch = hyprstream_rpc::auth::parse_composite_dispatch(&token, &["at+jwt"]).unwrap();
506 let decoded = hyprstream_rpc::auth::jwt::decode_composite(
507 &token,
508 &ml_dsa_vk,
509 &ed25519_vk,
510 None,
511 &dispatch,
512 )
513 .unwrap();
514 assert_eq!(decoded.sub, "bob");
515 assert!(decoded.jti.is_some());
516 }
517
518 #[test]
519 fn composite_jwk_structure() {
520 let (ml_dsa_sk, _) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
521 let ml_dsa_vk = ml_dsa::Keypair::verifying_key(&ml_dsa_sk);
522 let ed25519_sk = ed25519_dalek::SigningKey::generate(&mut rand::rngs::OsRng);
523 let ed25519_vk = ed25519_sk.verifying_key();
524
525 let jwk = composite_jwk(&ml_dsa_vk, &ed25519_vk);
526 assert_eq!(jwk["kty"], "AKP");
527 assert_eq!(jwk["alg"], "ML-DSA-65-Ed25519");
528 assert_eq!(jwk["use"], "sig");
529 assert!(jwk["kid"].as_str().unwrap().len() == 43);
530 assert!(jwk["pub"].as_str().is_some());
531 }
532
533 #[test]
534 fn ml_dsa_65_wrong_key_rejects() {
535 let (sk, _) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
536 let (_, wrong_vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
537 let claims = Claims::new("alice".to_owned(), 0, 9_999_999_999);
538 let token = encode_ml_dsa_65(&claims, &sk);
539 assert!(hyprstream_rpc::auth::jwt::decode_ml_dsa_65(&token, &wrong_vk, None).is_err());
540 }
541
542 #[test]
543 fn composite_wrong_ed25519_key_rejects() {
544 let (ml_dsa_sk, ml_dsa_vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
545 let ed25519_sk = ed25519_dalek::SigningKey::generate(&mut rand::rngs::OsRng);
546 let wrong_ed25519_vk =
547 ed25519_dalek::SigningKey::generate(&mut rand::rngs::OsRng).verifying_key();
548
549 let claims = Claims::new("bob".to_owned(), 0, 9_999_999_999);
550 let token = encode_composite_ml_dsa_65_ed25519(&claims, &ml_dsa_sk, &ed25519_sk);
551 let dispatch = hyprstream_rpc::auth::parse_composite_dispatch(&token, &["at+jwt"]).unwrap();
552 assert!(hyprstream_rpc::auth::jwt::decode_composite(
553 &token,
554 &ml_dsa_vk,
555 &wrong_ed25519_vk,
556 None,
557 &dispatch,
558 )
559 .is_err());
560 }
561
562 #[test]
563 fn ml_dsa_65_expired_token_rejected() {
564 let (sk, vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
565 let claims = Claims::new("alice".to_owned(), 0, 1);
566 let token = encode_ml_dsa_65(&claims, &sk);
567 let err = hyprstream_rpc::auth::jwt::decode_ml_dsa_65(&token, &vk, None).unwrap_err();
568 assert!(matches!(err, hyprstream_rpc::auth::JwtError::Expired));
569 }
570
571 #[test]
572 fn composite_expired_token_rejected() {
573 let (ml_dsa_sk, ml_dsa_vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
574 let ed25519_sk = ed25519_dalek::SigningKey::generate(&mut rand::rngs::OsRng);
575 let ed25519_vk = ed25519_sk.verifying_key();
576 let claims = Claims::new("bob".to_owned(), 0, 1);
577 let token = encode_composite_ml_dsa_65_ed25519(&claims, &ml_dsa_sk, &ed25519_sk);
578 let dispatch = hyprstream_rpc::auth::parse_composite_dispatch(&token, &["at+jwt"]).unwrap();
579 let err = hyprstream_rpc::auth::jwt::decode_composite(
580 &token,
581 &ml_dsa_vk,
582 &ed25519_vk,
583 None,
584 &dispatch,
585 )
586 .unwrap_err();
587 assert!(matches!(err, hyprstream_rpc::auth::JwtError::Expired));
588 }
589
590 #[test]
591 fn ml_dsa_65_rejects_eddsa_token() {
592 let ed25519_sk = ed25519_dalek::SigningKey::from_bytes(&[42u8; 32]);
593 let claims = Claims::new("alice".to_owned(), 0, 9_999_999_999);
594 let token = hyprstream_rpc::auth::encode(&claims, &ed25519_sk);
595 let (_, vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
596 assert!(hyprstream_rpc::auth::jwt::decode_ml_dsa_65(&token, &vk, None).is_err());
597 }
598
599 #[test]
600 fn ml_dsa_65_lenient_audience() {
601 let (sk, vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
602 let claims = Claims::new("alice".to_owned(), 0, 9_999_999_999);
603 let token = encode_ml_dsa_65(&claims, &sk);
605 assert!(hyprstream_rpc::auth::jwt::decode_ml_dsa_65(
606 &token,
607 &vk,
608 Some("https://example.com"),
609 )
610 .is_ok());
611 }
612
613 #[test]
614 fn ml_dsa_65_wrong_audience_rejected() {
615 let (sk, vk) = hyprstream_rpc::crypto::pq::ml_dsa_generate_keypair();
616 let mut claims = Claims::new("alice".to_owned(), 0, 9_999_999_999);
617 claims.aud = Some("https://wrong.example.com".to_owned());
618 let token = encode_ml_dsa_65(&claims, &sk);
619 let err =
620 hyprstream_rpc::auth::jwt::decode_ml_dsa_65(&token, &vk, Some("https://example.com"))
621 .unwrap_err();
622 assert!(matches!(
623 err,
624 hyprstream_rpc::auth::JwtError::InvalidAudience
625 ));
626 }
627}