tuwunel_service/resolver/
dns.rs1use 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
35pub(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 #[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 #[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 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 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 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 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}