modikai-echodns/echodns.go

package main

import (
	"flag"
	"fmt"
	_ "math/rand"
	"net"
	"strconv"
	"strings"
	_ "time"

	"github.com/miekg/dns"
	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

var CONFIG_SLD string
var UniqueCounter uint32 = 0xfffffffa

func strategyMaker(name string, qtype uint16) int8 {
	var subdomain string
	labels := strings.Split(name, ".")
	if len(labels) >= 4 {
		subdomain = strings.ToLower(labels[len(labels)-4])
	}

	if qtype == dns.TypeA {
		if len(labels) == 4 && (subdomain == "ns1" || subdomain == "ns2") {
			return 0
		} else if strings.Contains(subdomain, "fwd") {
			return 1 // return rdns ip in cname
		} else if strings.Contains(subdomain, "rdns") {
			return 2 // return honey cname record
		} else if strings.Contains(subdomain, "honey") {
			return 3 // return timestamp in a record
		} else if strings.Contains(subdomain, "echo") {
			return 4 // basic echodns
		} else if strings.Contains(subdomain, "ttl") {
			return 5 // ttl test
		} else if strings.Contains(subdomain, "wrong-id") {
			return 6 // return response with wrong txid
		} else if strings.Contains(subdomain, "wrong-rec") {
			return 7 // return response with wrong records
		}
	}
	return -1
}

func InttoIPv4(n uint32) net.IP {
	b0 := (n >> 24) & 0xff
	b1 := (n >> 16) & 0xff
	b2 := (n >> 8) & 0xff
	b3 := n & 0xff
	return net.IPv4(byte(b0), byte(b1), byte(b2), byte(b3))
}

func TtlParser(domain string) uint32 {
	subdomain := strings.ToLower(strings.Split(domain, ".")[0])
	ttl, _ := strconv.Atoi(strings.Split(subdomain, "-")[0])
	return uint32(ttl)
}

func handleReflect(w dns.ResponseWriter, r *dns.Msg) {
	var (
		ip    net.IP
		port  int
		id    uint16
		name  string
		qtype uint16
	)
	m := new(dns.Msg)
	m.SetReply(r)
	m.Compress = true
	m.Authoritative = true
	if addr, ok := w.RemoteAddr().(*net.UDPAddr); ok {
		ip = addr.IP
		port = addr.Port
	}
	id = m.MsgHdr.Id
	name = m.Question[0].Name
	qtype = m.Question[0].Qtype
	log.Log().Str("sip", ip.String()).Int64("port", int64(port)).Int64("id", int64(id)).Str("name", name).Int64("qtype", int64(qtype)).Msg("")
	//log.Printf("%v|%v|%v|%v|%v", ip, port, id, name, qtype)
	//fmt.Println(ip)
	//fmt.Println(name)
	//fmt.Println(qtype)
	switch strategyMaker(name, qtype) {
	case 1:
		cname_subdomain := "rdns-" + strings.Replace(ip.String(), ".", "-", -1)
		cname_fqdn := dns.Fqdn(cname_subdomain + "." + CONFIG_SLD)
		cname := &dns.CNAME{
			Hdr:    dns.RR_Header{Name: name, Rrtype: dns.TypeCNAME, Class: dns.ClassINET, Ttl: 14400},
			Target: cname_fqdn,
		}
		//fmt.Println(name+" "+cname_fqdn)
		m.Answer = append(m.Answer, cname)
	case 2:
		cname_fqdn := dns.Fqdn("honey." + CONFIG_SLD)
		cname := &dns.CNAME{
			Hdr:    dns.RR_Header{Name: name, Rrtype: dns.TypeCNAME, Class: dns.ClassINET, Ttl: 14400},
			Target: cname_fqdn,
		}
		//fmt.Println(cname_fqdn)
		m.Answer = append(m.Answer, cname)
	case 3:
		//time_str := strconv.FormatInt(time.Now().UnixMicro(), 10)
		//time_int, _ := strconv.Atoi(time_str[5 : len(time_str)-2])
		//time_int += rand.Intn(10000)
		UniqueCounter += 1
		timestamp := InttoIPv4(uint32(UniqueCounter))
		a := &dns.A{
			Hdr: dns.RR_Header{Name: name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 14400},
			A:   timestamp,
		}
		m.Answer = append(m.Answer, a)
	case 4:
		a := &dns.A{
			Hdr: dns.RR_Header{Name: name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 60},
			A:   ip,
		}
		m.Answer = append(m.Answer, a)
	case 5:
		query_ttl := TtlParser(name)
		//fmt.Println(query_ttl)
		a := &dns.A{
			Hdr: dns.RR_Header{Name: name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: query_ttl},
			A:   ip,
		}
		m.Answer = append(m.Answer, a)
	case 6:
		m.MsgHdr.Id += 1
		a := &dns.A{
			Hdr: dns.RR_Header{Name: name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 60},
			A:   ip,
		}
		m.Answer = append(m.Answer, a)
	case 7:
		wrong_answer := &dns.AAAA{
			Hdr:  dns.RR_Header{Name: "www.example.com.", Rrtype: dns.TypeAAAA, Class: dns.ClassINET, Ttl: 60},
			AAAA: net.ParseIP("fe80::7526:a2ae:a0b8:946d"),
		}
		m.Answer = append(m.Answer, wrong_answer)
	case 0:
		a := &dns.A{
			Hdr: dns.RR_Header{Name: name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 3600},
			A:   net.ParseIP("159.75.200.247"),
		}
		m.Answer = append(m.Answer, a)
	case -1:
		m.MsgHdr.Rcode = dns.RcodeNameError
	}
	w.WriteMsg(m)
}

func main() {
	flag.StringVar(&CONFIG_SLD, "sld", "", "configure sld for echo dns server")
	flag.Parse()
	if CONFIG_SLD == "" {
		panic("Please configure the SLD for the echo dns server!\n")
	}
	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
	dns.HandleFunc(dns.Fqdn(CONFIG_SLD), handleReflect)
	server := &dns.Server{Addr: ":53", Net: "udp"}
	if err := server.ListenAndServe(); err != nil {
		fmt.Println("Failed to set up dns server!")
		panic(err)
	}
}