2019-06-10 09:33:19 +01:00
|
|
|
package home
|
2018-10-11 18:52:23 +01:00
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
2018-11-28 13:45:30 +00:00
|
|
|
"net"
|
2019-09-06 13:42:21 +01:00
|
|
|
"path/filepath"
|
2018-10-11 18:52:23 +01:00
|
|
|
|
2018-11-30 10:24:42 +00:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/dnsfilter"
|
2018-11-28 13:45:30 +00:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/dnsforward"
|
2019-08-26 09:54:38 +01:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/querylog"
|
2019-08-22 14:34:58 +01:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/stats"
|
2020-02-27 08:48:59 +00:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/util"
|
2019-03-20 11:24:33 +00:00
|
|
|
"github.com/AdguardTeam/dnsproxy/proxy"
|
2019-02-25 13:44:22 +00:00
|
|
|
"github.com/AdguardTeam/golibs/log"
|
2018-11-28 13:45:30 +00:00
|
|
|
"github.com/joomcode/errorx"
|
2018-10-11 18:52:23 +01:00
|
|
|
)
|
|
|
|
|
2019-09-25 13:36:09 +01:00
|
|
|
// Called by other modules when configuration is changed
|
|
|
|
func onConfigModified() {
|
|
|
|
_ = config.write()
|
|
|
|
}
|
|
|
|
|
2019-02-10 17:47:43 +00:00
|
|
|
// initDNSServer creates an instance of the dnsforward.Server
|
|
|
|
// Please note that we must do it even if we don't start it
|
|
|
|
// so that we had access to the query log and the stats
|
2019-12-11 09:38:58 +00:00
|
|
|
func initDNSServer() error {
|
2020-02-18 16:27:09 +00:00
|
|
|
var err error
|
2020-02-13 15:42:07 +00:00
|
|
|
baseDir := Context.getDataDir()
|
2019-10-02 14:53:23 +01:00
|
|
|
|
2019-09-16 14:14:52 +01:00
|
|
|
statsConf := stats.Config{
|
2020-03-03 17:21:53 +00:00
|
|
|
Filename: filepath.Join(baseDir, "stats.db"),
|
|
|
|
LimitDays: config.DNS.StatsInterval,
|
|
|
|
AnonymizeClientIP: config.DNS.AnonymizeClientIP,
|
|
|
|
ConfigModified: onConfigModified,
|
|
|
|
HTTPRegister: httpRegister,
|
2019-09-16 14:14:52 +01:00
|
|
|
}
|
2019-12-11 09:38:58 +00:00
|
|
|
Context.stats, err = stats.New(statsConf)
|
2019-09-06 13:42:21 +01:00
|
|
|
if err != nil {
|
2020-04-05 16:34:43 +01:00
|
|
|
return fmt.Errorf("couldn't initialize statistics module")
|
2019-08-22 14:34:58 +01:00
|
|
|
}
|
2019-08-26 09:54:38 +01:00
|
|
|
conf := querylog.Config{
|
2020-03-03 17:21:53 +00:00
|
|
|
Enabled: config.DNS.QueryLogEnabled,
|
2020-05-28 13:29:36 +01:00
|
|
|
FileEnabled: config.DNS.QueryLogFileEnabled,
|
2020-03-03 17:21:53 +00:00
|
|
|
BaseDir: baseDir,
|
|
|
|
Interval: config.DNS.QueryLogInterval,
|
|
|
|
MemSize: config.DNS.QueryLogMemSize,
|
|
|
|
AnonymizeClientIP: config.DNS.AnonymizeClientIP,
|
|
|
|
ConfigModified: onConfigModified,
|
|
|
|
HTTPRegister: httpRegister,
|
2019-08-26 09:54:38 +01:00
|
|
|
}
|
2019-12-11 09:38:58 +00:00
|
|
|
Context.queryLog = querylog.New(conf)
|
2019-10-09 17:51:26 +01:00
|
|
|
|
|
|
|
filterConf := config.DNS.DnsfilterConf
|
|
|
|
bindhost := config.DNS.BindHost
|
|
|
|
if config.DNS.BindHost == "0.0.0.0" {
|
|
|
|
bindhost = "127.0.0.1"
|
|
|
|
}
|
|
|
|
filterConf.ResolverAddress = fmt.Sprintf("%s:%d", bindhost, config.DNS.Port)
|
2020-03-20 12:05:43 +00:00
|
|
|
filterConf.AutoHosts = &Context.autoHosts
|
2019-10-09 17:51:26 +01:00
|
|
|
filterConf.ConfigModified = onConfigModified
|
|
|
|
filterConf.HTTPRegister = httpRegister
|
2019-12-11 09:38:58 +00:00
|
|
|
Context.dnsFilter = dnsfilter.New(&filterConf, nil)
|
2019-10-09 17:51:26 +01:00
|
|
|
|
2020-06-23 10:13:13 +01:00
|
|
|
p := dnsforward.DNSCreateParams{
|
|
|
|
DNSFilter: Context.dnsFilter,
|
|
|
|
Stats: Context.stats,
|
|
|
|
QueryLog: Context.queryLog,
|
|
|
|
DHCPServer: Context.dhcpServer,
|
|
|
|
}
|
|
|
|
Context.dnsServer = dnsforward.NewServer(p)
|
2019-12-11 09:38:58 +00:00
|
|
|
dnsConfig := generateServerConfig()
|
|
|
|
err = Context.dnsServer.Prepare(&dnsConfig)
|
|
|
|
if err != nil {
|
2020-01-16 11:25:40 +00:00
|
|
|
closeDNSServer()
|
2019-12-11 09:38:58 +00:00
|
|
|
return fmt.Errorf("dnsServer.Prepare: %s", err)
|
|
|
|
}
|
2019-05-21 12:53:13 +01:00
|
|
|
|
2019-12-11 09:38:58 +00:00
|
|
|
Context.rdns = InitRDNS(Context.dnsServer, &Context.clients)
|
|
|
|
Context.whois = initWhois(&Context.clients)
|
2019-10-07 13:57:34 +01:00
|
|
|
|
2020-03-17 12:00:40 +00:00
|
|
|
Context.filters.Init()
|
2019-12-11 09:38:58 +00:00
|
|
|
return nil
|
2019-02-10 17:47:43 +00:00
|
|
|
}
|
2018-10-11 18:52:23 +01:00
|
|
|
|
|
|
|
func isRunning() bool {
|
2019-12-11 09:38:58 +00:00
|
|
|
return Context.dnsServer != nil && Context.dnsServer.IsRunning()
|
2018-10-11 18:52:23 +01:00
|
|
|
}
|
|
|
|
|
2019-10-02 14:40:26 +01:00
|
|
|
// nolint (gocyclo)
|
2019-09-18 16:44:27 +01:00
|
|
|
// Return TRUE if IP is within public Internet IP range
|
|
|
|
func isPublicIP(ip net.IP) bool {
|
|
|
|
ip4 := ip.To4()
|
|
|
|
if ip4 != nil {
|
|
|
|
switch ip4[0] {
|
|
|
|
case 0:
|
|
|
|
return false //software
|
|
|
|
case 10:
|
|
|
|
return false //private network
|
|
|
|
case 127:
|
|
|
|
return false //loopback
|
|
|
|
case 169:
|
|
|
|
if ip4[1] == 254 {
|
|
|
|
return false //link-local
|
|
|
|
}
|
|
|
|
case 172:
|
|
|
|
if ip4[1] >= 16 && ip4[1] <= 31 {
|
|
|
|
return false //private network
|
|
|
|
}
|
|
|
|
case 192:
|
|
|
|
if (ip4[1] == 0 && ip4[2] == 0) || //private network
|
|
|
|
(ip4[1] == 0 && ip4[2] == 2) || //documentation
|
|
|
|
(ip4[1] == 88 && ip4[2] == 99) || //reserved
|
|
|
|
(ip4[1] == 168) { //private network
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
case 198:
|
|
|
|
if (ip4[1] == 18 || ip4[2] == 19) || //private network
|
|
|
|
(ip4[1] == 51 || ip4[2] == 100) { //documentation
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
case 203:
|
|
|
|
if ip4[1] == 0 && ip4[2] == 113 { //documentation
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
case 224:
|
|
|
|
if ip4[1] == 0 && ip4[2] == 0 { //multicast
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
case 255:
|
|
|
|
if ip4[1] == 255 && ip4[2] == 255 && ip4[3] == 255 { //subnet
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if ip.IsLoopback() || ip.IsLinkLocalMulticast() || ip.IsLinkLocalUnicast() {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2019-05-21 12:53:13 +01:00
|
|
|
func onDNSRequest(d *proxy.DNSContext) {
|
2019-06-04 18:38:53 +01:00
|
|
|
ip := dnsforward.GetIPString(d.Addr)
|
|
|
|
if ip == "" {
|
|
|
|
// This would be quite weird if we get here
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-06-25 14:14:52 +01:00
|
|
|
ipAddr := net.ParseIP(ip)
|
|
|
|
if !ipAddr.IsLoopback() {
|
2019-12-11 09:38:58 +00:00
|
|
|
Context.rdns.Begin(ip)
|
2019-06-25 14:14:52 +01:00
|
|
|
}
|
2019-09-18 16:44:27 +01:00
|
|
|
if isPublicIP(ipAddr) {
|
2019-12-11 09:38:58 +00:00
|
|
|
Context.whois.Begin(ip)
|
2019-06-25 14:14:52 +01:00
|
|
|
}
|
2019-05-21 12:53:13 +01:00
|
|
|
}
|
|
|
|
|
2019-12-11 09:38:58 +00:00
|
|
|
func generateServerConfig() dnsforward.ServerConfig {
|
2018-11-28 13:45:30 +00:00
|
|
|
newconfig := dnsforward.ServerConfig{
|
2019-01-19 01:41:43 +00:00
|
|
|
UDPListenAddr: &net.UDPAddr{IP: net.ParseIP(config.DNS.BindHost), Port: config.DNS.Port},
|
|
|
|
TCPListenAddr: &net.TCPAddr{IP: net.ParseIP(config.DNS.BindHost), Port: config.DNS.Port},
|
2018-12-05 17:29:00 +00:00
|
|
|
FilteringConfig: config.DNS.FilteringConfig,
|
2019-10-30 08:52:58 +00:00
|
|
|
ConfigModified: onConfigModified,
|
|
|
|
HTTPRegister: httpRegister,
|
|
|
|
OnDNSRequest: onDNSRequest,
|
2018-11-28 13:45:30 +00:00
|
|
|
}
|
|
|
|
|
2020-02-19 12:28:06 +00:00
|
|
|
tlsConf := tlsConfigSettings{}
|
|
|
|
Context.tls.WriteDiskConfig(&tlsConf)
|
|
|
|
if tlsConf.Enabled {
|
|
|
|
newconfig.TLSConfig = tlsConf.TLSConfig
|
|
|
|
if tlsConf.PortDNSOverTLS != 0 {
|
|
|
|
newconfig.TLSListenAddr = &net.TCPAddr{
|
|
|
|
IP: net.ParseIP(config.DNS.BindHost),
|
|
|
|
Port: tlsConf.PortDNSOverTLS,
|
|
|
|
}
|
2019-02-14 15:00:23 +00:00
|
|
|
}
|
2019-02-12 14:23:38 +00:00
|
|
|
}
|
2020-03-04 12:11:17 +00:00
|
|
|
newconfig.TLSv12Roots = Context.tlsRoots
|
2020-03-23 07:23:34 +00:00
|
|
|
newconfig.TLSCiphers = Context.tlsCiphers
|
2020-02-27 08:48:59 +00:00
|
|
|
newconfig.TLSAllowUnencryptedDOH = tlsConf.AllowUnencryptedDOH
|
2019-02-12 14:23:38 +00:00
|
|
|
|
2019-07-23 10:21:37 +01:00
|
|
|
newconfig.FilterHandler = applyAdditionalFiltering
|
2020-05-13 18:31:43 +01:00
|
|
|
newconfig.GetCustomUpstreamByClient = Context.clients.FindUpstreams
|
2019-12-11 09:38:58 +00:00
|
|
|
return newconfig
|
2018-11-28 15:57:20 +00:00
|
|
|
}
|
|
|
|
|
2020-02-27 08:48:59 +00:00
|
|
|
// Get the list of DNS addresses the server is listening on
|
|
|
|
func getDNSAddresses() []string {
|
|
|
|
dnsAddresses := []string{}
|
|
|
|
|
|
|
|
if config.DNS.BindHost == "0.0.0.0" {
|
|
|
|
ifaces, e := util.GetValidNetInterfacesForWeb()
|
|
|
|
if e != nil {
|
|
|
|
log.Error("Couldn't get network interfaces: %v", e)
|
|
|
|
return []string{}
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, iface := range ifaces {
|
|
|
|
for _, addr := range iface.Addresses {
|
|
|
|
addDNSAddress(&dnsAddresses, addr)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
addDNSAddress(&dnsAddresses, config.DNS.BindHost)
|
|
|
|
}
|
|
|
|
|
|
|
|
tlsConf := tlsConfigSettings{}
|
|
|
|
Context.tls.WriteDiskConfig(&tlsConf)
|
|
|
|
if tlsConf.Enabled && len(tlsConf.ServerName) != 0 {
|
|
|
|
|
|
|
|
if tlsConf.PortHTTPS != 0 {
|
|
|
|
addr := tlsConf.ServerName
|
|
|
|
if tlsConf.PortHTTPS != 443 {
|
|
|
|
addr = fmt.Sprintf("%s:%d", addr, tlsConf.PortHTTPS)
|
|
|
|
}
|
|
|
|
addr = fmt.Sprintf("https://%s/dns-query", addr)
|
|
|
|
dnsAddresses = append(dnsAddresses, addr)
|
|
|
|
}
|
|
|
|
|
|
|
|
if tlsConf.PortDNSOverTLS != 0 {
|
|
|
|
addr := fmt.Sprintf("tls://%s:%d", tlsConf.ServerName, tlsConf.PortDNSOverTLS)
|
|
|
|
dnsAddresses = append(dnsAddresses, addr)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return dnsAddresses
|
|
|
|
}
|
|
|
|
|
2019-04-26 14:07:12 +01:00
|
|
|
// If a client has his own settings, apply them
|
2019-07-23 10:21:37 +01:00
|
|
|
func applyAdditionalFiltering(clientAddr string, setts *dnsfilter.RequestFilteringSettings) {
|
2020-02-18 17:17:35 +00:00
|
|
|
Context.dnsFilter.ApplyBlockedServices(setts, nil, true)
|
2019-07-23 10:21:37 +01:00
|
|
|
|
|
|
|
if len(clientAddr) == 0 {
|
|
|
|
return
|
|
|
|
}
|
2020-06-23 12:36:26 +01:00
|
|
|
setts.ClientIP = clientAddr
|
2019-07-23 10:21:37 +01:00
|
|
|
|
2019-12-11 09:38:58 +00:00
|
|
|
c, ok := Context.clients.Find(clientAddr)
|
2019-07-23 10:21:37 +01:00
|
|
|
if !ok {
|
2019-04-26 14:07:12 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-07-23 16:09:39 +01:00
|
|
|
log.Debug("Using settings for client %s with IP %s", c.Name, clientAddr)
|
2019-07-23 10:21:37 +01:00
|
|
|
|
|
|
|
if c.UseOwnBlockedServices {
|
2020-02-18 17:17:35 +00:00
|
|
|
Context.dnsFilter.ApplyBlockedServices(setts, c.BlockedServices, false)
|
2019-07-23 10:21:37 +01:00
|
|
|
}
|
|
|
|
|
2020-06-23 12:36:26 +01:00
|
|
|
setts.ClientName = c.Name
|
2020-01-28 11:06:52 +00:00
|
|
|
setts.ClientTags = c.Tags
|
|
|
|
|
2019-07-23 10:21:37 +01:00
|
|
|
if !c.UseOwnSettings {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-06-06 19:04:17 +01:00
|
|
|
setts.FilteringEnabled = c.FilteringEnabled
|
|
|
|
setts.SafeSearchEnabled = c.SafeSearchEnabled
|
|
|
|
setts.SafeBrowsingEnabled = c.SafeBrowsingEnabled
|
2019-06-06 20:42:17 +01:00
|
|
|
setts.ParentalEnabled = c.ParentalEnabled
|
2019-04-26 14:07:12 +01:00
|
|
|
}
|
|
|
|
|
2018-11-28 15:57:20 +00:00
|
|
|
func startDNSServer() error {
|
|
|
|
if isRunning() {
|
2019-01-25 13:01:27 +00:00
|
|
|
return fmt.Errorf("unable to start forwarding DNS server: Already running")
|
2018-11-28 15:57:20 +00:00
|
|
|
}
|
2018-10-17 18:43:26 +01:00
|
|
|
|
2019-10-09 17:51:26 +01:00
|
|
|
enableFilters(false)
|
|
|
|
|
2020-02-18 16:27:09 +00:00
|
|
|
Context.clients.Start()
|
|
|
|
|
2019-12-11 09:38:58 +00:00
|
|
|
err := Context.dnsServer.Start()
|
2018-10-11 18:52:23 +01:00
|
|
|
if err != nil {
|
2018-11-28 13:45:30 +00:00
|
|
|
return errorx.Decorate(err, "Couldn't start forwarding DNS server")
|
2018-10-11 18:52:23 +01:00
|
|
|
}
|
|
|
|
|
2020-01-16 11:25:40 +00:00
|
|
|
Context.dnsFilter.Start()
|
2020-03-17 12:00:40 +00:00
|
|
|
Context.filters.Start()
|
2020-01-16 11:25:40 +00:00
|
|
|
Context.stats.Start()
|
|
|
|
Context.queryLog.Start()
|
2019-10-17 12:33:38 +01:00
|
|
|
|
2019-10-10 11:54:26 +01:00
|
|
|
const topClientsNumber = 100 // the number of clients to get
|
2019-12-11 09:38:58 +00:00
|
|
|
topClients := Context.stats.GetTopClientsIP(topClientsNumber)
|
2019-10-10 11:54:26 +01:00
|
|
|
for _, ip := range topClients {
|
|
|
|
ipAddr := net.ParseIP(ip)
|
|
|
|
if !ipAddr.IsLoopback() {
|
2019-12-11 09:38:58 +00:00
|
|
|
Context.rdns.Begin(ip)
|
2019-10-10 11:54:26 +01:00
|
|
|
}
|
|
|
|
if isPublicIP(ipAddr) {
|
2019-12-11 09:38:58 +00:00
|
|
|
Context.whois.Begin(ip)
|
2019-10-10 11:54:26 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-11 18:52:23 +01:00
|
|
|
return nil
|
|
|
|
}
|
2018-11-28 15:57:20 +00:00
|
|
|
|
|
|
|
func reconfigureDNSServer() error {
|
2019-12-11 09:38:58 +00:00
|
|
|
newconfig := generateServerConfig()
|
|
|
|
err := Context.dnsServer.Reconfigure(&newconfig)
|
2018-11-28 15:57:20 +00:00
|
|
|
if err != nil {
|
|
|
|
return errorx.Decorate(err, "Couldn't start forwarding DNS server")
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2018-12-05 12:36:18 +00:00
|
|
|
|
|
|
|
func stopDNSServer() error {
|
2019-12-16 14:04:30 +00:00
|
|
|
if !isRunning() {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-12-11 09:38:58 +00:00
|
|
|
err := Context.dnsServer.Stop()
|
2018-12-05 12:36:18 +00:00
|
|
|
if err != nil {
|
|
|
|
return errorx.Decorate(err, "Couldn't stop forwarding DNS server")
|
|
|
|
}
|
|
|
|
|
2020-01-16 11:25:40 +00:00
|
|
|
closeDNSServer()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func closeDNSServer() {
|
2019-09-16 13:54:41 +01:00
|
|
|
// DNS forward module must be closed BEFORE stats or queryLog because it depends on them
|
2020-01-16 11:25:40 +00:00
|
|
|
if Context.dnsServer != nil {
|
|
|
|
Context.dnsServer.Close()
|
|
|
|
Context.dnsServer = nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if Context.dnsFilter != nil {
|
|
|
|
Context.dnsFilter.Close()
|
|
|
|
Context.dnsFilter = nil
|
|
|
|
}
|
2019-09-16 13:54:41 +01:00
|
|
|
|
2020-01-16 11:25:40 +00:00
|
|
|
if Context.stats != nil {
|
|
|
|
Context.stats.Close()
|
|
|
|
Context.stats = nil
|
|
|
|
}
|
2019-10-09 17:51:26 +01:00
|
|
|
|
2020-01-16 11:25:40 +00:00
|
|
|
if Context.queryLog != nil {
|
|
|
|
Context.queryLog.Close()
|
|
|
|
Context.queryLog = nil
|
|
|
|
}
|
2019-09-16 13:54:41 +01:00
|
|
|
|
2020-03-17 12:00:40 +00:00
|
|
|
Context.filters.Close()
|
|
|
|
|
2020-01-16 11:25:40 +00:00
|
|
|
log.Debug("Closed all DNS modules")
|
2018-12-05 12:36:18 +00:00
|
|
|
}
|