Skip to main content

tuwunel_service/server_keys/
acquire.rs

1//! Best-effort acquisition of missing federation verify keys.
2//!
3//! Requests are deduplicated by server and key ID, checked against local
4//! storage, and then sent to origins and trusted notaries in configured order.
5//! Missing keys are logged rather than returned to callers as an error.
6
7use 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/// Acquires the signing keys referenced by a collection of raw events.
29///
30/// Signature maps are grouped and deduplicated before acquisition. Events with
31/// malformed JSON or unreadable signature fields are silently skipped.
32#[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/// Best-effort acquires a batch of server signing keys into the local cache.
62///
63/// Local storage is checked first, then origins and trusted notaries are tried
64/// according to configuration. The method returns no status; keys still missing
65/// after all allowed sources are logged.
66#[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}