2019-06-10 11:33:19 +03:00
|
|
|
package home
|
2018-10-11 20:52:23 +03:00
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
2018-11-28 16:45:30 +03:00
|
|
|
"net"
|
2019-02-10 20:47:43 +03:00
|
|
|
"os"
|
2019-09-06 15:42:21 +03:00
|
|
|
"path/filepath"
|
2018-10-11 20:52:23 +03:00
|
|
|
|
2018-11-30 13:24:42 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/dnsfilter"
|
2018-11-28 16:45:30 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/dnsforward"
|
2019-08-26 11:54:38 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/querylog"
|
2019-08-22 16:34:58 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/stats"
|
2019-03-20 14:24:33 +03:00
|
|
|
"github.com/AdguardTeam/dnsproxy/proxy"
|
2019-12-23 19:31:27 +03:00
|
|
|
"github.com/AdguardTeam/dnsproxy/upstream"
|
2019-02-25 16:44:22 +03:00
|
|
|
"github.com/AdguardTeam/golibs/log"
|
2018-11-28 16:45:30 +03:00
|
|
|
"github.com/joomcode/errorx"
|
2018-10-11 20:52:23 +03:00
|
|
|
)
|
|
|
|
|
2019-09-25 15:36:09 +03:00
|
|
|
// Called by other modules when configuration is changed
|
|
|
|
func onConfigModified() {
|
|
|
|
_ = config.write()
|
|
|
|
}
|
|
|
|
|
2019-02-10 20:47:43 +03: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 12:38:58 +03:00
|
|
|
func initDNSServer() error {
|
2019-10-02 16:53:23 +03:00
|
|
|
baseDir := config.getDataDir()
|
|
|
|
|
2019-02-10 20:47:43 +03:00
|
|
|
err := os.MkdirAll(baseDir, 0755)
|
|
|
|
if err != nil {
|
2019-12-11 12:38:58 +03:00
|
|
|
return fmt.Errorf("Cannot create DNS data dir at %s: %s", baseDir, err)
|
2019-02-10 20:47:43 +03:00
|
|
|
}
|
|
|
|
|
2019-09-16 16:14:52 +03:00
|
|
|
statsConf := stats.Config{
|
2019-09-25 15:36:09 +03:00
|
|
|
Filename: filepath.Join(baseDir, "stats.db"),
|
|
|
|
LimitDays: config.DNS.StatsInterval,
|
|
|
|
ConfigModified: onConfigModified,
|
|
|
|
HTTPRegister: httpRegister,
|
2019-09-16 16:14:52 +03:00
|
|
|
}
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.stats, err = stats.New(statsConf)
|
2019-09-06 15:42:21 +03:00
|
|
|
if err != nil {
|
2019-12-11 12:38:58 +03:00
|
|
|
return fmt.Errorf("Couldn't initialize statistics module")
|
2019-08-22 16:34:58 +03:00
|
|
|
}
|
2019-08-26 11:54:38 +03:00
|
|
|
conf := querylog.Config{
|
2019-09-27 18:58:57 +03:00
|
|
|
Enabled: config.DNS.QueryLogEnabled,
|
|
|
|
BaseDir: baseDir,
|
|
|
|
Interval: config.DNS.QueryLogInterval,
|
2019-11-08 12:31:50 +03:00
|
|
|
MemSize: config.DNS.QueryLogMemSize,
|
2019-09-27 18:58:57 +03:00
|
|
|
ConfigModified: onConfigModified,
|
|
|
|
HTTPRegister: httpRegister,
|
2019-08-26 11:54:38 +03:00
|
|
|
}
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.queryLog = querylog.New(conf)
|
2019-10-09 19:51:26 +03: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)
|
|
|
|
filterConf.ConfigModified = onConfigModified
|
|
|
|
filterConf.HTTPRegister = httpRegister
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.dnsFilter = dnsfilter.New(&filterConf, nil)
|
2019-10-09 19:51:26 +03:00
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.dnsServer = dnsforward.NewServer(Context.dnsFilter, Context.stats, Context.queryLog)
|
|
|
|
dnsConfig := generateServerConfig()
|
|
|
|
err = Context.dnsServer.Prepare(&dnsConfig)
|
|
|
|
if err != nil {
|
2020-01-16 14:25:40 +03:00
|
|
|
closeDNSServer()
|
2019-12-11 12:38:58 +03:00
|
|
|
return fmt.Errorf("dnsServer.Prepare: %s", err)
|
|
|
|
}
|
2019-05-21 14:53:13 +03:00
|
|
|
|
2019-10-02 16:53:23 +03:00
|
|
|
sessFilename := filepath.Join(baseDir, "sessions.db")
|
2019-11-12 14:23:00 +03:00
|
|
|
config.auth = InitAuth(sessFilename, config.Users, config.WebSessionTTLHours*60*60)
|
2019-12-16 17:04:30 +03:00
|
|
|
if config.auth == nil {
|
2020-01-16 14:25:40 +03:00
|
|
|
closeDNSServer()
|
2019-12-16 17:04:30 +03:00
|
|
|
return fmt.Errorf("Couldn't initialize Auth module")
|
|
|
|
}
|
2019-08-29 12:34:07 +03:00
|
|
|
config.Users = nil
|
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.rdns = InitRDNS(Context.dnsServer, &Context.clients)
|
|
|
|
Context.whois = initWhois(&Context.clients)
|
2019-10-07 15:57:34 +03:00
|
|
|
|
2019-09-04 14:12:00 +03:00
|
|
|
initFiltering()
|
2019-12-11 12:38:58 +03:00
|
|
|
return nil
|
2019-02-10 20:47:43 +03:00
|
|
|
}
|
2018-10-11 20:52:23 +03:00
|
|
|
|
|
|
|
func isRunning() bool {
|
2019-12-11 12:38:58 +03:00
|
|
|
return Context.dnsServer != nil && Context.dnsServer.IsRunning()
|
2018-10-11 20:52:23 +03:00
|
|
|
}
|
|
|
|
|
2019-10-02 16:40:26 +03:00
|
|
|
// nolint (gocyclo)
|
2019-09-18 18:44:27 +03: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 14:53:13 +03:00
|
|
|
func onDNSRequest(d *proxy.DNSContext) {
|
2019-06-04 20:38:53 +03:00
|
|
|
ip := dnsforward.GetIPString(d.Addr)
|
|
|
|
if ip == "" {
|
|
|
|
// This would be quite weird if we get here
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-06-25 16:14:52 +03:00
|
|
|
ipAddr := net.ParseIP(ip)
|
|
|
|
if !ipAddr.IsLoopback() {
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.rdns.Begin(ip)
|
2019-06-25 16:14:52 +03:00
|
|
|
}
|
2019-09-18 18:44:27 +03:00
|
|
|
if isPublicIP(ipAddr) {
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.whois.Begin(ip)
|
2019-06-25 16:14:52 +03:00
|
|
|
}
|
2019-05-21 14:53:13 +03:00
|
|
|
}
|
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
func generateServerConfig() dnsforward.ServerConfig {
|
2018-11-28 16:45:30 +03:00
|
|
|
newconfig := dnsforward.ServerConfig{
|
2019-01-19 04:41:43 +03: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 20:29:00 +03:00
|
|
|
FilteringConfig: config.DNS.FilteringConfig,
|
2019-10-30 11:52:58 +03:00
|
|
|
ConfigModified: onConfigModified,
|
|
|
|
HTTPRegister: httpRegister,
|
|
|
|
OnDNSRequest: onDNSRequest,
|
2018-11-28 16:45:30 +03:00
|
|
|
}
|
|
|
|
|
2019-02-14 18:00:23 +03:00
|
|
|
if config.TLS.Enabled {
|
|
|
|
newconfig.TLSConfig = config.TLS.TLSConfig
|
|
|
|
if config.TLS.PortDNSOverTLS != 0 {
|
|
|
|
newconfig.TLSListenAddr = &net.TCPAddr{IP: net.ParseIP(config.DNS.BindHost), Port: config.TLS.PortDNSOverTLS}
|
|
|
|
}
|
2019-02-12 17:23:38 +03:00
|
|
|
}
|
|
|
|
|
2019-07-23 12:21:37 +03:00
|
|
|
newconfig.FilterHandler = applyAdditionalFiltering
|
2019-11-06 17:24:15 +03:00
|
|
|
newconfig.GetUpstreamsByClient = getUpstreamsByClient
|
2019-12-11 12:38:58 +03:00
|
|
|
return newconfig
|
2018-11-28 18:57:20 +03:00
|
|
|
}
|
|
|
|
|
2019-12-23 19:31:27 +03:00
|
|
|
func getUpstreamsByClient(clientAddr string) []upstream.Upstream {
|
|
|
|
return Context.clients.FindUpstreams(clientAddr)
|
2019-11-06 17:24:15 +03:00
|
|
|
}
|
|
|
|
|
2019-04-26 16:07:12 +03:00
|
|
|
// If a client has his own settings, apply them
|
2019-07-23 12:21:37 +03:00
|
|
|
func applyAdditionalFiltering(clientAddr string, setts *dnsfilter.RequestFilteringSettings) {
|
|
|
|
ApplyBlockedServices(setts, config.DNS.BlockedServices)
|
|
|
|
|
|
|
|
if len(clientAddr) == 0 {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
c, ok := Context.clients.Find(clientAddr)
|
2019-07-23 12:21:37 +03:00
|
|
|
if !ok {
|
2019-04-26 16:07:12 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Debug("Using settings for client with IP %s", clientAddr)
|
2019-07-23 12:21:37 +03:00
|
|
|
|
|
|
|
if c.UseOwnBlockedServices {
|
|
|
|
ApplyBlockedServices(setts, c.BlockedServices)
|
|
|
|
}
|
|
|
|
|
|
|
|
if !c.UseOwnSettings {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-06-06 21:04:17 +03:00
|
|
|
setts.FilteringEnabled = c.FilteringEnabled
|
|
|
|
setts.SafeSearchEnabled = c.SafeSearchEnabled
|
|
|
|
setts.SafeBrowsingEnabled = c.SafeBrowsingEnabled
|
2019-06-06 22:42:17 +03:00
|
|
|
setts.ParentalEnabled = c.ParentalEnabled
|
2019-04-26 16:07:12 +03:00
|
|
|
}
|
|
|
|
|
2018-11-28 18:57:20 +03:00
|
|
|
func startDNSServer() error {
|
|
|
|
if isRunning() {
|
2019-01-25 16:01:27 +03:00
|
|
|
return fmt.Errorf("unable to start forwarding DNS server: Already running")
|
2018-11-28 18:57:20 +03:00
|
|
|
}
|
2018-10-17 20:43:26 +03:00
|
|
|
|
2019-10-09 19:51:26 +03:00
|
|
|
enableFilters(false)
|
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
err := Context.dnsServer.Start()
|
2018-10-11 20:52:23 +03:00
|
|
|
if err != nil {
|
2018-11-28 16:45:30 +03:00
|
|
|
return errorx.Decorate(err, "Couldn't start forwarding DNS server")
|
2018-10-11 20:52:23 +03:00
|
|
|
}
|
|
|
|
|
2020-01-16 14:25:40 +03:00
|
|
|
Context.dnsFilter.Start()
|
2019-10-17 14:33:38 +03:00
|
|
|
startFiltering()
|
2020-01-16 14:25:40 +03:00
|
|
|
Context.stats.Start()
|
|
|
|
Context.queryLog.Start()
|
2019-10-17 14:33:38 +03:00
|
|
|
|
2019-10-10 13:54:26 +03:00
|
|
|
const topClientsNumber = 100 // the number of clients to get
|
2019-12-11 12:38:58 +03:00
|
|
|
topClients := Context.stats.GetTopClientsIP(topClientsNumber)
|
2019-10-10 13:54:26 +03:00
|
|
|
for _, ip := range topClients {
|
|
|
|
ipAddr := net.ParseIP(ip)
|
|
|
|
if !ipAddr.IsLoopback() {
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.rdns.Begin(ip)
|
2019-10-10 13:54:26 +03:00
|
|
|
}
|
|
|
|
if isPublicIP(ipAddr) {
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.whois.Begin(ip)
|
2019-10-10 13:54:26 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-11 20:52:23 +03:00
|
|
|
return nil
|
|
|
|
}
|
2018-11-28 18:57:20 +03:00
|
|
|
|
|
|
|
func reconfigureDNSServer() error {
|
2019-12-11 12:38:58 +03:00
|
|
|
newconfig := generateServerConfig()
|
|
|
|
err := Context.dnsServer.Reconfigure(&newconfig)
|
2018-11-28 18:57:20 +03:00
|
|
|
if err != nil {
|
|
|
|
return errorx.Decorate(err, "Couldn't start forwarding DNS server")
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
2018-12-05 15:36:18 +03:00
|
|
|
|
|
|
|
func stopDNSServer() error {
|
2019-12-16 17:04:30 +03:00
|
|
|
if !isRunning() {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
err := Context.dnsServer.Stop()
|
2018-12-05 15:36:18 +03:00
|
|
|
if err != nil {
|
|
|
|
return errorx.Decorate(err, "Couldn't stop forwarding DNS server")
|
|
|
|
}
|
|
|
|
|
2020-01-16 14:25:40 +03:00
|
|
|
closeDNSServer()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func closeDNSServer() {
|
2019-09-16 15:54:41 +03:00
|
|
|
// DNS forward module must be closed BEFORE stats or queryLog because it depends on them
|
2020-01-16 14:25:40 +03:00
|
|
|
if Context.dnsServer != nil {
|
|
|
|
Context.dnsServer.Close()
|
|
|
|
Context.dnsServer = nil
|
|
|
|
}
|
|
|
|
|
|
|
|
if Context.dnsFilter != nil {
|
|
|
|
Context.dnsFilter.Close()
|
|
|
|
Context.dnsFilter = nil
|
|
|
|
}
|
2019-09-16 15:54:41 +03:00
|
|
|
|
2020-01-16 14:25:40 +03:00
|
|
|
if Context.stats != nil {
|
|
|
|
Context.stats.Close()
|
|
|
|
Context.stats = nil
|
|
|
|
}
|
2019-10-09 19:51:26 +03:00
|
|
|
|
2020-01-16 14:25:40 +03:00
|
|
|
if Context.queryLog != nil {
|
|
|
|
Context.queryLog.Close()
|
|
|
|
Context.queryLog = nil
|
|
|
|
}
|
2019-09-16 15:54:41 +03:00
|
|
|
|
2020-01-16 14:25:40 +03:00
|
|
|
if config.auth != nil {
|
|
|
|
config.auth.Close()
|
|
|
|
config.auth = nil
|
|
|
|
}
|
2019-09-16 15:54:41 +03:00
|
|
|
|
2020-01-16 14:25:40 +03:00
|
|
|
log.Debug("Closed all DNS modules")
|
2018-12-05 15:36:18 +03:00
|
|
|
}
|