feat: Add DOH support

pkg/resolvers/classic.go

@@ -7,8 +7,8 @@ import (
 	"github.com/miekg/dns"
 )
 
-// Manager represents the config options for setting up a Resolver.
-type Manager struct {
+// ClassicResolver represents the config options for setting up a Resolver.
+type ClassicResolver struct {
 	client  *dns.Client
 	servers []string
 }
@@ -16,21 +16,25 @@ type Manager struct {
 //DefaultResolvConfPath specifies path to default resolv config file on UNIX.
 const DefaultResolvConfPath = "/etc/resolv.conf"
 
-// NewResolver accepts a list of nameservers and configures a DNS resolver.
-func NewResolver(servers []string) Resolver {
+// NewClassicResolver accepts a list of nameservers and configures a DNS resolver.
+func NewClassicResolver(servers []string) (Resolver, error) {
 	client := &dns.Client{}
 	var nameservers []string
 	for _, srv := range servers {
 		if i := net.ParseIP(srv); i != nil {
 			nameservers = append(nameservers, net.JoinHostPort(srv, "53"))
 		} else {
-			nameservers = append(nameservers, dns.Fqdn(srv)+":"+"53")
+			host, port, err := net.SplitHostPort(srv)
+			if err != nil {
+				return nil, err
+			}
+			nameservers = append(nameservers, fmt.Sprintf("%s:%s", host, port))
 		}
 	}
-	return &Manager{
+	return &ClassicResolver{
 		client:  client,
 		servers: nameservers,
-	}
+	}, nil
 }
 
 // NewResolverFromResolvFile loads the configuration from resolv config file
@@ -56,7 +60,7 @@ func NewResolverFromResolvFile(resolvFilePath string) (Resolver, error) {
 	}
 
 	client := &dns.Client{}
-	return &Manager{
+	return &ClassicResolver{
 		client:  client,
 		servers: servers,
 	}, nil
@@ -65,7 +69,7 @@ func NewResolverFromResolvFile(resolvFilePath string) (Resolver, error) {
 // Lookup prepare a list of DNS messages to be sent to the server.
 // It's possible to send multiple question in one message
 // but some nameservers are not able to
-func (m *Manager) Lookup(questions []dns.Question) error {
+func (c *ClassicResolver) Lookup(questions []dns.Question) error {
 	var messages = make([]dns.Msg, 0, len(questions))
 	for _, q := range questions {
 		msg := dns.Msg{}
@@ -76,8 +80,8 @@ func (m *Manager) Lookup(questions []dns.Question) error {
 		messages = append(messages, msg)
 	}
 	for _, msg := range messages {
-		for _, srv := range m.servers {
-			in, rtt, err := m.client.Exchange(&msg, srv)
+		for _, srv := range c.servers {
+			in, rtt, err := c.client.Exchange(&msg, srv)
 			if err != nil {
 				return err
 			}
@@ -91,7 +95,3 @@ func (m *Manager) Lookup(questions []dns.Question) error {
 	}
 	return nil
 }
-
-func (m *Manager) Name() string {
-	return "classic"
-}

pkg/resolvers/doh.go

@@ -1 +1,72 @@
 package resolvers
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	"github.com/miekg/dns"
+)
+
+// DOHResolver represents the config options for setting up a DOH based resolver.
+type DOHResolver struct {
+	client  *http.Client
+	servers []string
+}
+
+// NewDOHResolver accepts a list of nameservers and configures a DOH based resolver.
+func NewDOHResolver(servers []string) (Resolver, error) {
+	httpClient := &http.Client{
+		Timeout: 10 * time.Second,
+	}
+	return &DOHResolver{
+		client:  httpClient,
+		servers: servers,
+	}, nil
+}
+
+func (r *DOHResolver) Lookup(questions []dns.Question) error {
+	var messages = make([]dns.Msg, 0, len(questions))
+	for _, q := range questions {
+		msg := dns.Msg{}
+		msg.Id = dns.Id()
+		msg.RecursionDesired = true
+		// It's recommended to only send 1 question for 1 DNS message.
+		msg.Question = []dns.Question{q}
+		messages = append(messages, msg)
+	}
+	for _, m := range messages {
+		b, err := m.Pack()
+		if err != nil {
+			return err
+		}
+		for _, srv := range r.servers {
+			resp, err := r.client.Post(srv, "application/dns-message", bytes.NewBuffer(b))
+			if err != nil {
+				return err
+			}
+			if resp.StatusCode != http.StatusOK {
+				return err
+			}
+
+			body, err := ioutil.ReadAll(resp.Body)
+			if err != nil {
+				return err
+			}
+
+			r := &dns.Msg{}
+			err = r.Unpack(body)
+			if err != nil {
+				return err
+			}
+			for _, ans := range r.Answer {
+				if t, ok := ans.(*dns.A); ok {
+					fmt.Println(t.String())
+				}
+			}
+		}
+	}
+	return nil
+}

pkg/resolvers/resolver.go

@@ -2,7 +2,9 @@ package resolvers
 
 import "github.com/miekg/dns"
 
+// Resolver implements the configuration for a DNS
+// Client. Different types of client like (UDP/TCP/DOH/DOT)
+// can be initialised.
 type Resolver interface {
-	Name() string
 	Lookup([]dns.Question) error
 }