mirror of
https://github.com/tailscale/tailscale.git
synced 2026-05-05 12:16:44 +02:00
8d875a301c
Someone asked me if we use DNS-over-HTTPS if the system's resolver is an IP address that supports DoH and there's no global nameserver set (i.e. no "Override DNS servers" set). I didn't know the answer offhand, and it took a while for me to figure it out. The answer is yes, in cases where we take over the system's DNS configuration and read the base config, we do upgrade any DoH-capable resolver to use DoH. Here's a test that verifies this behaviour (and hopefully helps as documentation the next time someone has this question). Updates #cleanup Signed-off-by: Andrew Dunham <andrew@tailscale.com>
408 lines
15 KiB
Go
408 lines
15 KiB
Go
// Copyright (c) Tailscale Inc & contributors
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
// Package publicdns contains mapping and helpers for working with
|
|
// public DNS providers.
|
|
package publicdns
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"log"
|
|
"math/big"
|
|
"net/netip"
|
|
"slices"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
|
|
"tailscale.com/feature/buildfeatures"
|
|
"tailscale.com/util/testenv"
|
|
)
|
|
|
|
// dohOfIP maps from public DNS IPs to their DoH base URL.
|
|
//
|
|
// This does not include NextDNS which is handled specially.
|
|
var dohOfIP = map[netip.Addr]string{} // 8.8.8.8 => "https://..."
|
|
|
|
var dohIPsOfBase = map[string][]netip.Addr{}
|
|
var populateOnce sync.Once
|
|
|
|
const (
|
|
nextDNSBase = "https://dns.nextdns.io/"
|
|
controlDBase = "https://dns.controld.com/"
|
|
)
|
|
|
|
// DoHEndpointFromIP returns the DNS-over-HTTPS base URL for a given IP
|
|
// and whether it's DoH-only (not speaking DNS on port 53).
|
|
//
|
|
// The ok result is whether the IP is a known DNS server.
|
|
func DoHEndpointFromIP(ip netip.Addr) (dohBase string, dohOnly bool, ok bool) {
|
|
populateOnce.Do(populate)
|
|
if b, ok := dohOfIP[ip]; ok {
|
|
return b, false, true
|
|
}
|
|
|
|
// NextDNS DoH URLs are of the form "https://dns.nextdns.io/c3a884"
|
|
// where the path component is the lower 12 bytes of the IPv6 address
|
|
// in lowercase hex without any zero padding.
|
|
if nextDNSv6RangeA.Contains(ip) || nextDNSv6RangeB.Contains(ip) {
|
|
a := ip.As16()
|
|
var sb strings.Builder
|
|
sb.Grow(len(nextDNSBase) + 12)
|
|
sb.WriteString(nextDNSBase)
|
|
for _, b := range bytes.TrimLeft(a[4:], "\x00") {
|
|
fmt.Fprintf(&sb, "%02x", b)
|
|
}
|
|
return sb.String(), true, true
|
|
}
|
|
|
|
// Control D DoH URLs are of the form "https://dns.controld.com/8yezwenugs"
|
|
// where the path component is represented by 8 bytes (7-14) of the IPv6 address in base36
|
|
if controlDv6RangeA.Contains(ip) || controlDv6RangeB.Contains(ip) {
|
|
path := big.NewInt(0).SetBytes(ip.AsSlice()[6:14]).Text(36)
|
|
return controlDBase + path, true, true
|
|
}
|
|
|
|
return "", false, false
|
|
}
|
|
|
|
// KnownDoHPrefixes returns the list of DoH base URLs.
|
|
//
|
|
// It returns a new copy each time, sorted. It's meant for tests.
|
|
//
|
|
// It does not include providers that have customer-specific DoH URLs like
|
|
// NextDNS.
|
|
func KnownDoHPrefixes() []string {
|
|
populateOnce.Do(populate)
|
|
ret := make([]string, 0, len(dohIPsOfBase))
|
|
for b := range dohIPsOfBase {
|
|
ret = append(ret, b)
|
|
}
|
|
sort.Strings(ret)
|
|
return ret
|
|
}
|
|
|
|
func isSlashOrQuestionMark(r rune) bool {
|
|
return r == '/' || r == '?'
|
|
}
|
|
|
|
// DoHIPsOfBase returns the IP addresses to use to dial the provided DoH base
|
|
// URL.
|
|
//
|
|
// It is basically the inverse of DoHEndpointFromIP with the exception that for
|
|
// NextDNS it returns IPv4 addresses that DoHEndpointFromIP doesn't map back.
|
|
func DoHIPsOfBase(dohBase string) []netip.Addr {
|
|
populateOnce.Do(populate)
|
|
if s := dohIPsOfBase[dohBase]; len(s) > 0 {
|
|
return s
|
|
}
|
|
if hexStr, ok := strings.CutPrefix(dohBase, nextDNSBase); ok {
|
|
// The path is of the form /<profile-hex>[/<hostname>/<model>/<device id>...]
|
|
// or /<profile-hex>?<query params>
|
|
// but only the <profile-hex> is required. Ignore the rest:
|
|
if i := strings.IndexFunc(hexStr, isSlashOrQuestionMark); i != -1 {
|
|
hexStr = hexStr[:i]
|
|
}
|
|
|
|
// TODO(bradfitz): using the NextDNS anycast addresses works but is not
|
|
// ideal. Some of their regions have better latency via a non-anycast IP
|
|
// which we could get by first resolving A/AAAA "dns.nextdns.io" over
|
|
// DoH using their anycast address. For now we only use the anycast
|
|
// addresses. The IPv4 IPs we use are just the first one in their ranges.
|
|
// For IPv6 we put the profile ID in the lower bytes, but that seems just
|
|
// conventional for them and not required (it'll already be in the DoH path).
|
|
// (Really we shouldn't use either IPv4 or IPv6 anycast for DoH once we
|
|
// resolve "dns.nextdns.io".)
|
|
if b, err := hex.DecodeString(hexStr); err == nil && len(b) <= 12 && len(b) > 0 {
|
|
return []netip.Addr{
|
|
nextDNSv4One,
|
|
nextDNSv4Two,
|
|
nextDNSv6Gen(nextDNSv6RangeA.Addr(), b),
|
|
nextDNSv6Gen(nextDNSv6RangeB.Addr(), b),
|
|
}
|
|
}
|
|
}
|
|
if pathStr, ok := strings.CutPrefix(dohBase, controlDBase); ok {
|
|
if i := strings.IndexFunc(pathStr, isSlashOrQuestionMark); i != -1 {
|
|
pathStr = pathStr[:i]
|
|
}
|
|
return []netip.Addr{
|
|
controlDv4One,
|
|
controlDv4Two,
|
|
controlDv6Gen(controlDv6RangeA.Addr(), pathStr),
|
|
controlDv6Gen(controlDv6RangeB.Addr(), pathStr),
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// DoHV6 returns the first IPv6 DNS address from a given public DNS provider
|
|
// if found, along with a boolean indicating success.
|
|
func DoHV6(base string) (ip netip.Addr, ok bool) {
|
|
populateOnce.Do(populate)
|
|
for _, ip := range dohIPsOfBase[base] {
|
|
if ip.Is6() {
|
|
return ip, true
|
|
}
|
|
}
|
|
return ip, false
|
|
}
|
|
|
|
// addDoH parses a given well-formed ip string into a netip.Addr type and
|
|
// adds it to both knownDoH and dohIPsOFBase maps.
|
|
func addDoH(ipStr, base string) {
|
|
ip := netip.MustParseAddr(ipStr)
|
|
dohOfIP[ip] = base
|
|
dohIPsOfBase[base] = append(dohIPsOfBase[base], ip)
|
|
}
|
|
|
|
const (
|
|
wikimediaDNSv4 = "185.71.138.138"
|
|
wikimediaDNSv6 = "2001:67c:930::1"
|
|
)
|
|
|
|
// populate is called once to initialize the knownDoH and dohIPsOfBase maps.
|
|
func populate() {
|
|
if !buildfeatures.HasDNS {
|
|
return
|
|
}
|
|
// Cloudflare
|
|
// https://developers.cloudflare.com/1.1.1.1/ip-addresses/
|
|
addDoH("1.1.1.1", "https://cloudflare-dns.com/dns-query")
|
|
addDoH("1.0.0.1", "https://cloudflare-dns.com/dns-query")
|
|
addDoH("2606:4700:4700::1111", "https://cloudflare-dns.com/dns-query")
|
|
addDoH("2606:4700:4700::1001", "https://cloudflare-dns.com/dns-query")
|
|
|
|
// Cloudflare -Malware
|
|
addDoH("1.1.1.2", "https://security.cloudflare-dns.com/dns-query")
|
|
addDoH("1.0.0.2", "https://security.cloudflare-dns.com/dns-query")
|
|
addDoH("2606:4700:4700::1112", "https://security.cloudflare-dns.com/dns-query")
|
|
addDoH("2606:4700:4700::1002", "https://security.cloudflare-dns.com/dns-query")
|
|
|
|
// Cloudflare -Malware -Adult
|
|
addDoH("1.1.1.3", "https://family.cloudflare-dns.com/dns-query")
|
|
addDoH("1.0.0.3", "https://family.cloudflare-dns.com/dns-query")
|
|
addDoH("2606:4700:4700::1113", "https://family.cloudflare-dns.com/dns-query")
|
|
addDoH("2606:4700:4700::1003", "https://family.cloudflare-dns.com/dns-query")
|
|
|
|
// Google
|
|
addDoH("8.8.8.8", "https://dns.google/dns-query")
|
|
addDoH("8.8.4.4", "https://dns.google/dns-query")
|
|
addDoH("2001:4860:4860::8888", "https://dns.google/dns-query")
|
|
addDoH("2001:4860:4860::8844", "https://dns.google/dns-query")
|
|
|
|
// OpenDNS
|
|
// TODO(bradfitz): OpenDNS is unique amongst this current set in that
|
|
// its DoH DNS names resolve to different IPs than its normal DNS
|
|
// IPs. Support that later. For now we assume that they're the same.
|
|
// addDoH("208.67.222.222", "https://doh.opendns.com/dns-query")
|
|
// addDoH("208.67.220.220", "https://doh.opendns.com/dns-query")
|
|
// addDoH("208.67.222.123", "https://doh.familyshield.opendns.com/dns-query")
|
|
// addDoH("208.67.220.123", "https://doh.familyshield.opendns.com/dns-query")
|
|
|
|
// Quad9
|
|
// https://www.quad9.net/service/service-addresses-and-features
|
|
addDoH("9.9.9.9", "https://dns.quad9.net/dns-query")
|
|
addDoH("149.112.112.112", "https://dns.quad9.net/dns-query")
|
|
addDoH("2620:fe::fe", "https://dns.quad9.net/dns-query")
|
|
addDoH("2620:fe::9", "https://dns.quad9.net/dns-query")
|
|
|
|
// Quad9 +ECS +DNSSEC
|
|
addDoH("9.9.9.11", "https://dns11.quad9.net/dns-query")
|
|
addDoH("149.112.112.11", "https://dns11.quad9.net/dns-query")
|
|
addDoH("2620:fe::11", "https://dns11.quad9.net/dns-query")
|
|
addDoH("2620:fe::fe:11", "https://dns11.quad9.net/dns-query")
|
|
|
|
// Quad9 -DNSSEC
|
|
addDoH("9.9.9.10", "https://dns10.quad9.net/dns-query")
|
|
addDoH("149.112.112.10", "https://dns10.quad9.net/dns-query")
|
|
addDoH("2620:fe::10", "https://dns10.quad9.net/dns-query")
|
|
addDoH("2620:fe::fe:10", "https://dns10.quad9.net/dns-query")
|
|
|
|
// Mullvad
|
|
// See https://mullvad.net/en/help/dns-over-https-and-dns-over-tls/
|
|
// Mullvad (default)
|
|
addDoH("194.242.2.2", "https://dns.mullvad.net/dns-query")
|
|
addDoH("2a07:e340::2", "https://dns.mullvad.net/dns-query")
|
|
// Mullvad (adblock)
|
|
addDoH("194.242.2.3", "https://adblock.dns.mullvad.net/dns-query")
|
|
addDoH("2a07:e340::3", "https://adblock.dns.mullvad.net/dns-query")
|
|
// Mullvad (base)
|
|
addDoH("194.242.2.4", "https://base.dns.mullvad.net/dns-query")
|
|
addDoH("2a07:e340::4", "https://base.dns.mullvad.net/dns-query")
|
|
// Mullvad (extended)
|
|
addDoH("194.242.2.5", "https://extended.dns.mullvad.net/dns-query")
|
|
addDoH("2a07:e340::5", "https://extended.dns.mullvad.net/dns-query")
|
|
// Mullvad (family)
|
|
addDoH("194.242.2.6", "https://family.dns.mullvad.net/dns-query")
|
|
addDoH("2a07:e340::6", "https://family.dns.mullvad.net/dns-query")
|
|
// Mullvad (all)
|
|
addDoH("194.242.2.9", "https://all.dns.mullvad.net/dns-query")
|
|
addDoH("2a07:e340::9", "https://all.dns.mullvad.net/dns-query")
|
|
|
|
// Wikimedia
|
|
addDoH(wikimediaDNSv4, "https://wikimedia-dns.org/dns-query")
|
|
addDoH(wikimediaDNSv6, "https://wikimedia-dns.org/dns-query")
|
|
|
|
// Control D
|
|
addDoH("76.76.2.0", "https://freedns.controld.com/p0")
|
|
addDoH("76.76.10.0", "https://freedns.controld.com/p0")
|
|
addDoH("2606:1a40::", "https://freedns.controld.com/p0")
|
|
addDoH("2606:1a40:1::", "https://freedns.controld.com/p0")
|
|
|
|
// Control D -Malware
|
|
addDoH("76.76.2.1", "https://freedns.controld.com/p1")
|
|
addDoH("76.76.10.1", "https://freedns.controld.com/p1")
|
|
addDoH("2606:1a40::1", "https://freedns.controld.com/p1")
|
|
addDoH("2606:1a40:1::1", "https://freedns.controld.com/p1")
|
|
|
|
// Control D -Malware + Ads
|
|
addDoH("76.76.2.2", "https://freedns.controld.com/p2")
|
|
addDoH("76.76.10.2", "https://freedns.controld.com/p2")
|
|
addDoH("2606:1a40::2", "https://freedns.controld.com/p2")
|
|
addDoH("2606:1a40:1::2", "https://freedns.controld.com/p2")
|
|
|
|
// Control D -Malware + Ads + Social
|
|
addDoH("76.76.2.3", "https://freedns.controld.com/p3")
|
|
addDoH("76.76.10.3", "https://freedns.controld.com/p3")
|
|
addDoH("2606:1a40::3", "https://freedns.controld.com/p3")
|
|
addDoH("2606:1a40:1::3", "https://freedns.controld.com/p3")
|
|
|
|
// Control D -Malware + Ads + Adult
|
|
addDoH("76.76.2.4", "https://freedns.controld.com/family")
|
|
addDoH("76.76.10.4", "https://freedns.controld.com/family")
|
|
addDoH("2606:1a40::4", "https://freedns.controld.com/family")
|
|
addDoH("2606:1a40:1::4", "https://freedns.controld.com/family")
|
|
|
|
// CIRA Canadian Shield: https://www.cira.ca/en/canadian-shield/configure/summary-cira-canadian-shield-dns-resolver-addresses/
|
|
|
|
// CIRA Canadian Shield Private (DNS resolution only)
|
|
addDoH("149.112.121.10", "https://private.canadianshield.cira.ca/dns-query")
|
|
addDoH("149.112.122.10", "https://private.canadianshield.cira.ca/dns-query")
|
|
addDoH("2620:10a:80bb::10", "https://private.canadianshield.cira.ca/dns-query")
|
|
addDoH("2620:10a:80bc::10", "https://private.canadianshield.cira.ca/dns-query")
|
|
|
|
// CIRA Canadian Shield Protected (Malware and phishing protection)
|
|
addDoH("149.112.121.20", "https://protected.canadianshield.cira.ca/dns-query")
|
|
addDoH("149.112.122.20", "https://protected.canadianshield.cira.ca/dns-query")
|
|
addDoH("2620:10a:80bb::20", "https://protected.canadianshield.cira.ca/dns-query")
|
|
addDoH("2620:10a:80bc::20", "https://protected.canadianshield.cira.ca/dns-query")
|
|
|
|
// CIRA Canadian Shield Family (Protected + blocking adult content)
|
|
addDoH("149.112.121.30", "https://family.canadianshield.cira.ca/dns-query")
|
|
addDoH("149.112.122.30", "https://family.canadianshield.cira.ca/dns-query")
|
|
addDoH("2620:10a:80bb::30", "https://family.canadianshield.cira.ca/dns-query")
|
|
addDoH("2620:10a:80bc::30", "https://family.canadianshield.cira.ca/dns-query")
|
|
}
|
|
|
|
var (
|
|
// The NextDNS IPv6 ranges (primary and secondary). The customer ID is
|
|
// encoded in the lower bytes and is used (in hex form) as the DoH query
|
|
// path.
|
|
nextDNSv6RangeA = netip.MustParsePrefix("2a07:a8c0::/33")
|
|
nextDNSv6RangeB = netip.MustParsePrefix("2a07:a8c1::/33")
|
|
|
|
// The first two IPs in the /24 v4 ranges can be used for DoH to NextDNS.
|
|
//
|
|
// They're Anycast and usually okay, but NextDNS has some locations that
|
|
// don't do BGP and can get results for querying them over DoH to find the
|
|
// IPv4 address of "dns.mynextdns.io" and find an even better result.
|
|
//
|
|
// Note that the Tailscale DNS client does not do any of the "IP address
|
|
// linking" that NextDNS can do with its IPv4 addresses. These addresses
|
|
// are only used for DoH.
|
|
nextDNSv4RangeA = netip.MustParsePrefix("45.90.28.0/24")
|
|
nextDNSv4RangeB = netip.MustParsePrefix("45.90.30.0/24")
|
|
nextDNSv4One = nextDNSv4RangeA.Addr()
|
|
nextDNSv4Two = nextDNSv4RangeB.Addr()
|
|
|
|
// Wikimedia DNS server IPs (anycast)
|
|
wikimediaDNSv4Addr = netip.MustParseAddr(wikimediaDNSv4)
|
|
wikimediaDNSv6Addr = netip.MustParseAddr(wikimediaDNSv6)
|
|
|
|
// The Control D IPv6 ranges (primary and secondary). The customer ID is
|
|
// encoded in the ipv6 address is used (in base 36 form) as the DoH query
|
|
controlDv6RangeA = netip.MustParsePrefix("2606:1a40::/48")
|
|
controlDv6RangeB = netip.MustParsePrefix("2606:1a40:1::/48")
|
|
controlDv4One = netip.MustParseAddr("76.76.2.22")
|
|
controlDv4Two = netip.MustParseAddr("76.76.10.22")
|
|
)
|
|
|
|
// nextDNSv6Gen generates a NextDNS IPv6 address from the upper 8 bytes in the
|
|
// provided ip and using id as the lowest 0-8 bytes.
|
|
func nextDNSv6Gen(ip netip.Addr, id []byte) netip.Addr {
|
|
if len(id) > 12 {
|
|
return netip.Addr{}
|
|
}
|
|
a := ip.As16()
|
|
copy(a[16-len(id):], id)
|
|
return netip.AddrFrom16(a)
|
|
}
|
|
|
|
// controlDv6Gen generates a Control D IPv6 address from provided ip and id.
|
|
//
|
|
// The id is taken from the DoH query path component and represents a unique resolver configuration.
|
|
// e.g. https://dns.controld.com/hyq3ipr2ct
|
|
func controlDv6Gen(ip netip.Addr, id string) netip.Addr {
|
|
b := make([]byte, 8)
|
|
decoded, err := strconv.ParseUint(id, 36, 64)
|
|
if err != nil {
|
|
log.Printf("controlDv6Gen: failed to parse id %q: %v", id, err)
|
|
}
|
|
binary.BigEndian.PutUint64(b, decoded)
|
|
a := ip.AsSlice()
|
|
copy(a[6:14], b)
|
|
addr, _ := netip.AddrFromSlice(a)
|
|
return addr
|
|
}
|
|
|
|
// IPIsDoHOnlyServer reports whether ip is a DNS server that should only use
|
|
// DNS-over-HTTPS (not regular port 53 DNS).
|
|
func IPIsDoHOnlyServer(ip netip.Addr) bool {
|
|
return nextDNSv6RangeA.Contains(ip) || nextDNSv6RangeB.Contains(ip) ||
|
|
nextDNSv4RangeA.Contains(ip) || nextDNSv4RangeB.Contains(ip) ||
|
|
ip == wikimediaDNSv4Addr || ip == wikimediaDNSv6Addr ||
|
|
controlDv6RangeA.Contains(ip) || controlDv6RangeB.Contains(ip) ||
|
|
ip == controlDv4One || ip == controlDv4Two
|
|
}
|
|
|
|
var testMu sync.Mutex
|
|
|
|
// RegisterTestDoHEndpoint registers a test DoH endpoint mapping for use in tests.
|
|
// It maps the given IP to the DoH base URL, and the URL back to the IP.
|
|
//
|
|
// This function panics if called outside of tests, and cannot be called
|
|
// concurrently with any usage of this package (i.e. before any DNS forwarders
|
|
// are created). It is safe to call concurrently with itself.
|
|
//
|
|
// It returns a cleanup function that removes the registration.
|
|
func RegisterTestDoHEndpoint(ip netip.Addr, dohBase string) func() {
|
|
if !testenv.InTest() {
|
|
panic("RegisterTestDoHEndpoint called outside of tests")
|
|
}
|
|
populateOnce.Do(populate)
|
|
|
|
testMu.Lock()
|
|
defer testMu.Unlock()
|
|
|
|
dohOfIP[ip] = dohBase
|
|
dohIPsOfBase[dohBase] = append(dohIPsOfBase[dohBase], ip)
|
|
|
|
return func() {
|
|
testMu.Lock()
|
|
defer testMu.Unlock()
|
|
|
|
delete(dohOfIP, ip)
|
|
dohIPsOfBase[dohBase] = slices.DeleteFunc(dohIPsOfBase[dohBase], func(addr netip.Addr) bool {
|
|
return addr == ip
|
|
})
|
|
if len(dohIPsOfBase[dohBase]) == 0 {
|
|
delete(dohIPsOfBase, dohBase)
|
|
}
|
|
}
|
|
}
|