Files
Markson Joe Hon 9fcbd6a5db fix(core/dns): fix DNS split routing, bootstrap loop, and response corruption
## Issue 1: DNS rule matching logic (MatchAll + OrMatcher)

BuildMatchers flattened all geosite-expanded domains into a single list,
and the old MatchAny used AND logic (all matchers must match). This
made geosite:cn rules impossible to hit (e.g. qq.com and baidu.com
can never match simultaneously).

Fix: introduce OrMatcher to group matchers from the same rule field
with OR semantics, while different field groups use AND. The thousands
of domains from geosite:cn expansion are wrapped in a single OrMatcher
so matching any one domain satisfies the rule.

## Issue 2: Bootstrap self-reference loop (SO_MARK + public DNS fallback)

Bootstrap resolution runs before the DNS listener starts, but iptables
already hijacks :53 traffic:
- bootstrap query to system DNS(:53) → iptables redirects to 127.2.0.17:53
- DNS module not yet listening → connection refused → bootstrap fails
- Domain upstreams (e.g. dns.google) remain unresolved → relies on proxy
- Proxy DNS may re-enter DNS module → loop or REFUSED

Fix:
1. Add SO_MARK=0x80 to bootstrap DNS client to bypass iptables redirect
2. collectBootstrapDns() with 3-tier priority (config > system > hardcoded)
3. Hardcoded fallback includes Alibaba/Tencent/Google/Cloudflare: 13 servers
4. isOwnAddress() filters self-referencing addresses (127.0.0.1:53 etc.)

## Issue 3: handlePacket mutates cached response in-place

m = resp.RawMsg; m.SetReply(msg) directly modifies the *dns.Msg shared
with the cache, corrupting subsequent cache hits. SetReply also forces
Rcode=RcodeSuccess, overwriting NXDOMAIN etc. from upstream.

Fix: Pack/Unpack deep copy before modification; preserve original Rcode.

## Issue 4: Double OPT record causes FORMERR

Three exchange functions called AddECSSubnet BEFORE SetEdns0.
miekg/dns v1.1.72's SetEdns0 always appends a new OPT record without
checking for existing ones, producing a malformed query with two OPT
records.

Fix: call SetEdns0 before AddECSSubnet; use UDP size 4096 in
AddECSSubnet instead of 512 to preserve the size set by SetEdns0.

## Issue 5: localhost upstream skipped in template (template_dns.go)

localhost upstream was continue-skipped during config generation,
making the geosite:private rule reference a non-existent upstream.

Fix: map localhost to 127.0.0.1, keep it as a valid upstream.

## Incidental fixes

- handler.go: remove duplicate :53 in log format (dns.google:53:53)
- response.go: use 4096 instead of dns.DefaultMsgSize(512) for ECS
2026-07-22 14:01:39 +08:00

344 lines
9.7 KiB
Go

