Skip to main content

tuwunel_service/server_keys/
request.rs

1//! Federation requests for origin and notary signing-key documents.
2//!
3//! Notary queries include the configured minimum validity horizon and can be
4//! split across bounded concurrent batches. Origin responses are checked to
5//! ensure the returned server name matches the requested target.
6
7use std::{collections::BTreeMap, convert::identity, fmt::Debug};
8
9use futures::{StreamExt, TryFutureExt};
10use ruma::{
11	OwnedServerName, OwnedServerSigningKeyId, ServerName, ServerSigningKeyId,
12	api::federation::discovery::{
13		ServerSigningKeys, get_remote_server_keys,
14		get_remote_server_keys_batch::{self, v2::QueryCriteria},
15		get_server_keys,
16	},
17};
18use tuwunel_core::{
19	Err, Result, error, implement, info, trace,
20	utils::stream::{IterStream, ReadyExt, TryBroadbandExt, TryReadyExt},
21};
22
23/// Requests a batch of signing-key documents from one trusted notary.
24///
25/// The request is split by configured batch size and concurrency. Malformed
26/// individual documents are skipped, while a failed batch aborts the operation.
27#[implement(super::Service)]
28pub(super) async fn batch_notary_request<'a, S, K>(
29	&self,
30	notary: &ServerName,
31	batch: S,
32) -> Result<Vec<ServerSigningKeys>>
33where
34	S: Iterator<Item = (&'a ServerName, K)> + Send,
35	K: Iterator<Item = &'a ServerSigningKeyId> + Send,
36{
37	use get_remote_server_keys_batch::v2::Request;
38	type RumaBatch = BTreeMap<OwnedServerName, BTreeMap<OwnedServerSigningKeyId, QueryCriteria>>;
39
40	let criteria = QueryCriteria {
41		minimum_valid_until_ts: Some(self.minimum_valid_ts()),
42	};
43
44	let mut server_keys = batch.fold(RumaBatch::new(), |mut batch, (server, key_ids)| {
45		batch
46			.entry(server.into())
47			.or_default()
48			.extend(key_ids.map(|key_id| (key_id.into(), criteria.clone())));
49
50		batch
51	});
52
53	let total_keys = server_keys
54		.values()
55		.flat_map(|ids| ids.iter())
56		.count();
57
58	debug_assert!(total_keys > 0, "empty batch request to notary");
59
60	let batch_max = self
61		.services
62		.server
63		.config
64		.federation
65		.keys
66		.trusted_server_batch_size;
67
68	let batch_concurrency = self
69		.services
70		.server
71		.config
72		.federation
73		.keys
74		.trusted_server_batch_concurrency;
75
76	let batches: Vec<_> = server_keys
77		.keys()
78		.rev()
79		.step_by(batch_max.saturating_sub(1))
80		.skip(1)
81		.chain(server_keys.keys().next())
82		.cloned()
83		.collect();
84
85	batches
86		.iter()
87		.stream()
88		.enumerate()
89		.map(|(i, batch)| {
90			let request = Request {
91				server_keys: server_keys.split_off(batch),
92			};
93
94			if request.server_keys.is_empty() {
95				return None;
96			}
97
98			trace!(
99				%i, %notary, ?batch,
100				remaining = ?server_keys,
101				requesting = ?request.server_keys.keys(),
102				"Request to notary server."
103			);
104
105			info!(
106				%notary,
107				remaining = %server_keys.len(),
108				requesting = %request.server_keys.len(),
109				"Sending request to notary server..."
110			);
111
112			Some(Ok(request))
113		})
114		.ready_filter_map(identity)
115		.broadn_and_then(batch_concurrency, |request| {
116			self.services
117				.federation
118				.execute_synapse(notary, request)
119		})
120		.ready_try_fold(Vec::new(), |mut results, response| {
121			let response = response
122				.server_keys
123				.into_iter()
124				.map(|key| key.deserialize())
125				.filter_map(Result::ok);
126
127			trace!(
128				%notary, ?response,
129				"Response from notary server."
130			);
131
132			results.extend(response);
133
134			info!(
135				"Received {0} keys out of {1} from notary server so far...",
136				results.len(),
137				total_keys,
138			);
139
140			Ok(results)
141		})
142		.inspect_err(|e| {
143			error!(
144				?notary, %batch_max, %batch_concurrency, %total_keys,
145				"Requesting keys from notary server failed: {e}",
146			);
147		})
148		.await
149}
150
151/// Requests signing-key documents for one target from a trusted notary.
152///
153/// The query requires the configured minimum validity horizon. Malformed
154/// documents in an otherwise successful response are omitted from the iterator.
155#[implement(super::Service)]
156pub async fn notary_request(
157	&self,
158	notary: &ServerName,
159	target: &ServerName,
160) -> Result<impl Iterator<Item = ServerSigningKeys> + Clone + Debug + Send + use<>> {
161	use get_remote_server_keys::v2::Request;
162
163	let request = Request {
164		server_name: target.into(),
165		minimum_valid_until_ts: self.minimum_valid_ts(),
166	};
167
168	let response = self
169		.services
170		.federation
171		.execute(notary, request)
172		.await?
173		.server_keys
174		.into_iter()
175		.map(|key| key.deserialize())
176		.filter_map(Result::ok);
177
178	Ok(response)
179}
180
181/// Requests the current signing-key document directly from its origin server.
182///
183/// The response must deserialize and name the requested target; a mismatched
184/// `server_name` is rejected as a bad server response.
185#[implement(super::Service)]
186pub async fn server_request(&self, target: &ServerName) -> Result<ServerSigningKeys> {
187	use get_server_keys::v2::Request;
188
189	let server_signing_key = self
190		.services
191		.federation
192		.execute(target, Request::new())
193		.await
194		.map(|response| response.server_key)
195		.and_then(|key| key.deserialize().map_err(Into::into))?;
196
197	if server_signing_key.server_name != target {
198		return Err!(BadServerResponse(debug_warn!(
199			requested = ?target,
200			response = ?server_signing_key.server_name,
201			"Server responded with bogus server_name"
202		)));
203	}
204
205	Ok(server_signing_key)
206}