Skip to main content

tuwunel_service/server_keys/
get.rs

1//! Retrieval of cached and remote federation verify keys.
2//!
3//! Event signature requirements are translated into ruma public-key maps.
4//! Individual keys can fall back from the cache to trusted notaries and the
5//! origin server according to configuration.
6
7use 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/// Resolves the public keys required to verify an event.
18///
19/// Invalid signature metadata returns an error. Fetch failures for individual
20/// keys are omitted, so a successful result can still be a partial key map.
21#[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/// Resolves public-key sets for a batch of servers and key IDs.
44///
45/// Every requested server is inserted, even when its key set is empty.
46/// Individual key errors are suppressed by [`Self::get_pubkeys_for`].
47#[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/// Resolves the requested public keys for one server.
63///
64/// Keys that cannot be loaded or fetched are omitted, making the returned set
65/// intentionally partial rather than failing the whole request.
66#[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/// Retrieves one current or retired verify key for a server.
82///
83/// The cache is checked first. Trusted notaries and the origin are then queried
84/// in configured order, with origin requests disabled in notary-only mode.
85#[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}