package dns
import (
"fmt"
"net"
"regexp"
"strings"
)
// GeositeResolver resolves a geosite tag (e.g. "cn", "geolocation-!cn")
// into domain and suffix patterns. Returns (domains, suffixes) where
// domains are for exact/full matching and suffixes for suffix matching.
// Nil means the tag is not recognized/loaded.
type GeositeResolver func(tag string) (domains, suffixes []string)
// RuleMatcher is the interface for DNS query rule matchers.
type RuleMatcher interface {
// Match checks whether the given query matches this rule.
Match(query *DnsQuery) bool
// Type returns the matcher type description (e.g., "domain", "ip", "querytype", "clientip").
Type() string
// Value returns the matcher value description.
Value() string
}
// DomainRule matches DNS queries by domain name.
// It supports exact match, suffix match (wildcard), and regex match.
type DomainRule struct {
Domain string
IsSuffix bool // true: match suffix like .example.com; false: exact match
IsRegex bool // true: regex match
Re *regexp.Regexp
}
// Match checks if the query domain matches this domain rule.
func (r *DomainRule) Match(query *DnsQuery) bool {
name := strings.TrimSuffix(query.Name, ".")
if r.IsRegex {
return r.Re.MatchString(name)
}
if r.IsSuffix {
// Suffix match: domain ".example.com" matches "sub.example.com" or "example.com"
// If the rule domain starts with ".", treat it as a suffix match for subdomains.
domain := strings.TrimSuffix(r.Domain, ".")
if strings.HasPrefix(domain, ".") {
// ".example.com" matches anything ending with ".example.com"
return strings.HasSuffix(name, domain)
}
// "example.com" matches "example.com" itself and "sub.example.com"
if name == domain {
return true
}
return strings.HasSuffix(name, "."+domain)
}
// Exact match
domain := strings.TrimSuffix(r.Domain, ".")
return name == domain
}
// Type returns the matcher type.
func (r *DomainRule) Type() string {
if r.IsRegex {
return "domain_regex"
}
if r.IsSuffix {
return "domain_suffix"
}
return "domain"
}
// Value returns the matcher value.
func (r *DomainRule) Value() string {
return r.Domain
}
// IPRule matches DNS queries by response IP CIDR range.
// Note: This matcher is used for response IP-based filtering.
// For query-time matching, it checks against the query name's resolved IPs
// (pre-match mode) or is used in post-processing.
type IPRule struct {
CIDR *net.IPNet
}
// Match checks if the client IP or any embedded IP matches this rule.
// For request-time use, this typically matches the query's ClientIP against
// the CIDR range. Response-time matching would check answer records.
func (r *IPRule) Match(query *DnsQuery) bool {
if r.CIDR == nil {
return false
}
return r.CIDR.Contains(query.ClientIP)
}
// Type returns the matcher type.
func (r *IPRule) Type() string {
return "ip"
}
// Value returns the matcher value.
func (r *IPRule) Value() string {
if r.CIDR == nil {
return ""
}
return r.CIDR.String()
}
// QueryTypeRule matches DNS queries by query type (A, AAAA, etc.).
type QueryTypeRule struct {
QType QueryType
}
// Match checks if the query type matches this rule.
func (r *QueryTypeRule) Match(query *DnsQuery) bool {
return r.QType == query.QType
}
// Type returns the matcher type.
func (r *QueryTypeRule) Type() string {
return "query_type"
}
// Value returns the matcher value.
func (r *QueryTypeRule) Value() string {
return fmt.Sprintf("%d", uint16(r.QType))
}
// ClientIPRule matches DNS queries by client IP CIDR range.
type ClientIPRule struct {
CIDR *net.IPNet
}
// Match checks if the query's client IP matches this rule.
func (r *ClientIPRule) Match(query *DnsQuery) bool {
if r.CIDR == nil || query.ClientIP == nil {
return false
}
return r.CIDR.Contains(query.ClientIP)
}
// Type returns the matcher type.
func (r *ClientIPRule) Type() string {
return "client_ip"
}
// Value returns the matcher value.
func (r *ClientIPRule) Value() string {
if r.CIDR == nil {
return ""
}
return r.CIDR.String()
}
// OrMatcher matches if ANY of its child matchers match (OR logic).
// It is used to group matchers from the same rule field together,
// so that multiple domain patterns from a geosite expansion are OR-ed.
type OrMatcher struct {
Matchers []RuleMatcher
}
// Match returns true if any child matcher matches.
func (m *OrMatcher) Match(query *DnsQuery) bool {
for _, matcher := range m.Matchers {
if matcher.Match(query) {
return true
}
}
return false
}
// Type returns the matcher type.
func (m *OrMatcher) Type() string {
return "or_group"
}
// Value returns a description of the group.
func (m *OrMatcher) Value() string {
return fmt.Sprintf("%d matchers", len(m.Matchers))
}
// parseCIDR parses a CIDR string and returns the IPNet.
// Supports both regular CIDR (e.g., "10.0.0.0/8") and single IP (e.g., "10.0.0.1").
func parseCIDR(s string) (*net.IPNet, error) {
if strings.Contains(s, "/") {
_, cidr, err := net.ParseCIDR(s)
if err != nil {
return nil, fmt.Errorf("invalid CIDR %q: %w", s, err)
}
return cidr, nil
}
// Single IP: treat as /32 for IPv4 or /128 for IPv6
ip := net.ParseIP(s)
if ip == nil {
return nil, fmt.Errorf("invalid IP address %q", s)
}
if ip.To4() != nil {
_, cidr, err := net.ParseCIDR(s + "/32")
if err != nil {
return nil, err
}
return cidr, nil
}
_, cidr, err := net.ParseCIDR(s + "/128")
if err != nil {
return nil, err
}
return cidr, nil
}
// BuildMatchers constructs a list of RuleMatcher from a DnsRule configuration.
//
// Matching semantics: within each field group, matchers are OR-ed (any one match
// is sufficient); across different field groups, matchers are AND-ed (all groups
// must match). For example, a rule with domain=["geosite:cn"] and query_type=[A]
// matches if the domain is in geosite:cn AND the query type is A.
//
// If a resolver is provided, geosite tags (e.g. "geosite:cn") are expanded into
// individual domain matchers, all grouped into a single OR group.
func BuildMatchers(rule *DnsRule, resolver GeositeResolver) ([]RuleMatcher, error) {
// Collect matchers by field group. Each group uses OR logic internally.
var domainMatchers []RuleMatcher
var ipMatchers []RuleMatcher
var qtypeMatchers []RuleMatcher
var clientIPMatchers []RuleMatcher
// ── Domain group (OR): exact + suffix + regex + geosite expansion ──
for _, d := range rule.Domain {
if strings.HasPrefix(d, "geosite:") {
if resolver != nil {
doms, suffs := resolver(strings.TrimPrefix(d, "geosite:"))
for _, dom := range doms {
domainMatchers = append(domainMatchers, &DomainRule{Domain: dom, IsSuffix: false, IsRegex: false})
}
for _, suf := range suffs {
domainMatchers = append(domainMatchers, &DomainRule{Domain: suf, IsSuffix: true, IsRegex: false})
}
}
// Without resolver, geosite tags are silently skipped (no matcher created).
continue
}
domainMatchers = append(domainMatchers, &DomainRule{Domain: d, IsSuffix: false, IsRegex: false})
}
for _, d := range rule.DomainSuffix {
if strings.HasPrefix(d, "geosite:") {
if resolver != nil {
doms, suffs := resolver(strings.TrimPrefix(d, "geosite:"))
for _, dom := range doms {
domainMatchers = append(domainMatchers, &DomainRule{Domain: dom, IsSuffix: false, IsRegex: false})
}
for _, suf := range suffs {
domainMatchers = append(domainMatchers, &DomainRule{Domain: suf, IsSuffix: true, IsRegex: false})
}
}
continue
}
domainMatchers = append(domainMatchers, &DomainRule{Domain: d, IsSuffix: true, IsRegex: false})
}
for _, d := range rule.DomainRegex {
re, err := regexp.Compile(d)
if err != nil {
return nil, fmt.Errorf("invalid domain regex %q: %w", d, err)
}
domainMatchers = append(domainMatchers, &DomainRule{Domain: d, IsRegex: true, Re: re})
}
// ── IP group (OR) ──
for _, ipStr := range rule.IP {
cidr, err := parseCIDR(ipStr)
if err != nil {
return nil, fmt.Errorf("invalid IP CIDR %q: %w", ipStr, err)
}
ipMatchers = append(ipMatchers, &IPRule{CIDR: cidr})
}
// ── QueryType group (OR) ──
for _, qt := range rule.QueryType {
qtypeMatchers = append(qtypeMatchers, &QueryTypeRule{QType: qt})
}
// ── ClientIP group (OR) ──
for _, cipStr := range rule.ClientIP {
cidr, err := parseCIDR(cipStr)
if err != nil {
return nil, fmt.Errorf("invalid client IP CIDR %q: %w", cipStr, err)
}
clientIPMatchers = append(clientIPMatchers, &ClientIPRule{CIDR: cidr})
}
// ── Build final list: each group is OR internally, AND across groups ──
var matchers []RuleMatcher
if len(domainMatchers) > 0 {
if len(domainMatchers) == 1 {
matchers = append(matchers, domainMatchers[0])
} else {
matchers = append(matchers, &OrMatcher{Matchers: domainMatchers})
}
}
if len(ipMatchers) > 0 {
if len(ipMatchers) == 1 {
matchers = append(matchers, ipMatchers[0])
} else {
matchers = append(matchers, &OrMatcher{Matchers: ipMatchers})
}
}
if len(qtypeMatchers) > 0 {
if len(qtypeMatchers) == 1 {
matchers = append(matchers, qtypeMatchers[0])
} else {
matchers = append(matchers, &OrMatcher{Matchers: qtypeMatchers})
}
}
if len(clientIPMatchers) > 0 {
if len(clientIPMatchers) == 1 {
matchers = append(matchers, clientIPMatchers[0])
} else {
matchers = append(matchers, &OrMatcher{Matchers: clientIPMatchers})
}
}
return matchers, nil
}
// MatchAll checks if all matcher groups match the query (AND across groups).
// Within each group (e.g. OrMatcher), the semantics is OR (any one matches).
// Empty matchers list means no constraints — matches everything.
func MatchAll(matchers []RuleMatcher, query *DnsQuery) bool {
if len(matchers) == 0 {
// Empty matchers means no constraints — matches everything.
return true
}
for _, m := range matchers {
if !m.Match(query) {
return false
}
}
return true
}