astra/doggo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

feat: Multiple resolvers continued

Browse source
This commit is contained in:
Karan Sharma 2020-12-16 18:38:34 +05:30
parent b46b64c1ae
commit 53e7f2e59c
11 changed files with 253 additions and 214 deletions
Download patch file Download diff file Expand all files Collapse all files

31
cmd/cli.go
View file

@ -1,6 +1,7 @@
package main
import (
"fmt"
"os"
"github.com/knadh/koanf"
@ -78,6 +79,36 @@ func main() {
hub.Logger.WithError(err).Error("error parsing flags/arguments")
hub.Logger.Exit(2)
}
// Load Nameservers
for _, srv := range hub.QueryFlags.Nameservers {
ns, err := initNameserver(srv)
if err != nil {
hub.Logger.WithError(err).Errorf("error parsing nameserver: %s", ns)
hub.Logger.Exit(2)
}
if ns.Address != "" && ns.Type != "" {
fmt.Println("appending", ns.Address, ns.Type)
hub.Nameservers = append(hub.Nameservers, ns)
}
}
// fallback to system nameserver
if len(hub.Nameservers) == 0 {
ns, err := getDefaultServers()
if err != nil {
hub.Logger.WithError(err).Errorf("error fetching system default nameserver")
hub.Logger.Exit(2)
}
hub.Nameservers = ns
}
// Load Resolvers
err = hub.initResolver()
if err != nil {
hub.Logger.WithError(err).Error("error loading resolver")
hub.Logger.Exit(2)
}
// Start App
if len(hub.QueryFlags.QNames) == 0 {
f.Usage()

21
cmd/hub.go
View file

@ -10,12 +10,13 @@ import (
// Hub represents the structure for all app wide functions and structs.
type Hub struct {
Logger *logrus.Logger
Version string
QueryFlags QueryFlags
FreeArgs []string
Questions []dns.Question
Resolver []resolvers.Resolver
Logger *logrus.Logger
Version string
QueryFlags QueryFlags
FreeArgs []string
Questions []dns.Question
Resolver []resolvers.Resolver
Nameservers []Nameserver
}
// QueryFlags is used store the value of CLI flags.
@ -38,6 +39,13 @@ type QueryFlags struct {
Timeout time.Duration `koanf:"timeout"`
}
// Nameserver represents the type of Nameserver
// along with it's address.
type Nameserver struct {
Address string
Type string
}
// NewHub initializes an instance of Hub which holds app wide configuration.
func NewHub(logger *logrus.Logger, buildVersion string) *Hub {
// Initialise Resolver
@ -50,6 +58,7 @@ func NewHub(logger *logrus.Logger, buildVersion string) *Hub {
QClasses: []string{},
Nameservers: []string{},
},
Nameservers: []Nameserver{},
}
return hub
}

2
cmd/lookup.go
View file

@ -78,7 +78,7 @@ func (hub *Hub) prepareQuestions() error {
}
func fetchDomainList(d string, ndots int) ([]string, int, error) {
cfg, err := dns.ClientConfigFromFile(resolvers.DefaultResolvConfPath)
cfg, err := dns.ClientConfigFromFile(DefaultResolvConfPath)
if err != nil {
return nil, 0, err
}

27
cmd/output.go
View file

@ -124,10 +124,6 @@ func (hub *Hub) outputTerminal(out []Output) {
// on the output format specified displays the information.
func (hub *Hub) Output(responses [][]resolvers.Response) {
out := collectOutput(responses)
if len(out) == 0 {
hub.Logger.Info("No records found")
hub.Logger.Exit(0)
}
if hub.QueryFlags.ShowJSON {
hub.outputJSON(out)
} else {
@ -142,6 +138,29 @@ func collectOutput(responses [][]resolvers.Response) []Output {
// get the response
for _, r := range rslvr {
var addr string
if r.Message.Rcode != dns.RcodeSuccess {
for _, ns := range r.Message.Ns {
blah, ok := ns.(*dns.SOA)
fmt.Println(blah, ok)
blah.String()
h := ns.Header()
name := h.Name
qclass := dns.Class(h.Class).String()
ttl := strconv.FormatInt(int64(h.Ttl), 10) + "s"
qtype := dns.Type(h.Rrtype).String()
rtt := fmt.Sprintf("%dms", r.RTT.Milliseconds())
o := Output{
Name: name,
Type: qtype,
TTL: ttl,
Class: qclass,
Address: addr,
TimeTaken: rtt,
Nameserver: r.Nameserver,
}
out = append(out, o)
}
}
for _, a := range r.Message.Answer {
switch t := a.(type) {
case *dns.A:

4
cmd/parse.go
View file

@ -15,10 +15,6 @@ func (hub *Hub) loadQueryArgs() error {
if err != nil {
return err
}
err = hub.initResolver()
if err != nil {
return err
}
hub.loadFallbacks()
return nil
}

144
cmd/resolver.go
View file

@ -1,49 +1,129 @@
package main
import (
"errors"
"fmt"
"net"
"net/url"
"runtime"
"time"
"github.com/miekg/dns"
"github.com/mr-karan/doggo/pkg/resolvers"
)
const (
//DefaultResolvConfPath specifies path to default resolv config file on UNIX.
DefaultResolvConfPath = "/etc/resolv.conf"
// DefaultTLSPort specifies the default port for a DNS server connecting over TCP over TLS
DefaultTLSPort = "853"
// DefaultUDPPort specifies the default port for a DNS server connecting over UDP
DefaultUDPPort = "53"
)
// initResolver checks for various flags and initialises
// the correct resolver based on the config.
func (hub *Hub) initResolver() error {
// check if DOH flag is set.
if hub.QueryFlags.IsDOH {
hub.Logger.Debug("initiating DOH resolver")
rslvr, err := resolvers.NewDOHResolver(hub.QueryFlags.Nameservers, resolvers.DOHResolverOpts{
Timeout: hub.QueryFlags.Timeout * time.Second,
})
if err != nil {
return err
// for each nameserver, initialise the correct resolver
for _, ns := range hub.Nameservers {
if ns.Type == "doh" {
hub.Logger.Debug("initiating DOH resolver")
rslvr, err := resolvers.NewDOHResolver(ns.Address, resolvers.DOHResolverOpts{
Timeout: hub.QueryFlags.Timeout * time.Second,
})
if err != nil {
return err
}
hub.Resolver = append(hub.Resolver, rslvr)
}
hub.Resolver = append(hub.Resolver, rslvr)
}
if hub.QueryFlags.IsTCP {
hub.Logger.Debug("initiating TCP resolver")
rslvr, err := resolvers.NewTCPResolver(hub.QueryFlags.Nameservers, resolvers.TCPResolverOpts{
IPv4Only: hub.QueryFlags.UseIPv4,
IPv6Only: hub.QueryFlags.UseIPv6,
Timeout: hub.QueryFlags.Timeout * time.Second,
})
if err != nil {
return err
if ns.Type == "tcp" {
hub.Logger.Debug("initiating TCP resolver")
rslvr, err := resolvers.NewTCPResolver(ns.Address, resolvers.TCPResolverOpts{
IPv4Only: hub.QueryFlags.UseIPv4,
IPv6Only: hub.QueryFlags.UseIPv6,
Timeout: hub.QueryFlags.Timeout * time.Second,
})
if err != nil {
return err
}
hub.Resolver = append(hub.Resolver, rslvr)
}
hub.Resolver = append(hub.Resolver, rslvr)
}
// If so far no resolver has been set, then fallback to UDP.
if hub.QueryFlags.IsUDP || len(hub.Resolver) == 0 {
hub.Logger.Debug("initiating UDP resolver")
rslvr, err := resolvers.NewUDPResolver(hub.QueryFlags.Nameservers, resolvers.UDPResolverOpts{
IPv4Only: hub.QueryFlags.UseIPv4,
IPv6Only: hub.QueryFlags.UseIPv6,
Timeout: hub.QueryFlags.Timeout * time.Second,
})
if err != nil {
return err
if ns.Type == "udp" {
hub.Logger.Debug("initiating UDP resolver")
rslvr, err := resolvers.NewUDPResolver(ns.Address, resolvers.UDPResolverOpts{
IPv4Only: hub.QueryFlags.UseIPv4,
IPv6Only: hub.QueryFlags.UseIPv6,
Timeout: hub.QueryFlags.Timeout * time.Second,
})
if err != nil {
return err
}
hub.Resolver = append(hub.Resolver, rslvr)
}
hub.Resolver = append(hub.Resolver, rslvr)
}
return nil
}
func getDefaultServers() ([]Nameserver, error) {
if runtime.GOOS == "windows" {
// TODO: Add a method for reading system default nameserver in windows.
return nil, errors.New(`unable to read default nameservers in this machine`)
}
// if no nameserver is provided, take it from `resolv.conf`
cfg, err := dns.ClientConfigFromFile(DefaultResolvConfPath)
if err != nil {
return nil, err
}
servers := make([]Nameserver, 0, len(cfg.Servers))
for _, s := range cfg.Servers {
ip := net.ParseIP(s)
// handle IPv6
if ip != nil && ip.To4() != nil {
ns := Nameserver{
Type: "udp",
Address: fmt.Sprintf("%s:%s", s, cfg.Port),
}
servers = append(servers, ns)
} else {
ns := Nameserver{
Type: "udp",
Address: fmt.Sprintf("[%s]:%s", s, cfg.Port),
}
servers = append(servers, ns)
}
}
return servers, nil
}
func initNameserver(n string) (Nameserver, error) {
// Instantiate a dumb UDP resolver as a fallback.
ns := Nameserver{
Type: "udp",
Address: n,
}
u, err := url.Parse(n)
if err != nil {
return ns, err
}
if u.Scheme == "https" {
ns.Address = u.String()
ns.Type = "doh"
}
if u.Scheme == "tcp" {
if i := net.ParseIP(n); i != nil {
// if no port specified in nameserver, append defaults.
n = net.JoinHostPort(n, DefaultTLSPort)
}
ns.Address = u.String()
ns.Type = "tcp"
}
if u.Scheme == "udp" {
ns.Type = "udp"
if u.Port() == "" {
ns.Address = net.JoinHostPort(u.Hostname(), DefaultUDPPort)
} else {
ns.Address = net.JoinHostPort(u.Hostname(), u.Port())
}
}
return ns, nil
}