Exemple #1
0
func main() {
	c, err := dns.ClientConfigFromFile("/etc/resolv.conf")
	if len(os.Args) != 2 || err != nil {
		fmt.Printf("%s DOMAIN\n", os.Args[0])
		os.Exit(1)
	}
	m := new(dns.Msg)
	m.MsgHdr.RecursionDesired = true //only set this bit
	m.Question = make([]dns.Question, 1)
	m.Question[0] = dns.Question{os.Args[1], dns.TypeDNSKEY, dns.ClassINET}

	d := new(dns.Conn)
	d.RemoteAddr = c.Servers[0]
	in, err := dns.SimpleQuery("udp", d, m)
	if in != nil {
		if in.Rcode != dns.RcodeSuccess {
			fmt.Printf(" *** invalid answer name %s after DNSKEY query for %s\n", os.Args[1], os.Args[1])
			os.Exit(1)
		}
		// Stuff must be in the answer section
		for _, k := range in.Answer {
			// Foreach key would need to provide a DS records, both sha1 and sha256
			if key, ok := k.(*dns.RR_DNSKEY); ok {
				ds := key.ToDS(dns.HashSHA1)
				ds.Hdr.Ttl = 0
				fmt.Printf("%v\n", ds)
				ds = key.ToDS(dns.HashSHA256)
				ds.Hdr.Ttl = 0
				fmt.Printf("%v\n", ds)
			}
		}
	} else {
		fmt.Printf("*** error: %s\n", err.String())
	}
}
Exemple #2
0
func main() {
	c, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
	if len(os.Args) != 2 {
		fmt.Printf("%s DOMAIN\n", os.Args[0])
		os.Exit(1)
	}

	m := new(dns.Msg)
	m.Question = make([]dns.Question, 1)
	d := new(dns.Conn)
	d.RemoteAddr = c.Servers[0]
	for _, a := range addresses(d, os.Args[0]) {
		d.RemoteAddr = a
		if err := d.Dial("udp"); err != nil {
			fmt.Printf("%v\n", err)
			os.Exit(1)
		}

		m.Question[0] = dns.Question{"version.bind.", dns.TypeTXT, dns.ClassCHAOS}
		in, _ := dns.SimpleQuery("udp", d, m)
		if in != nil && in.Answer != nil {
			fmt.Printf("%v\n", in.Answer[0])
		}
		m.Question[0] = dns.Question{"hostname.bind.", dns.TypeTXT, dns.ClassCHAOS}
		in, _ = dns.SimpleQuery("udp", d, m)
		if in != nil && in.Answer != nil {
			fmt.Printf("%v\n", in.Answer[0])
		}
	}
}
Exemple #3
0
func handle(c *dns.Conn, in *dns.Msg) {
	if in.MsgHdr.Response == true {
		return // We don't do responses
	}
	answer := reply(c, in)
	c.Write(answer)
}
Exemple #4
0
func newConnMsg(qname, nameserver string, attempts int, qtype, qclass uint16, aa, ad, cd, rd, dnssec, nsid bool) (*dns.Conn, *dns.Msg) {
	d := new(dns.Conn)
	d.RemoteAddr = nameserver
	d.Attempts = attempts

	m := new(dns.Msg)
	m.MsgHdr.Authoritative = aa
	m.MsgHdr.AuthenticatedData = ad
	m.MsgHdr.CheckingDisabled = cd
	m.MsgHdr.RecursionDesired = rd
	m.Question = make([]dns.Question, 1)
	if dnssec || nsid {
		opt := new(dns.RR_OPT)
		opt.SetDo()
		opt.SetVersion(0)
		opt.SetUDPSize(dns.DefaultMsgSize)
		if nsid {
			opt.SetNsid("")
		}
		m.Extra = make([]dns.RR, 1)
		m.Extra[0] = opt
	}
	m.Question[0] = dns.Question{qname, qtype, qclass}
	m.Id = dns.Id()
	return d, m
}
Exemple #5
0
func reply(c *dns.Conn, i *dns.Msg) {
	out, err := doFunkensturm(i)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error: %s\n", err.String())
		return
	}
	if out != nil {
		c.Write(out)
	}
}
Exemple #6
0
func handleNotifyOut(addr string) {
	if Zone.name == "" || !Zone.correct {
		return
	}
	d := new(dns.Conn)
	d.RemoteAddr = addr
	m := new(dns.Msg)
	m.SetNotify(Zone.name)
	fmt.Printf("Sending notifies: zone is ok\n")
	dns.QueryRequest <- &dns.Query{Conn: d, Query: m}
}
Exemple #7
0
func handleXfrIn(i *dns.Msg) os.Error {
	q := new(dns.Msg)
	q.SetAxfr(i.Question[0].Name)

	m := make(chan *dns.Xfr)
	fmt.Printf("Preparing Xfr for %s\n", i.Question[0].Name)

	d := new(dns.Conn)
	d.RemoteAddr = "127.0.0.1:53"
	err := d.Dial("tcp")
	if err != nil {
		return err
	}
	defer d.Close()

	fmt.Printf("Calling 127.0.0.1 successful\n")
	go d.XfrRead(q, m)

	Zone.name = i.Question[0].Name
	j := 0
	for x := range m {
		Zone.rrs[j] = x.RR
		j++
	}
	fmt.Printf("Success retrieved %s\n", Zone.name)
	Zone.size = j
	return nil
}
Exemple #8
0
func handleNotify(d *dns.Conn, i *dns.Msg) os.Error {
	if i.IsNotify() {
		fmt.Printf("Incoming notify seen\n")
		q := new(dns.Msg)
		q.SetReply(i)
		err := d.WriteMsg(q)
		if err != nil {
			return err
		}
		err = handleXfrIn(i)
		if err != nil {
			return err
		}
	}
	return nil
}
Exemple #9
0
func main() {
	var sserver *string = flag.String("sserver", "127.0.0.1:8053", "Set the listener address")
	var rserver *string = flag.String("rserver", "127.0.0.1:53", "Remote server address(es), seperate with commas")
	verbose = flag.Bool("verbose", false, "Print packet as it flows through") // verbose needs to be global
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage: %s\n", os.Args[0])
		flag.PrintDefaults()
	}
	flag.Parse()

	resolvers := strings.Split(*rserver, ",", -1)
	qr = make([]*dns.Resolver, len(resolvers))
	for i, ra := range resolvers {
		d := new(dns.Conn)
		d.RemoteAddr = addr
		qr[i] = d
	}

	f = funkensturm()
	ok := f.Setup()
	if !ok {
		fmt.Fprintf(os.Stderr, "Setup failed")
		return
	}

	err := make(chan os.Error)
	go udp(*sserver, err)
	go tcp(*sserver, err)

