Skip to main content

hyprstream_rpc/
federated_identity.rs

1//! Federated identity provider — extends node identity with cross-node trust.
2//!
3//! Combines local signing (via `NodeIdentityProvider`) with federated
4//! trust resolution (via `FederationKeySource`). Local identity derivation
5//! is identical to `NodeIdentityProvider`; the difference is `resolve()`
6//! which can verify remote nodes' pubkeys via federation entity statements.
7
8use anyhow::Result;
9use async_trait::async_trait;
10use std::sync::Arc;
11
12use crate::auth::FederationKeySource;
13use crate::identity::{IdentityProvider, SigningIdentity};
14use crate::node_identity::NodeIdentityProvider;
15use crate::Subject;
16
17/// Identity provider with cross-node trust via federation.
18///
19/// - `identity_open()` — delegates to `NodeIdentityProvider` (local signing)
20/// - `resolve()` — checks local node key first, then federation trust chain
21pub struct FederatedIdentityProvider {
22    node: NodeIdentityProvider,
23    federation: Arc<dyn FederationKeySource>,
24}
25
26impl FederatedIdentityProvider {
27    pub fn new(node: NodeIdentityProvider, federation: Arc<dyn FederationKeySource>) -> Self {
28        Self { node, federation }
29    }
30
31    /// Access the underlying federation key source.
32    pub fn federation(&self) -> &dyn FederationKeySource {
33        self.federation.as_ref()
34    }
35}
36
37#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
38#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
39impl IdentityProvider for FederatedIdentityProvider {
40    async fn identity_open(&self, purpose: &str) -> Result<Box<dyn SigningIdentity>> {
41        // Local signing — same as NodeIdentityProvider
42        self.node.identity_open(purpose).await
43    }
44
45    fn resolve(&self, pubkey: &[u8; 32]) -> Subject {
46        // Check local node key first
47        let local = self.node.resolve(pubkey);
48        if local.name().is_some() {
49            return local;
50        }
51
52        // TODO: Check federation trust chain.
53        // This requires async key resolution (JWKS fetch) but resolve() is sync.
54        // For now, return anonymous for unknown keys. The async verification
55        // happens in verify_claims() via FederationKeySource::get_key().
56        //
57        // The proper fix: make resolve() async, or split into
58        // resolve_local() (sync) + resolve_federated() (async).
59        Subject::anonymous()
60    }
61}
62
63#[cfg(test)]
64mod tests {
65    use super::*;
66    use ed25519_dalek::SigningKey;
67
68    struct MockFederation;
69
70    #[async_trait::async_trait]
71    impl FederationKeySource for MockFederation {
72        fn is_trusted(&self, _issuer: &str) -> bool {
73            true
74        }
75        async fn get_keys(
76            &self,
77            _issuer: &str,
78            _kid: Option<&str>,
79        ) -> Result<Vec<crate::auth::FederationKey>> {
80            anyhow::bail!("mock: no key")
81        }
82    }
83
84    #[allow(clippy::unwrap_used)]
85    #[tokio::test]
86    async fn federated_provider_signs_locally() {
87        let root = SigningKey::generate(&mut rand::rngs::OsRng);
88        let node = NodeIdentityProvider::new(&root);
89        let provider = FederatedIdentityProvider::new(node, Arc::new(MockFederation));
90
91        let id = provider.identity_open("test-v1").await.unwrap();
92        let sig = id.sign(b"hello").await.unwrap();
93
94        let vk = ed25519_dalek::VerifyingKey::from_bytes(&id.pubkey()).unwrap();
95        let signature = ed25519_dalek::Signature::from_bytes(&sig);
96        use ed25519_dalek::Verifier;
97        assert!(vk.verify(b"hello", &signature).is_ok());
98    }
99
100    #[allow(clippy::unwrap_used)]
101    #[test]
102    fn federated_resolve_local_key() {
103        let root = SigningKey::generate(&mut rand::rngs::OsRng);
104        let node_pub = root.verifying_key().to_bytes();
105        let node = NodeIdentityProvider::new(&root);
106        let provider = FederatedIdentityProvider::new(node, Arc::new(MockFederation));
107
108        assert_eq!(provider.resolve(&node_pub).name(), Some("system"));
109        assert_eq!(provider.resolve(&[0u8; 32]).name(), None);
110    }
111}