1use anyhow::{anyhow, Result};
16use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
17use ed25519_dalek::VerifyingKey;
18use hyprstream_rpc::auth::{FederationKey, FederationKeySource};
19use hyprstream_rpc_std::discovery_client::DiscoveryClient;
20use std::collections::HashMap;
21use std::pin::Pin;
22use std::sync::Arc;
23use std::time::{Duration, Instant};
24use tokio::sync::{Mutex, RwLock};
25
26type JwksFetcher = Arc<
29 dyn Fn(&str) -> Pin<Box<dyn std::future::Future<Output = Result<serde_json::Value>> + Send>>
30 + Send
31 + Sync,
32>;
33
34#[derive(Clone)]
36struct JwksEntry {
37 kid: Option<String>,
38 key: VerifyingKey,
39}
40
41struct CachedJwks {
43 entries: Vec<JwksEntry>,
44 fetched_at: Instant,
45 ttl: Duration,
46}
47
48impl CachedJwks {
49 fn is_expired(&self) -> bool {
50 self.fetched_at.elapsed() > self.ttl
51 }
52}
53
54pub struct FederationKeyResolver {
64 cache: RwLock<HashMap<String, CachedJwks>>,
67 negative_cache: Mutex<HashMap<(String, String), Instant>>,
70 fetch_locks: Mutex<HashMap<String, Arc<Mutex<()>>>>,
73 config: HashMap<String, (Option<String>, Duration, bool)>,
75 http: reqwest::Client,
76 jwks_fetcher: JwksFetcher,
80 discovery_client: Option<Arc<DiscoveryClient>>,
89 policy_client: Option<Arc<hyprstream_rpc_std::policy_client::PolicyClient>>,
99}
100
101impl FederationKeyResolver {
102 pub fn new(trusted_issuers: &HashMap<String, crate::config::TrustedIssuerConfig>) -> Self {
103 let config = trusted_issuers
104 .iter()
105 .map(|(iss, cfg)| {
106 (
107 iss.clone(),
108 (
109 cfg.jwks_uri.clone(),
110 Duration::from_secs(cfg.jwks_cache_ttl_secs),
111 cfg.allow_http,
112 ),
113 )
114 })
115 .collect();
116 let http = reqwest::Client::builder()
117 .timeout(Duration::from_secs(10))
118 .build()
119 .unwrap_or_default();
120 Self {
121 cache: RwLock::new(HashMap::new()),
122 negative_cache: Mutex::new(HashMap::new()),
123 fetch_locks: Mutex::new(HashMap::new()),
124 config,
125 jwks_fetcher: default_jwks_fetcher(http.clone()),
127 http,
128 discovery_client: None,
129 policy_client: None,
130 }
131 }
132
133 #[cfg(test)]
137 pub(crate) fn with_jwks_fetcher(mut self, fetcher: JwksFetcher) -> Self {
138 self.jwks_fetcher = fetcher;
139 self
140 }
141
142 pub fn with_policy_client(
148 mut self,
149 client: Arc<hyprstream_rpc_std::policy_client::PolicyClient>,
150 ) -> Self {
151 self.policy_client = Some(client);
152 self
153 }
154
155 pub fn with_discovery_client(mut self, client: Arc<DiscoveryClient>) -> Self {
166 self.discovery_client = Some(client);
167 self
168 }
169
170 pub fn is_trusted(&self, issuer: &str) -> bool {
172 self.config.contains_key(issuer)
173 }
174
175 pub async fn get_keys(&self, issuer: &str, kid: Option<&str>) -> Result<Vec<FederationKey>> {
184 let (jwks_uri_override, ttl, allow_http) = self
186 .config
187 .get(issuer)
188 .map(|(u, t, h)| (u.clone(), *t, *h))
189 .ok_or_else(|| anyhow!("Issuer not in trusted list: {}", issuer))?;
190
191 if let Some(ref pc) = self.policy_client {
200 use hyprstream_rpc_std::policy_client::PolicyCheck;
201 let origin = crate::services::oauth::registration::extract_origin(issuer)
206 .ok_or_else(|| anyhow!("Invalid issuer URL: {issuer}"))?;
207 let resource = crate::auth::federation_registration_resource(&origin)?;
208 match pc
209 .check(&PolicyCheck {
210 subject: String::new(),
211 domain: String::new(),
212 resource,
213 operation: "check".to_owned(),
214 })
215 .await
216 {
217 Ok(true) => { }
218 Ok(false) => {
219 anyhow::bail!(
220 "peer {origin} is not permitted by policy (federation:register denied)"
221 );
222 }
223 Err(e) => {
224 tracing::error!(
225 issuer = %issuer,
226 origin = %origin,
227 error = %e,
228 "PolicyService unreachable during peer federation:register check — failing closed"
229 );
230 anyhow::bail!(
231 "PolicyService unreachable; peer federation rejected (fail-closed): {e}"
232 );
233 }
234 }
235 }
236
237 if let Some(candidates) = self.fresh_candidates(issuer, kid).await {
238 return Ok(candidates);
239 }
240 if self.is_negative_cached(issuer, kid).await {
241 anyhow::bail!("JWKS has no Ed25519 key with requested kid (negative cached)");
242 }
243
244 let fetch_lock = {
248 let mut locks = self.fetch_locks.lock().await;
249 Arc::clone(
250 locks
251 .entry(issuer.to_owned())
252 .or_insert_with(|| Arc::new(Mutex::new(()))),
253 )
254 };
255 let _fetch_guard = fetch_lock.lock().await;
256 if let Some(candidates) = self.fresh_candidates(issuer, kid).await {
257 return Ok(candidates);
258 }
259 if self.is_negative_cached(issuer, kid).await {
260 anyhow::bail!("JWKS has no Ed25519 key with requested kid (negative cached)");
261 }
262
263 if let Some(ref dc) = self.discovery_client {
269 match self.try_get_keys_from_discovery(dc, issuer).await {
270 Ok(entries) if !entries.is_empty() => {
271 if has_requested_kid(&entries, kid) {
272 self.cache_entries(issuer, entries, ttl).await;
273 self.clear_negative_cache(issuer, kid).await;
274 return self.fresh_candidates(issuer, kid).await.ok_or_else(|| {
277 anyhow!("fresh Discovery JWKS unexpectedly missing requested key")
278 });
279 }
280 self.cache_entries(issuer, entries, ttl).await;
284 }
285 Ok(_) => {
286 tracing::debug!(
287 issuer = %issuer,
288 "DiscoveryService federation lookup returned no Ed25519 keys; \
289 falling through to HTTPS"
290 );
291 }
292 Err(e) => {
293 tracing::debug!(
294 issuer = %issuer,
295 error = %e,
296 "DiscoveryService federation lookup miss; falling through to HTTPS"
297 );
298 }
299 }
300 }
301
302 let jwks_uri = if let Some(uri) = jwks_uri_override {
306 self.check_scheme(&uri, allow_http)?;
307 uri
308 } else {
309 self.discover_jwks_uri(issuer, allow_http).await?
310 };
311
312 let entries = self.fetch_ed25519_keys(&jwks_uri).await?;
313 if entries.is_empty() {
314 anyhow::bail!("No Ed25519 key found in JWKS at {}", jwks_uri);
315 }
316
317 let found = has_requested_kid(&entries, kid);
318 self.cache_entries(issuer, entries, ttl).await;
319 if !found {
320 self.record_negative_cache(issuer, kid).await;
321 let Some(requested_kid) = kid else {
322 anyhow::bail!("JWKS unexpectedly contained no usable Ed25519 key");
323 };
324 anyhow::bail!(
325 "JWKS at {} has no Ed25519 key with kid={}",
326 jwks_uri,
327 requested_kid
328 );
329 }
330 self.clear_negative_cache(issuer, kid).await;
331 let cache = self.cache.read().await;
332 Ok(select_candidates(&cache[issuer].entries, kid))
333 }
334
335 async fn fresh_candidates(
336 &self,
337 issuer: &str,
338 kid: Option<&str>,
339 ) -> Option<Vec<FederationKey>> {
340 let cache = self.cache.read().await;
341 let entry = cache.get(issuer)?;
342 (!entry.is_expired() && has_requested_kid(&entry.entries, kid))
343 .then(|| select_candidates(&entry.entries, kid))
344 }
345
346 async fn cache_entries(&self, issuer: &str, entries: Vec<JwksEntry>, ttl: Duration) {
347 self.cache.write().await.insert(
348 issuer.to_owned(),
349 CachedJwks {
350 entries,
351 fetched_at: Instant::now(),
352 ttl,
353 },
354 );
355 }
356
357 async fn is_negative_cached(&self, issuer: &str, kid: Option<&str>) -> bool {
358 const NEGATIVE_TTL: Duration = Duration::from_secs(5);
359 let Some(kid) = kid else {
360 return false;
361 };
362 let key = (issuer.to_owned(), kid.to_owned());
363 let mut misses = self.negative_cache.lock().await;
364 match misses.get(&key) {
365 Some(seen) if seen.elapsed() < NEGATIVE_TTL => true,
366 Some(_) => {
367 misses.remove(&key);
368 false
369 }
370 None => false,
371 }
372 }
373
374 async fn record_negative_cache(&self, issuer: &str, kid: Option<&str>) {
375 const NEGATIVE_TTL: Duration = Duration::from_secs(5);
376 const MAX_NEGATIVE_ENTRIES: usize = 1024;
377 let Some(kid) = kid else {
378 return;
379 };
380 let mut misses = self.negative_cache.lock().await;
381 misses.retain(|_, seen| seen.elapsed() < NEGATIVE_TTL);
382 if misses.len() >= MAX_NEGATIVE_ENTRIES {
383 if let Some(key) = misses.keys().next().cloned() {
384 misses.remove(&key);
385 }
386 }
387 misses.insert((issuer.to_owned(), kid.to_owned()), Instant::now());
388 }
389
390 async fn clear_negative_cache(&self, issuer: &str, kid: Option<&str>) {
391 if let Some(kid) = kid {
392 self.negative_cache
393 .lock()
394 .await
395 .remove(&(issuer.to_owned(), kid.to_owned()));
396 }
397 }
398
399 async fn try_get_keys_from_discovery(
435 &self,
436 dc: &DiscoveryClient,
437 issuer: &str,
438 ) -> Result<Vec<JwksEntry>> {
439 let stmt = dc
440 .get_entity_statement(issuer)
441 .await
442 .map_err(|e| anyhow!("DiscoveryService.getEntityStatement RPC failed: {}", e))?;
443
444 if stmt.jwt.is_empty() {
445 anyhow::bail!("DiscoveryService returned empty entity statement JWT");
446 }
447
448 extract_self_issued_jwks(&stmt.jwt, issuer)
453 }
454
455 fn check_scheme(&self, url: &str, allow_http: bool) -> Result<()> {
460 if url.starts_with("https://") || (allow_http && url.starts_with("http://")) {
461 Ok(())
462 } else if url.starts_with("http://") {
463 anyhow::bail!(
465 "JWKS URI must use HTTPS for security (got '{}'). \
466 Set allow_http: true in trusted_issuers config to permit HTTP \
467 (development / internal networks only).",
468 url
469 )
470 } else {
471 anyhow::bail!("JWKS URI must use HTTPS or HTTP scheme (got '{}').", url)
473 }
474 }
475
476 async fn discover_jwks_uri(&self, issuer: &str, allow_http: bool) -> Result<String> {
477 self.check_scheme(issuer, allow_http)?;
479 let meta_url = format!("{}/.well-known/oauth-authorization-server", issuer);
480 let meta: serde_json::Value = self.http.get(&meta_url).send().await?.json().await?;
481 let jwks_uri = meta["jwks_uri"]
482 .as_str()
483 .map(str::to_owned)
484 .ok_or_else(|| anyhow!("No jwks_uri in AS metadata for {}", issuer))?;
485 self.check_scheme(&jwks_uri, allow_http)?;
487 Ok(jwks_uri)
488 }
489
490 async fn fetch_ed25519_keys(&self, jwks_uri: &str) -> Result<Vec<JwksEntry>> {
494 let jwks = (self.jwks_fetcher)(jwks_uri).await?;
495 Ok(parse_jwks_ed25519(&jwks, jwks_uri))
496 }
497}
498
499fn default_jwks_fetcher(http: reqwest::Client) -> JwksFetcher {
503 Arc::new(move |url: &str| {
504 let url = url.to_owned();
505 let http = http.clone();
506 Box::pin(async move {
507 let jwks: serde_json::Value = http.get(&url).send().await?.json().await?;
508 Ok(jwks)
509 })
510 })
511}
512
513fn parse_jwks_ed25519(jwks: &serde_json::Value, jwks_uri: &str) -> Vec<JwksEntry> {
517 let mut out = Vec::new();
518 let Some(keys) = jwks["keys"].as_array() else {
519 return out;
520 };
521 for key in keys {
522 if key["kty"].as_str() != Some("OKP") || key["crv"].as_str() != Some("Ed25519") {
523 continue;
524 }
525 let x = match key["x"].as_str() {
526 Some(s) => s,
527 None => continue,
528 };
529 let raw = match URL_SAFE_NO_PAD.decode(x) {
530 Ok(r) => r,
531 Err(_) => continue,
532 };
533 let bytes: [u8; 32] = match raw.try_into() {
534 Ok(b) => b,
535 Err(_) => continue,
536 };
537 let vk = match VerifyingKey::from_bytes(&bytes) {
538 Ok(v) => v,
539 Err(_) => continue,
540 };
541 let kid = key["kid"]
542 .as_str()
543 .filter(|s| !s.is_empty())
544 .map(str::to_owned);
545 out.push(JwksEntry { kid, key: vk });
546 }
547 let _ = jwks_uri; out
549}
550
551fn select_candidates(entries: &[JwksEntry], kid: Option<&str>) -> Vec<FederationKey> {
554 entries
555 .iter()
556 .filter(|entry| match kid {
557 Some(requested_kid) => entry.kid.as_deref() == Some(requested_kid),
558 None => true,
559 })
560 .map(|entry| FederationKey {
561 kid: entry.kid.clone(),
562 verifying_key: entry.key,
563 })
564 .collect()
565}
566
567fn has_requested_kid(entries: &[JwksEntry], kid: Option<&str>) -> bool {
568 match kid {
569 Some(requested_kid) => entries
570 .iter()
571 .any(|entry| entry.kid.as_deref() == Some(requested_kid)),
572 None => !entries.is_empty(),
573 }
574}
575
576#[cfg(test)]
602pub(crate) fn verify_self_issued_entity_statement(
603 jwt: &str,
604 expected_issuer: &str,
605) -> Result<VerifyingKey> {
606 let (_entries, signer) = parse_self_issued_entity_statement(jwt, expected_issuer)?;
607 Ok(signer)
608}
609
610fn extract_self_issued_jwks(jwt: &str, expected_issuer: &str) -> Result<Vec<JwksEntry>> {
619 let (entries, _signer) = parse_self_issued_entity_statement(jwt, expected_issuer)?;
620 Ok(entries)
621}
622
623fn parse_self_issued_entity_statement(
632 jwt: &str,
633 expected_issuer: &str,
634) -> Result<(Vec<JwksEntry>, VerifyingKey)> {
635 let parts: Vec<&str> = jwt.split('.').collect();
636 if parts.len() != 3 {
637 anyhow::bail!("entity statement JWT not in 3-part compact form");
638 }
639
640 let header_bytes = URL_SAFE_NO_PAD
642 .decode(parts[0])
643 .map_err(|e| anyhow!("entity statement JWT header not base64url: {}", e))?;
644 let header: serde_json::Value = serde_json::from_slice(&header_bytes)
645 .map_err(|e| anyhow!("entity statement JWT header not JSON: {}", e))?;
646 let alg = header.get("alg").and_then(|v| v.as_str()).unwrap_or("");
647 if alg != "EdDSA" {
648 anyhow::bail!(
649 "entity statement JWT alg is '{}', only EdDSA supported",
650 alg
651 );
652 }
653
654 let payload_bytes = URL_SAFE_NO_PAD
656 .decode(parts[1])
657 .map_err(|e| anyhow!("entity statement JWT payload not base64url: {}", e))?;
658 let claims: serde_json::Value = serde_json::from_slice(&payload_bytes)
659 .map_err(|e| anyhow!("entity statement JWT payload not JSON: {}", e))?;
660
661 let iss = claims.get("iss").and_then(|v| v.as_str()).unwrap_or("");
662 let sub = claims.get("sub").and_then(|v| v.as_str()).unwrap_or("");
663 if iss != expected_issuer {
664 anyhow::bail!(
665 "entity statement iss '{}' != expected issuer '{}'",
666 iss,
667 expected_issuer
668 );
669 }
670 if sub != expected_issuer {
671 anyhow::bail!(
672 "entity statement sub '{}' != iss (must be self-issued)",
673 sub
674 );
675 }
676
677 if let Some(exp) = claims.get("exp").and_then(serde_json::Value::as_i64) {
678 let now = std::time::SystemTime::now()
679 .duration_since(std::time::UNIX_EPOCH)
680 .map(|d| d.as_secs() as i64)
681 .unwrap_or(0);
682 if exp <= now {
683 anyhow::bail!("entity statement expired (exp={} now={})", exp, now);
684 }
685 }
686
687 let keys = claims
690 .get("jwks")
691 .and_then(|j| j.get("keys"))
692 .and_then(|k| k.as_array())
693 .ok_or_else(|| anyhow!("entity statement missing jwks.keys"))?;
694
695 let signing_input = format!("{}.{}", parts[0], parts[1]);
697 let sig_bytes = URL_SAFE_NO_PAD
698 .decode(parts[2])
699 .map_err(|e| anyhow!("entity statement signature not base64url: {}", e))?;
700 if sig_bytes.len() != 64 {
701 anyhow::bail!(
702 "Ed25519 signature must be 64 bytes, got {}",
703 sig_bytes.len()
704 );
705 }
706 let mut sig_arr = [0u8; 64];
707 sig_arr.copy_from_slice(&sig_bytes);
708 let signature = ed25519_dalek::Signature::from_bytes(&sig_arr);
709
710 let mut entries: Vec<JwksEntry> = Vec::new();
711 let mut signer: Option<VerifyingKey> = None;
712 for key in keys {
713 if key.get("kty").and_then(|v| v.as_str()) != Some("OKP")
714 || key.get("crv").and_then(|v| v.as_str()) != Some("Ed25519")
715 {
716 continue;
717 }
718 let x = match key.get("x").and_then(|v| v.as_str()) {
719 Some(s) => s,
720 None => continue,
721 };
722 let raw = match URL_SAFE_NO_PAD.decode(x) {
723 Ok(r) => r,
724 Err(_) => continue,
725 };
726 let bytes: [u8; 32] = match raw.try_into() {
727 Ok(b) => b,
728 Err(_) => continue,
729 };
730 let vk = match VerifyingKey::from_bytes(&bytes) {
731 Ok(v) => v,
732 Err(_) => continue,
733 };
734 let kid = key
735 .get("kid")
736 .and_then(|v| v.as_str())
737 .filter(|s| !s.is_empty())
738 .map(str::to_owned);
739 if signer.is_none()
740 && vk
741 .verify_strict(signing_input.as_bytes(), &signature)
742 .is_ok()
743 {
744 signer = Some(vk);
745 }
746 entries.push(JwksEntry { kid, key: vk });
747 }
748
749 match signer {
750 Some(vk) => Ok((entries, vk)),
751 None => anyhow::bail!(
752 "entity statement self-validation failed: no Ed25519 key in jwks verifies the signature"
753 ),
754 }
755}
756
757#[async_trait::async_trait]
761impl FederationKeySource for FederationKeyResolver {
762 fn is_trusted(&self, issuer: &str) -> bool {
763 FederationKeyResolver::is_trusted(self, issuer)
764 }
765
766 async fn get_keys(
767 &self,
768 issuer: &str,
769 kid: Option<&str>,
770 ) -> anyhow::Result<Vec<FederationKey>> {
771 FederationKeyResolver::get_keys(self, issuer, kid).await
772 }
773}
774
775#[cfg(test)]
776#[allow(clippy::unwrap_used, clippy::expect_used)]
777mod tests {
778 use super::*;
779
780 #[test]
781 fn test_untrusted_issuer_rejected() {
782 let resolver = FederationKeyResolver::new(&Default::default());
783 assert!(!resolver.is_trusted("https://evil.example.com"));
784 assert!(!resolver.is_trusted(""));
785 }
786
787 #[test]
788 fn test_trusted_issuer_recognized() {
789 let mut issuers = HashMap::new();
790 issuers.insert(
791 "https://trusted.example.com".to_owned(),
792 crate::config::TrustedIssuerConfig {
793 jwks_uri: Some("https://trusted.example.com/jwks".to_owned()),
794 jwks_cache_ttl_secs: 300,
795 allow_http: false,
796 federate_tui_client: None,
797 },
798 );
799 let resolver = FederationKeyResolver::new(&issuers);
800 assert!(resolver.is_trusted("https://trusted.example.com"));
801 assert!(!resolver.is_trusted("https://untrusted.example.com"));
802 }
803
804 use ed25519_dalek::{Signer, SigningKey};
809 use hyprstream_rpc::auth::{jwt, Claims};
810 use rand::rngs::OsRng;
811
812 fn b64u(bytes: &[u8]) -> String {
813 URL_SAFE_NO_PAD.encode(bytes)
814 }
815
816 fn b64u_json(value: &serde_json::Value) -> String {
817 b64u(&serde_json::to_vec(value).expect("json"))
818 }
819
820 fn build_entity_statement(
827 signing_key: &SigningKey,
828 issuer: &str,
829 sub: &str,
830 exp: i64,
831 jwks_keys: Vec<serde_json::Value>,
832 ) -> String {
833 let header = serde_json::json!({"alg": "EdDSA", "typ": "entity-statement+jwt"});
834 let payload = serde_json::json!({
835 "iss": issuer,
836 "sub": sub,
837 "iat": exp - 86400,
838 "exp": exp,
839 "jwks": {"keys": jwks_keys},
840 });
841 let h = b64u_json(&header);
842 let p = b64u_json(&payload);
843 let signing_input = format!("{}.{}", h, p);
844 let sig = signing_key.sign(signing_input.as_bytes());
845 format!("{}.{}", signing_input, b64u(&sig.to_bytes()))
846 }
847
848 fn jwk_of(vk: &VerifyingKey) -> serde_json::Value {
849 serde_json::json!({
850 "kty": "OKP",
851 "crv": "Ed25519",
852 "x": b64u(vk.as_bytes()),
853 "use": "sig",
854 })
855 }
856
857 fn future_exp() -> i64 {
858 std::time::SystemTime::now()
859 .duration_since(std::time::UNIX_EPOCH)
860 .map(|d| d.as_secs() as i64)
861 .unwrap_or(0)
862 + 3600
863 }
864
865 #[test]
866 fn entity_stmt_self_validation_accepts_legitimate_statement() {
867 let sk = SigningKey::generate(&mut OsRng);
868 let vk = sk.verifying_key();
869 let jwt = build_entity_statement(
870 &sk,
871 "https://issuer.example",
872 "https://issuer.example",
873 future_exp(),
874 vec![jwk_of(&vk)],
875 );
876 let resolved = verify_self_issued_entity_statement(&jwt, "https://issuer.example")
877 .expect("legitimate self-issued statement must verify");
878 assert_eq!(resolved.as_bytes(), vk.as_bytes());
879 }
880
881 #[test]
882 fn entity_stmt_self_validation_rejects_iss_mismatch() {
883 let sk = SigningKey::generate(&mut OsRng);
884 let vk = sk.verifying_key();
885 let jwt = build_entity_statement(
886 &sk,
887 "https://other.example",
888 "https://other.example",
889 future_exp(),
890 vec![jwk_of(&vk)],
891 );
892 let err = verify_self_issued_entity_statement(&jwt, "https://issuer.example")
893 .expect_err("iss mismatch must reject");
894 assert!(format!("{err}").contains("iss"), "got: {err}");
895 }
896
897 #[test]
898 fn entity_stmt_self_validation_rejects_sub_iss_mismatch() {
899 let sk = SigningKey::generate(&mut OsRng);
901 let vk = sk.verifying_key();
902 let jwt = build_entity_statement(
903 &sk,
904 "https://issuer.example",
905 "https://different.example",
906 future_exp(),
907 vec![jwk_of(&vk)],
908 );
909 let err = verify_self_issued_entity_statement(&jwt, "https://issuer.example")
910 .expect_err("sub != iss must reject");
911 assert!(format!("{err}").contains("sub"), "got: {err}");
912 }
913
914 #[test]
915 fn entity_stmt_self_validation_rejects_expired() {
916 let sk = SigningKey::generate(&mut OsRng);
917 let vk = sk.verifying_key();
918 let past_exp = std::time::SystemTime::now()
919 .duration_since(std::time::UNIX_EPOCH)
920 .map(|d| d.as_secs() as i64)
921 .unwrap_or(0)
922 - 60;
923 let jwt = build_entity_statement(
924 &sk,
925 "https://issuer.example",
926 "https://issuer.example",
927 past_exp,
928 vec![jwk_of(&vk)],
929 );
930 let err = verify_self_issued_entity_statement(&jwt, "https://issuer.example")
931 .expect_err("expired must reject");
932 assert!(format!("{err}").contains("expired"), "got: {err}");
933 }
934
935 #[test]
936 fn entity_stmt_self_validation_rejects_tampered_payload() {
937 let sk = SigningKey::generate(&mut OsRng);
938 let vk = sk.verifying_key();
939 let jwt = build_entity_statement(
940 &sk,
941 "https://issuer.example",
942 "https://issuer.example",
943 future_exp(),
944 vec![jwk_of(&vk)],
945 );
946 let parts: Vec<&str> = jwt.split('.').collect();
949 let tampered_payload = b64u_json(&serde_json::json!({
950 "iss": "https://issuer.example",
951 "sub": "https://issuer.example",
952 "iat": future_exp() - 7200,
953 "exp": future_exp() + 99999, "jwks": {"keys": [jwk_of(&vk)]},
955 }));
956 let tampered_jwt = format!("{}.{}.{}", parts[0], tampered_payload, parts[2]);
957 let err = verify_self_issued_entity_statement(&tampered_jwt, "https://issuer.example")
958 .expect_err("tampered payload must reject");
959 assert!(format!("{err}").contains("no Ed25519 key"), "got: {err}");
960 }
961
962 #[test]
963 fn entity_stmt_self_validation_rejects_stripping_attack() {
964 let attacker_sk = SigningKey::generate(&mut OsRng);
982 let attacker_vk = attacker_sk.verifying_key();
983 let jwt = build_entity_statement(
984 &attacker_sk,
985 "https://issuer.example",
986 "https://issuer.example",
987 future_exp(),
988 vec![jwk_of(&attacker_vk)],
989 );
990 let resolved = verify_self_issued_entity_statement(&jwt, "https://issuer.example")
994 .expect("self-consistent statement validates regardless of who signed it");
995 assert_eq!(resolved.as_bytes(), attacker_vk.as_bytes());
996 }
997
998 #[test]
999 fn entity_stmt_self_validation_rejects_signature_from_key_not_in_jwks() {
1000 let legit_sk = SigningKey::generate(&mut OsRng);
1004 let legit_vk = legit_sk.verifying_key();
1005 let attacker_sk = SigningKey::generate(&mut OsRng);
1006
1007 let header = serde_json::json!({"alg": "EdDSA", "typ": "entity-statement+jwt"});
1009 let payload = serde_json::json!({
1010 "iss": "https://issuer.example",
1011 "sub": "https://issuer.example",
1012 "iat": future_exp() - 3600,
1013 "exp": future_exp(),
1014 "jwks": {"keys": [jwk_of(&legit_vk)]},
1015 });
1016 let h = b64u_json(&header);
1017 let p = b64u_json(&payload);
1018 let signing_input = format!("{}.{}", h, p);
1019 let bad_sig = attacker_sk.sign(signing_input.as_bytes());
1020 let bad_jwt = format!("{}.{}", signing_input, b64u(&bad_sig.to_bytes()));
1021
1022 let err = verify_self_issued_entity_statement(&bad_jwt, "https://issuer.example")
1023 .expect_err("signature from key not in jwks must reject");
1024 assert!(format!("{err}").contains("no Ed25519 key"), "got: {err}");
1025 }
1026
1027 #[test]
1028 fn entity_stmt_self_validation_rejects_non_eddsa_alg() {
1029 let sk = SigningKey::generate(&mut OsRng);
1031 let vk = sk.verifying_key();
1032 let header = serde_json::json!({"alg": "RS256", "typ": "entity-statement+jwt"});
1033 let payload = serde_json::json!({
1034 "iss": "https://issuer.example",
1035 "sub": "https://issuer.example",
1036 "iat": future_exp() - 3600,
1037 "exp": future_exp(),
1038 "jwks": {"keys": [jwk_of(&vk)]},
1039 });
1040 let h = b64u_json(&header);
1041 let p = b64u_json(&payload);
1042 let signing_input = format!("{}.{}", h, p);
1043 let sig = sk.sign(signing_input.as_bytes());
1044 let jwt = format!("{}.{}", signing_input, b64u(&sig.to_bytes()));
1045 let err = verify_self_issued_entity_statement(&jwt, "https://issuer.example")
1046 .expect_err("non-EdDSA alg must reject");
1047 assert!(format!("{err}").contains("EdDSA"), "got: {err}");
1048 }
1049
1050 #[test]
1051 fn entity_stmt_self_validation_rejects_malformed_jwt() {
1052 let err = verify_self_issued_entity_statement("not.a.jwt.with.too.many.parts", "x")
1053 .expect_err("malformed JWT must reject");
1054 assert!(format!("{err}").contains("3-part"), "got: {err}");
1055 }
1056
1057 use std::sync::atomic::{AtomicU32, Ordering};
1062
1063 fn jwk_with_kid(vk: &VerifyingKey, kid: &str) -> serde_json::Value {
1064 serde_json::json!({
1065 "kty": "OKP",
1066 "crv": "Ed25519",
1067 "x": b64u(vk.as_bytes()),
1068 "use": "sig",
1069 "alg": "EdDSA",
1070 "kid": kid,
1071 })
1072 }
1073
1074 fn federation_token(signing_key: &SigningKey, kid: &str, sub: &str) -> String {
1075 let exp = future_exp();
1076 let claims = Claims::new(sub.to_owned(), exp - 3600, exp)
1077 .with_issuer("https://fed.example".to_owned());
1078 let header = serde_json::json!({"alg": "EdDSA", "typ": "at+jwt", "kid": kid});
1079 let signing_input = format!(
1080 "{}.{}",
1081 b64u_json(&header),
1082 b64u(&serde_json::to_vec(&claims).expect("claims json"))
1083 );
1084 let signature = signing_key.sign(signing_input.as_bytes());
1085 format!("{}.{}", signing_input, b64u(&signature.to_bytes()))
1086 }
1087
1088 fn trusted_issuer(jwks_uri: &str) -> HashMap<String, crate::config::TrustedIssuerConfig> {
1089 let mut issuers = HashMap::new();
1090 issuers.insert(
1091 "https://fed.example".to_owned(),
1092 crate::config::TrustedIssuerConfig {
1093 jwks_uri: Some(jwks_uri.to_owned()),
1094 jwks_cache_ttl_secs: 300,
1095 allow_http: true,
1096 federate_tui_client: None,
1097 },
1098 );
1099 issuers
1100 }
1101
1102 #[test]
1105 fn parse_jwks_retains_all_ed25519_entries_with_kids() {
1106 let sk_a = SigningKey::generate(&mut OsRng);
1107 let sk_b = SigningKey::generate(&mut OsRng);
1108 let jwks = serde_json::json!({
1109 "keys": [
1110 jwk_with_kid(&sk_a.verifying_key(), "kid-old"),
1111 jwk_with_kid(&sk_b.verifying_key(), "kid-new"),
1112 ]
1113 });
1114 let entries = parse_jwks_ed25519(&jwks, "https://fed.example/jwks");
1115 assert_eq!(entries.len(), 2, "both published keys must be retained");
1116 let kids: Vec<Option<&str>> = entries.iter().map(|e| e.kid.as_deref()).collect();
1117 assert!(kids.contains(&Some("kid-old")));
1118 assert!(kids.contains(&Some("kid-new")));
1119 }
1120
1121 #[tokio::test]
1125 async fn get_keys_overlap_returns_both_and_resolves_second_by_kid() {
1126 let sk_old = SigningKey::generate(&mut OsRng);
1127 let sk_new = SigningKey::generate(&mut OsRng);
1128 let vk_old = sk_old.verifying_key();
1129 let vk_new = sk_new.verifying_key();
1130 let jwks = serde_json::json!({
1131 "keys": [
1132 jwk_with_kid(&vk_old, "kid-old"),
1133 jwk_with_kid(&vk_new, "kid-new"),
1134 ]
1135 });
1136 let fetcher: JwksFetcher = Arc::new(move |_url| {
1137 let jwks = jwks.clone();
1138 Box::pin(async move { Ok(jwks) })
1139 });
1140 let resolver = FederationKeyResolver::new(&trusted_issuer("https://fed.example/jwks"))
1141 .with_jwks_fetcher(fetcher);
1142
1143 let old_token = federation_token(&sk_old, "kid-old", "old-subject");
1144 let new_token = federation_token(&sk_new, "kid-new", "new-subject");
1145
1146 let all = resolver
1148 .get_keys("https://fed.example", None)
1149 .await
1150 .expect("both keys");
1151 assert_eq!(all.len(), 2, "overlap: both keys must be returned");
1152
1153 let new_candidates = resolver
1154 .get_keys("https://fed.example", Some("kid-new"))
1155 .await
1156 .expect("kid-new resolves");
1157 assert_eq!(new_candidates.len(), 1, "named lookup must not fall back");
1158 assert_eq!(new_candidates[0].verifying_key, vk_new);
1159 assert_eq!(
1160 jwt::decode_with_federation_candidates(&new_token, &new_candidates, None)
1161 .expect("new overlap token verifies")
1162 .sub,
1163 "new-subject"
1164 );
1165
1166 let old_candidates = resolver
1167 .get_keys("https://fed.example", Some("kid-old"))
1168 .await
1169 .expect("kid-old resolves");
1170 assert_eq!(old_candidates.len(), 1, "named lookup must not fall back");
1171 assert_eq!(old_candidates[0].verifying_key, vk_old);
1172 assert_eq!(
1173 jwt::decode_with_federation_candidates(&old_token, &old_candidates, None)
1174 .expect("old overlap token verifies")
1175 .sub,
1176 "old-subject"
1177 );
1178 }
1179
1180 #[tokio::test]
1184 async fn get_keys_unknown_kid_fails_closed_without_substitution() {
1185 let sk = SigningKey::generate(&mut OsRng);
1186 let jwks = serde_json::json!({"keys": [jwk_with_kid(&sk.verifying_key(), "kid-real")]});
1187 let fetcher: JwksFetcher = Arc::new(move |_url| {
1188 let jwks = jwks.clone();
1189 Box::pin(async move { Ok(jwks) })
1190 });
1191 let resolver = FederationKeyResolver::new(&trusted_issuer("https://fed.example/jwks"))
1192 .with_jwks_fetcher(fetcher);
1193
1194 let err = resolver
1195 .get_keys("https://fed.example", Some("kid-ghost"))
1196 .await
1197 .expect_err("unknown kid must fail closed");
1198 assert!(
1199 format!("{err}").contains("kid-ghost"),
1200 "error must name the missing kid: {err}"
1201 );
1202 }
1203
1204 #[tokio::test]
1205 async fn repeated_unknown_kid_uses_one_refresh_within_negative_ttl() {
1206 let sk = SigningKey::generate(&mut OsRng);
1207 let jwks = serde_json::json!({"keys": [jwk_with_kid(&sk.verifying_key(), "kid-real")]});
1208 let fetch_count = Arc::new(AtomicU32::new(0));
1209 let count = Arc::clone(&fetch_count);
1210 let fetcher: JwksFetcher = Arc::new(move |_url| {
1211 let jwks = jwks.clone();
1212 let count = Arc::clone(&count);
1213 Box::pin(async move {
1214 count.fetch_add(1, Ordering::SeqCst);
1215 Ok(jwks)
1216 })
1217 });
1218 let resolver = FederationKeyResolver::new(&trusted_issuer("https://fed.example/jwks"))
1219 .with_jwks_fetcher(fetcher);
1220
1221 for _ in 0..3 {
1222 assert!(resolver
1223 .get_keys("https://fed.example", Some("kid-ghost"))
1224 .await
1225 .is_err());
1226 }
1227 assert_eq!(
1228 fetch_count.load(Ordering::SeqCst),
1229 1,
1230 "one miss → one refresh per negative TTL"
1231 );
1232 }
1233
1234 #[tokio::test]
1240 async fn get_keys_retired_key_rejected_after_rotation_completes() {
1241 let sk_old = SigningKey::generate(&mut OsRng);
1242 let sk_new = SigningKey::generate(&mut OsRng);
1243 let vk_old = sk_old.verifying_key();
1244 let vk_new = sk_new.verifying_key();
1245
1246 let overlap = serde_json::json!({
1248 "keys": [
1249 jwk_with_kid(&vk_old, "kid-old"),
1250 jwk_with_kid(&vk_new, "kid-new"),
1251 ]
1252 });
1253 let rotated = serde_json::json!({"keys": [jwk_with_kid(&vk_new, "kid-new")]});
1255
1256 let call_count = Arc::new(AtomicU32::new(0));
1260 let cc = call_count.clone();
1261 let fetcher: JwksFetcher = Arc::new(move |_url| {
1262 let cc = cc.clone();
1263 let overlap = overlap.clone();
1264 let rotated = rotated.clone();
1265 Box::pin(async move {
1266 let n = cc.fetch_add(1, Ordering::SeqCst);
1267 if n == 0 {
1268 Ok(overlap)
1269 } else {
1270 Ok(rotated)
1271 }
1272 })
1273 });
1274
1275 let mut issuers = HashMap::new();
1277 issuers.insert(
1278 "https://fed.example".to_owned(),
1279 crate::config::TrustedIssuerConfig {
1280 jwks_uri: Some("https://fed.example/jwks".to_owned()),
1281 jwks_cache_ttl_secs: 0,
1282 allow_http: true,
1283 federate_tui_client: None,
1284 },
1285 );
1286 let resolver = FederationKeyResolver::new(&issuers).with_jwks_fetcher(fetcher);
1287
1288 let old_token = federation_token(&sk_old, "kid-old", "old-subject");
1289 let new_token = federation_token(&sk_new, "kid-new", "new-subject");
1290
1291 let during_overlap = resolver
1294 .get_keys("https://fed.example", Some("kid-old"))
1295 .await
1296 .expect("old key honoured during overlap");
1297 assert!(jwt::decode_with_federation_candidates(&old_token, &during_overlap, None).is_ok());
1298 let new_during_overlap = resolver
1299 .get_keys("https://fed.example", Some("kid-new"))
1300 .await
1301 .expect("new key honoured during overlap");
1302 assert!(
1303 jwt::decode_with_federation_candidates(&new_token, &new_during_overlap, None).is_ok()
1304 );
1305
1306 let err = resolver
1308 .get_keys("https://fed.example", Some("kid-old"))
1309 .await
1310 .expect_err("retired key must be rejected after drain");
1311 assert!(
1312 format!("{err}").contains("kid-old"),
1313 "retired-key error must name the kid: {err}"
1314 );
1315
1316 let after = resolver
1318 .get_keys("https://fed.example", Some("kid-new"))
1319 .await
1320 .expect("new key still resolves");
1321 assert!(jwt::decode_with_federation_candidates(&new_token, &after, None).is_ok());
1322 }
1323}