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

feat: Add support for multiple resolvers

Browse source
This commit is contained in:
Karan Sharma 2020-12-15 23:09:10 +05:30
parent 80d43011f8
commit b46b64c1ae
13 changed files with 332 additions and 226 deletions
Download patch file Download diff file Expand all files Collapse all files

16
cmd/cli.go
View file

@ -41,6 +41,7 @@ func main() {
f.BoolP("dot", "S", false, "Use the DNS-over-TLS")
// Resolver Options
f.Int("timeout", 5, "Sets the timeout for a query to T seconds. The default timeout is 5 seconds.")
f.Bool("search", false, "Use the search list provided in resolv.conf. It sets the `ndots` parameter as well unless overriden by `ndots` flag.")
f.Int("ndots", 1, "Specify the ndots paramter. Default value is taken from resolv.conf and fallbacks to 1 if ndots statement is missing in resolv.conf")
@ -72,12 +73,19 @@ func main() {
hub.Logger.Debug("Starting doggo 🐶")
// Parse Query Args
hub.loadQueryArgs()
err := hub.loadQueryArgs()
if err != nil {
hub.Logger.WithError(err).Error("error parsing flags/arguments")
hub.Logger.Exit(2)
}
// Start App
if len(hub.QueryFlags.QNames) == 0 {
f.Usage()
hub.Logger.Exit(0)
}
err = hub.Lookup()
if err != nil {
hub.Logger.WithError(err).Error("error looking up DNS records")
hub.Logger.Exit(2)
}
hub.Lookup()
}

37
cmd/hub.go
View file

@ -1,6 +1,8 @@
package main
import (
"time"
"github.com/miekg/dns"
"github.com/mr-karan/doggo/pkg/resolvers"
"github.com/sirupsen/logrus"
@ -13,26 +15,27 @@ type Hub struct {
QueryFlags QueryFlags
FreeArgs []string
Questions []dns.Question
Resolver resolvers.Resolver
Resolver []resolvers.Resolver
}
// QueryFlags is used store the value of CLI flags.
type QueryFlags struct {
QNames []string `koanf:"query"`
QTypes []string `koanf:"type"`
QClasses []string `koanf:"class"`
Nameservers []string `koanf:"nameserver"`
IsDOH bool `koanf:"doh"`
IsDOT bool `koanf:"dot"`
IsUDP bool `koanf:"udp"`
UseTCP bool `koanf:"tcp"`
UseIPv4 bool `koanf:"ipv4"`
UseIPv6 bool `koanf:"ipv6"`
DisplayTimeTaken bool `koanf:"time"`
ShowJSON bool `koanf:"json"`
UseSearchList bool `koanf:"search"`
Ndots int `koanf:"ndots"`
Color bool `koanf:"color"`
QNames []string `koanf:"query"`
QTypes []string `koanf:"type"`
QClasses []string `koanf:"class"`
Nameservers []string `koanf:"nameserver"`
IsDOH bool `koanf:"doh"`
IsDOT bool `koanf:"dot"`
IsUDP bool `koanf:"udp"`
IsTCP bool `koanf:"tcp"`
UseIPv4 bool `koanf:"ipv4"`
UseIPv6 bool `koanf:"ipv6"`
DisplayTimeTaken bool `koanf:"time"`
ShowJSON bool `koanf:"json"`
UseSearchList bool `koanf:"search"`
Ndots int `koanf:"ndots"`
Color bool `koanf:"color"`
Timeout time.Duration `koanf:"timeout"`
}
// NewHub initializes an instance of Hub which holds app wide configuration.
@ -55,7 +58,7 @@ func NewHub(logger *logrus.Logger, buildVersion string) *Hub {
func initLogger() *logrus.Logger {
logger := logrus.New()
logger.SetFormatter(&logrus.TextFormatter{
DisableTimestamp: true,
FullTimestamp: true,
DisableLevelTruncation: true,
})
return logger

15
cmd/lookup.go
View file

@ -1,6 +1,7 @@
package main
import (
"errors"
"strings"
"github.com/miekg/dns"
@ -14,9 +15,17 @@ func (hub *Hub) Lookup() error {
if err != nil {
return err
}
responses, err := hub.Resolver.Lookup(hub.Questions)
if err != nil {
return err
// for each type of resolver do a DNS lookup
responses := make([][]resolvers.Response, 0, len(hub.Questions))
for _, r := range hub.Resolver {
resp, err := r.Lookup(hub.Questions)
if err != nil {
return err
}
responses = append(responses, resp)
}
if len(responses) == 0 {
return errors.New(`no DNS records found`)
}
hub.Output(responses)
return nil

112
cmd/output.go
View file

@ -37,9 +37,9 @@ type JSONResponse struct {
Response `json:"responses"`
}
func (hub *Hub) outputJSON(out []Output, msgs []resolvers.Response) {
func (hub *Hub) outputJSON(out []Output) {
// get the questions
queries := make([]Query, 0, len(msgs))
queries := make([]Query, 0)
for _, ques := range hub.Questions {
q := Query{
Name: ques.Name,
@ -122,73 +122,77 @@ func (hub *Hub) outputTerminal(out []Output) {
// Output takes a list of `dns.Answers` and based
// on the output format specified displays the information.
func (hub *Hub) Output(responses []resolvers.Response) {
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, responses)
hub.outputJSON(out)
} else {
hub.outputTerminal(out)
}
}
func collectOutput(responses []resolvers.Response) []Output {
func collectOutput(responses [][]resolvers.Response) []Output {
var out []Output
// gather Output from the DNS Messages
for _, r := range responses {
var addr string
for _, a := range r.Message.Answer {
switch t := a.(type) {
case *dns.A:
addr = t.A.String()
case *dns.AAAA:
addr = t.AAAA.String()
case *dns.CNAME:
addr = t.Target
case *dns.CAA:
addr = t.Tag + " " + t.Value
case *dns.HINFO:
addr = t.Cpu + " " + t.Os
// case *dns.LOC:
// addr = t.String()
case *dns.PTR:
addr = t.Ptr
case *dns.SRV:
addr = strconv.Itoa(int(t.Priority)) + " " +
strconv.Itoa(int(t.Weight)) + " " +
t.Target + ":" + strconv.Itoa(int(t.Port))
case *dns.TXT:
addr = t.String()
case *dns.NS:
addr = t.Ns
case *dns.MX:
addr = strconv.Itoa(int(t.Preference)) + " " + t.Mx
case *dns.SOA:
addr = t.String()
case *dns.NAPTR:
addr = t.String()
}
// for each resolver
for _, rslvr := range responses {
// get the response
for _, r := range rslvr {
var addr string
for _, a := range r.Message.Answer {
switch t := a.(type) {
case *dns.A:
addr = t.A.String()
case *dns.AAAA:
addr = t.AAAA.String()
case *dns.CNAME:
addr = t.Target
case *dns.CAA:
addr = t.Tag + " " + t.Value
case *dns.HINFO:
addr = t.Cpu + " " + t.Os
// case *dns.LOC:
// addr = t.String()
case *dns.PTR:
addr = t.Ptr
case *dns.SRV:
addr = strconv.Itoa(int(t.Priority)) + " " +
strconv.Itoa(int(t.Weight)) + " " +
t.Target + ":" + strconv.Itoa(int(t.Port))
case *dns.TXT:
addr = t.String()
case *dns.NS:
addr = t.Ns
case *dns.MX:
addr = strconv.Itoa(int(t.Preference)) + " " + t.Mx
case *dns.SOA:
addr = t.String()
case *dns.NAPTR:
addr = t.String()
}
h := a.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,
h := a.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)
}
out = append(out, o)
}
}
return out
}

14
cmd/parse.go
View file

@ -7,22 +7,20 @@ import (
)
func (hub *Hub) loadQueryArgs() error {
err := hub.loadNamedArgs()
if err != nil {
return err
}
err = hub.loadFreeArgs()
if err != nil {
hub.Logger.WithError(err).Error("Error parsing arguments")
hub.Logger.Exit(2)
return err
}
err = hub.initResolver()
if err != nil {
hub.Logger.WithError(err).Error("Error parsing nameservers")
hub.Logger.Exit(2)
return err
}
hub.loadFallbacks()
return err
return nil
}
// loadFreeArgs tries to parse all the arguments

57
cmd/resolver.go
View file

@ -1,7 +1,7 @@
package main
import (
"runtime"
"time"
"github.com/mr-karan/doggo/pkg/resolvers"
)
@ -11,36 +11,39 @@ import (
func (hub *Hub) initResolver() error {
// check if DOH flag is set.
if hub.QueryFlags.IsDOH {
rslvr, err := resolvers.NewDOHResolver(hub.QueryFlags.Nameservers)
if err != nil {
return err
}
hub.Resolver = rslvr
return nil
}
if len(hub.QueryFlags.Nameservers) == 0 {
if runtime.GOOS == "windows" {
// TODO: Add a method for reading system default nameserver in windows.
} else {
rslvr, err := resolvers.NewSystemResolver(resolvers.DefaultResolvConfPath)
if err != nil {
return err
}
hub.Resolver = rslvr
return nil
}
} else {
rslvr, err := resolvers.NewClassicResolver(hub.QueryFlags.Nameservers, resolvers.ClassicResolverOpts{
UseIPv4: hub.QueryFlags.UseIPv4,
UseIPv6: hub.QueryFlags.UseIPv6,
UseTLS: hub.QueryFlags.IsDOT,
UseTCP: hub.QueryFlags.UseTCP,
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
}
hub.Resolver = rslvr
return nil
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
}
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
}
hub.Resolver = append(hub.Resolver, rslvr)
}
return nil
}