github.com/zartbot/goflow@v0.0.0-20221001080520-456f7dfad288/service/ciscoeta/idp/dns.go (about)

     1  package idp
     2  
     3  import (
     4  	"encoding/binary"
     5  	"fmt"
     6  	"math"
     7  	"strings"
     8  	"time"
     9  
    10  	"github.com/zartbot/goflow/lib/ksyncmap"
    11  
    12  	"github.com/zartbot/goflow/lib/iputil"
    13  	"github.com/zartbot/goflow/service/identity"
    14  
    15  	"github.com/google/gopacket"
    16  	"github.com/google/gopacket/layers"
    17  	"github.com/zartbot/go_utils/map2value"
    18  )
    19  
    20  var DNSRTT ksyncmap.Map
    21  
    22  func init() {
    23  	DNSRTT.Name = "IDP_DNS_RTT"
    24  	DNSRTT.Timeout = 5
    25  	DNSRTT.CheckFreq = 5
    26  	DNSRTT.Verbose = false
    27  	go DNSRTT.Run()
    28  }
    29  
    30  type DnsMsg struct {
    31  	TrasactionID uint16
    32  	QueryName    string
    33  	AnswersIP    []string
    34  	AnswersName  []string
    35  	AnswersCount int
    36  	ResponseType string
    37  	ResponseCode int
    38  	OpCode       int
    39  }
    40  
    41  func (d *DnsMsg) String() string {
    42  	var r string
    43  	r += fmt.Sprintf("------------------------\n")
    44  	r += fmt.Sprintf("    DNS Transaction: %d\n", d.TrasactionID)
    45  	r += fmt.Sprintf("    DNS OpCode: %d\n", d.OpCode)
    46  	r += fmt.Sprintf("    DNS ResponseCode: %s[%d]\n", d.ResponseType, d.ResponseCode)
    47  	r += fmt.Sprintf("    DNS # Answers: %d\n", d.AnswersCount)
    48  	r += fmt.Sprintf("    DNS Question: %s\n", d.QueryName)
    49  	for k, item := range d.AnswersIP {
    50  		r += fmt.Sprintf("    DNS Answer: %s : %s\n", d.AnswersName[k], item)
    51  	}
    52  	return r
    53  }
    54  
    55  func IsDNSPacket(d map[string]interface{}) bool {
    56  	ProtocolID, _ := map2value.MapToUInt8(d, "protocolIdentifier")
    57  	srcPort := iputil.FetchPort(d, "src")
    58  	dstPort := iputil.FetchPort(d, "dst")
    59  
    60  	if (ProtocolID == 17) && ((srcPort == 53) || (dstPort == 53)) {
    61  		return true
    62  	}
    63  	return false
    64  }
    65  
    66  func DecodeDNS(packet gopacket.Packet) []*DnsMsg {
    67  	var result []*DnsMsg
    68  	dnsLayer := packet.Layer(layers.LayerTypeDNS)
    69  	if dnsLayer != nil {
    70  		dns, _ := dnsLayer.(*layers.DNS)
    71  		payload := dnsLayer.LayerContents()
    72  		var transid uint16
    73  		if len(payload) > 4 {
    74  			transid = binary.BigEndian.Uint16(payload[0:2])
    75  		}
    76  		dnsOpCode := int(dns.OpCode)
    77  		dnsResponseCode := int(dns.ResponseCode)
    78  		dnsANCount := int(dns.ANCount)
    79  
    80  		for _, dnsQuestion := range dns.Questions {
    81  			d := DnsMsg{TrasactionID: transid,
    82  				QueryName:    string(dnsQuestion.Name),
    83  				OpCode:       dnsOpCode,
    84  				ResponseCode: dnsResponseCode,
    85  				ResponseType: dns.ResponseCode.String(),
    86  				AnswersCount: dnsANCount}
    87  
    88  			if dnsANCount > 0 {
    89  				for _, dnsAnswer := range dns.Answers {
    90  					//d.DnsAnswerTTL = append(d.DnsAnswerTTL, fmt.Sprint(dnsAnswer.TTL))
    91  					/*
    92  						//Debug log
    93  							recordString, error := json.MarshalIndent(dnsAnswer, "", "\t")
    94  							if error == nil {
    95  								logrus.Warn(fmt.Sprintf("RecordMap: %s", recordString))
    96  							} else {
    97  								logrus.Warn(fmt.Sprintf("RecordMap: %+v", dnsAnswer))
    98  							}
    99  					*/
   100  					if dnsAnswer.IP != nil {
   101  						d.AnswersIP = append(d.AnswersIP, dnsAnswer.IP.String())
   102  						d.AnswersName = append(d.AnswersName, string(dnsAnswer.Name[:]))
   103  					}
   104  				}
   105  			}
   106  			result = append(result, &d)
   107  		}
   108  	}
   109  	return result
   110  }
   111  
   112  func CalculateDNSRTT(d map[string]interface{}, r *DnsMsg) float64 {
   113  	var key string
   114  	var rtt float64
   115  	flowinfo, valid := d["flowinfo"]
   116  	timestamp, _ := map2value.MapToUInt64(d, "flowStartMilliseconds")
   117  	if valid {
   118  		v, _ := flowinfo.(iputil.FlowInfo)
   119  		key = fmt.Sprintf("%s__%d__%s", v.FlowIDWithPort, r.TrasactionID, r.QueryName)
   120  		cachetime, cvalid := DNSRTT.Load(key)
   121  		if cvalid {
   122  			t1 := cachetime.(uint64)
   123  			rtt = math.Abs(float64(t1) - float64(timestamp))
   124  			//DNSRTT.Delete(key) //system has timeout mechanism
   125  		} else {
   126  			DNSRTT.Store(key, timestamp, time.Unix(0, int64(timestamp)*1e6))
   127  			rtt = -1 // set rtt as invalid value, filter later
   128  		}
   129  	}
   130  	/*recordTime := time.Unix(0, int64(timestamp)*1e6)
   131  	logrus.WithFields(logrus.Fields{
   132  		"TimeStamp": recordTime,
   133  		"Key":       key,
   134  		"RTT":       rtt,
   135  	}).Warn(r)*/
   136  	return rtt
   137  }
   138  
   139  func ParseDNSPacket(d map[string]interface{}, packet gopacket.Packet) {
   140  	if IsDNSPacket(d) {
   141  		rlist := DecodeDNS(packet)
   142  		for idx, r := range rlist {
   143  			if !strings.HasSuffix(r.QueryName, ".in-addr.arpa") {
   144  				if idx == 0 {
   145  					//d["IDP_DNS"] = r
   146  					d["dns_domain-name"] = r.QueryName
   147  					d["dns_response_code"] = r.ResponseType
   148  					rtt := CalculateDNSRTT(d, r)
   149  					if rtt >= 0 {
   150  						d["dns_rtt"] = rtt
   151  					}
   152  				}
   153  				if r.AnswersCount > 0 {
   154  					for _, item := range r.AnswersIP {
   155  						//add to identity service database
   156  						identity.Service["DNS"].Store(item, r.QueryName, time.Now())
   157  					}
   158  				}
   159  			}
   160  		}
   161  	}
   162  }