hyprstream_rpc/
federated_identity.rs1use 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
17pub 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 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 self.node.identity_open(purpose).await
43 }
44
45 fn resolve(&self, pubkey: &[u8; 32]) -> Subject {
46 let local = self.node.resolve(pubkey);
48 if local.name().is_some() {
49 return local;
50 }
51
52 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}