tuwunel_service/server_keys/
get.rs1use std::borrow::Borrow;
8
9use ruma::{
10 CanonicalJsonObject, ServerName, ServerSigningKeyId, api::federation::discovery::VerifyKey,
11 room_version_rules::RoomVersionRules,
12};
13use tuwunel_core::{Err, Result, implement};
14
15use super::{PubKeyMap, PubKeys, extract_key};
16
17#[implement(super::Service)]
22pub async fn get_event_keys(
23 &self,
24 object: &CanonicalJsonObject,
25 version: &RoomVersionRules,
26) -> Result<PubKeyMap> {
27 use ruma::signatures::required_keys;
28
29 let required = match required_keys(object, &version.signatures) {
30 | Ok(required) => required,
31 | Err(e) => {
32 return Err!(BadServerResponse("Failed to determine keys required to verify: {e}"));
33 },
34 };
35
36 let batch = required
37 .iter()
38 .map(|(s, ids)| (s.borrow(), ids.iter().map(Borrow::borrow)));
39
40 Ok(self.get_pubkeys(batch).await)
41}
42
43#[implement(super::Service)]
48pub async fn get_pubkeys<'a, S, K>(&self, batch: S) -> PubKeyMap
49where
50 S: Iterator<Item = (&'a ServerName, K)> + Send,
51 K: Iterator<Item = &'a ServerSigningKeyId> + Send,
52{
53 let mut keys = PubKeyMap::new();
54 for (server, key_ids) in batch {
55 let pubkeys = self.get_pubkeys_for(server, key_ids).await;
56 keys.insert(server.as_str().into(), pubkeys);
57 }
58
59 keys
60}
61
62#[implement(super::Service)]
67pub async fn get_pubkeys_for<'a, I>(&self, origin: &ServerName, key_ids: I) -> PubKeys
68where
69 I: Iterator<Item = &'a ServerSigningKeyId> + Send,
70{
71 let mut keys = PubKeys::new();
72 for key_id in key_ids {
73 if let Ok(verify_key) = self.get_verify_key(origin, key_id).await {
74 keys.insert(key_id.as_str().into(), verify_key.key);
75 }
76 }
77
78 keys
79}
80
81#[implement(super::Service)]
86pub async fn get_verify_key(
87 &self,
88 origin: &ServerName,
89 key_id: &ServerSigningKeyId,
90) -> Result<VerifyKey> {
91 let notary_first = self
92 .services
93 .server
94 .config
95 .federation
96 .keys
97 .query_trusted_servers_first;
98
99 let notary_only = self
100 .services
101 .server
102 .config
103 .federation
104 .keys
105 .only_query_trusted_servers;
106
107 if let Some(result) = self.verify_keys_for(origin).await.remove(key_id) {
108 return Ok(result);
109 }
110
111 if notary_first
112 && let Ok(result) = self
113 .get_verify_key_from_notaries(origin, key_id)
114 .await
115 {
116 return Ok(result);
117 }
118
119 if !notary_only
120 && let Ok(result) = self
121 .get_verify_key_from_origin(origin, key_id)
122 .await
123 {
124 return Ok(result);
125 }
126
127 if !notary_first
128 && let Ok(result) = self
129 .get_verify_key_from_notaries(origin, key_id)
130 .await
131 {
132 return Ok(result);
133 }
134
135 Err!(BadServerResponse(debug_error!(
136 ?key_id,
137 ?origin,
138 "Failed to fetch federation signing-key"
139 )))
140}
141
142#[implement(super::Service)]
143async fn get_verify_key_from_notaries(
144 &self,
145 origin: &ServerName,
146 key_id: &ServerSigningKeyId,
147) -> Result<VerifyKey> {
148 for notary in &self
149 .services
150 .config
151 .federation
152 .keys
153 .trusted_servers
154 {
155 if let Ok(server_keys) = self.notary_request(notary, origin).await {
156 for server_key in server_keys.clone() {
157 self.add_signing_keys(server_key).await;
158 }
159
160 for server_key in server_keys {
161 if let Some(result) = extract_key(server_key, key_id) {
162 return Ok(result);
163 }
164 }
165 }
166 }
167
168 Err!(Request(NotFound("Failed to fetch signing-key from notaries")))
169}
170
171#[implement(super::Service)]
172async fn get_verify_key_from_origin(
173 &self,
174 origin: &ServerName,
175 key_id: &ServerSigningKeyId,
176) -> Result<VerifyKey> {
177 if let Ok(server_key) = self.server_request(origin).await {
178 self.add_signing_keys(server_key.clone()).await;
179 if let Some(result) = extract_key(server_key, key_id) {
180 return Ok(result);
181 }
182 }
183
184 Err!(Request(NotFound("Failed to fetch signing-key from origin")))
185}