forever:
	for {
		select {
		case e := <-err:
			fmt.Printf("Error received, stopping: %s\n", e.String())
			break forever
		case <-signal.Incoming:
			fmt.Printf("Signal received, stopping")
			break forever
		}
	}
	close(err)
}
Exemple #10
0
func handleXfrOut(d *dns.Conn, i *dns.Msg) os.Error {
	if i.IsAxfr() {
		fmt.Printf("Incoming Axfr request seen\n")
		if i.Question[0].Name == Zone.name {
			fmt.Printf("Matches current zone\n")
			if !Zone.correct {
				fmt.Printf("Zone was not deemed correct\n")
				if err := d.WriteMsg(i); err != nil {
					return err
				}
				return nil
			} else {
				fmt.Printf("Zone was correct\n")
			}

			m := make(chan *dns.Xfr)
			e := make(chan os.Error)
			go d.XfrWrite(i, m, e)
			for j := 0; j < Zone.size; j++ {
				select {
				case m <- &dns.Xfr{Add: true, RR: Zone.rrs[j]}: //
				case err := <-e:
					return err
				}
			}
			close(m)
		} else {
			fmt.Printf("No matching zone found\n")
			if err := d.WriteMsg(i); err != nil {
				return err
			}
		}
	}
	return nil
}
Exemple #11
0
func main() {
	if len(os.Args) != 2 {
		fmt.Printf("%s DOMAIN\n", os.Args[0])
		os.Exit(1)
	}
	d := new(dns.Conn)
	c, err := dns.ClientConfigFromFile("/etc/resolv.conf")
	// Errorchecking
	d.RemoteAddr = c.Servers[0]

	m := new(dns.Msg)
	m.Id = dns.Id()
	m.MsgHdr.RecursionDesired = true
	m.Question = make([]dns.Question, 1)
	m.Question[0] = dns.Question{os.Args[1], dns.TypeMX, dns.ClassINET}

	err = d.Dial("udp")
	if err != nil {
		fmt.Printf("*** error: %s\n", err.String())
		os.Exit(1)
	}

	in, err := dns.SimpleQuery("udp", d, m)
	if in != nil {
		if in.Rcode != dns.RcodeSuccess {
			fmt.Printf(" *** invalid answer name %s after MX query for %s\n", os.Args[1], os.Args[1])
			os.Exit(1)
		}
		// Stuff must be in the answer section
		for _, a := range in.Answer {
			fmt.Printf("%v\n", a)
		}
	} else {
		fmt.Printf("*** error: %s\n", err.String())
	}
}
Exemple #12
0
// reply checking 'n stuff
func qhandle(d *dns.Conn, i *dns.Msg) {
	o, err := d.ExchangeMsg(i, false)
	dns.QueryReply <- &dns.Query{Query: i, Reply: o, Conn: d, Err: err}
	d.Close()
}