1 // Copyright 2011 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/dns/dns_util.h"
6
7 #include <errno.h>
8 #include <limits.h>
9 #include <stdint.h>
10
11 #include <cstring>
12 #include <string>
13 #include <string_view>
14 #include <unordered_map>
15 #include <vector>
16
17 #include "base/check_op.h"
18 #include "base/containers/contains.h"
19 #include "base/feature_list.h"
20 #include "base/metrics/field_trial.h"
21 #include "base/metrics/histogram_macros.h"
22 #include "base/numerics/byte_conversions.h"
23 #include "base/ranges/algorithm.h"
24 #include "base/strings/string_number_conversions.h"
25 #include "base/strings/string_split.h"
26 #include "build/build_config.h"
27 #include "net/dns/public/dns_protocol.h"
28 #include "net/dns/public/doh_provider_entry.h"
29 #include "net/dns/public/util.h"
30 #include "net/third_party/uri_template/uri_template.h"
31
32 #if BUILDFLAG(IS_POSIX)
33 #include <net/if.h>
34 #include <netinet/in.h>
35 #if !BUILDFLAG(IS_ANDROID)
36 #include <ifaddrs.h>
37 #endif // !BUILDFLAG(IS_ANDROID)
38 #endif // BUILDFLAG(IS_POSIX)
39
40 #if BUILDFLAG(IS_ANDROID)
41 #include "net/android/network_library.h"
42 #endif
43
44 namespace net {
45 namespace {
46
GetDohProviderEntriesFromNameservers(const std::vector<IPEndPoint> & dns_servers)47 DohProviderEntry::List GetDohProviderEntriesFromNameservers(
48 const std::vector<IPEndPoint>& dns_servers) {
49 const DohProviderEntry::List& providers = DohProviderEntry::GetList();
50 DohProviderEntry::List entries;
51
52 for (const auto& server : dns_servers) {
53 for (const net::DohProviderEntry* entry : providers) {
54 // DoH servers should only be added once.
55 // Note: Check whether the provider is enabled *after* we've determined
56 // that the IP addresses match so that if we are doing experimentation via
57 // Finch, the experiment only includes possible users of the
58 // corresponding DoH provider (since the client will be included in the
59 // experiment if the provider feature flag is checked).
60 if (base::Contains(entry->ip_addresses, server.address()) &&
61 base::FeatureList::IsEnabled(entry->feature.get()) &&
62 !base::Contains(entries, entry)) {
63 entries.push_back(entry);
64 }
65 }
66 }
67 return entries;
68 }
69
70 } // namespace
71
GetURLFromTemplateWithoutParameters(const string & server_template)72 std::string GetURLFromTemplateWithoutParameters(const string& server_template) {
73 std::string url_string;
74 std::unordered_map<string, string> parameters;
75 uri_template::Expand(server_template, parameters, &url_string);
76 return url_string;
77 }
78
79 namespace {
80
GetTimeDeltaForConnectionTypeFromFieldTrial(const char * field_trial,NetworkChangeNotifier::ConnectionType type,base::TimeDelta * out)81 bool GetTimeDeltaForConnectionTypeFromFieldTrial(
82 const char* field_trial,
83 NetworkChangeNotifier::ConnectionType type,
84 base::TimeDelta* out) {
85 std::string group = base::FieldTrialList::FindFullName(field_trial);
86 if (group.empty())
87 return false;
88 std::vector<std::string_view> group_parts = base::SplitStringPiece(
89 group, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
90 if (type < 0)
91 return false;
92 size_t type_size = static_cast<size_t>(type);
93 if (type_size >= group_parts.size())
94 return false;
95 int64_t ms;
96 if (!base::StringToInt64(group_parts[type_size], &ms))
97 return false;
98 *out = base::Milliseconds(ms);
99 return true;
100 }
101
102 } // namespace
103
GetTimeDeltaForConnectionTypeFromFieldTrialOrDefault(const char * field_trial,base::TimeDelta default_delta,NetworkChangeNotifier::ConnectionType type)104 base::TimeDelta GetTimeDeltaForConnectionTypeFromFieldTrialOrDefault(
105 const char* field_trial,
106 base::TimeDelta default_delta,
107 NetworkChangeNotifier::ConnectionType type) {
108 base::TimeDelta out;
109 if (!GetTimeDeltaForConnectionTypeFromFieldTrial(field_trial, type, &out))
110 out = default_delta;
111 return out;
112 }
113
CreateNamePointer(uint16_t offset)114 std::string CreateNamePointer(uint16_t offset) {
115 DCHECK_EQ(offset & ~dns_protocol::kOffsetMask, 0);
116 std::array<uint8_t, 2> buf = base::U16ToBigEndian(offset);
117 buf[0u] |= dns_protocol::kLabelPointer;
118 return std::string(buf.begin(), buf.end());
119 }
120
DnsQueryTypeToQtype(DnsQueryType dns_query_type)121 uint16_t DnsQueryTypeToQtype(DnsQueryType dns_query_type) {
122 switch (dns_query_type) {
123 case DnsQueryType::UNSPECIFIED:
124 NOTREACHED();
125 case DnsQueryType::A:
126 return dns_protocol::kTypeA;
127 case DnsQueryType::AAAA:
128 return dns_protocol::kTypeAAAA;
129 case DnsQueryType::TXT:
130 return dns_protocol::kTypeTXT;
131 case DnsQueryType::PTR:
132 return dns_protocol::kTypePTR;
133 case DnsQueryType::SRV:
134 return dns_protocol::kTypeSRV;
135 case DnsQueryType::HTTPS:
136 return dns_protocol::kTypeHttps;
137 }
138 }
139
AddressFamilyToDnsQueryType(AddressFamily address_family)140 DnsQueryType AddressFamilyToDnsQueryType(AddressFamily address_family) {
141 switch (address_family) {
142 case ADDRESS_FAMILY_UNSPECIFIED:
143 return DnsQueryType::UNSPECIFIED;
144 case ADDRESS_FAMILY_IPV4:
145 return DnsQueryType::A;
146 case ADDRESS_FAMILY_IPV6:
147 return DnsQueryType::AAAA;
148 default:
149 NOTREACHED();
150 }
151 }
152
GetDohUpgradeServersFromDotHostname(const std::string & dot_server)153 std::vector<DnsOverHttpsServerConfig> GetDohUpgradeServersFromDotHostname(
154 const std::string& dot_server) {
155 std::vector<DnsOverHttpsServerConfig> doh_servers;
156
157 if (dot_server.empty())
158 return doh_servers;
159
160 for (const net::DohProviderEntry* entry : DohProviderEntry::GetList()) {
161 // Note: Check whether the provider is enabled *after* we've determined that
162 // the hostnames match so that if we are doing experimentation via Finch,
163 // the experiment only includes possible users of the corresponding DoH
164 // provider (since the client will be included in the experiment if the
165 // provider feature flag is checked).
166 if (base::Contains(entry->dns_over_tls_hostnames, dot_server) &&
167 base::FeatureList::IsEnabled(entry->feature.get())) {
168 doh_servers.push_back(entry->doh_server_config);
169 }
170 }
171 return doh_servers;
172 }
173
GetDohUpgradeServersFromNameservers(const std::vector<IPEndPoint> & dns_servers)174 std::vector<DnsOverHttpsServerConfig> GetDohUpgradeServersFromNameservers(
175 const std::vector<IPEndPoint>& dns_servers) {
176 const auto entries = GetDohProviderEntriesFromNameservers(dns_servers);
177 std::vector<DnsOverHttpsServerConfig> doh_servers;
178 doh_servers.reserve(entries.size());
179 base::ranges::transform(entries, std::back_inserter(doh_servers),
180 &DohProviderEntry::doh_server_config);
181 return doh_servers;
182 }
183
GetDohProviderIdForHistogramFromServerConfig(const DnsOverHttpsServerConfig & doh_server)184 std::string GetDohProviderIdForHistogramFromServerConfig(
185 const DnsOverHttpsServerConfig& doh_server) {
186 const auto& entries = DohProviderEntry::GetList();
187 const auto it = base::ranges::find(entries, doh_server,
188 &DohProviderEntry::doh_server_config);
189 return it != entries.end() ? std::string((*it)->provider) : "Other";
190 }
191
GetDohProviderIdForHistogramFromNameserver(const IPEndPoint & nameserver)192 std::string GetDohProviderIdForHistogramFromNameserver(
193 const IPEndPoint& nameserver) {
194 const auto entries = GetDohProviderEntriesFromNameservers({nameserver});
195 return entries.empty() ? "Other" : std::string(entries[0]->provider);
196 }
197
SecureDnsModeToString(const SecureDnsMode secure_dns_mode)198 std::string SecureDnsModeToString(const SecureDnsMode secure_dns_mode) {
199 switch (secure_dns_mode) {
200 case SecureDnsMode::kOff:
201 return "Off";
202 case SecureDnsMode::kAutomatic:
203 return "Automatic";
204 case SecureDnsMode::kSecure:
205 return "Secure";
206 }
207 }
208
209 } // namespace net
210