From 146249a13dc0a50fa05ccf101666665274523d07 Mon Sep 17 00:00:00 2001 From: Jeff Carr Date: Mon, 20 Feb 2023 22:22:58 -0600 Subject: [PATCH] add log() and go-arg Signed-off-by: Jeff Carr --- README.md | 10 ++++ args.go | 45 ++++++++++++++++ connection_handler.go | 38 +++++++------- dnstrace.go | 37 ++++++------- log.go | 119 ++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 212 insertions(+), 37 deletions(-) create mode 100644 args.go create mode 100644 log.go diff --git a/README.md b/README.md index 03c3282..2ef96b9 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,13 @@ +# Intro + Attempt at some code to validate via DNS / DNSSEC the hostname is valid on a simple socket listen server + +This recursively runs from the root TLD's and purposesly bypasses +any DNS cache so that the DNS <-> IP address mappings can be verified + +## References + +* https://github.com/mactsouk/opensource.com.git +* https://coderwall.com/p/wohavg/creating-a-simple-tcp-server-in-go diff --git a/args.go b/args.go new file mode 100644 index 0000000..555e42c --- /dev/null +++ b/args.go @@ -0,0 +1,45 @@ +package dnssecsocket + +// +// By using the package "github.com/alexflint/go-arg", +// these can be configured from the command line +// + +import ( + // arg "github.com/alexflint/go-arg" + // "log" + // "os" +) + +type Args struct { + VerboseDnssec bool `arg:"--verbose-dnssec" help:"debug dnssec lookups"` + Foo string `arg:"env:USER"` +} + +var args struct { + Args + Verbose bool +} + +func Parse (b bool) { + args.Verbose = b + args.VerboseDnssec = b +} + +// I attempted to pass the *arg.Parser down +// to see if I could find the value somewhere but I couldn't find it +/* +var conf arg.Config + +func Parse (p *arg.Parser) { + // conf.Program = "control-panel-dns" + // conf.IgnoreEnv = false + // arg.NewParser(conf, &args) + log.Println("fuckit", p, args.VerboseDnssec) + for i, v := range p.SubcommandNames() { + log.Println("dnssec.Parse", i, v) + } + p.Jcarr() + exit() +} +*/ diff --git a/connection_handler.go b/connection_handler.go index e1350a7..0c7250a 100644 --- a/connection_handler.go +++ b/connection_handler.go @@ -11,7 +11,7 @@ import "math/rand" import "net" import "strconv" import "strings" -import log "github.com/sirupsen/logrus" +// import log "github.com/sirupsen/logrus" // import "github.com/wercker/journalhook" import "git.wit.org/wit/shell" @@ -49,41 +49,41 @@ func HandleConnection(conn *net.TCPConn) { // spew.Dump(conn) // ipv6client := GetRemoteAddr(c) ipv6client := conn.RemoteAddr() - log.Println("Serving to %s as the IPv6 client", ipv6client) + log(args.VerboseDnssec, "Serving to %s as the IPv6 client", ipv6client) // setup this TCP socket as the "standard input" // newStdin, _ := bufio.NewReader(conn.File()) newStdin, _ := conn.File() newreader := bufio.NewReader(newStdin) - log.Println("Waiting for the client to tell me its name") + log(args.VerboseDnssec, "Waiting for the client to tell me its name") netData, err := newreader.ReadString('\n') if err != nil { - log.Println(err) + log(args.VerboseDnssec, err) return } clientHostname := strings.TrimSpace(netData) - log.Println("Recieved client hostname as:", clientHostname) + log(args.VerboseDnssec, "Recieved client hostname as:", clientHostname) dnsRR := Dnstrace(clientHostname, "AAAA") if (dnsRR == nil) { - log.Println("dnsRR IS NIL") - log.Println("dnsRR IS NIL") - log.Println("dnsRR IS NIL") + log(args.VerboseDnssec, "dnsRR IS NIL") + log(args.VerboseDnssec, "dnsRR IS NIL") + log(args.VerboseDnssec, "dnsRR IS NIL") conn.Close() return } ipaddr := dns.Field(dnsRR[1], 1) - log.Println("Client claims to be: ", ipaddr) - log.Println("Serving to IPv6 client:", ipv6client) + log(args.VerboseDnssec, "Client claims to be: ", ipaddr) + log(args.VerboseDnssec, "Serving to IPv6 client:", ipv6client) /* TODO: figure out how to fix this check if (ipaddr != ipv6client) { - log.Println() - log.Println("DNSSEC ERROR: client IPv6 does not work") - log.Println("DNSSEC ERROR: client IPv6 does not work") - log.Println("DNSSEC ERROR: client IPv6 does not work") - log.Println() + log(args.VerboseDnssec) + log(args.VerboseDnssec, "DNSSEC ERROR: client IPv6 does not work") + log(args.VerboseDnssec, "DNSSEC ERROR: client IPv6 does not work") + log(args.VerboseDnssec, "DNSSEC ERROR: client IPv6 does not work") + log(args.VerboseDnssec) conn.Close() return } @@ -101,7 +101,7 @@ func HandleConnection(conn *net.TCPConn) { defer conn.Close() netData, err := newreader.ReadString('\n') if err != nil { - log.Println(err) + log(args.VerboseDnssec, err) return } @@ -109,17 +109,17 @@ func HandleConnection(conn *net.TCPConn) { if temp == "STOP" { break } - log.Println("Recieved: ", temp) + log(args.VerboseDnssec, "Recieved: ", temp) if (temp == "list") { - log.Println("Should run list here") + log(args.VerboseDnssec, "Should run list here") shell.SetStdout(f) shell.Run("/root/bin/list.testing.com") shell.SetStdout(os.Stdout) } if (temp == "cpuinfo") { - log.Println("Should cat /proc/cpuinfo") + log(args.VerboseDnssec, "Should cat /proc/cpuinfo") shell.SetStdout(f) shell.Run("cat /proc/cpuinfo") shell.SetStdout(os.Stdout) diff --git a/dnstrace.go b/dnstrace.go index 7e71cab..7377203 100644 --- a/dnstrace.go +++ b/dnstrace.go @@ -4,14 +4,14 @@ package dnssecsocket import "fmt" import "net" -import "os" +// import "os" import "strings" import "time" import "github.com/miekg/dns" import "github.com/rs/dnstrace/client" -import log "github.com/sirupsen/logrus" +// import log "github.com/sirupsen/logrus" // this is cool, but breaks the Windows build // import "github.com/wercker/journalhook" @@ -75,13 +75,13 @@ func Dnstrace(hostname string, qtypestr string) []dns.RR { qname := m.Question[0].Name qtype := dns.TypeToString[m.Question[0].Qtype] if i > 1 { - log.Println() + log(args.VerboseDnssec) } - log.Printf("%d - query %s %s", i, qtype, qname) + log(args.VerboseDnssec, "%d - query %s %s", i, qtype, qname) if r != nil { - log.Printf(": %s", strings.Replace(strings.Replace(r.MsgHdr.String(), ";; ", "", -1), "\n", ", ", -1)) + log(args.VerboseDnssec, ": %s", strings.Replace(strings.Replace(r.MsgHdr.String(), ";; ", "", -1), "\n", ", ", -1)) } - log.Println() + log(args.VerboseDnssec) for _, pr := range rs { ln := 0 if pr.Msg != nil { @@ -94,15 +94,15 @@ func Dnstrace(hostname string, qtypestr string) []dns.RR { } else if pr.Server.LookupRTT > 0 { lrtt = fmt.Sprintf("%.2fms", float64(pr.Server.LookupRTT)/float64(time.Millisecond)) } - log.Printf(col(" - %d bytes in %.2fms + %s lookup on %s(%s)", cDarkGray), ln, rtt, lrtt, pr.Server.Name, pr.Addr) + log(args.VerboseDnssec, col(" - %d bytes in %.2fms + %s lookup on %s(%s)", cDarkGray), ln, rtt, lrtt, pr.Server.Name, pr.Addr) if pr.Err != nil { err := pr.Err if oerr, ok := err.(*net.OpError); ok { err = oerr.Err } - log.Printf(": %v", col(err, cRed)) + log(args.VerboseDnssec, ": %v", col(err, cRed)) } - log.Print("\n") + log(args.VerboseDnssec, "\n") } switch rtype { @@ -122,28 +122,29 @@ func Dnstrace(hostname string, qtypestr string) []dns.RR { } else { glue = col("no glue", cYellow) } - log.Printf("%s %d NS %s (%s)\n", label, s.TTL, s.Name, glue) + log(args.VerboseDnssec, "%s %d NS %s (%s)\n", label, s.TTL, s.Name, glue) } case client.ResponseTypeCNAME: for _, rr := range r.Answer { - log.Println(rr) + log(args.VerboseDnssec, rr) } } }, FollowingCNAME: func(domain, target string) { - log.Printf(col("\n~ following CNAME %s -> %s\n", cBlue), domain, target) + log(args.VerboseDnssec, col("\n~ following CNAME %s -> %s\n", cBlue), domain, target) }, } r, rtt, err := c.RecursiveQuery(m, t) if err != nil { - log.Printf(col("*** error: %v\n", cRed), err) - os.Exit(1) + log(args.VerboseDnssec, col("*** error: %v\n", cRed), err) + exit(1) } - log.Println() - log.Printf(col(";; Cold best path time: %s\n\n", cGray), rtt) + log(args.VerboseDnssec) + log(args.VerboseDnssec, col(";; Cold best path time: %s\n\n", cGray), rtt) for i, rr := range r.Answer { - log.Println("r.Answer =", i, rr) + log(args.VerboseDnssec, "r.Answer =", i, rr, args.VerboseDnssec) + // exit(0) } return r.Answer // for _, rr := range r.Answer { @@ -163,6 +164,6 @@ func ResolveIPv6hostname(hostname string) *net.TCPAddr { } func UseJournalctl() { - log.Println("journalhook is disabled because it breaks the Windows build right now") + log(args.VerboseDnssec, "journalhook is disabled because it breaks the Windows build right now") // journalhook.Enable() } diff --git a/log.go b/log.go new file mode 100644 index 0000000..77dff6d --- /dev/null +++ b/log.go @@ -0,0 +1,119 @@ +// +// version v1.1 +// +// I like things to be easy. +// +// this means all the log settings are in one place. it should allow +// things to be over-ridden externally to the library +// but still allow command line --args to pass debugging settings +// +// I also have a generic sleep() and exit() in here because it's simple +// +// Usage: +// +// log("something", foo, bar) +// var DEBUG bool = true +// log(DEBUG, "something else", someOtherVariable) # if DEBUG == false, return doing nothing +// log(SPEW, "something else", someOtherVariable) # this get's sent to spew.Dump(). Very useful for debugging! +// +package dnssecsocket + +import ( + "os" + golog "log" + "time" + "reflect" + "github.com/davecgh/go-spew/spew" + // "net" +) + +var LOGOFF bool = false // turn this off, all logging stops +var WARN bool +var INFO bool + +type spewt struct { + a bool +} + +var SPEW spewt + + +/* + sleep() # you know what this does? sleeps for 1 second. yep. dump. easy. + sleep(.1) # you know what this does? yes, it sleeps for 1/10th of a second +*/ +func sleep(a ...any) { + if (a == nil) { + time.Sleep(time.Second) + return + } + + log(args.Verbose, "sleep", a[0]) + + switch a[0].(type) { + case int: + time.Sleep(time.Duration(a[0].(int)) * time.Second) + case float64: + time.Sleep(time.Duration(a[0].(float64) * 1000) * time.Millisecond) + default: + log("sleep a[0], type = ", a[0], reflect.TypeOf(a[0])) + } +} + +/* + exit() # yep. exits. I guess everything must be fine + exit(3) # I guess 3 it is then + exit("dont like apples") # ok. I'll make a note of that +*/ +func exit(a ...any) { + log("exit", a) + //if (a) { + // os.Exit(a) + //} + os.Exit(0) +} + +/* + I've spent, am spending, too much time thinking about 'logging'. 'log', 'logrus', 'zap', whatever. + I'm not twitter. i don't give a fuck about how many nanoseconds it takes to log. Anyway, this + implementation is probably faster than all of those because you just set one bool to FALSE + and it all stops. + Sometimes I need to capture to stdout, sometimes stdout can't + work because it doesn't exist for the user. This whole thing is a PITA. Then it's spread + over 8 million references in every .go file. I'm tapping out and putting + it in one place. here it is. Also, this makes having debug levels really fucking easy. + You can define whatever level of logging you want from anywhere (command line) etc. + + log() # doesn't do anything + log(stuff) # sends it to whatever log you define in a single place. here is the place +*/ + +func log(a ...any) { + if (LOGOFF) { + return + } + + if (a == nil) { + return + } + var blah bool + if (reflect.TypeOf(a[0]) == reflect.TypeOf(blah)) { + // golog.Println("\t a[0] = bool") + if (a[0] == false) { + return + } + a = a[1:] + } + + if (reflect.TypeOf(a[0]) == reflect.TypeOf(SPEW)) { + a = a[1:] + spew.Dump(a) + return + } + + golog.Println(a...) + // golog.Println("\t a[0] =", a[0]) + // for argNum, arg := range a { + // golog.Println("\t", argNum, arg) + // } +}