host_resolver.cc 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481
  1. // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "net/dns/host_resolver.h"
  5. #include <set>
  6. #include <string>
  7. #include <utility>
  8. #include <vector>
  9. #include "base/bind.h"
  10. #include "base/check.h"
  11. #include "base/no_destructor.h"
  12. #include "base/notreached.h"
  13. #include "base/ranges/algorithm.h"
  14. #include "base/strings/string_number_conversions.h"
  15. #include "base/time/time_delta_from_string.h"
  16. #include "base/values.h"
  17. #include "net/base/address_list.h"
  18. #include "net/base/features.h"
  19. #include "net/base/net_errors.h"
  20. #include "net/base/network_change_notifier.h"
  21. #include "net/dns/context_host_resolver.h"
  22. #include "net/dns/dns_client.h"
  23. #include "net/dns/dns_util.h"
  24. #include "net/dns/host_cache.h"
  25. #include "net/dns/host_resolver_manager.h"
  26. #include "net/dns/host_resolver_results.h"
  27. #include "net/dns/mapped_host_resolver.h"
  28. #include "net/dns/resolve_context.h"
  29. #include "third_party/abseil-cpp/absl/types/optional.h"
  30. #if BUILDFLAG(IS_ANDROID)
  31. #include "base/android/build_info.h"
  32. #include "net/android/network_library.h"
  33. #endif // BUILDFLAG(IS_ANDROID)
  34. namespace net {
  35. namespace {
  36. // The experiment settings of features::kUseDnsHttpsSvcb. See the comments in
  37. // net/base/features.h for more details.
  38. const char kUseDnsHttpsSvcbEnable[] = "enable";
  39. const char kUseDnsHttpsSvcbEnableInsecure[] = "enable_insecure";
  40. const char kUseDnsHttpsSvcbInsecureExtraTimeMax[] = "insecure_extra_time_max";
  41. const char kUseDnsHttpsSvcbInsecureExtraTimePercent[] =
  42. "insecure_extra_time_percent";
  43. const char kUseDnsHttpsSvcbInsecureExtraTimeMin[] = "insecure_extra_time_min";
  44. const char kUseDnsHttpsSvcbSecureExtraTimeMax[] = "secure_extra_time_max";
  45. const char kUseDnsHttpsSvcbSecureExtraTimePercent[] =
  46. "secure_extra_time_percent";
  47. const char kUseDnsHttpsSvcbSecureExtraTimeMin[] = "secure_extra_time_min";
  48. const char kUseDnsHttpsSvcbExtraTimeAbsolute[] = "extra_time_absolute";
  49. const char kUseDnsHttpsSvcbExtraTimePercent[] = "extra_time_percent";
  50. class FailingRequestImpl : public HostResolver::ResolveHostRequest,
  51. public HostResolver::ProbeRequest {
  52. public:
  53. explicit FailingRequestImpl(int error) : error_(error) {}
  54. FailingRequestImpl(const FailingRequestImpl&) = delete;
  55. FailingRequestImpl& operator=(const FailingRequestImpl&) = delete;
  56. ~FailingRequestImpl() override = default;
  57. int Start(CompletionOnceCallback callback) override { return error_; }
  58. int Start() override { return error_; }
  59. AddressList* GetAddressResults() const override { return nullptr; }
  60. std::vector<HostResolverEndpointResult>* GetEndpointResults() const override {
  61. return nullptr;
  62. }
  63. const absl::optional<std::vector<std::string>>& GetTextResults()
  64. const override {
  65. static const base::NoDestructor<absl::optional<std::vector<std::string>>>
  66. nullopt_result;
  67. return *nullopt_result;
  68. }
  69. const absl::optional<std::vector<HostPortPair>>& GetHostnameResults()
  70. const override {
  71. static const base::NoDestructor<absl::optional<std::vector<HostPortPair>>>
  72. nullopt_result;
  73. return *nullopt_result;
  74. }
  75. const std::set<std::string>* GetDnsAliasResults() const override {
  76. return nullptr;
  77. }
  78. ResolveErrorInfo GetResolveErrorInfo() const override {
  79. return ResolveErrorInfo(error_);
  80. }
  81. const absl::optional<HostCache::EntryStaleness>& GetStaleInfo()
  82. const override {
  83. static const absl::optional<HostCache::EntryStaleness> nullopt_result;
  84. return nullopt_result;
  85. }
  86. private:
  87. const int error_;
  88. };
  89. bool EndpointResultIsNonProtocol(const HostResolverEndpointResult& result) {
  90. return result.metadata.supported_protocol_alpns.empty();
  91. }
  92. void GetTimeDeltaFromDictString(const base::Value::Dict& args,
  93. base::StringPiece key,
  94. base::TimeDelta* out) {
  95. const std::string* value_string = args.FindString(key);
  96. if (!value_string)
  97. return;
  98. *out = base::TimeDeltaFromString(*value_string).value_or(*out);
  99. }
  100. } // namespace
  101. HostResolver::HttpsSvcbOptions::HttpsSvcbOptions() = default;
  102. HostResolver::HttpsSvcbOptions::HttpsSvcbOptions(
  103. const HttpsSvcbOptions& other) = default;
  104. HostResolver::HttpsSvcbOptions::HttpsSvcbOptions(HttpsSvcbOptions&& other) =
  105. default;
  106. HostResolver::HttpsSvcbOptions::~HttpsSvcbOptions() = default;
  107. // static
  108. HostResolver::HttpsSvcbOptions HostResolver::HttpsSvcbOptions::FromDict(
  109. const base::Value::Dict& dict) {
  110. net::HostResolver::HttpsSvcbOptions options;
  111. options.enable =
  112. dict.FindBool(kUseDnsHttpsSvcbEnable).value_or(options.enable);
  113. options.enable_insecure = dict.FindBool(kUseDnsHttpsSvcbEnableInsecure)
  114. .value_or(options.enable_insecure);
  115. GetTimeDeltaFromDictString(dict, kUseDnsHttpsSvcbInsecureExtraTimeMax,
  116. &options.insecure_extra_time_max);
  117. options.insecure_extra_time_percent =
  118. dict.FindInt(kUseDnsHttpsSvcbInsecureExtraTimePercent)
  119. .value_or(options.insecure_extra_time_percent);
  120. GetTimeDeltaFromDictString(dict, kUseDnsHttpsSvcbInsecureExtraTimeMin,
  121. &options.insecure_extra_time_min);
  122. GetTimeDeltaFromDictString(dict, kUseDnsHttpsSvcbSecureExtraTimeMax,
  123. &options.secure_extra_time_max);
  124. options.secure_extra_time_percent =
  125. dict.FindInt(kUseDnsHttpsSvcbSecureExtraTimePercent)
  126. .value_or(options.secure_extra_time_percent);
  127. GetTimeDeltaFromDictString(dict, kUseDnsHttpsSvcbSecureExtraTimeMin,
  128. &options.secure_extra_time_min);
  129. GetTimeDeltaFromDictString(dict, kUseDnsHttpsSvcbExtraTimeAbsolute,
  130. &options.extra_time_absolute);
  131. options.extra_time_percent = dict.FindInt(kUseDnsHttpsSvcbExtraTimePercent)
  132. .value_or(options.extra_time_percent);
  133. return options;
  134. }
  135. // static
  136. HostResolver::HttpsSvcbOptions HostResolver::HttpsSvcbOptions::FromFeatures() {
  137. net::HostResolver::HttpsSvcbOptions options;
  138. options.enable = base::FeatureList::IsEnabled(features::kUseDnsHttpsSvcb);
  139. options.enable_insecure = features::kUseDnsHttpsSvcbEnableInsecure.Get();
  140. options.insecure_extra_time_max =
  141. features::kUseDnsHttpsSvcbInsecureExtraTimeMax.Get();
  142. options.insecure_extra_time_percent =
  143. features::kUseDnsHttpsSvcbInsecureExtraTimePercent.Get();
  144. options.insecure_extra_time_min =
  145. features::kUseDnsHttpsSvcbInsecureExtraTimeMin.Get();
  146. options.secure_extra_time_max =
  147. features::kUseDnsHttpsSvcbSecureExtraTimeMax.Get();
  148. options.secure_extra_time_percent =
  149. features::kUseDnsHttpsSvcbSecureExtraTimePercent.Get();
  150. options.secure_extra_time_min =
  151. features::kUseDnsHttpsSvcbSecureExtraTimeMin.Get();
  152. options.extra_time_absolute =
  153. features::kUseDnsHttpsSvcbExtraTimeAbsolute.Get();
  154. options.extra_time_percent = features::kUseDnsHttpsSvcbExtraTimePercent.Get();
  155. return options;
  156. }
  157. HostResolver::ManagerOptions::ManagerOptions() = default;
  158. HostResolver::ManagerOptions::ManagerOptions(const ManagerOptions& other) =
  159. default;
  160. HostResolver::ManagerOptions::ManagerOptions(ManagerOptions&& other) = default;
  161. HostResolver::ManagerOptions::~ManagerOptions() = default;
  162. const std::vector<bool>*
  163. HostResolver::ResolveHostRequest::GetExperimentalResultsForTesting() const {
  164. NOTREACHED();
  165. return nullptr;
  166. }
  167. const size_t HostResolver::ManagerOptions::kDefaultRetryAttempts =
  168. static_cast<size_t>(-1);
  169. std::unique_ptr<HostResolver> HostResolver::Factory::CreateResolver(
  170. HostResolverManager* manager,
  171. base::StringPiece host_mapping_rules,
  172. bool enable_caching) {
  173. return HostResolver::CreateResolver(manager, host_mapping_rules,
  174. enable_caching);
  175. }
  176. std::unique_ptr<HostResolver> HostResolver::Factory::CreateStandaloneResolver(
  177. NetLog* net_log,
  178. const ManagerOptions& options,
  179. base::StringPiece host_mapping_rules,
  180. bool enable_caching) {
  181. return HostResolver::CreateStandaloneResolver(
  182. net_log, options, host_mapping_rules, enable_caching);
  183. }
  184. HostResolver::ResolveHostParameters::ResolveHostParameters() = default;
  185. HostResolver::ResolveHostParameters::ResolveHostParameters(
  186. const ResolveHostParameters& other) = default;
  187. HostResolver::~HostResolver() = default;
  188. std::unique_ptr<HostResolver::ProbeRequest>
  189. HostResolver::CreateDohProbeRequest() {
  190. // Should be overridden in any HostResolver implementation where this method
  191. // may be called.
  192. NOTREACHED();
  193. return nullptr;
  194. }
  195. std::unique_ptr<HostResolver::MdnsListener> HostResolver::CreateMdnsListener(
  196. const HostPortPair& host,
  197. DnsQueryType query_type) {
  198. // Should be overridden in any HostResolver implementation where this method
  199. // may be called.
  200. NOTREACHED();
  201. return nullptr;
  202. }
  203. HostCache* HostResolver::GetHostCache() {
  204. return nullptr;
  205. }
  206. base::Value HostResolver::GetDnsConfigAsValue() const {
  207. return base::Value(base::Value::Type::DICTIONARY);
  208. }
  209. void HostResolver::SetRequestContext(URLRequestContext* request_context) {
  210. // Should be overridden in any HostResolver implementation where this method
  211. // may be called.
  212. NOTREACHED();
  213. }
  214. HostResolverManager* HostResolver::GetManagerForTesting() {
  215. // Should be overridden in any HostResolver implementation where this method
  216. // may be called.
  217. NOTREACHED();
  218. return nullptr;
  219. }
  220. const URLRequestContext* HostResolver::GetContextForTesting() const {
  221. // Should be overridden in any HostResolver implementation where this method
  222. // may be called.
  223. NOTREACHED();
  224. return nullptr;
  225. }
  226. handles::NetworkHandle HostResolver::GetTargetNetworkForTesting() const {
  227. return handles::kInvalidNetworkHandle;
  228. }
  229. // static
  230. std::unique_ptr<HostResolver> HostResolver::CreateResolver(
  231. HostResolverManager* manager,
  232. base::StringPiece host_mapping_rules,
  233. bool enable_caching) {
  234. DCHECK(manager);
  235. auto resolve_context = std::make_unique<ResolveContext>(
  236. nullptr /* url_request_context */, enable_caching);
  237. auto resolver = std::make_unique<ContextHostResolver>(
  238. manager, std::move(resolve_context));
  239. if (host_mapping_rules.empty())
  240. return resolver;
  241. auto remapped_resolver =
  242. std::make_unique<MappedHostResolver>(std::move(resolver));
  243. remapped_resolver->SetRulesFromString(host_mapping_rules);
  244. return remapped_resolver;
  245. }
  246. // static
  247. std::unique_ptr<HostResolver> HostResolver::CreateStandaloneResolver(
  248. NetLog* net_log,
  249. absl::optional<ManagerOptions> options,
  250. base::StringPiece host_mapping_rules,
  251. bool enable_caching) {
  252. std::unique_ptr<ContextHostResolver> resolver =
  253. CreateStandaloneContextResolver(net_log, std::move(options),
  254. enable_caching);
  255. if (host_mapping_rules.empty())
  256. return resolver;
  257. auto remapped_resolver =
  258. std::make_unique<MappedHostResolver>(std::move(resolver));
  259. remapped_resolver->SetRulesFromString(host_mapping_rules);
  260. return remapped_resolver;
  261. }
  262. // static
  263. std::unique_ptr<ContextHostResolver>
  264. HostResolver::CreateStandaloneContextResolver(
  265. NetLog* net_log,
  266. absl::optional<ManagerOptions> options,
  267. bool enable_caching) {
  268. auto resolve_context = std::make_unique<ResolveContext>(
  269. nullptr /* url_request_context */, enable_caching);
  270. return std::make_unique<ContextHostResolver>(
  271. std::make_unique<HostResolverManager>(
  272. std::move(options).value_or(ManagerOptions()),
  273. NetworkChangeNotifier::GetSystemDnsConfigNotifier(), net_log),
  274. std::move(resolve_context));
  275. }
  276. // static
  277. std::unique_ptr<HostResolver>
  278. HostResolver::CreateStandaloneNetworkBoundResolver(
  279. NetLog* net_log,
  280. handles::NetworkHandle target_network,
  281. absl::optional<ManagerOptions> options,
  282. base::StringPiece host_mapping_rules,
  283. bool enable_caching) {
  284. #if BUILDFLAG(IS_ANDROID)
  285. // Note that the logic below uses Android APIs that don't work on a sandboxed
  286. // process: This is not problematic because this function is used only by
  287. // Cronet which doesn't enable sandboxing.
  288. auto resolve_context = std::make_unique<ResolveContext>(
  289. nullptr /*url_request_context */, enable_caching);
  290. auto manager_options = std::move(options).value_or(ManagerOptions());
  291. // Support the use of the built-in resolver when possible.
  292. bool is_builtin_resolver_supported =
  293. manager_options.insecure_dns_client_enabled &&
  294. base::android::BuildInfo::GetInstance()->sdk_int() >=
  295. base::android::SDK_VERSION_P;
  296. if (is_builtin_resolver_supported) {
  297. // Pre-existing DnsConfigOverrides is currently ignored, consider extending
  298. // if a use case arises.
  299. DCHECK(manager_options.dns_config_overrides == DnsConfigOverrides());
  300. std::vector<IPEndPoint> dns_servers;
  301. bool dns_over_tls_active;
  302. std::string dns_over_tls_hostname;
  303. std::vector<std::string> search_suffixes;
  304. if (android::GetDnsServersForNetwork(&dns_servers, &dns_over_tls_active,
  305. &dns_over_tls_hostname,
  306. &search_suffixes, target_network)) {
  307. DnsConfigOverrides dns_config_overrides =
  308. DnsConfigOverrides::CreateOverridingEverythingWithDefaults();
  309. dns_config_overrides.nameservers = dns_servers;
  310. // Android APIs don't specify whether to use DoT or DoH. So, leave the
  311. // decision to `DnsConfig::allow_dns_over_https_upgrade` default value.
  312. dns_config_overrides.dns_over_tls_active = dns_over_tls_active;
  313. dns_config_overrides.dns_over_tls_hostname = dns_over_tls_hostname;
  314. dns_config_overrides.search = search_suffixes;
  315. manager_options.dns_config_overrides = dns_config_overrides;
  316. // Regardless of DoH vs DoT, the important contract to respect is not to
  317. // perform insecure DNS lookups if `dns_over_tls_active` == true.
  318. manager_options.additional_types_via_insecure_dns_enabled =
  319. !dns_over_tls_active;
  320. } else {
  321. // Disable when android::GetDnsServersForNetwork fails.
  322. is_builtin_resolver_supported = false;
  323. }
  324. }
  325. manager_options.insecure_dns_client_enabled = is_builtin_resolver_supported;
  326. return std::make_unique<ContextHostResolver>(
  327. HostResolverManager::CreateNetworkBoundHostResolverManager(
  328. manager_options, target_network, net_log),
  329. std::move(resolve_context));
  330. #else // !BUILDFLAG(IS_ANDROID)
  331. NOTIMPLEMENTED();
  332. return nullptr;
  333. #endif // BUILDFLAG(IS_ANDROID)
  334. }
  335. // static
  336. AddressFamily HostResolver::DnsQueryTypeSetToAddressFamily(
  337. DnsQueryTypeSet dns_query_types) {
  338. DCHECK(HasAddressType(dns_query_types));
  339. // If the set of query types contains A and AAAA, defer the choice of address
  340. // family. Otherwise, pick the corresponding address family.
  341. if (dns_query_types.HasAll({DnsQueryType::A, DnsQueryType::AAAA}))
  342. return ADDRESS_FAMILY_UNSPECIFIED;
  343. if (dns_query_types.Has(DnsQueryType::AAAA))
  344. return ADDRESS_FAMILY_IPV6;
  345. DCHECK(dns_query_types.Has(DnsQueryType::A));
  346. return ADDRESS_FAMILY_IPV4;
  347. }
  348. // static
  349. HostResolverFlags HostResolver::ParametersToHostResolverFlags(
  350. const ResolveHostParameters& parameters) {
  351. HostResolverFlags flags = 0;
  352. if (parameters.include_canonical_name)
  353. flags |= HOST_RESOLVER_CANONNAME;
  354. if (parameters.loopback_only)
  355. flags |= HOST_RESOLVER_LOOPBACK_ONLY;
  356. if (parameters.avoid_multicast_resolution)
  357. flags |= HOST_RESOLVER_AVOID_MULTICAST;
  358. return flags;
  359. }
  360. // static
  361. int HostResolver::SquashErrorCode(int error) {
  362. // TODO(crbug.com/1043281): Consider squashing ERR_INTERNET_DISCONNECTED.
  363. if (error == OK || error == ERR_IO_PENDING ||
  364. error == ERR_INTERNET_DISCONNECTED || error == ERR_NAME_NOT_RESOLVED ||
  365. error == ERR_DNS_NAME_HTTPS_ONLY) {
  366. return error;
  367. } else {
  368. return ERR_NAME_NOT_RESOLVED;
  369. }
  370. }
  371. // static
  372. std::vector<HostResolverEndpointResult>
  373. HostResolver::AddressListToEndpointResults(const AddressList& address_list) {
  374. HostResolverEndpointResult connection_endpoint;
  375. connection_endpoint.ip_endpoints = address_list.endpoints();
  376. std::vector<HostResolverEndpointResult> list;
  377. list.push_back(std::move(connection_endpoint));
  378. return list;
  379. }
  380. // static
  381. AddressList HostResolver::EndpointResultToAddressList(
  382. const std::vector<HostResolverEndpointResult>& endpoints,
  383. const std::set<std::string>& aliases) {
  384. AddressList list;
  385. auto non_protocol_endpoint =
  386. base::ranges::find_if(endpoints, &EndpointResultIsNonProtocol);
  387. if (non_protocol_endpoint == endpoints.end())
  388. return list;
  389. list.endpoints() = non_protocol_endpoint->ip_endpoints;
  390. std::vector<std::string> aliases_vector(aliases.begin(), aliases.end());
  391. list.SetDnsAliases(std::move(aliases_vector));
  392. return list;
  393. }
  394. HostResolver::HostResolver() = default;
  395. // static
  396. std::unique_ptr<HostResolver::ResolveHostRequest>
  397. HostResolver::CreateFailingRequest(int error) {
  398. return std::make_unique<FailingRequestImpl>(error);
  399. }
  400. // static
  401. std::unique_ptr<HostResolver::ProbeRequest>
  402. HostResolver::CreateFailingProbeRequest(int error) {
  403. return std::make_unique<FailingRequestImpl>(error);
  404. }
  405. } // namespace net