Skip to main content

tuwunel_service/resolver/
actual.rs

1use std::{fmt::Debug, net::IpAddr};
2
3use futures::{FutureExt, TryFutureExt, future::ready};
4use hickory_resolver::{
5	net::{DnsError, NetError},
6	proto::rr::{Name, RData, rdata::SRV},
7};
8use ruma::ServerName;
9use tuwunel_core::{
10	Err, Result, debug, debug_info, debug_warn, err, error, format_array_string, implement,
11	trace, utils::string::to_small_string,
12};
13
14use super::{
15	DestString, FedDest,
16	cache::{CachedDest, CachedOverride, MAX_IPS},
17	fed::{HostString, PortString, add_port_to_hostname, get_ip_with_port, unbracket},
18};
19
20#[derive(Clone, Debug)]
21pub(crate) struct ActualDest {
22	pub(crate) dest: FedDest,
23	pub(crate) host: DestString,
24	pub(crate) srv: bool,
25}
26
27impl ActualDest {
28	#[inline]
29	pub(crate) fn to_string(&self) -> DestString { self.dest.https_string() }
30}
31
32impl From<CachedDest> for ActualDest {
33	fn from(CachedDest { dest, host, srv, .. }: CachedDest) -> Self { Self { dest, host, srv } }
34}
35
36#[implement(ActualDest)]
37fn direct(dest: FedDest, host: &str) -> Self {
38	Self {
39		dest,
40		host: Self::dest_host(host).uri_string(),
41		srv: false,
42	}
43}
44
45#[implement(ActualDest)]
46fn via_srv(dest: FedDest, host: &str) -> Self { Self { srv: true, ..Self::direct(dest, host) } }
47
48#[implement(ActualDest)]
49fn dest_host(host: &str) -> FedDest {
50	get_ip_with_port(host).unwrap_or_else(|| add_port_to_hostname(host))
51}
52
53#[implement(super::Service)]
54#[tracing::instrument(skip_all, level = "debug", name = "resolve")]
55pub(crate) async fn get_actual_dest(&self, server_name: &ServerName) -> Result<ActualDest> {
56	self.lookup_actual_dest_with_policy(server_name, false)
57		.map_ok(|(cached, _)| cached.into())
58		.await
59}
60
61#[implement(super::Service)]
62#[tracing::instrument(skip_all, level = "debug", name = "resolve")]
63pub(crate) async fn get_actual_dest_allow_self(
64	&self,
65	server_name: &ServerName,
66) -> Result<ActualDest> {
67	self.lookup_actual_dest_with_policy(server_name, true)
68		.map_ok(|(cached, _)| cached.into())
69		.await
70}
71
72#[implement(super::Service)]
73async fn lookup_actual_dest_with_policy(
74	&self,
75	server_name: &ServerName,
76	allow_self: bool,
77) -> Result<(CachedDest, bool)> {
78	self.validate_self_destination(server_name, allow_self)?;
79
80	if let Ok(result) = self.cache.get_destination(server_name).await {
81		return Ok((result, true));
82	}
83
84	let _dedup = self.resolving.lock(server_name).await;
85	if let Ok(result) = self.cache.get_destination(server_name).await {
86		return Ok((result, true));
87	}
88
89	self.validate_dest_address(server_name)?;
90
91	self.resolve_actual_dest_unchecked(server_name, true)
92		.inspect_ok(|result| self.cache.set_destination(server_name, result))
93		.map_ok(|result| (result, false))
94		.boxed() // query-depth firewall
95		.await
96}
97
98/// Returns: `actual_destination`, host header
99/// Implemented according to the specification at <https://matrix.org/docs/spec/server_server/r0.1.4#resolving-server-names>
100/// Numbers in comments below refer to bullet points in linked section of
101/// specification
102#[implement(super::Service)]
103pub async fn resolve_actual_dest(&self, dest: &ServerName, cache: bool) -> Result<CachedDest> {
104	self.validate_dest(dest, false)?;
105	self.resolve_actual_dest_unchecked(dest, cache)
106		.await
107}
108
109#[implement(super::Service)]
110#[tracing::instrument(name = "actual", level = "debug", skip(self, cache))]
111async fn resolve_actual_dest_unchecked(
112	&self,
113	dest: &ServerName,
114	cache: bool,
115) -> Result<CachedDest> {
116	let ActualDest { dest: actual, host, srv } = self.actual_dest(dest, cache).await?;
117
118	debug!(?actual, ?host, srv, "Actual destination");
119	Ok(CachedDest {
120		dest: actual,
121		host,
122		expire: CachedDest::default_expire(),
123		srv,
124	})
125}
126
127#[implement(super::Service)]
128async fn actual_dest(&self, dest: &ServerName, cache: bool) -> Result<ActualDest> {
129	let name = dest.as_str();
130	let direct = |actual| ActualDest::direct(actual, name);
131
132	match get_ip_with_port(name) {
133		| Some(host_port) => Self::actual_dest_1(host_port).map(direct),
134		| None if name.contains(':') =>
135			self.actual_dest_2(dest, cache)
136				.map_ok(direct)
137				.await,
138		| None => self.actual_dest_named(dest, cache).await,
139	}
140}
141
142#[implement(super::Service)]
143fn actual_dest_1(host_port: FedDest) -> Result<FedDest> {
144	debug!("1: IP literal with provided or default port");
145	Ok(host_port)
146}
147
148#[implement(super::Service)]
149async fn actual_dest_2(&self, dest: &ServerName, cache: bool) -> Result<FedDest> {
150	debug!("2: Hostname with included port");
151	self.direct_route(dest.as_str(), cache).await
152}
153
154#[implement(super::Service)]
155async fn actual_dest_named(&self, dest: &ServerName, cache: bool) -> Result<ActualDest> {
156	let name = dest.as_str();
157
158	self.services.server.check_running()?;
159	match self.request_well_known(name).await? {
160		| Some(delegated) => self.actual_dest_3(cache, &delegated).await,
161		| None => match self.query_srv_record(name).await? {
162			| Some(overrider) =>
163				self.actual_dest_4(name, cache, overrider)
164					.map_ok(|actual| ActualDest::via_srv(actual, name))
165					.await,
166			| None =>
167				self.actual_dest_5(dest, cache)
168					.map_ok(|actual| ActualDest::direct(actual, name))
169					.await,
170		},
171	}
172}
173
174#[implement(super::Service)]
175pub(super) async fn actual_dest_3(&self, cache: bool, delegated: &str) -> Result<ActualDest> {
176	debug!("3: A .well-known file is available");
177	let direct = |actual| ActualDest::direct(actual, delegated);
178
179	match get_ip_with_port(delegated) {
180		| Some(host_and_port) => Self::actual_dest_3_1(host_and_port).map(direct),
181		| None if delegated.contains(':') =>
182			self.actual_dest_3_2(cache, delegated)
183				.map_ok(direct)
184				.await,
185		| None => match self.query_srv_record(delegated).await? {
186			| Some(overrider) =>
187				self.actual_dest_3_3(cache, delegated, overrider)
188					.map_ok(|actual| ActualDest::via_srv(actual, delegated))
189					.await,
190			| None =>
191				self.actual_dest_3_4(cache, delegated)
192					.map_ok(direct)
193					.await,
194		},
195	}
196}
197
198#[cfg(test)]
199#[implement(super::Service)]
200pub(crate) async fn test_delegated_dest(&self, delegated: &str) -> Result<ActualDest> {
201	self.actual_dest_3(false, delegated).await
202}
203
204#[implement(super::Service)]
205fn actual_dest_3_1(host_and_port: FedDest) -> Result<FedDest> {
206	debug!("3.1: IP literal in .well-known file");
207	Ok(host_and_port)
208}
209
210#[implement(super::Service)]
211async fn actual_dest_3_2(&self, cache: bool, delegated: &str) -> Result<FedDest> {
212	debug!("3.2: Hostname with port in .well-known file");
213	self.direct_route(delegated, cache).await
214}
215
216#[implement(super::Service)]
217async fn actual_dest_3_3(
218	&self,
219	cache: bool,
220	delegated: &str,
221	overrider: FedDest,
222) -> Result<FedDest> {
223	debug!("3.3: SRV lookup successful");
224	self.srv_route(delegated, cache, overrider).await
225}
226
227#[implement(super::Service)]
228async fn actual_dest_3_4(&self, cache: bool, delegated: &str) -> Result<FedDest> {
229	debug!("3.4: No SRV records, just use the hostname from .well-known");
230	self.direct_route(delegated, cache).await
231}
232
233#[implement(super::Service)]
234async fn actual_dest_4(&self, host: &str, cache: bool, overrider: FedDest) -> Result<FedDest> {
235	debug!("4: No .well-known; SRV record found");
236	self.srv_route(host, cache, overrider).await
237}
238
239#[implement(super::Service)]
240async fn actual_dest_5(&self, dest: &ServerName, cache: bool) -> Result<FedDest> {
241	debug!("5: No SRV record found");
242	self.direct_route(dest.as_str(), cache).await
243}
244
245#[implement(super::Service)]
246async fn direct_route(&self, name: &str, cache: bool) -> Result<FedDest> {
247	let dest = add_port_to_hostname(name);
248
249	self.query_direct(&dest.hostname(), cache)
250		.map_ok(|()| dest)
251		.await
252}
253
254#[implement(super::Service)]
255async fn srv_route(&self, name: &str, cache: bool, overrider: FedDest) -> Result<FedDest> {
256	let force_port = overrider.port();
257	self.maybe_query_and_cache_override(
258		name,
259		&overrider.hostname(),
260		force_port.unwrap_or(8448),
261		cache,
262	)
263	.await?;
264
265	if let Some(port) = force_port {
266		let port: PortString = format_array_string!(":{port}");
267
268		return Ok(FedDest::Named(name.into(), port));
269	}
270
271	Ok(add_port_to_hostname(name))
272}
273
274#[implement(super::Service)]
275#[tracing::instrument(level = "debug", skip(self))]
276async fn query_direct(&self, hostname: &str, cache: bool) -> Result {
277	if !cache {
278		return Ok(());
279	}
280
281	self.services.server.check_running()?;
282
283	// Warm the DNS cache without publishing a hostname-wide SRV override.
284	self.resolver
285		.resolver
286		.lookup_ip(hostname)
287		.map_ok(drop)
288		.or_else(|error| ready(Self::handle_resolve_error(&error, hostname)))
289		.await
290}
291
292#[implement(super::Service)]
293#[inline]
294async fn maybe_query_and_cache_override(
295	&self,
296	untername: &str,
297	hostname: &str,
298	port: u16,
299	cache: bool,
300) -> Result {
301	if !cache {
302		return Ok(());
303	}
304
305	if self.cache.has_override(untername, hostname).await {
306		return Ok(());
307	}
308
309	self.query_and_cache_override(untername, hostname, port)
310		.await
311}
312
313#[implement(super::Service)]
314#[tracing::instrument(name = "ip", level = "debug", skip(self))]
315async fn query_and_cache_override(
316	&self,
317	untername: &'_ str,
318	hostname: &'_ str,
319	port: u16,
320) -> Result {
321	self.services.server.check_running()?;
322
323	debug!("querying IP for {untername:?} ({hostname:?}:{port})");
324	match self
325		.resolver
326		.resolver
327		.lookup_ip(hostname.to_owned())
328		.await
329	{
330		| Err(e) => Self::handle_resolve_error(&e, hostname),
331		| Ok(override_ip) => {
332			debug_info!(?untername, ?hostname, "Overriding hostname");
333			self.cache
334				.set_override(untername, &CachedOverride {
335					ips: override_ip.iter().take(MAX_IPS).collect(),
336					port,
337					expire: CachedOverride::default_expire(),
338					overriding: Some(hostname.into()),
339				});
340
341			Ok(())
342		},
343	}
344}
345
346#[implement(super::Service)]
347#[tracing::instrument(name = "srv", level = "debug", skip(self))]
348async fn query_srv_record(&self, hostname: &'_ str) -> Result<Option<FedDest>> {
349	let hostnames =
350		[format!("_matrix-fed._tcp.{hostname}."), format!("_matrix._tcp.{hostname}.")];
351
352	for hostname in hostnames {
353		self.services.server.check_running()?;
354
355		debug!("querying SRV for {hostname:?}");
356		let hostname = hostname.trim_end_matches('.');
357		match self.resolver.resolver.srv_lookup(hostname).await {
358			| Err(e) => Self::handle_resolve_error(&e, hostname)?,
359			| Ok(result) => {
360				let srv = result
361					.answers()
362					.iter()
363					.find_map(|r| match &r.data {
364						| RData::SRV(srv) => Some(srv),
365						| _ => None,
366					});
367
368				return Ok(srv.map(Self::srv_dest));
369			},
370		}
371	}
372
373	Ok(None)
374}
375
376#[implement(super::Service)]
377fn srv_dest(srv: &SRV) -> FedDest {
378	let host: HostString = to_small_string(&srv.target);
379	let port: PortString = format_array_string!(":{}", srv.port);
380
381	FedDest::Named(host.trim_end_matches('.').into(), port)
382}
383
384#[implement(super::Service)]
385fn handle_resolve_error(e: &NetError, host: &'_ str) -> Result {
386	// `NetError::Dns(_)` covers responses returned by the remote side (NXDOMAIN,
387	// SERVFAIL, REFUSED, ...) only seen with verbose-logging. Local-origin failures
388	// (Timeout, NoConnections, Io, ...) keep their warn/error level so an operator
389	// notices when their own resolver is unhealthy.
390	match e {
391		| NetError::Dns(DnsError::NoRecordsFound(_)) => {
392			// Raise to debug_warn if we can find out the result wasn't from cache
393			debug!(%host, "No DNS records found: {e}");
394			Ok(())
395		},
396		| NetError::Dns(_) => {
397			debug_warn!(%host, "DNS response error: {e}");
398			Ok(())
399		},
400		// Remote-supplied name (server name, delegation or SRV target), not a local fault.
401		| NetError::Proto(_) if Name::from_utf8(host).is_err() =>
402			Err!(debug_error!(%host, error = %e, "Invalid DNS name")),
403		| NetError::Timeout => Err!(warn!(%host, "DNS {e}")),
404		| NetError::NoConnections => {
405			error!(
406				"Your DNS server is overloaded and has ran out of connections. It is strongly \
407				 recommended you remediate this issue to ensure proper federation connectivity."
408			);
409
410			Err!(error!(%host, "DNS error: {e}"))
411		},
412		| _ => Err!(error!(%host, "DNS error: {e}")),
413	}
414}
415
416#[implement(super::Service)]
417fn validate_dest(&self, dest: &ServerName, allow_self: bool) -> Result {
418	self.validate_self_destination(dest, allow_self)?;
419	self.validate_dest_address(dest)
420}
421
422#[implement(super::Service)]
423fn validate_self_destination(&self, dest: &ServerName, allow_self: bool) -> Result {
424	if !allow_self
425		&& dest == self.services.server.name
426		&& !self.services.server.config.federation.loopback
427	{
428		return Err!("Won't send federation request to ourselves");
429	}
430
431	Ok(())
432}
433
434#[implement(super::Service)]
435fn validate_dest_address(&self, dest: &ServerName) -> Result {
436	if dest.is_ip_literal() || unbracket(dest.host()).parse::<IpAddr>().is_ok() {
437		self.validate_dest_ip_literal(dest)?;
438	}
439
440	Ok(())
441}
442
443#[implement(super::Service)]
444fn validate_dest_ip_literal(&self, dest: &ServerName) -> Result {
445	trace!("Destination is an IP literal, checking against IP range denylist.",);
446	let ip = unbracket(dest.host()).parse().map_err(|e| {
447		err!(BadServerResponse(debug_error!("Failed to parse IP literal from string: {e}")))
448	})?;
449
450	if !self.services.client.valid_cidr_range_ip(ip) {
451		return Err!(BadServerResponse("Not allowed to send requests to this IP"));
452	}
453
454	Ok(())
455}