tuwunel_service/server_keys/
acquire.rs1use std::{
8 borrow::Borrow,
9 collections::{BTreeMap, BTreeSet},
10 time::Duration,
11};
12
13use futures::{StreamExt, stream::FuturesUnordered};
14use ruma::{
15 CanonicalJsonObject, OwnedServerName, OwnedServerSigningKeyId, ServerName,
16 ServerSigningKeyId, api::federation::discovery::ServerSigningKeys, serde::Raw,
17};
18use serde_json::value::RawValue as RawJsonValue;
19use tokio::time::{Instant, timeout_at};
20use tuwunel_core::{
21 debug, debug_error, debug_warn, error, implement, info, result::FlatOk, trace, warn,
22};
23
24use super::key_exists;
25
26type Batch = BTreeMap<OwnedServerName, Vec<OwnedServerSigningKeyId>>;
27
28#[implement(super::Service)]
33pub async fn acquire_events_pubkeys<'a, I>(&self, events: I)
34where
35 I: Iterator<Item = &'a Box<RawJsonValue>> + Send,
36{
37 type Batch = BTreeMap<OwnedServerName, BTreeSet<OwnedServerSigningKeyId>>;
38 type Signatures = BTreeMap<OwnedServerName, BTreeMap<OwnedServerSigningKeyId, String>>;
39
40 let mut batch = Batch::new();
41 events
42 .cloned()
43 .map(Raw::<CanonicalJsonObject>::from_json)
44 .map(|event| event.get_field::<Signatures>("signatures"))
45 .filter_map(FlatOk::flat_ok)
46 .flat_map(IntoIterator::into_iter)
47 .for_each(|(server, sigs)| {
48 batch
49 .entry(server)
50 .or_default()
51 .extend(sigs.into_keys());
52 });
53
54 let batch = batch
55 .iter()
56 .map(|(server, keys)| (server.borrow(), keys.iter().map(Borrow::borrow)));
57
58 self.acquire_pubkeys(batch).await;
59}
60
61#[implement(super::Service)]
67pub async fn acquire_pubkeys<'a, S, K>(&self, batch: S)
68where
69 S: Iterator<Item = (&'a ServerName, K)> + Send + Clone,
70 K: Iterator<Item = &'a ServerSigningKeyId> + Send + Clone,
71{
72 let notary_only = self
73 .services
74 .config
75 .federation
76 .keys
77 .only_query_trusted_servers;
78
79 let notary_first_always = self
80 .services
81 .config
82 .federation
83 .keys
84 .query_trusted_servers_first;
85
86 let notary_first_on_join = self
87 .services
88 .config
89 .federation
90 .keys
91 .query_trusted_servers_first_on_join;
92
93 let requested_servers = batch.clone().count();
94 let requested_keys = batch
95 .clone()
96 .flat_map(|(_, key_ids)| key_ids)
97 .count();
98
99 debug!("acquire {requested_keys} keys from {requested_servers}");
100
101 let mut missing = self.acquire_locals(batch).await;
102 let mut missing_keys = keys_count(&missing);
103 let mut missing_servers = missing.len();
104 if missing_servers == 0 {
105 return;
106 }
107
108 info!("{missing_keys} keys for {missing_servers} servers will be acquired");
109
110 if notary_first_always || notary_first_on_join {
111 missing = self.acquire_notary(missing.into_iter()).await;
112 missing_keys = keys_count(&missing);
113 missing_servers = missing.len();
114 if missing_keys == 0 {
115 return;
116 }
117
118 warn!(
119 "missing {missing_keys} keys for {missing_servers} servers from all notaries first"
120 );
121 }
122
123 if !notary_only {
124 missing = self.acquire_origins(missing.into_iter()).await;
125 missing_keys = keys_count(&missing);
126 missing_servers = missing.len();
127 if missing_keys == 0 {
128 return;
129 }
130
131 debug_warn!("missing {missing_keys} keys for {missing_servers} servers unreachable");
132 }
133
134 if !notary_first_always && !notary_first_on_join {
135 missing = self.acquire_notary(missing.into_iter()).await;
136 missing_keys = keys_count(&missing);
137 missing_servers = missing.len();
138 if missing_keys == 0 {
139 return;
140 }
141
142 debug_warn!(
143 "still missing {missing_keys} keys for {missing_servers} servers from all notaries."
144 );
145 }
146
147 if missing_keys > 0 {
148 warn!(
149 "did not obtain {missing_keys} keys for {missing_servers} servers out of \
150 {requested_keys} total keys for {requested_servers} total servers."
151 );
152 }
153
154 for (server, key_ids) in missing {
155 debug_warn!(?server, ?key_ids, "missing");
156 }
157}
158
159#[implement(super::Service)]
160async fn acquire_locals<'a, S, K>(&self, batch: S) -> Batch
161where
162 S: Iterator<Item = (&'a ServerName, K)> + Send,
163 K: Iterator<Item = &'a ServerSigningKeyId> + Send,
164{
165 let mut missing = Batch::new();
166 for (server, key_ids) in batch {
167 for key_id in key_ids {
168 if !self.verify_key_exists(server, key_id).await {
169 missing
170 .entry(server.into())
171 .or_default()
172 .push(key_id.into());
173 }
174 }
175 }
176
177 missing
178}
179
180#[implement(super::Service)]
181async fn acquire_origins<I>(&self, batch: I) -> Batch
182where
183 I: Iterator<Item = (OwnedServerName, Vec<OwnedServerSigningKeyId>)> + Send,
184{
185 let timeout = Instant::now()
186 .checked_add(Duration::from_secs(45))
187 .expect("timeout overflows");
188
189 let mut requests: FuturesUnordered<_> = batch
190 .map(|(origin, key_ids)| self.acquire_origin(origin, key_ids, timeout))
191 .collect();
192
193 let mut missing = Batch::new();
194 while let Some((origin, key_ids)) = requests.next().await {
195 if !key_ids.is_empty() {
196 missing.insert(origin, key_ids);
197 }
198 }
199
200 missing
201}
202
203#[implement(super::Service)]
204async fn acquire_origin(
205 &self,
206 origin: OwnedServerName,
207 mut key_ids: Vec<OwnedServerSigningKeyId>,
208 timeout: Instant,
209) -> (OwnedServerName, Vec<OwnedServerSigningKeyId>) {
210 match timeout_at(timeout, self.server_request(&origin)).await {
211 | Err(e) => debug_warn!(?origin, "timed out: {e}"),
212 | Ok(Err(e)) => debug_error!(?origin, "{e}"),
213 | Ok(Ok(server_keys)) => {
214 trace!(
215 %origin,
216 ?key_ids,
217 ?server_keys,
218 "received server_keys"
219 );
220
221 self.add_signing_keys(server_keys.clone()).await;
222 key_ids.retain(|key_id| !key_exists(&server_keys, key_id));
223 },
224 }
225
226 (origin, key_ids)
227}
228
229#[implement(super::Service)]
230async fn acquire_notary<I>(&self, batch: I) -> Batch
231where
232 I: Iterator<Item = (OwnedServerName, Vec<OwnedServerSigningKeyId>)> + Send,
233{
234 let mut missing: Batch = batch.collect();
235
236 for notary in &self
237 .services
238 .config
239 .federation
240 .keys
241 .trusted_servers
242 {
243 let missing_keys = keys_count(&missing);
244 let missing_servers = missing.len();
245 debug!(
246 "Asking notary {notary} for {missing_keys} missing keys from {missing_servers} \
247 servers"
248 );
249
250 let batch = missing
251 .iter()
252 .map(|(server, keys)| (server.borrow(), keys.iter().map(Borrow::borrow)));
253
254 match self.batch_notary_request(notary, batch).await {
255 | Err(e) => error!("Failed to contact notary {notary:?}: {e}"),
256 | Ok(results) =>
257 for server_keys in results {
258 self.acquire_notary_result(&mut missing, server_keys)
259 .await;
260 },
261 }
262 }
263
264 missing
265}
266
267#[implement(super::Service)]
268async fn acquire_notary_result(&self, missing: &mut Batch, server_keys: ServerSigningKeys) {
269 let server = &server_keys.server_name;
270 self.add_signing_keys(server_keys.clone()).await;
271
272 if let Some(key_ids) = missing.get_mut(server) {
273 key_ids.retain(|key_id| !key_exists(&server_keys, key_id));
274 if key_ids.is_empty() {
275 missing.remove(server);
276 }
277 }
278}
279
280fn keys_count(batch: &Batch) -> usize {
281 batch
282 .values()
283 .flat_map(|key_ids| key_ids.iter())
284 .count()
285}