Skip to main content

tuwunel_service/resolver/
dns.rs

1use std::{
2	io,
3	io::ErrorKind::PermissionDenied,
4	net::{IpAddr, SocketAddr},
5	sync::Arc,
6	time::Duration,
7};
8
9use futures::FutureExt;
10use hickory_resolver::{
11	TokioResolver,
12	config::{LookupIpStrategy, NameServerConfig, ProtocolConfig, ResolverConfig, ResolverOpts},
13	lookup_ip::LookupIp,
14	net::runtime::TokioRuntimeProvider,
15	system_conf::read_system_conf,
16};
17use ipaddress::IPAddress;
18use reqwest::dns::{Addrs, Name, Resolve, Resolving};
19use tuwunel_core::{
20	Result, Server,
21	config::{network::Dns, proxy::ProxyHosts},
22	err, trace,
23};
24
25use super::cache::{Cache, CachedOverride};
26use crate::client::valid_cidr_range_ip;
27
28pub struct Resolver {
29	pub(crate) resolver: Arc<TokioResolver>,
30	pub(crate) passthru: Arc<Passthru>,
31	pub(crate) hooked: Arc<Hooked>,
32	server: Arc<Server>,
33}
34
35/// Filters destination DNS answers through the configured CIDR denylist.
36///
37/// Proxy endpoint names are exempt because their addresses describe the
38/// transport hop rather than the request destination.
39pub(crate) struct Validating<R> {
40	inner: Arc<R>,
41	denylist: Arc<[IPAddress]>,
42	proxy_hosts: ProxyHosts,
43}
44
45pub(crate) struct Hooked {
46	resolver: Arc<TokioResolver>,
47	passthru: Arc<Passthru>,
48	cache: Arc<Cache>,
49	server: Arc<Server>,
50}
51
52pub(crate) struct Passthru {
53	resolver: Arc<TokioResolver>,
54	server: Arc<Server>,
55}
56
57type ResolvingResult = Result<Addrs, Box<dyn std::error::Error + Send + Sync>>;
58
59impl Resolver {
60	pub(super) fn build(server: &Arc<Server>, cache: Arc<Cache>) -> Result<Arc<Self>> {
61		let (conf, opts) = Self::configure(server)?;
62		let opts = cache_opts(opts, &server.config.network.dns);
63		let resolver = Self::create(server, conf.clone(), opts.clone())?;
64		let opts = passthru_opts(opts);
65		let passthru = Arc::new(Passthru {
66			resolver: Self::create(server, conf, opts)?,
67			server: server.clone(),
68		});
69
70		Ok(Arc::new(Self {
71			hooked: Arc::new(Hooked {
72				resolver: resolver.clone(),
73				passthru: passthru.clone(),
74				server: server.clone(),
75				cache,
76			}),
77			server: server.clone(),
78			passthru,
79			resolver,
80		}))
81	}
82
83	fn create(
84		server: &Arc<Server>,
85		conf: ResolverConfig,
86		opts: ResolverOpts,
87	) -> Result<Arc<TokioResolver>> {
88		let mut builder =
89			TokioResolver::builder_with_config(conf, TokioRuntimeProvider::default());
90
91		*builder.options_mut() = Self::configure_opts(&server.config.network.dns, opts);
92
93		builder
94			.build()
95			.map(Arc::new)
96			.map_err(|e| err!(error!("Failed to build DNS resolver: {e}")))
97	}
98
99	fn configure(server: &Arc<Server>) -> Result<(ResolverConfig, ResolverOpts)> {
100		let config = &server.config;
101
102		// hickory's android system_conf panics in ndk-context without a JVM.
103		#[cfg(target_os = "android")]
104		if config.network.dns.servers.is_empty() {
105			return Err(err!(Config(
106				"network.dns.servers",
107				"The system resolver requires a JVM on Android; set network.dns.servers to your \
108				 upstream nameservers instead."
109			)));
110		}
111
112		let (base_conf, opts) = if config.network.dns.servers.is_empty() {
113			read_system_conf().map_err(|e| {
114				err!(error!("Failed to configure DNS resolver from `/etc/resolv.conf': {e}"))
115			})?
116		} else {
117			(Self::configure_custom(&config.network.dns.servers)?, ResolverOpts::default())
118		};
119
120		let name_servers = base_conf
121			.name_servers()
122			.iter()
123			.cloned()
124			.map(|mut ns| {
125				ns.trust_negative_responses = !config.network.dns.query_all_nameservers;
126				if config.network.dns.query_over_tcp_only {
127					ns.connections
128						.retain(|conn| matches!(conn.protocol, ProtocolConfig::Tcp));
129				}
130
131				ns
132			})
133			.collect();
134
135		let conf = ResolverConfig::from_parts(
136			base_conf.domain().cloned(),
137			base_conf.search().to_vec(),
138			name_servers,
139		);
140
141		Ok((conf, opts))
142	}
143
144	fn configure_custom(servers: &[String]) -> Result<ResolverConfig> {
145		let name_servers = servers
146			.iter()
147			.map(String::as_str)
148			.map(Self::parse_nameserver)
149			.collect::<Result<_>>()?;
150
151		Ok(ResolverConfig::from_parts(None, vec![], name_servers))
152	}
153
154	pub(super) fn parse_nameserver(server: &str) -> Result<NameServerConfig> {
155		let (ip, port) = server
156			.parse::<SocketAddr>()
157			.map(|addr| (addr.ip(), addr.port()))
158			.or_else(|_| server.parse::<IpAddr>().map(|ip| (ip, 53)))
159			.map_err(|e| {
160				err!(Config(
161					"network.dns.servers",
162					"{server:?} is not an IP address or socket address: {e}"
163				))
164			})?;
165
166		let mut conf = NameServerConfig::udp_and_tcp(ip);
167		for connection in &mut conf.connections {
168			connection.port = port;
169		}
170
171		Ok(conf)
172	}
173
174	fn configure_opts(config: &Dns, mut opts: ResolverOpts) -> ResolverOpts {
175		opts.negative_max_ttl = Some(Duration::from_hours(720));
176		opts.positive_max_ttl = Some(Duration::from_hours(168));
177		opts.timeout = Duration::from_secs(config.timeout);
178		opts.attempts = usize::from(config.attempts);
179		opts.try_tcp_on_error = config.tcp_fallback;
180		opts.num_concurrent_reqs = 1;
181		opts.edns0 = true;
182		opts.case_randomization = config.case_randomization;
183		opts.preserve_intermediates = true;
184		opts.ip_strategy = match config.ip_lookup_strategy {
185			| 1 => LookupIpStrategy::Ipv4Only,
186			| 2 => LookupIpStrategy::Ipv6Only,
187			| 3 => LookupIpStrategy::Ipv4AndIpv6,
188			| 4 => LookupIpStrategy::Ipv6thenIpv4,
189			| _ => LookupIpStrategy::Ipv4thenIpv6,
190		};
191
192		opts
193	}
194
195	/// Clear the in-memory hickory-dns caches
196	#[inline]
197	pub fn clear_cache(&self) { self.resolver.clear_cache(); }
198}
199
200fn cache_opts(mut opts: ResolverOpts, config: &Dns) -> ResolverOpts {
201	opts.negative_min_ttl = Some(Duration::from_secs(config.min_ttl_nxdomain));
202	opts.positive_min_ttl = Some(Duration::from_secs(config.min_ttl));
203	opts.cache_size = config.cache_entries.into();
204
205	opts
206}
207
208fn passthru_opts(mut opts: ResolverOpts) -> ResolverOpts {
209	opts.negative_min_ttl = Some(Duration::ZERO);
210	opts.positive_min_ttl = Some(Duration::ZERO);
211	opts.cache_size = ResolverOpts::default().cache_size;
212
213	opts
214}
215
216impl<R: Resolve + 'static> Validating<R> {
217	pub(crate) fn new(
218		inner: Arc<R>,
219		denylist: Arc<[IPAddress]>,
220		proxy_hosts: ProxyHosts,
221	) -> Arc<Self> {
222		Arc::new(Self { inner, denylist, proxy_hosts })
223	}
224}
225
226impl<R: Resolve + 'static> Resolve for Validating<R> {
227	fn resolve(&self, name: Name) -> Resolving {
228		if self
229			.proxy_hosts
230			.iter()
231			.any(|host| host.eq_ignore_ascii_case(name.as_str()))
232		{
233			return self.inner.resolve(name);
234		}
235
236		// type-erasure boundary
237		validate_addrs(self.inner.clone(), self.denylist.clone(), name).boxed()
238	}
239}
240
241async fn validate_addrs<R: Resolve + 'static>(
242	inner: Arc<R>,
243	denylist: Arc<[IPAddress]>,
244	name: Name,
245) -> ResolvingResult {
246	let addrs = inner.resolve(name).await?;
247
248	let mut filtered = addrs
249		.filter(move |sa| valid_cidr_range_ip(&denylist, sa.ip()))
250		.peekable();
251
252	if filtered.peek().is_none() {
253		return Err(Box::new(io::Error::new(
254			PermissionDenied,
255			"All resolved addresses are denied by network.http.ip_range_denylist",
256		)));
257	}
258
259	Ok(Box::new(filtered))
260}
261
262impl Resolve for Resolver {
263	fn resolve(&self, name: Name) -> Resolving {
264		let resolver = if self
265			.server
266			.config
267			.network
268			.dns
269			.passthru_domains
270			.is_match(name.as_str())
271		{
272			trace!(?name, "matched to passthru resolver");
273			&self.passthru.resolver
274		} else {
275			trace!(?name, "using primary resolver");
276			&self.resolver
277		};
278
279		// type-erasure boundary
280		resolve_to_reqwest(self.server.clone(), resolver.clone(), name).boxed()
281	}
282}
283
284impl Resolve for Hooked {
285	fn resolve(&self, name: Name) -> Resolving {
286		let resolver = if self
287			.server
288			.config
289			.network
290			.dns
291			.passthru_domains
292			.is_match(name.as_str())
293		{
294			trace!(?name, "matched to passthru resolver");
295			&self.passthru.resolver
296		} else {
297			trace!(?name, "using hooked resolver");
298			&self.resolver
299		};
300
301		// type-erasure boundary
302		hooked_resolve(self.cache.clone(), self.server.clone(), resolver.clone(), name).boxed()
303	}
304}
305
306impl Resolve for Passthru {
307	fn resolve(&self, name: Name) -> Resolving {
308		trace!(?name, "using passthru resolver");
309		// type-erasure boundary
310		resolve_to_reqwest(self.server.clone(), self.resolver.clone(), name).boxed()
311	}
312}
313
314#[tracing::instrument(
315	level = "debug",
316	skip_all,
317	fields(name = ?name.as_str())
318)]
319async fn hooked_resolve(
320	cache: Arc<Cache>,
321	server: Arc<Server>,
322	resolver: Arc<TokioResolver>,
323	name: Name,
324) -> Result<Addrs, Box<dyn std::error::Error + Send + Sync>> {
325	match cache.get_override(name.as_str()).await {
326		| Ok(cached) if cached.valid() => cached_to_reqwest(cached),
327		| Ok(CachedOverride { overriding, .. }) if overriding.is_some() =>
328			resolve_to_reqwest(
329				server,
330				resolver,
331				overriding
332					.as_deref()
333					.map(str::parse)
334					.expect("overriding is set for this record")
335					.expect("overriding is a valid internet name"),
336			)
337			.await,
338
339		| _ => resolve_to_reqwest(server, resolver, name).await,
340	}
341}
342
343async fn resolve_to_reqwest(
344	server: Arc<Server>,
345	resolver: Arc<TokioResolver>,
346	name: Name,
347) -> ResolvingResult {
348	use std::io::ErrorKind::Interrupted;
349
350	let handle_shutdown = || Box::new(io::Error::new(Interrupted, "Server shutting down"));
351
352	let handle_results = |results: LookupIp| -> Addrs {
353		let addrs = results
354			.iter()
355			.map(|ip| SocketAddr::new(ip, 0))
356			.collect::<Vec<_>>()
357			.into_iter();
358
359		Box::new(addrs)
360	};
361
362	tokio::select! {
363		results = resolver.lookup_ip(name.as_str()) => Ok(handle_results(results?)),
364		() = server.until_shutdown() => Err(handle_shutdown()),
365	}
366}
367
368fn cached_to_reqwest(cached: CachedOverride) -> ResolvingResult {
369	let addrs = cached
370		.ips
371		.into_iter()
372		.map(move |ip| SocketAddr::new(ip, cached.port));
373
374	Ok(Box::new(addrs))
375}