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 }