Skip to main content

hyprstream_core/auth/
jwt.rs

1//! JWT token implementation.
2//!
3//! Re-exports EdDSA signing from hyprstream-rpc and adds ES256 (P-256) signing.
4
5pub 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
13/// Encode and sign an OAuth 2.0 access token with ES256 (P-256 ECDSA).
14///
15/// Produces a standard `at+jwt` with `alg: "ES256"` in the JOSE header.
16/// The `kid` is the RFC 7638 JWK Thumbprint of the P-256 public key.
17/// Automatically assigns a `jti` if not already set.
18pub 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    // Uncompressed P-256 point always has x and y (32 bytes each).
42    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
49/// Compute the RFC 7638 JWK Thumbprint for a P-256 signing key.
50pub 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
58/// Build a JWK (serde_json::Value) for JWKS publishing from a P-256 signing key.
59pub 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
73/// Generate a new random P-256 signing key.
74pub fn generate_es256_key() -> Es256SigningKey {
75    Es256SigningKey::random(&mut rand::rngs::OsRng)
76}
77
78// ── ML-DSA-65 JWT encoding (draft-ietf-cose-dilithium-11) ──────────────
79
80/// Encode and sign a JWT with ML-DSA-65 (`alg: "ML-DSA-65"`, `kty: "AKP"`).
81pub 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
110/// Encode and sign a composite ML-DSA-65-Ed25519 JWT.
111///
112/// Signature = ML-DSA-65 sig (3309 bytes) ∥ Ed25519 sig (64 bytes).
113/// Per draft-ietf-jose-pq-composite-sigs.
114pub 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
151/// Encode a service WIT (`typ: "wit+jwt"`) with ML-DSA-65-Ed25519 composite signature.
152pub 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
189/// Encode a service WIT with the mandatory hybrid suite for the dispatch plane.
190///
191/// When a composite signing authority is configured, mints with its active
192/// OAuth pair through the authority barrier (rotation-aware, mirroring
193/// PolicyService's token signing seam) — a mint-snapshot failure or a missing
194/// active pair is an error, never a silent downgrade to another key: the
195/// callers' `fallback_ed` is the rotating `active_jwt_signing_key()` slot, so
196/// a derived pair minted behind a configured authority would carry a
197/// composite kid nothing resolves while bypassing the staleness barrier.
198///
199/// Only when NO authority has been initialized (fresh install, before
200/// rotation bootstrap) does it fall back to the self-contained CA JWT pair
201/// `(derive_mesh_mldsa_key(fallback_ed), fallback_ed)`, whose composite kid
202/// the dispatch key sources resolve offline from the `ca-mldsa-pubkey`
203/// credential. A classical WIT is never minted: the dispatch plane's Hybrid
204/// policy would reject it unconditionally.
205pub 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
216/// Key-set-parameterized body of [`encode_service_jwt_hybrid_via_authority`].
217fn 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
244/// Build a JWK for an ML-DSA-65 key (`kty: "AKP"`).
245pub 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
261/// Compute the RFC 7638 JWK thumbprint for one exact composite key pair.
262pub 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
269/// Build a JWK for a composite ML-DSA-65-Ed25519 key (`kty: "AKP"`).
270pub 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    /// With NO composite authority initialized (fresh install), the hybrid
295    /// WIT mint falls back to the self-contained pair derived from the passed
296    /// Ed25519 key, and the token verifies against exactly that pair.
297    #[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    /// With a CONFIGURED authority whose mint snapshot fails (stale / pending
323    /// cutover / unreadable), the hybrid WIT mint propagates the error — it
324    /// must never silently downgrade to a derived pair, whose kid nothing
325    /// resolves and which would bypass the authority mint barrier.
326    #[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        // Configured, but no committed generation exists on disk, so
331        // mint_snapshot fails closed.
332        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    /// With a healthy authority that has no ACTIVE OAuth signing pair, the
350    /// hybrid WIT mint refuses rather than downgrading to a derived pair.
351    #[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        // Publish only a Policy-role signing pair — no active OAuth pair.
369        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        // Verify signature
415        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        // Token without aud should be accepted even when expected_aud is set
604        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}