2020-05-08 18:39:37 +03:00
|
|
|
package dnsforward
|
|
|
|
|
|
|
|
import (
|
2021-12-03 17:56:07 +03:00
|
|
|
"encoding/binary"
|
2020-08-18 12:36:52 +03:00
|
|
|
"net"
|
2022-10-26 21:12:51 +03:00
|
|
|
"net/netip"
|
2020-06-23 12:13:13 +03:00
|
|
|
"strings"
|
2020-05-08 18:39:37 +03:00
|
|
|
"time"
|
|
|
|
|
2020-10-30 13:32:02 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/dhcpd"
|
2021-05-21 16:15:47 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/filtering"
|
2020-05-08 18:39:37 +03:00
|
|
|
"github.com/AdguardTeam/dnsproxy/proxy"
|
|
|
|
"github.com/AdguardTeam/golibs/log"
|
2021-08-09 16:03:37 +03:00
|
|
|
"github.com/AdguardTeam/golibs/netutil"
|
2021-07-29 17:40:31 +03:00
|
|
|
"github.com/AdguardTeam/golibs/stringutil"
|
2020-05-08 18:39:37 +03:00
|
|
|
"github.com/miekg/dns"
|
|
|
|
)
|
|
|
|
|
|
|
|
// To transfer information between modules
|
|
|
|
type dnsContext struct {
|
2021-01-27 18:32:13 +03:00
|
|
|
proxyCtx *proxy.DNSContext
|
2021-12-13 18:06:01 +03:00
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
// setts are the filtering settings for the client.
|
2021-12-13 18:06:01 +03:00
|
|
|
setts *filtering.Settings
|
|
|
|
|
|
|
|
result *filtering.Result
|
2021-01-27 18:32:13 +03:00
|
|
|
// origResp is the response received from upstream. It is set when the
|
|
|
|
// response is modified by filters.
|
|
|
|
origResp *dns.Msg
|
2021-12-13 18:06:01 +03:00
|
|
|
|
2023-01-23 19:10:56 +03:00
|
|
|
// unreversedReqIP stores an IP address obtained from a PTR request if it
|
|
|
|
// was parsed successfully and belongs to one of the locally served IP
|
|
|
|
// ranges. It is also filled with unmapped version of the address if it's
|
|
|
|
// within DNS64 prefixes.
|
2021-03-31 15:00:47 +03:00
|
|
|
unreversedReqIP net.IP
|
2021-12-13 18:06:01 +03:00
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
// err is the error returned from a processing function.
|
|
|
|
err error
|
2021-12-13 18:06:01 +03:00
|
|
|
|
2022-02-10 15:42:59 +03:00
|
|
|
// clientID is the ClientID from DoH, DoQ, or DoT, if provided.
|
2021-01-27 18:32:13 +03:00
|
|
|
clientID string
|
2021-12-13 18:06:01 +03:00
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
// origQuestion is the question received from the client. It is set
|
|
|
|
// when the request is modified by rewrites.
|
|
|
|
origQuestion dns.Question
|
2021-12-13 18:06:01 +03:00
|
|
|
|
|
|
|
// startTime is the time at which the processing of the request has started.
|
|
|
|
startTime time.Time
|
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
// protectionEnabled shows if the filtering is enabled, and if the
|
|
|
|
// server's DNS filter is ready.
|
|
|
|
protectionEnabled bool
|
2021-12-13 18:06:01 +03:00
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
// responseFromUpstream shows if the response is received from the
|
|
|
|
// upstream servers.
|
|
|
|
responseFromUpstream bool
|
2021-12-13 18:06:01 +03:00
|
|
|
|
|
|
|
// responseAD shows if the response had the AD bit set.
|
|
|
|
responseAD bool
|
|
|
|
|
2023-01-23 19:10:56 +03:00
|
|
|
// isLocalClient shows if client's IP address is from locally served
|
2021-04-08 18:07:29 +03:00
|
|
|
// network.
|
|
|
|
isLocalClient bool
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
// resultCode is the result of a request processing function.
|
|
|
|
type resultCode int
|
|
|
|
|
2020-05-08 18:39:37 +03:00
|
|
|
const (
|
2021-01-27 18:32:13 +03:00
|
|
|
// resultCodeSuccess is returned when a handler performed successfully,
|
|
|
|
// and the next handler must be called.
|
|
|
|
resultCodeSuccess resultCode = iota
|
|
|
|
// resultCodeFinish is returned when a handler performed successfully,
|
|
|
|
// and the processing of the request must be stopped.
|
|
|
|
resultCodeFinish
|
|
|
|
// resultCodeError is returned when a handler failed, and the processing
|
|
|
|
// of the request must be stopped.
|
|
|
|
resultCodeError
|
2020-05-08 18:39:37 +03:00
|
|
|
)
|
|
|
|
|
2022-04-27 11:39:48 +03:00
|
|
|
// ddrHostFQDN is the FQDN used in Discovery of Designated Resolvers (DDR) requests.
|
|
|
|
// See https://www.ietf.org/archive/id/draft-ietf-add-ddr-06.html.
|
|
|
|
const ddrHostFQDN = "_dns.resolver.arpa."
|
|
|
|
|
2020-05-08 18:39:37 +03:00
|
|
|
// handleDNSRequest filters the incoming DNS requests and writes them to the query log
|
2022-09-02 14:52:19 +03:00
|
|
|
func (s *Server) handleDNSRequest(_ *proxy.Proxy, pctx *proxy.DNSContext) error {
|
|
|
|
dctx := &dnsContext{
|
|
|
|
proxyCtx: pctx,
|
2021-05-21 16:15:47 +03:00
|
|
|
result: &filtering.Result{},
|
2021-01-27 18:32:13 +03:00
|
|
|
startTime: time.Now(),
|
|
|
|
}
|
2020-05-08 18:39:37 +03:00
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
type modProcessFunc func(ctx *dnsContext) (rc resultCode)
|
2020-12-28 19:26:37 +03:00
|
|
|
|
|
|
|
// Since (*dnsforward.Server).handleDNSRequest(...) is used as
|
|
|
|
// proxy.(Config).RequestHandler, there is no need for additional index
|
|
|
|
// out of range checking in any of the following functions, because the
|
|
|
|
// (*proxy.Proxy).handleDNSRequest method performs it before calling the
|
|
|
|
// appropriate handler.
|
2020-05-08 18:39:37 +03:00
|
|
|
mods := []modProcessFunc{
|
2021-05-27 19:19:19 +03:00
|
|
|
s.processRecursion,
|
2021-11-15 17:42:10 +03:00
|
|
|
s.processInitial,
|
2022-04-27 11:39:48 +03:00
|
|
|
s.processDDRQuery,
|
2021-04-08 18:07:29 +03:00
|
|
|
s.processDetermineLocal,
|
2022-06-28 19:09:26 +03:00
|
|
|
s.processDHCPHosts,
|
2021-03-31 15:00:47 +03:00
|
|
|
s.processRestrictLocal,
|
2022-06-28 19:09:26 +03:00
|
|
|
s.processDHCPAddrs,
|
2021-10-20 19:52:13 +03:00
|
|
|
s.processFilteringBeforeRequest,
|
2021-03-31 15:00:47 +03:00
|
|
|
s.processLocalPTR,
|
2021-05-27 19:19:19 +03:00
|
|
|
s.processUpstream,
|
2021-11-15 17:42:10 +03:00
|
|
|
s.processFilteringAfterResponse,
|
2020-09-02 14:13:45 +03:00
|
|
|
s.ipset.process,
|
2021-11-15 17:42:10 +03:00
|
|
|
s.processQueryLogsAndStats,
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
for _, process := range mods {
|
2022-09-02 14:52:19 +03:00
|
|
|
r := process(dctx)
|
2020-05-08 18:39:37 +03:00
|
|
|
switch r {
|
2021-01-27 18:32:13 +03:00
|
|
|
case resultCodeSuccess:
|
2020-05-08 18:39:37 +03:00
|
|
|
// continue: call the next filter
|
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
case resultCodeFinish:
|
2020-05-08 18:39:37 +03:00
|
|
|
return nil
|
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
case resultCodeError:
|
2022-09-02 14:52:19 +03:00
|
|
|
return dctx.err
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
if pctx.Res != nil {
|
|
|
|
// Some devices require DNS message compression.
|
|
|
|
pctx.Res.Compress = true
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
2022-09-02 14:52:19 +03:00
|
|
|
|
2020-05-08 18:39:37 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2023-01-23 19:10:56 +03:00
|
|
|
// processRecursion checks the incoming request and halts its handling by
|
|
|
|
// answering NXDOMAIN if s has tried to resolve it recently.
|
2021-05-27 19:19:19 +03:00
|
|
|
func (s *Server) processRecursion(dctx *dnsContext) (rc resultCode) {
|
|
|
|
pctx := dctx.proxyCtx
|
|
|
|
|
|
|
|
if msg := pctx.Req; msg != nil && s.recDetector.check(*msg) {
|
|
|
|
log.Debug("recursion detected resolving %q", msg.Question[0].Name)
|
|
|
|
pctx.Res = s.genNXDomain(pctx.Req)
|
|
|
|
|
|
|
|
return resultCodeFinish
|
|
|
|
}
|
|
|
|
|
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
|
|
|
|
2021-12-03 17:56:07 +03:00
|
|
|
// processInitial terminates the following processing for some requests if
|
|
|
|
// needed and enriches the ctx with some client-specific information.
|
|
|
|
//
|
|
|
|
// TODO(e.burkov): Decompose into less general processors.
|
2022-09-02 14:52:19 +03:00
|
|
|
func (s *Server) processInitial(dctx *dnsContext) (rc resultCode) {
|
|
|
|
pctx := dctx.proxyCtx
|
|
|
|
q := pctx.Req.Question[0]
|
|
|
|
qt := q.Qtype
|
|
|
|
if s.conf.AAAADisabled && qt == dns.TypeAAAA {
|
|
|
|
_ = proxy.CheckDisabledAAAARequest(pctx, true)
|
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeFinish
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if s.conf.OnDNSRequest != nil {
|
2022-09-02 14:52:19 +03:00
|
|
|
s.conf.OnDNSRequest(pctx)
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
// Disable Mozilla DoH.
|
|
|
|
//
|
|
|
|
// See https://support.mozilla.org/en-US/kb/canary-domain-use-application-dnsnet.
|
|
|
|
if (qt == dns.TypeA || qt == dns.TypeAAAA) && q.Name == "use-application-dns.net." {
|
|
|
|
pctx.Res = s.genNXDomain(pctx.Req)
|
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeFinish
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
// Get the ClientID, if any, before getting client-specific filtering
|
|
|
|
// settings.
|
2021-12-03 17:56:07 +03:00
|
|
|
var key [8]byte
|
2022-09-02 14:52:19 +03:00
|
|
|
binary.BigEndian.PutUint64(key[:], pctx.RequestID)
|
|
|
|
dctx.clientID = string(s.clientIDCache.Get(key[:]))
|
2021-12-03 17:56:07 +03:00
|
|
|
|
|
|
|
// Get the client-specific filtering settings.
|
2022-09-02 14:52:19 +03:00
|
|
|
dctx.protectionEnabled = s.conf.ProtectionEnabled
|
|
|
|
dctx.setts = s.getClientRequestFilteringSettings(dctx)
|
2021-11-15 17:42:10 +03:00
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeSuccess
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2021-04-15 17:52:53 +03:00
|
|
|
func (s *Server) setTableHostToIP(t hostToIPTable) {
|
|
|
|
s.tableHostToIPLock.Lock()
|
|
|
|
defer s.tableHostToIPLock.Unlock()
|
|
|
|
|
|
|
|
s.tableHostToIP = t
|
|
|
|
}
|
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
func (s *Server) setTableIPToHost(t ipToHostTable) {
|
2021-04-15 17:52:53 +03:00
|
|
|
s.tableIPToHostLock.Lock()
|
|
|
|
defer s.tableIPToHostLock.Unlock()
|
|
|
|
|
|
|
|
s.tableIPToHost = t
|
|
|
|
}
|
|
|
|
|
2020-06-23 12:13:13 +03:00
|
|
|
func (s *Server) onDHCPLeaseChanged(flags int) {
|
|
|
|
switch flags {
|
|
|
|
case dhcpd.LeaseChangedAdded,
|
|
|
|
dhcpd.LeaseChangedAddedStatic,
|
|
|
|
dhcpd.LeaseChangedRemovedStatic:
|
2021-04-15 17:52:53 +03:00
|
|
|
// Go on.
|
|
|
|
case dhcpd.LeaseChangedRemovedAll:
|
2022-10-26 21:12:51 +03:00
|
|
|
s.setTableHostToIP(nil)
|
|
|
|
s.setTableIPToHost(nil)
|
|
|
|
|
|
|
|
return
|
2020-06-23 12:13:13 +03:00
|
|
|
default:
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
ll := s.dhcpServer.Leases(dhcpd.LeasesAll)
|
|
|
|
hostToIP := make(hostToIPTable, len(ll))
|
|
|
|
ipToHost := make(ipToHostTable, len(ll))
|
|
|
|
|
|
|
|
for _, l := range ll {
|
|
|
|
// TODO(a.garipov): Remove this after we're finished with the client
|
|
|
|
// hostname validations in the DHCP server code.
|
|
|
|
err := netutil.ValidateDomainName(l.Hostname)
|
|
|
|
if err != nil {
|
|
|
|
log.Debug("dnsforward: skipping invalid hostname %q from dhcp: %s", l.Hostname, err)
|
2020-08-18 12:36:52 +03:00
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
continue
|
|
|
|
}
|
2021-06-29 15:53:28 +03:00
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
lowhost := strings.ToLower(l.Hostname + "." + s.localDomainSuffix)
|
2020-08-18 17:40:36 +03:00
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
// Assume that we only process IPv4 now.
|
|
|
|
//
|
|
|
|
// TODO(a.garipov): Remove once we switch to netip.Addr more fully.
|
|
|
|
ip, err := netutil.IPToAddr(l.IP, netutil.AddrFamilyIPv4)
|
|
|
|
if err != nil {
|
|
|
|
log.Debug("dnsforward: skipping invalid ip %v from dhcp: %s", l.IP, err)
|
2020-08-18 12:36:52 +03:00
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
continue
|
2021-04-15 17:52:53 +03:00
|
|
|
}
|
2020-08-18 12:36:52 +03:00
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
ipToHost[ip] = lowhost
|
|
|
|
hostToIP[lowhost] = ip
|
2021-04-15 17:52:53 +03:00
|
|
|
}
|
2020-08-18 12:36:52 +03:00
|
|
|
|
2021-04-15 17:52:53 +03:00
|
|
|
s.setTableHostToIP(hostToIP)
|
|
|
|
s.setTableIPToHost(ipToHost)
|
2022-10-26 21:12:51 +03:00
|
|
|
|
|
|
|
log.Debug("dnsforward: added %d a and ptr entries from dhcp", len(ipToHost))
|
2020-06-23 12:13:13 +03:00
|
|
|
}
|
|
|
|
|
2022-09-02 16:56:59 +03:00
|
|
|
// processDDRQuery responds to Discovery of Designated Resolvers (DDR) SVCB
|
|
|
|
// queries. The response contains different types of encryption supported by
|
|
|
|
// current user configuration.
|
2022-04-27 11:39:48 +03:00
|
|
|
//
|
2022-09-02 16:56:59 +03:00
|
|
|
// See https://www.ietf.org/archive/id/draft-ietf-add-ddr-10.html.
|
2022-09-02 14:52:19 +03:00
|
|
|
func (s *Server) processDDRQuery(dctx *dnsContext) (rc resultCode) {
|
2022-04-27 11:39:48 +03:00
|
|
|
if !s.conf.HandleDDR {
|
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
|
|
|
|
2022-11-02 14:37:41 +03:00
|
|
|
pctx := dctx.proxyCtx
|
|
|
|
q := pctx.Req.Question[0]
|
2022-09-02 14:52:19 +03:00
|
|
|
if q.Name == ddrHostFQDN {
|
|
|
|
pctx.Res = s.makeDDRResponse(pctx.Req)
|
2022-04-27 11:39:48 +03:00
|
|
|
|
|
|
|
return resultCodeFinish
|
|
|
|
}
|
|
|
|
|
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
|
|
|
|
2022-09-02 16:56:59 +03:00
|
|
|
// makeDDRResponse creates a DDR answer based on the server configuration. The
|
|
|
|
// constructed SVCB resource records have the priority of 1 for each entry,
|
|
|
|
// similar to examples provided by the [draft standard].
|
2022-06-20 17:48:56 +03:00
|
|
|
//
|
|
|
|
// TODO(a.meshkov): Consider setting the priority values based on the protocol.
|
2022-09-02 16:56:59 +03:00
|
|
|
//
|
|
|
|
// [draft standard]: https://www.ietf.org/archive/id/draft-ietf-add-ddr-10.html.
|
2022-04-27 11:39:48 +03:00
|
|
|
func (s *Server) makeDDRResponse(req *dns.Msg) (resp *dns.Msg) {
|
|
|
|
resp = s.makeResponse(req)
|
2022-11-02 14:37:41 +03:00
|
|
|
if req.Question[0].Qtype != dns.TypeSVCB {
|
|
|
|
return resp
|
|
|
|
}
|
|
|
|
|
2022-05-31 17:28:50 +03:00
|
|
|
// TODO(e.burkov): Think about storing the FQDN version of the server's
|
2022-05-30 16:04:28 +03:00
|
|
|
// name somewhere.
|
|
|
|
domainName := dns.Fqdn(s.conf.ServerName)
|
2022-04-27 11:39:48 +03:00
|
|
|
|
2022-05-31 17:28:50 +03:00
|
|
|
for _, addr := range s.conf.HTTPSListenAddrs {
|
2022-04-27 11:39:48 +03:00
|
|
|
values := []dns.SVCBKeyValue{
|
|
|
|
&dns.SVCBAlpn{Alpn: []string{"h2"}},
|
|
|
|
&dns.SVCBPort{Port: uint16(addr.Port)},
|
2022-09-20 15:26:10 +03:00
|
|
|
&dns.SVCBDoHPath{Template: "/dns-query{?dns}"},
|
2022-04-27 11:39:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
ans := &dns.SVCB{
|
|
|
|
Hdr: s.hdr(req, dns.TypeSVCB),
|
|
|
|
Priority: 1,
|
|
|
|
Target: domainName,
|
|
|
|
Value: values,
|
|
|
|
}
|
|
|
|
|
|
|
|
resp.Answer = append(resp.Answer, ans)
|
|
|
|
}
|
|
|
|
|
2022-11-02 14:37:41 +03:00
|
|
|
if s.conf.hasIPAddrs {
|
|
|
|
// Only add DNS-over-TLS resolvers in case the certificate contains IP
|
|
|
|
// addresses.
|
|
|
|
//
|
|
|
|
// See https://github.com/AdguardTeam/AdGuardHome/issues/4927.
|
|
|
|
for _, addr := range s.dnsProxy.TLSListenAddr {
|
|
|
|
values := []dns.SVCBKeyValue{
|
|
|
|
&dns.SVCBAlpn{Alpn: []string{"dot"}},
|
|
|
|
&dns.SVCBPort{Port: uint16(addr.Port)},
|
|
|
|
}
|
|
|
|
|
|
|
|
ans := &dns.SVCB{
|
|
|
|
Hdr: s.hdr(req, dns.TypeSVCB),
|
|
|
|
Priority: 1,
|
|
|
|
Target: domainName,
|
|
|
|
Value: values,
|
|
|
|
}
|
|
|
|
|
|
|
|
resp.Answer = append(resp.Answer, ans)
|
2022-04-27 11:39:48 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-26 17:53:11 +03:00
|
|
|
for _, addr := range s.dnsProxy.QUICListenAddr {
|
|
|
|
values := []dns.SVCBKeyValue{
|
|
|
|
&dns.SVCBAlpn{Alpn: []string{"doq"}},
|
|
|
|
&dns.SVCBPort{Port: uint16(addr.Port)},
|
|
|
|
}
|
|
|
|
|
|
|
|
ans := &dns.SVCB{
|
|
|
|
Hdr: s.hdr(req, dns.TypeSVCB),
|
2022-06-20 17:48:56 +03:00
|
|
|
Priority: 1,
|
2022-05-26 17:53:11 +03:00
|
|
|
Target: domainName,
|
|
|
|
Value: values,
|
|
|
|
}
|
|
|
|
|
|
|
|
resp.Answer = append(resp.Answer, ans)
|
|
|
|
}
|
|
|
|
|
2022-04-27 11:39:48 +03:00
|
|
|
return resp
|
|
|
|
}
|
|
|
|
|
2023-01-23 19:10:56 +03:00
|
|
|
// processDetermineLocal determines if the client's IP address is from locally
|
|
|
|
// served network and saves the result into the context.
|
2021-04-08 18:07:29 +03:00
|
|
|
func (s *Server) processDetermineLocal(dctx *dnsContext) (rc resultCode) {
|
|
|
|
rc = resultCodeSuccess
|
|
|
|
|
|
|
|
var ip net.IP
|
2021-08-09 16:03:37 +03:00
|
|
|
if ip, _ = netutil.IPAndPortFromAddr(dctx.proxyCtx.Addr); ip == nil {
|
2021-04-08 18:07:29 +03:00
|
|
|
return rc
|
|
|
|
}
|
|
|
|
|
2022-03-18 13:37:27 +03:00
|
|
|
dctx.isLocalClient = s.privateNets.Contains(ip)
|
2021-04-08 18:07:29 +03:00
|
|
|
|
|
|
|
return rc
|
|
|
|
}
|
|
|
|
|
2022-09-02 16:56:59 +03:00
|
|
|
// dhcpHostToIP tries to get an IP leased by DHCP and returns the copy of
|
|
|
|
// address since the data inside the internal table may be changed while request
|
2021-03-31 15:00:47 +03:00
|
|
|
// processing. It's safe for concurrent use.
|
2022-10-26 21:12:51 +03:00
|
|
|
func (s *Server) dhcpHostToIP(host string) (ip netip.Addr, ok bool) {
|
2021-03-31 15:00:47 +03:00
|
|
|
s.tableHostToIPLock.Lock()
|
|
|
|
defer s.tableHostToIPLock.Unlock()
|
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
ip, ok = s.tableHostToIP[host]
|
2021-03-31 15:00:47 +03:00
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
return ip, ok
|
2021-03-31 15:00:47 +03:00
|
|
|
}
|
|
|
|
|
2022-06-28 19:09:26 +03:00
|
|
|
// processDHCPHosts respond to A requests if the target hostname is known to
|
2023-01-23 19:10:56 +03:00
|
|
|
// the server. It responds with a mapped IP address if the DNS64 is enabled and
|
|
|
|
// the request is for AAAA.
|
2021-03-25 16:00:27 +03:00
|
|
|
//
|
|
|
|
// TODO(a.garipov): Adapt to AAAA as well.
|
2022-06-28 19:09:26 +03:00
|
|
|
func (s *Server) processDHCPHosts(dctx *dnsContext) (rc resultCode) {
|
2022-09-02 16:56:59 +03:00
|
|
|
pctx := dctx.proxyCtx
|
|
|
|
req := pctx.Req
|
2021-03-25 16:00:27 +03:00
|
|
|
q := req.Question[0]
|
2022-09-02 16:56:59 +03:00
|
|
|
reqHost, ok := s.isDHCPClientHostQ(q)
|
|
|
|
if !ok {
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeSuccess
|
2020-08-18 12:36:52 +03:00
|
|
|
}
|
|
|
|
|
2021-04-08 18:07:29 +03:00
|
|
|
if !dctx.isLocalClient {
|
2022-10-26 21:12:51 +03:00
|
|
|
log.Debug("dnsforward: %q requests for dhcp host %q", pctx.Addr, reqHost)
|
2022-09-02 14:52:19 +03:00
|
|
|
pctx.Res = s.genNXDomain(req)
|
2021-04-08 18:07:29 +03:00
|
|
|
|
|
|
|
// Do not even put into query log.
|
|
|
|
return resultCodeFinish
|
|
|
|
}
|
2021-03-31 15:00:47 +03:00
|
|
|
|
2022-09-02 16:56:59 +03:00
|
|
|
ip, ok := s.dhcpHostToIP(reqHost)
|
2020-08-18 12:36:52 +03:00
|
|
|
if !ok {
|
2022-09-02 16:56:59 +03:00
|
|
|
// Go on and process them with filters, including dnsrewrite ones, and
|
|
|
|
// possibly route them to a domain-specific upstream.
|
2022-10-26 21:12:51 +03:00
|
|
|
log.Debug("dnsforward: no dhcp record for %q", reqHost)
|
2021-04-08 18:07:29 +03:00
|
|
|
|
2022-09-02 16:56:59 +03:00
|
|
|
return resultCodeSuccess
|
2020-08-18 12:36:52 +03:00
|
|
|
}
|
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
log.Debug("dnsforward: dhcp record for %q is %s", reqHost, ip)
|
2020-08-18 12:36:52 +03:00
|
|
|
|
|
|
|
resp := s.makeResponse(req)
|
2023-01-23 19:10:56 +03:00
|
|
|
switch q.Qtype {
|
|
|
|
case dns.TypeA:
|
2021-03-25 16:00:27 +03:00
|
|
|
a := &dns.A{
|
|
|
|
Hdr: s.hdr(req, dns.TypeA),
|
2022-10-26 21:12:51 +03:00
|
|
|
A: ip.AsSlice(),
|
2020-08-18 12:36:52 +03:00
|
|
|
}
|
|
|
|
resp.Answer = append(resp.Answer, a)
|
2023-01-23 19:10:56 +03:00
|
|
|
case dns.TypeAAAA:
|
|
|
|
if len(s.dns64Prefs) > 0 {
|
|
|
|
// Respond with DNS64-mapped address for IPv4 host if DNS64 is
|
|
|
|
// enabled.
|
|
|
|
aaaa := &dns.AAAA{
|
|
|
|
Hdr: s.hdr(req, dns.TypeAAAA),
|
|
|
|
AAAA: s.mapDNS64(ip),
|
|
|
|
}
|
|
|
|
resp.Answer = append(resp.Answer, aaaa)
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
// Go on.
|
2020-08-18 12:36:52 +03:00
|
|
|
}
|
2023-01-23 19:10:56 +03:00
|
|
|
|
2021-03-25 16:00:27 +03:00
|
|
|
dctx.proxyCtx.Res = resp
|
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
|
|
|
|
2021-04-08 18:07:29 +03:00
|
|
|
// processRestrictLocal responds with NXDOMAIN to PTR requests for IP addresses
|
2023-01-23 19:10:56 +03:00
|
|
|
// in locally served network from external clients.
|
2022-09-02 14:52:19 +03:00
|
|
|
func (s *Server) processRestrictLocal(dctx *dnsContext) (rc resultCode) {
|
|
|
|
pctx := dctx.proxyCtx
|
|
|
|
req := pctx.Req
|
2021-03-31 15:00:47 +03:00
|
|
|
q := req.Question[0]
|
|
|
|
if q.Qtype != dns.TypePTR {
|
|
|
|
// No need for restriction.
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeSuccess
|
2020-06-23 12:13:13 +03:00
|
|
|
}
|
|
|
|
|
2021-08-09 16:03:37 +03:00
|
|
|
ip, err := netutil.IPFromReversedAddr(q.Name)
|
|
|
|
if err != nil {
|
2022-10-26 21:12:51 +03:00
|
|
|
log.Debug("dnsforward: parsing reversed addr: %s", err)
|
2021-08-09 16:03:37 +03:00
|
|
|
|
2022-01-18 14:20:25 +03:00
|
|
|
// DNS-Based Service Discovery uses PTR records having not an ARPA
|
|
|
|
// format of the domain name in question. Those shouldn't be
|
|
|
|
// invalidated. See http://www.dns-sd.org/ServerStaticSetup.html and
|
|
|
|
// RFC 2782.
|
|
|
|
name := strings.TrimSuffix(q.Name, ".")
|
|
|
|
if err = netutil.ValidateSRVDomainName(name); err != nil {
|
2022-10-26 21:12:51 +03:00
|
|
|
log.Debug("dnsforward: validating service domain: %s", err)
|
2022-01-18 14:20:25 +03:00
|
|
|
|
|
|
|
return resultCodeError
|
|
|
|
}
|
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
log.Debug("dnsforward: request is for a service domain")
|
2022-01-18 14:20:25 +03:00
|
|
|
|
|
|
|
return resultCodeSuccess
|
2020-06-23 12:13:13 +03:00
|
|
|
}
|
|
|
|
|
2023-01-23 19:10:56 +03:00
|
|
|
if s.shouldStripDNS64(ip) {
|
|
|
|
// Strip the prefix from the address to get the original IPv4.
|
|
|
|
ip = ip[nat64PrefixLen:]
|
|
|
|
|
|
|
|
// Treat a DNS64-prefixed address as a locally served one since those
|
|
|
|
// queries should never be sent to the global DNS.
|
|
|
|
dctx.unreversedReqIP = ip
|
|
|
|
}
|
|
|
|
|
2021-03-31 15:00:47 +03:00
|
|
|
// Restrict an access to local addresses for external clients. We also
|
2023-01-23 19:10:56 +03:00
|
|
|
// assume that all the DHCP leases we give are locally served or at least
|
|
|
|
// shouldn't be accessible externally.
|
2022-03-18 13:37:27 +03:00
|
|
|
if !s.privateNets.Contains(ip) {
|
2021-11-15 17:42:10 +03:00
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
|
|
|
|
2023-01-23 19:10:56 +03:00
|
|
|
log.Debug("dnsforward: addr %s is from locally served network", ip)
|
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
if !dctx.isLocalClient {
|
2022-10-26 21:12:51 +03:00
|
|
|
log.Debug("dnsforward: %q requests an internal ip", pctx.Addr)
|
2022-09-02 14:52:19 +03:00
|
|
|
pctx.Res = s.genNXDomain(req)
|
2021-03-31 15:00:47 +03:00
|
|
|
|
2021-11-11 16:19:33 +03:00
|
|
|
// Do not even put into query log.
|
|
|
|
return resultCodeFinish
|
2021-03-31 15:00:47 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Do not perform unreversing ever again.
|
2022-09-02 14:52:19 +03:00
|
|
|
dctx.unreversedReqIP = ip
|
2021-03-31 15:00:47 +03:00
|
|
|
|
2021-11-15 17:42:10 +03:00
|
|
|
// There is no need to filter request from external addresses since this
|
2023-01-23 19:10:56 +03:00
|
|
|
// code is only executed when the request is for locally served ARPA
|
2021-11-15 17:42:10 +03:00
|
|
|
// hostname so disable redundant filters.
|
2022-09-02 14:52:19 +03:00
|
|
|
dctx.setts.ParentalEnabled = false
|
|
|
|
dctx.setts.SafeBrowsingEnabled = false
|
|
|
|
dctx.setts.SafeSearchEnabled = false
|
|
|
|
dctx.setts.ServicesRules = nil
|
2021-04-07 20:16:06 +03:00
|
|
|
|
2021-03-31 15:00:47 +03:00
|
|
|
// Nothing to restrict.
|
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
|
|
|
|
2022-09-02 16:56:59 +03:00
|
|
|
// ipToDHCPHost tries to get a hostname leased by DHCP. It's safe for
|
|
|
|
// concurrent use.
|
2022-10-26 21:12:51 +03:00
|
|
|
func (s *Server) ipToDHCPHost(ip netip.Addr) (host string, ok bool) {
|
2021-04-15 17:52:53 +03:00
|
|
|
s.tableIPToHostLock.Lock()
|
|
|
|
defer s.tableIPToHostLock.Unlock()
|
2021-03-31 15:00:47 +03:00
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
host, ok = s.tableIPToHost[ip]
|
2021-03-31 15:00:47 +03:00
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
return host, ok
|
2021-03-31 15:00:47 +03:00
|
|
|
}
|
|
|
|
|
2022-09-02 16:56:59 +03:00
|
|
|
// processDHCPAddrs responds to PTR requests if the target IP is leased by the
|
|
|
|
// DHCP server.
|
2022-09-02 14:52:19 +03:00
|
|
|
func (s *Server) processDHCPAddrs(dctx *dnsContext) (rc resultCode) {
|
|
|
|
pctx := dctx.proxyCtx
|
|
|
|
if pctx.Res != nil {
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeSuccess
|
2020-06-23 12:13:13 +03:00
|
|
|
}
|
2021-03-31 15:00:47 +03:00
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
ip := dctx.unreversedReqIP
|
2021-03-31 15:00:47 +03:00
|
|
|
if ip == nil {
|
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
|
|
|
|
2023-01-23 19:10:56 +03:00
|
|
|
// TODO(a.garipov): Remove once we switch to [netip.Addr] more fully.
|
2022-10-26 21:12:51 +03:00
|
|
|
ipAddr, err := netutil.IPToAddrNoMapped(ip)
|
|
|
|
if err != nil {
|
|
|
|
log.Debug("dnsforward: bad reverse ip %v from dhcp: %s", ip, err)
|
|
|
|
|
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
|
|
|
|
|
|
|
host, ok := s.ipToDHCPHost(ipAddr)
|
2020-06-23 12:13:13 +03:00
|
|
|
if !ok {
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeSuccess
|
2020-06-23 12:13:13 +03:00
|
|
|
}
|
|
|
|
|
2022-10-26 21:12:51 +03:00
|
|
|
log.Debug("dnsforward: dhcp reverse record for %s is %q", ip, host)
|
2020-06-23 12:13:13 +03:00
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
req := pctx.Req
|
2020-06-23 12:13:13 +03:00
|
|
|
resp := s.makeResponse(req)
|
2021-03-31 15:00:47 +03:00
|
|
|
ptr := &dns.PTR{
|
|
|
|
Hdr: dns.RR_Header{
|
|
|
|
Name: req.Question[0].Name,
|
|
|
|
Rrtype: dns.TypePTR,
|
|
|
|
Ttl: s.conf.BlockedResponseTTL,
|
|
|
|
Class: dns.ClassINET,
|
|
|
|
},
|
|
|
|
Ptr: dns.Fqdn(host),
|
2020-06-23 12:13:13 +03:00
|
|
|
}
|
|
|
|
resp.Answer = append(resp.Answer, ptr)
|
2022-09-02 14:52:19 +03:00
|
|
|
pctx.Res = resp
|
2021-03-31 15:00:47 +03:00
|
|
|
|
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
|
|
|
|
|
|
|
// processLocalPTR responds to PTR requests if the target IP is detected to be
|
|
|
|
// inside the local network and the query was not answered from DHCP.
|
2022-09-02 14:52:19 +03:00
|
|
|
func (s *Server) processLocalPTR(dctx *dnsContext) (rc resultCode) {
|
|
|
|
pctx := dctx.proxyCtx
|
|
|
|
if pctx.Res != nil {
|
2021-03-31 15:00:47 +03:00
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
ip := dctx.unreversedReqIP
|
2021-03-31 15:00:47 +03:00
|
|
|
if ip == nil {
|
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
|
|
|
|
2021-05-26 17:55:19 +03:00
|
|
|
s.serverLock.RLock()
|
|
|
|
defer s.serverLock.RUnlock()
|
|
|
|
|
|
|
|
if s.conf.UsePrivateRDNS {
|
2022-09-02 14:52:19 +03:00
|
|
|
s.recDetector.add(*pctx.Req)
|
|
|
|
if err := s.localResolvers.Resolve(pctx); err != nil {
|
|
|
|
dctx.err = err
|
2021-03-31 15:00:47 +03:00
|
|
|
|
2021-05-26 17:55:19 +03:00
|
|
|
return resultCodeError
|
|
|
|
}
|
2021-03-31 15:00:47 +03:00
|
|
|
}
|
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
if pctx.Res == nil {
|
|
|
|
pctx.Res = s.genNXDomain(pctx.Req)
|
2021-04-09 21:01:21 +03:00
|
|
|
|
2021-05-26 17:55:19 +03:00
|
|
|
// Do not even put into query log.
|
2021-04-09 21:01:21 +03:00
|
|
|
return resultCodeFinish
|
|
|
|
}
|
2021-03-31 15:00:47 +03:00
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeSuccess
|
2020-06-23 12:13:13 +03:00
|
|
|
}
|
|
|
|
|
2020-05-08 18:39:37 +03:00
|
|
|
// Apply filtering logic
|
2021-10-20 19:52:13 +03:00
|
|
|
func (s *Server) processFilteringBeforeRequest(ctx *dnsContext) (rc resultCode) {
|
|
|
|
if ctx.proxyCtx.Res != nil {
|
|
|
|
// Go on since the response is already set.
|
|
|
|
return resultCodeSuccess
|
2020-06-23 12:13:13 +03:00
|
|
|
}
|
|
|
|
|
2021-05-26 17:55:19 +03:00
|
|
|
s.serverLock.RLock()
|
|
|
|
defer s.serverLock.RUnlock()
|
2020-05-08 18:39:37 +03:00
|
|
|
|
2021-10-20 19:52:13 +03:00
|
|
|
if s.dnsFilter == nil {
|
2021-05-26 17:55:19 +03:00
|
|
|
return resultCodeSuccess
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2021-05-26 17:55:19 +03:00
|
|
|
var err error
|
2021-10-20 19:52:13 +03:00
|
|
|
if ctx.result, err = s.filterDNSRequest(ctx); err != nil {
|
2020-05-08 18:39:37 +03:00
|
|
|
ctx.err = err
|
2021-04-07 20:16:06 +03:00
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeError
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
2021-04-07 20:16:06 +03:00
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeSuccess
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2021-05-28 13:02:59 +03:00
|
|
|
// ipStringFromAddr extracts an IP address string from net.Addr.
|
|
|
|
func ipStringFromAddr(addr net.Addr) (ipStr string) {
|
2021-08-09 16:03:37 +03:00
|
|
|
if ip, _ := netutil.IPAndPortFromAddr(addr); ip != nil {
|
2021-05-28 13:02:59 +03:00
|
|
|
return ip.String()
|
|
|
|
}
|
|
|
|
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
2021-01-13 16:56:05 +03:00
|
|
|
// processUpstream passes request to upstream servers and handles the response.
|
2021-12-13 18:06:01 +03:00
|
|
|
func (s *Server) processUpstream(dctx *dnsContext) (rc resultCode) {
|
|
|
|
pctx := dctx.proxyCtx
|
2022-09-02 16:56:59 +03:00
|
|
|
req := pctx.Req
|
|
|
|
q := req.Question[0]
|
2021-12-13 18:06:01 +03:00
|
|
|
if pctx.Res != nil {
|
|
|
|
// The response has already been set.
|
|
|
|
return resultCodeSuccess
|
2022-09-02 16:56:59 +03:00
|
|
|
} else if reqHost, ok := s.isDHCPClientHostQ(q); ok {
|
|
|
|
// A DHCP client hostname query that hasn't been handled or filtered.
|
|
|
|
// Respond with an NXDOMAIN.
|
|
|
|
//
|
|
|
|
// TODO(a.garipov): Route such queries to a custom upstream for the
|
|
|
|
// local domain name if there is one.
|
2022-10-26 21:12:51 +03:00
|
|
|
log.Debug("dnsforward: dhcp client hostname %q was not filtered", reqHost)
|
2022-09-02 16:56:59 +03:00
|
|
|
pctx.Res = s.genNXDomain(req)
|
|
|
|
|
|
|
|
return resultCodeFinish
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
s.setCustomUpstream(pctx, dctx.clientID)
|
2020-05-08 18:39:37 +03:00
|
|
|
|
2021-12-13 18:06:01 +03:00
|
|
|
origReqAD := false
|
2020-05-08 18:39:37 +03:00
|
|
|
if s.conf.EnableDNSSEC {
|
2023-01-23 19:10:56 +03:00
|
|
|
origReqAD = req.AuthenticatedData
|
|
|
|
if !req.AuthenticatedData {
|
2021-12-13 18:06:01 +03:00
|
|
|
req.AuthenticatedData = true
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-06 13:14:41 +03:00
|
|
|
// Process the request further since it wasn't filtered.
|
|
|
|
prx := s.proxy()
|
|
|
|
if prx == nil {
|
2021-12-13 18:06:01 +03:00
|
|
|
dctx.err = srvClosedErr
|
2021-10-06 13:14:41 +03:00
|
|
|
|
|
|
|
return resultCodeError
|
|
|
|
}
|
|
|
|
|
2021-12-13 18:06:01 +03:00
|
|
|
if dctx.err = prx.Resolve(pctx); dctx.err != nil {
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeError
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2023-01-23 19:10:56 +03:00
|
|
|
if s.performDNS64(prx, dctx) == resultCodeError {
|
|
|
|
return resultCodeError
|
|
|
|
}
|
|
|
|
|
2021-12-13 18:06:01 +03:00
|
|
|
dctx.responseFromUpstream = true
|
|
|
|
dctx.responseAD = pctx.Res.AuthenticatedData
|
2020-05-08 18:39:37 +03:00
|
|
|
|
2021-12-13 18:06:01 +03:00
|
|
|
if s.conf.EnableDNSSEC && !origReqAD {
|
|
|
|
pctx.Req.AuthenticatedData = false
|
|
|
|
pctx.Res.AuthenticatedData = false
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeSuccess
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2022-09-02 16:56:59 +03:00
|
|
|
// isDHCPClientHostQ returns true if q is from a request for a DHCP client
|
|
|
|
// hostname. If ok is true, reqHost contains the requested hostname.
|
|
|
|
func (s *Server) isDHCPClientHostQ(q dns.Question) (reqHost string, ok bool) {
|
|
|
|
if !s.dhcpServer.Enabled() {
|
|
|
|
return "", false
|
|
|
|
}
|
|
|
|
|
|
|
|
// Include AAAA here, because despite the fact that we don't support it yet,
|
|
|
|
// the expected behavior here is to respond with an empty answer and not
|
|
|
|
// NXDOMAIN.
|
|
|
|
if qt := q.Qtype; qt != dns.TypeA && qt != dns.TypeAAAA {
|
|
|
|
return "", false
|
|
|
|
}
|
|
|
|
|
|
|
|
reqHost = strings.ToLower(q.Name[:len(q.Name)-1])
|
|
|
|
if strings.HasSuffix(reqHost, s.localDomainSuffix) {
|
|
|
|
return reqHost, true
|
|
|
|
}
|
|
|
|
|
|
|
|
return "", false
|
|
|
|
}
|
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
// setCustomUpstream sets custom upstream settings in pctx, if necessary.
|
|
|
|
func (s *Server) setCustomUpstream(pctx *proxy.DNSContext, clientID string) {
|
|
|
|
customUpsByClient := s.conf.GetCustomUpstreamByClient
|
|
|
|
if pctx.Addr == nil || customUpsByClient == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Use the ClientID first, since it has a higher priority.
|
|
|
|
id := stringutil.Coalesce(clientID, ipStringFromAddr(pctx.Addr))
|
|
|
|
upsConf, err := customUpsByClient(id)
|
|
|
|
if err != nil {
|
2022-10-26 21:12:51 +03:00
|
|
|
log.Error("dnsforward: getting custom upstreams for client %s: %s", id, err)
|
2020-05-08 18:39:37 +03:00
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if upsConf != nil {
|
2022-10-26 21:12:51 +03:00
|
|
|
log.Debug("dnsforward: using custom upstreams for client %s", id)
|
2022-09-02 14:52:19 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
pctx.CustomUpstreamConfig = upsConf
|
|
|
|
}
|
|
|
|
|
|
|
|
// Apply filtering logic after we have received response from upstream servers
|
|
|
|
func (s *Server) processFilteringAfterResponse(dctx *dnsContext) (rc resultCode) {
|
|
|
|
pctx := dctx.proxyCtx
|
|
|
|
switch res := dctx.result; res.Reason {
|
2021-10-20 19:52:13 +03:00
|
|
|
case filtering.NotFilteredAllowList:
|
2022-09-02 14:52:19 +03:00
|
|
|
return resultCodeSuccess
|
2021-10-20 19:52:13 +03:00
|
|
|
case
|
|
|
|
filtering.Rewritten,
|
2021-05-21 16:15:47 +03:00
|
|
|
filtering.RewrittenRule:
|
2020-12-21 17:48:07 +03:00
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
if dctx.origQuestion.Name == "" {
|
2021-10-20 19:52:13 +03:00
|
|
|
// origQuestion is set in case we get only CNAME without IP from
|
|
|
|
// rewrites table.
|
2022-09-02 14:52:19 +03:00
|
|
|
return resultCodeSuccess
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
2020-06-01 15:23:08 +03:00
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
pctx.Req.Question[0], pctx.Res.Question[0] = dctx.origQuestion, dctx.origQuestion
|
|
|
|
if len(pctx.Res.Answer) > 0 {
|
|
|
|
rr := s.genAnswerCNAME(pctx.Req, res.CanonName)
|
|
|
|
answer := append([]dns.RR{rr}, pctx.Res.Answer...)
|
|
|
|
pctx.Res.Answer = answer
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
2022-09-02 14:52:19 +03:00
|
|
|
|
|
|
|
return resultCodeSuccess
|
2020-05-08 18:39:37 +03:00
|
|
|
default:
|
2022-09-02 14:52:19 +03:00
|
|
|
return s.filterAfterResponse(dctx, pctx)
|
|
|
|
}
|
|
|
|
}
|
2021-10-20 19:52:13 +03:00
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
// filterAfterResponse returns the result of filtering the response that wasn't
|
|
|
|
// explicitly allowed or rewritten.
|
|
|
|
func (s *Server) filterAfterResponse(dctx *dnsContext, pctx *proxy.DNSContext) (res resultCode) {
|
|
|
|
// Check the response only if it's from an upstream. Don't check the
|
|
|
|
// response if the protection is disabled since dnsrewrite rules aren't
|
|
|
|
// applied to it anyway.
|
|
|
|
if !dctx.protectionEnabled || !dctx.responseFromUpstream || s.dnsFilter == nil {
|
|
|
|
return resultCodeSuccess
|
|
|
|
}
|
2021-10-20 19:52:13 +03:00
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
result, err := s.filterDNSResponse(pctx, dctx.setts)
|
|
|
|
if err != nil {
|
|
|
|
dctx.err = err
|
2021-10-20 19:52:13 +03:00
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
return resultCodeError
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|
|
|
|
|
2022-09-02 14:52:19 +03:00
|
|
|
if result != nil {
|
|
|
|
dctx.result = result
|
|
|
|
dctx.origResp = pctx.Res
|
2021-10-20 19:52:13 +03:00
|
|
|
}
|
|
|
|
|
2021-01-27 18:32:13 +03:00
|
|
|
return resultCodeSuccess
|
2020-05-08 18:39:37 +03:00
|
|
|
}
|