515 lines
14 KiB
Go
515 lines
14 KiB
Go
package dns
|
|
|
|
import (
|
|
"encoding/hex"
|
|
"errors"
|
|
"net"
|
|
"strconv"
|
|
)
|
|
|
|
// EDNS0 Option codes.
|
|
const (
|
|
EDNS0LLQ = 0x1 // long lived queries: http://tools.ietf.org/html/draft-sekar-dns-llq-01
|
|
EDNS0UL = 0x2 // update lease draft: http://files.dns-sd.org/draft-sekar-dns-ul.txt
|
|
EDNS0NSID = 0x3 // nsid (RFC5001)
|
|
EDNS0DAU = 0x5 // DNSSEC Algorithm Understood
|
|
EDNS0DHU = 0x6 // DS Hash Understood
|
|
EDNS0N3U = 0x7 // NSEC3 Hash Understood
|
|
EDNS0SUBNET = 0x8 // client-subnet (RFC6891)
|
|
EDNS0EXPIRE = 0x9 // EDNS0 expire
|
|
EDNS0SUBNETDRAFT = 0x50fa // Don't use! Use EDNS0SUBNET
|
|
EDNS0LOCALSTART = 0xFDE9 // Beginning of range reserved for local/experimental use (RFC6891)
|
|
EDNS0LOCALEND = 0xFFFE // End of range reserved for local/experimental use (RFC6891)
|
|
_DO = 1 << 15 // dnssec ok
|
|
)
|
|
|
|
// OPT is the EDNS0 RR appended to messages to convey extra (meta) information.
|
|
// See RFC 6891.
|
|
type OPT struct {
|
|
Hdr RR_Header
|
|
Option []EDNS0 `dns:"opt"`
|
|
}
|
|
|
|
// Header implements the RR interface.
|
|
func (rr *OPT) Header() *RR_Header {
|
|
return &rr.Hdr
|
|
}
|
|
|
|
func (rr *OPT) String() string {
|
|
s := "\n;; OPT PSEUDOSECTION:\n; EDNS: version " + strconv.Itoa(int(rr.Version())) + "; "
|
|
if rr.Do() {
|
|
s += "flags: do; "
|
|
} else {
|
|
s += "flags: ; "
|
|
}
|
|
s += "udp: " + strconv.Itoa(int(rr.UDPSize()))
|
|
|
|
for _, o := range rr.Option {
|
|
switch o.(type) {
|
|
case *EDNS0_NSID:
|
|
s += "\n; NSID: " + o.String()
|
|
h, e := o.pack()
|
|
var r string
|
|
if e == nil {
|
|
for _, c := range h {
|
|
r += "(" + string(c) + ")"
|
|
}
|
|
s += " " + r
|
|
}
|
|
case *EDNS0_SUBNET:
|
|
s += "\n; SUBNET: " + o.String()
|
|
if o.(*EDNS0_SUBNET).DraftOption {
|
|
s += " (draft)"
|
|
}
|
|
case *EDNS0_UL:
|
|
s += "\n; UPDATE LEASE: " + o.String()
|
|
case *EDNS0_LLQ:
|
|
s += "\n; LONG LIVED QUERIES: " + o.String()
|
|
case *EDNS0_DAU:
|
|
s += "\n; DNSSEC ALGORITHM UNDERSTOOD: " + o.String()
|
|
case *EDNS0_DHU:
|
|
s += "\n; DS HASH UNDERSTOOD: " + o.String()
|
|
case *EDNS0_N3U:
|
|
s += "\n; NSEC3 HASH UNDERSTOOD: " + o.String()
|
|
case *EDNS0_LOCAL:
|
|
s += "\n; LOCAL OPT: " + o.String()
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
func (rr *OPT) len() int {
|
|
l := rr.Hdr.len()
|
|
for i := 0; i < len(rr.Option); i++ {
|
|
l += 4 // Account for 2-byte option code and 2-byte option length.
|
|
lo, _ := rr.Option[i].pack()
|
|
l += len(lo)
|
|
}
|
|
return l
|
|
}
|
|
|
|
func (rr *OPT) copy() RR {
|
|
return &OPT{*rr.Hdr.copyHeader(), rr.Option}
|
|
}
|
|
|
|
// return the old value -> delete SetVersion?
|
|
|
|
// Version returns the EDNS version used. Only zero is defined.
|
|
func (rr *OPT) Version() uint8 {
|
|
return uint8((rr.Hdr.Ttl & 0x00FF0000) >> 16)
|
|
}
|
|
|
|
// SetVersion sets the version of EDNS. This is usually zero.
|
|
func (rr *OPT) SetVersion(v uint8) {
|
|
rr.Hdr.Ttl = rr.Hdr.Ttl&0xFF00FFFF | (uint32(v) << 16)
|
|
}
|
|
|
|
// ExtendedRcode returns the EDNS extended RCODE field (the upper 8 bits of the TTL).
|
|
func (rr *OPT) ExtendedRcode() uint8 {
|
|
return uint8((rr.Hdr.Ttl & 0xFF000000) >> 24)
|
|
}
|
|
|
|
// SetExtendedRcode sets the EDNS extended RCODE field.
|
|
func (rr *OPT) SetExtendedRcode(v uint8) {
|
|
rr.Hdr.Ttl = rr.Hdr.Ttl&0x00FFFFFF | (uint32(v) << 24)
|
|
}
|
|
|
|
// UDPSize returns the UDP buffer size.
|
|
func (rr *OPT) UDPSize() uint16 {
|
|
return rr.Hdr.Class
|
|
}
|
|
|
|
// SetUDPSize sets the UDP buffer size.
|
|
func (rr *OPT) SetUDPSize(size uint16) {
|
|
rr.Hdr.Class = size
|
|
}
|
|
|
|
// Do returns the value of the DO (DNSSEC OK) bit.
|
|
func (rr *OPT) Do() bool {
|
|
return rr.Hdr.Ttl&_DO == _DO
|
|
}
|
|
|
|
// SetDo sets the DO (DNSSEC OK) bit.
|
|
func (rr *OPT) SetDo() {
|
|
rr.Hdr.Ttl |= _DO
|
|
}
|
|
|
|
// EDNS0 defines an EDNS0 Option. An OPT RR can have multiple options appended to
|
|
// it.
|
|
type EDNS0 interface {
|
|
// Option returns the option code for the option.
|
|
Option() uint16
|
|
// pack returns the bytes of the option data.
|
|
pack() ([]byte, error)
|
|
// unpack sets the data as found in the buffer. Is also sets
|
|
// the length of the slice as the length of the option data.
|
|
unpack([]byte) error
|
|
// String returns the string representation of the option.
|
|
String() string
|
|
}
|
|
|
|
// The nsid EDNS0 option is used to retrieve a nameserver
|
|
// identifier. When sending a request Nsid must be set to the empty string
|
|
// The identifier is an opaque string encoded as hex.
|
|
// Basic use pattern for creating an nsid option:
|
|
//
|
|
// o := new(dns.OPT)
|
|
// o.Hdr.Name = "."
|
|
// o.Hdr.Rrtype = dns.TypeOPT
|
|
// e := new(dns.EDNS0_NSID)
|
|
// e.Code = dns.EDNS0NSID
|
|
// e.Nsid = "AA"
|
|
// o.Option = append(o.Option, e)
|
|
type EDNS0_NSID struct {
|
|
Code uint16 // Always EDNS0NSID
|
|
Nsid string // This string needs to be hex encoded
|
|
}
|
|
|
|
func (e *EDNS0_NSID) pack() ([]byte, error) {
|
|
h, err := hex.DecodeString(e.Nsid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return h, nil
|
|
}
|
|
|
|
func (e *EDNS0_NSID) Option() uint16 { return EDNS0NSID }
|
|
func (e *EDNS0_NSID) unpack(b []byte) error { e.Nsid = hex.EncodeToString(b); return nil }
|
|
func (e *EDNS0_NSID) String() string { return string(e.Nsid) }
|
|
|
|
// EDNS0_SUBNET is the subnet option that is used to give the remote nameserver
|
|
// an idea of where the client lives. It can then give back a different
|
|
// answer depending on the location or network topology.
|
|
// Basic use pattern for creating an subnet option:
|
|
//
|
|
// o := new(dns.OPT)
|
|
// o.Hdr.Name = "."
|
|
// o.Hdr.Rrtype = dns.TypeOPT
|
|
// e := new(dns.EDNS0_SUBNET)
|
|
// e.Code = dns.EDNS0SUBNET
|
|
// e.Family = 1 // 1 for IPv4 source address, 2 for IPv6
|
|
// e.NetMask = 32 // 32 for IPV4, 128 for IPv6
|
|
// e.SourceScope = 0
|
|
// e.Address = net.ParseIP("127.0.0.1").To4() // for IPv4
|
|
// // e.Address = net.ParseIP("2001:7b8:32a::2") // for IPV6
|
|
// o.Option = append(o.Option, e)
|
|
//
|
|
// Note: the spec (draft-ietf-dnsop-edns-client-subnet-00) has some insane logic
|
|
// for which netmask applies to the address. This code will parse all the
|
|
// available bits when unpacking (up to optlen). When packing it will apply
|
|
// SourceNetmask. If you need more advanced logic, patches welcome and good luck.
|
|
type EDNS0_SUBNET struct {
|
|
Code uint16 // Always EDNS0SUBNET
|
|
Family uint16 // 1 for IP, 2 for IP6
|
|
SourceNetmask uint8
|
|
SourceScope uint8
|
|
Address net.IP
|
|
DraftOption bool // Set to true if using the old (0x50fa) option code
|
|
}
|
|
|
|
func (e *EDNS0_SUBNET) Option() uint16 {
|
|
if e.DraftOption {
|
|
return EDNS0SUBNETDRAFT
|
|
}
|
|
return EDNS0SUBNET
|
|
}
|
|
|
|
func (e *EDNS0_SUBNET) pack() ([]byte, error) {
|
|
b := make([]byte, 4)
|
|
b[0], b[1] = packUint16(e.Family)
|
|
b[2] = e.SourceNetmask
|
|
b[3] = e.SourceScope
|
|
switch e.Family {
|
|
case 1:
|
|
if e.SourceNetmask > net.IPv4len*8 {
|
|
return nil, errors.New("dns: bad netmask")
|
|
}
|
|
if len(e.Address.To4()) != net.IPv4len {
|
|
return nil, errors.New("dns: bad address")
|
|
}
|
|
ip := e.Address.To4().Mask(net.CIDRMask(int(e.SourceNetmask), net.IPv4len*8))
|
|
needLength := (e.SourceNetmask + 8 - 1) / 8 // division rounding up
|
|
b = append(b, ip[:needLength]...)
|
|
case 2:
|
|
if e.SourceNetmask > net.IPv6len*8 {
|
|
return nil, errors.New("dns: bad netmask")
|
|
}
|
|
if len(e.Address) != net.IPv6len {
|
|
return nil, errors.New("dns: bad address")
|
|
}
|
|
ip := e.Address.Mask(net.CIDRMask(int(e.SourceNetmask), net.IPv6len*8))
|
|
needLength := (e.SourceNetmask + 8 - 1) / 8 // division rounding up
|
|
b = append(b, ip[:needLength]...)
|
|
default:
|
|
return nil, errors.New("dns: bad address family")
|
|
}
|
|
return b, nil
|
|
}
|
|
|
|
func (e *EDNS0_SUBNET) unpack(b []byte) error {
|
|
if len(b) < 4 {
|
|
return ErrBuf
|
|
}
|
|
e.Family, _ = unpackUint16(b, 0)
|
|
e.SourceNetmask = b[2]
|
|
e.SourceScope = b[3]
|
|
switch e.Family {
|
|
case 1:
|
|
if e.SourceNetmask > net.IPv4len*8 || e.SourceScope > net.IPv4len*8 {
|
|
return errors.New("dns: bad netmask")
|
|
}
|
|
addr := make([]byte, net.IPv4len)
|
|
for i := 0; i < net.IPv4len && 4+i < len(b); i++ {
|
|
addr[i] = b[4+i]
|
|
}
|
|
e.Address = net.IPv4(addr[0], addr[1], addr[2], addr[3])
|
|
case 2:
|
|
if e.SourceNetmask > net.IPv6len*8 || e.SourceScope > net.IPv6len*8 {
|
|
return errors.New("dns: bad netmask")
|
|
}
|
|
addr := make([]byte, net.IPv6len)
|
|
for i := 0; i < net.IPv6len && 4+i < len(b); i++ {
|
|
addr[i] = b[4+i]
|
|
}
|
|
e.Address = net.IP{addr[0], addr[1], addr[2], addr[3], addr[4],
|
|
addr[5], addr[6], addr[7], addr[8], addr[9], addr[10],
|
|
addr[11], addr[12], addr[13], addr[14], addr[15]}
|
|
default:
|
|
return errors.New("dns: bad address family")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (e *EDNS0_SUBNET) String() (s string) {
|
|
if e.Address == nil {
|
|
s = "<nil>"
|
|
} else if e.Address.To4() != nil {
|
|
s = e.Address.String()
|
|
} else {
|
|
s = "[" + e.Address.String() + "]"
|
|
}
|
|
s += "/" + strconv.Itoa(int(e.SourceNetmask)) + "/" + strconv.Itoa(int(e.SourceScope))
|
|
return
|
|
}
|
|
|
|
// The EDNS0_UL (Update Lease) (draft RFC) option is used to tell the server to set
|
|
// an expiration on an update RR. This is helpful for clients that cannot clean
|
|
// up after themselves. This is a draft RFC and more information can be found at
|
|
// http://files.dns-sd.org/draft-sekar-dns-ul.txt
|
|
//
|
|
// o := new(dns.OPT)
|
|
// o.Hdr.Name = "."
|
|
// o.Hdr.Rrtype = dns.TypeOPT
|
|
// e := new(dns.EDNS0_UL)
|
|
// e.Code = dns.EDNS0UL
|
|
// e.Lease = 120 // in seconds
|
|
// o.Option = append(o.Option, e)
|
|
type EDNS0_UL struct {
|
|
Code uint16 // Always EDNS0UL
|
|
Lease uint32
|
|
}
|
|
|
|
func (e *EDNS0_UL) Option() uint16 { return EDNS0UL }
|
|
func (e *EDNS0_UL) String() string { return strconv.FormatUint(uint64(e.Lease), 10) }
|
|
|
|
// Copied: http://golang.org/src/pkg/net/dnsmsg.go
|
|
func (e *EDNS0_UL) pack() ([]byte, error) {
|
|
b := make([]byte, 4)
|
|
b[0] = byte(e.Lease >> 24)
|
|
b[1] = byte(e.Lease >> 16)
|
|
b[2] = byte(e.Lease >> 8)
|
|
b[3] = byte(e.Lease)
|
|
return b, nil
|
|
}
|
|
|
|
func (e *EDNS0_UL) unpack(b []byte) error {
|
|
if len(b) < 4 {
|
|
return ErrBuf
|
|
}
|
|
e.Lease = uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3])
|
|
return nil
|
|
}
|
|
|
|
// EDNS0_LLQ stands for Long Lived Queries: http://tools.ietf.org/html/draft-sekar-dns-llq-01
|
|
// Implemented for completeness, as the EDNS0 type code is assigned.
|
|
type EDNS0_LLQ struct {
|
|
Code uint16 // Always EDNS0LLQ
|
|
Version uint16
|
|
Opcode uint16
|
|
Error uint16
|
|
Id uint64
|
|
LeaseLife uint32
|
|
}
|
|
|
|
func (e *EDNS0_LLQ) Option() uint16 { return EDNS0LLQ }
|
|
|
|
func (e *EDNS0_LLQ) pack() ([]byte, error) {
|
|
b := make([]byte, 18)
|
|
b[0], b[1] = packUint16(e.Version)
|
|
b[2], b[3] = packUint16(e.Opcode)
|
|
b[4], b[5] = packUint16(e.Error)
|
|
b[6] = byte(e.Id >> 56)
|
|
b[7] = byte(e.Id >> 48)
|
|
b[8] = byte(e.Id >> 40)
|
|
b[9] = byte(e.Id >> 32)
|
|
b[10] = byte(e.Id >> 24)
|
|
b[11] = byte(e.Id >> 16)
|
|
b[12] = byte(e.Id >> 8)
|
|
b[13] = byte(e.Id)
|
|
b[14] = byte(e.LeaseLife >> 24)
|
|
b[15] = byte(e.LeaseLife >> 16)
|
|
b[16] = byte(e.LeaseLife >> 8)
|
|
b[17] = byte(e.LeaseLife)
|
|
return b, nil
|
|
}
|
|
|
|
func (e *EDNS0_LLQ) unpack(b []byte) error {
|
|
if len(b) < 18 {
|
|
return ErrBuf
|
|
}
|
|
e.Version, _ = unpackUint16(b, 0)
|
|
e.Opcode, _ = unpackUint16(b, 2)
|
|
e.Error, _ = unpackUint16(b, 4)
|
|
e.Id = uint64(b[6])<<56 | uint64(b[6+1])<<48 | uint64(b[6+2])<<40 |
|
|
uint64(b[6+3])<<32 | uint64(b[6+4])<<24 | uint64(b[6+5])<<16 | uint64(b[6+6])<<8 | uint64(b[6+7])
|
|
e.LeaseLife = uint32(b[14])<<24 | uint32(b[14+1])<<16 | uint32(b[14+2])<<8 | uint32(b[14+3])
|
|
return nil
|
|
}
|
|
|
|
func (e *EDNS0_LLQ) String() string {
|
|
s := strconv.FormatUint(uint64(e.Version), 10) + " " + strconv.FormatUint(uint64(e.Opcode), 10) +
|
|
" " + strconv.FormatUint(uint64(e.Error), 10) + " " + strconv.FormatUint(uint64(e.Id), 10) +
|
|
" " + strconv.FormatUint(uint64(e.LeaseLife), 10)
|
|
return s
|
|
}
|
|
|
|
type EDNS0_DAU struct {
|
|
Code uint16 // Always EDNS0DAU
|
|
AlgCode []uint8
|
|
}
|
|
|
|
func (e *EDNS0_DAU) Option() uint16 { return EDNS0DAU }
|
|
func (e *EDNS0_DAU) pack() ([]byte, error) { return e.AlgCode, nil }
|
|
func (e *EDNS0_DAU) unpack(b []byte) error { e.AlgCode = b; return nil }
|
|
|
|
func (e *EDNS0_DAU) String() string {
|
|
s := ""
|
|
for i := 0; i < len(e.AlgCode); i++ {
|
|
if a, ok := AlgorithmToString[e.AlgCode[i]]; ok {
|
|
s += " " + a
|
|
} else {
|
|
s += " " + strconv.Itoa(int(e.AlgCode[i]))
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
type EDNS0_DHU struct {
|
|
Code uint16 // Always EDNS0DHU
|
|
AlgCode []uint8
|
|
}
|
|
|
|
func (e *EDNS0_DHU) Option() uint16 { return EDNS0DHU }
|
|
func (e *EDNS0_DHU) pack() ([]byte, error) { return e.AlgCode, nil }
|
|
func (e *EDNS0_DHU) unpack(b []byte) error { e.AlgCode = b; return nil }
|
|
|
|
func (e *EDNS0_DHU) String() string {
|
|
s := ""
|
|
for i := 0; i < len(e.AlgCode); i++ {
|
|
if a, ok := HashToString[e.AlgCode[i]]; ok {
|
|
s += " " + a
|
|
} else {
|
|
s += " " + strconv.Itoa(int(e.AlgCode[i]))
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
type EDNS0_N3U struct {
|
|
Code uint16 // Always EDNS0N3U
|
|
AlgCode []uint8
|
|
}
|
|
|
|
func (e *EDNS0_N3U) Option() uint16 { return EDNS0N3U }
|
|
func (e *EDNS0_N3U) pack() ([]byte, error) { return e.AlgCode, nil }
|
|
func (e *EDNS0_N3U) unpack(b []byte) error { e.AlgCode = b; return nil }
|
|
|
|
func (e *EDNS0_N3U) String() string {
|
|
// Re-use the hash map
|
|
s := ""
|
|
for i := 0; i < len(e.AlgCode); i++ {
|
|
if a, ok := HashToString[e.AlgCode[i]]; ok {
|
|
s += " " + a
|
|
} else {
|
|
s += " " + strconv.Itoa(int(e.AlgCode[i]))
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
type EDNS0_EXPIRE struct {
|
|
Code uint16 // Always EDNS0EXPIRE
|
|
Expire uint32
|
|
}
|
|
|
|
func (e *EDNS0_EXPIRE) Option() uint16 { return EDNS0EXPIRE }
|
|
func (e *EDNS0_EXPIRE) String() string { return strconv.FormatUint(uint64(e.Expire), 10) }
|
|
|
|
func (e *EDNS0_EXPIRE) pack() ([]byte, error) {
|
|
b := make([]byte, 4)
|
|
b[0] = byte(e.Expire >> 24)
|
|
b[1] = byte(e.Expire >> 16)
|
|
b[2] = byte(e.Expire >> 8)
|
|
b[3] = byte(e.Expire)
|
|
return b, nil
|
|
}
|
|
|
|
func (e *EDNS0_EXPIRE) unpack(b []byte) error {
|
|
if len(b) < 4 {
|
|
return ErrBuf
|
|
}
|
|
e.Expire = uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3])
|
|
return nil
|
|
}
|
|
|
|
// The EDNS0_LOCAL option is used for local/experimental purposes. The option
|
|
// code is recommended to be within the range [EDNS0LOCALSTART, EDNS0LOCALEND]
|
|
// (RFC6891), although any unassigned code can actually be used. The content of
|
|
// the option is made available in Data, unaltered.
|
|
// Basic use pattern for creating a local option:
|
|
//
|
|
// o := new(dns.OPT)
|
|
// o.Hdr.Name = "."
|
|
// o.Hdr.Rrtype = dns.TypeOPT
|
|
// e := new(dns.EDNS0_LOCAL)
|
|
// e.Code = dns.EDNS0LOCALSTART
|
|
// e.Data = []byte{72, 82, 74}
|
|
// o.Option = append(o.Option, e)
|
|
type EDNS0_LOCAL struct {
|
|
Code uint16
|
|
Data []byte
|
|
}
|
|
|
|
func (e *EDNS0_LOCAL) Option() uint16 { return e.Code }
|
|
func (e *EDNS0_LOCAL) String() string {
|
|
return strconv.FormatInt(int64(e.Code), 10) + ":0x" + hex.EncodeToString(e.Data)
|
|
}
|
|
|
|
func (e *EDNS0_LOCAL) pack() ([]byte, error) {
|
|
b := make([]byte, len(e.Data))
|
|
copied := copy(b, e.Data)
|
|
if copied != len(e.Data) {
|
|
return nil, ErrBuf
|
|
}
|
|
return b, nil
|
|
}
|
|
|
|
func (e *EDNS0_LOCAL) unpack(b []byte) error {
|
|
e.Data = make([]byte, len(b))
|
|
copied := copy(e.Data, b)
|
|
if copied != len(b) {
|
|
return ErrBuf
|
|
}
|
|
return nil
|
|
}
|