From 0ef0257fbecbcdd976e9a56608d1c6177bb64193 Mon Sep 17 00:00:00 2001 From: Kent Gruber Date: Thu, 17 May 2018 12:43:42 -0400 Subject: [PATCH 1/8] add arp test --- packets/arp_test.go | 98 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 packets/arp_test.go diff --git a/packets/arp_test.go b/packets/arp_test.go new file mode 100644 index 00000000..265d7362 --- /dev/null +++ b/packets/arp_test.go @@ -0,0 +1,98 @@ +package packets + +import ( + "net" + "reflect" + "testing" +) + +func TestNewARPTo(t *testing.T) { + from := net.IP{0, 0, 0, 0} + from_hw, _ := net.ParseMAC("01:23:45:67:89:ab") + to := net.IP{0, 0, 0, 0} + to_hw, _ := net.ParseMAC("01:23:45:67:89:ab") + req := uint16(0) + + eth, arp := NewARPTo(from, from_hw, to, to_hw, req) + + if !reflect.DeepEqual(eth.SrcMAC, from_hw) { + t.Fatalf("expected '%s', got '%s'", eth.SrcMAC, from_hw) + } + + if !reflect.DeepEqual(eth.DstMAC, to_hw) { + t.Fatalf("expected '%s', got '%s'", eth.DstMAC, to_hw) + } + + if !reflect.DeepEqual(arp.Operation, req) { + t.Fatalf("expected '%d', got '%d'", arp.Operation, req) + } + + if !reflect.DeepEqual(arp.SourceHwAddress, []byte(from_hw)) { + t.Fatalf("expected '%v', got '%v'", arp.SourceHwAddress, []byte(from_hw)) + } + + if !reflect.DeepEqual(arp.DstHwAddress, []byte(to_hw)) { + t.Fatalf("expected '%v', got '%v'", arp.DstHwAddress, []byte(to_hw)) + } +} + +func TestNewARP(t *testing.T) { + from := net.IP{0, 0, 0, 0} + from_hw, _ := net.ParseMAC("01:23:45:67:89:ab") + to_hw, _ := net.ParseMAC("00:00:00:00:00:00") + to := net.IP{0, 0, 0, 0} + req := uint16(0) + + eth, arp := NewARP(from, from_hw, to, req) + + if !reflect.DeepEqual(eth.SrcMAC, from_hw) { + t.Fatalf("expected '%s', got '%s'", eth.SrcMAC, from_hw) + } + + if !reflect.DeepEqual(eth.DstMAC, to_hw) { + t.Fatalf("expected '%s', got '%s'", eth.DstMAC, to_hw) + } + + if !reflect.DeepEqual(arp.Operation, req) { + t.Fatalf("expected '%d', got '%d'", arp.Operation, req) + } + + if !reflect.DeepEqual(arp.SourceHwAddress, []byte(from_hw)) { + t.Fatalf("expected '%v', got '%v'", arp.SourceHwAddress, []byte(from_hw)) + } + + if !reflect.DeepEqual(arp.DstHwAddress, []byte{0, 0, 0, 0, 0, 0}) { + t.Fatalf("expected '%v', got '%v'", arp.DstHwAddress, []byte{0, 0, 0, 0, 0, 0}) + } +} + +func TestNewARPRequest(t *testing.T) { + from := net.IP{0, 0, 0, 0} + from_hw, _ := net.ParseMAC("01:23:45:67:89:ab") + to := net.IP{0, 0, 0, 0} + + err, bytes := NewARPRequest(from, from_hw, to) + if err != nil { + t.Error(err) + } + + if len(bytes) <= 0 { + t.Error("unable to serialize new arp request packet") + } +} + +func TestNewARPReply(t *testing.T) { + from := net.IP{0, 0, 0, 0} + from_hw, _ := net.ParseMAC("01:23:45:67:89:ab") + to := net.IP{0, 0, 0, 0} + to_hw, _ := net.ParseMAC("01:23:45:67:89:ab") + + err, bytes := NewARPReply(from, from_hw, to, to_hw) + if err != nil { + t.Error(err) + } + + if len(bytes) <= 0 { + t.Error("unable to serialize new arp request packet") + } +} From c3cfc1ef68fb4daaa4111f802ca24903bdf13bd6 Mon Sep 17 00:00:00 2001 From: Kent Gruber Date: Thu, 17 May 2018 13:11:37 -0400 Subject: [PATCH 2/8] add dhcp6 test --- packets/dhcp6_test.go | 61 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 packets/dhcp6_test.go diff --git a/packets/dhcp6_test.go b/packets/dhcp6_test.go new file mode 100644 index 00000000..51039d6e --- /dev/null +++ b/packets/dhcp6_test.go @@ -0,0 +1,61 @@ +package packets + +import ( + "github.com/mdlayher/dhcp6" + "testing" +) + +func TestDHCP6OptDNSServers(t *testing.T) { + exp := 23 + got := DHCP6OptDNSServers + if exp != got { + t.Fatalf("expected '%v', got '%v'", exp, got) + } +} + +func TestDHCP6OptDNSDomains(t *testing.T) { + exp := 24 + got := DHCP6OptDNSDomains + if exp != got { + t.Fatalf("expected '%v', got '%v'", exp, got) + } +} + +func TestDHCP6OptClientFQDN(t *testing.T) { + exp := 39 + got := DHCP6OptClientFQDN + if exp != got { + t.Fatalf("expected '%v', got '%v'", exp, got) + } +} + +func TestIPv6Prefix(t *testing.T) { + exp := "fe80::" + got := IPv6Prefix + if exp != got { + t.Fatalf("expected '%v', got '%v'", exp, got) + } +} + +func TestDHCP6EncodeList(t *testing.T) { + domains := []string{"microsoft.com", "google.com", "facebook.com"} + + encoded := DHCP6EncodeList(domains) + + if len(encoded) <= 0 { + t.Error("unable to dhcp6 encode a given list") + } +} + +func TestDHCP6For(t *testing.T) { + mesg := dhcp6.MessageTypeSolicit + pakt := dhcp6.Packet{Options: dhcp6.Options{}} + pakt.Options.AddRaw(dhcp6.OptionClientID, []byte{}) + duid := []byte{} + + err, _ := DHCP6For(mesg, pakt, duid) + + if err != nil { + t.Error(err) + } +} From 56c411031298e496c886800b5fc6448fb5664643 Mon Sep 17 00:00:00 2001 From: Kent Gruber Date: Thu, 17 May 2018 13:19:13 -0400 Subject: [PATCH 3/8] add dhcp6 layer test --- packets/dhcp6_layer_test.go | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 packets/dhcp6_layer_test.go diff --git a/packets/dhcp6_layer_test.go b/packets/dhcp6_layer_test.go new file mode 100644 index 00000000..af151a43 --- /dev/null +++ b/packets/dhcp6_layer_test.go @@ -0,0 +1,29 @@ +package packets + +import ( + "github.com/google/gopacket" + "testing" +) + +func TestDHCPv6Layer(t *testing.T) { + layer := DHCPv6Layer{} + + exp := 0 + got := len(layer.Raw) + + if exp != got { + t.Fatalf("expected '%v', got '%v'", exp, got) + } +} + +func TestDHCP6SerializeTo(t *testing.T) { + layer := DHCPv6Layer{} + buffer := gopacket.NewSerializeBuffer() + opts := gopacket.SerializeOptions{} + + got := layer.SerializeTo(buffer, opts) + + if got != nil { + t.Fatalf("expected '%v', got '%v'", nil, got) + } +} From cca6fc05d44f103d73e912dbd81b38c07935be7f Mon Sep 17 00:00:00 2001 From: Kent Gruber Date: Sun, 20 May 2018 14:28:22 -0400 Subject: [PATCH 4/8] add some dot11 tests --- packets/dot11_test.go | 274 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 274 insertions(+) create mode 100644 packets/dot11_test.go diff --git a/packets/dot11_test.go b/packets/dot11_test.go new file mode 100644 index 00000000..00559c0a --- /dev/null +++ b/packets/dot11_test.go @@ -0,0 +1,274 @@ +package packets + +import ( + "github.com/google/gopacket" + "github.com/google/gopacket/layers" + "net" + "reflect" + "testing" +) + +func TestDot11Vars(t *testing.T) { + var units = []struct { + got interface{} + exp interface{} + }{ + {openFlags, 1057}, + {wpaFlags, 1041}, + {supportedRates, []byte{0x82, 0x84, 0x8b, 0x96, 0x24, 0x30, 0x48, 0x6c, 0x03, 0x01}}, + {wpaRSN, []byte{ + 0x01, 0x00, // RSN Version 1 + 0x00, 0x0f, 0xac, 0x02, // Group Cipher Suite : 00-0f-ac TKIP + 0x02, 0x00, // 2 Pairwise Cipher Suites (next two lines) + 0x00, 0x0f, 0xac, 0x04, // AES Cipher / CCMP + 0x00, 0x0f, 0xac, 0x02, // TKIP Cipher + 0x01, 0x00, // 1 Authentication Key Management Suite (line below) + 0x00, 0x0f, 0xac, 0x02, // Pre-Shared Key + 0x00, 0x00, + }}, + {wpaSignatureBytes, []byte{0, 0x50, 0xf2, 1}}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func BuildDot11ApConfig() Dot11ApConfig { + ssid := "I still love Ruby, don't worry!" + bssid, _ := net.ParseMAC("pi:ca:tw:as:he:re") + channel := 1 + encryption := false + + config := Dot11ApConfig{ + SSID: ssid, + BSSID: bssid, + Channel: channel, + Encryption: encryption, + } + + return config +} + +func TestDot11ApConfig(t *testing.T) { + ssid := "I still love Ruby, don't worry!" + bssid, _ := net.ParseMAC("pi:ca:tw:as:he:re") + channel := 1 + encryption := false + + config := Dot11ApConfig{ + SSID: ssid, + BSSID: bssid, + Channel: channel, + Encryption: encryption, + } + + var units = []struct { + got interface{} + exp interface{} + }{ + {config.SSID, ssid}, + {config.BSSID, bssid}, + {config.Channel, channel}, + {config.Encryption, encryption}, + } + + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11Info(t *testing.T) { + id := layers.Dot11InformationElementIDSSID + info := []byte{} + + dot11InfoElement := Dot11Info(id, info) + + var units = []struct { + got interface{} + exp interface{} + }{ + {dot11InfoElement.ID, id}, + {dot11InfoElement.Length, uint8(len(info))}, + {dot11InfoElement.Info, info}, + } + + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestNewDot11Beacon(t *testing.T) { + conf := BuildDot11ApConfig() + seq := uint16(0) + + err, bytes := NewDot11Beacon(conf, seq) + + if err != nil { + t.Error(err) + } + + if len(bytes) <= 0 { + t.Error("unable to create new dot11 beacon") + } +} + +func TestNewDot11Deauth(t *testing.T) { + mac, _ := net.ParseMAC("00:00:00:00:00:00") + seq := uint16(0) + + err, bytes := NewDot11Deauth(mac, mac, mac, seq) + + if err != nil { + t.Error(err) + } + + if len(bytes) <= 0 { + t.Error("unable to create new dot11 beacon") + } +} + +func BuildDot11Packet() gopacket.Packet { + mac, _ := net.ParseMAC("00:00:00:00:00:00") + seq := uint16(0) + _, bytes := Serialize( + &layers.RadioTap{}, + &layers.Dot11{ + Address1: mac, + Address2: mac, + Address3: mac, + Type: layers.Dot11TypeMgmtDeauthentication, + SequenceNumber: seq, + }, + &layers.Dot11MgmtDeauthentication{ + Reason: layers.Dot11ReasonClass2FromNonAuth, + }, + ) + + return gopacket.NewPacket(bytes, layers.LayerTypeRadioTap, gopacket.Default) +} + +func TestDot11Parse(t *testing.T) { + packet := BuildDot11Packet() + + ok, radiotap, dot11 := Dot11Parse(packet) + + var units = []struct { + got interface{} + exp interface{} + }{ + // testing for the known bad cases + {ok, false}, + {radiotap, nil}, + {dot11, nil}, + } + + for _, u := range units { + if reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11ParseIDSSID(t *testing.T) { + conf := BuildDot11ApConfig() + seq := uint16(0) + + err, bytes := NewDot11Beacon(conf, seq) + + if err != nil { + t.Error(err) + } + + packet := gopacket.NewPacket(bytes, layers.LayerTypeRadioTap, gopacket.Default) + + ok, id := Dot11ParseIDSSID(packet) + + var units = []struct { + got interface{} + exp interface{} + }{ + {ok, true}, + {id, "I still love Ruby, don't worry!"}, + } + + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11ParseEncryption(t *testing.T) { + ssid := "I still love Ruby, don't worry!" + bssid, _ := net.ParseMAC("pi:ca:tw:as:he:re") + channel := 1 + encryption := true + + config := Dot11ApConfig{ + SSID: ssid, + BSSID: bssid, + Channel: channel, + Encryption: encryption, + } + + seq := uint16(0) + + err, bytes := NewDot11Beacon(config, seq) + + if err != nil { + t.Error(err) + } + + packet := gopacket.NewPacket(bytes, layers.LayerTypeRadioTap, gopacket.Default) + _, _, dot11 := Dot11Parse(packet) + + found, enc, cipher, auth := Dot11ParseEncryption(packet, dot11) + + var units = []struct { + got interface{} + exp interface{} + }{ + {found, true}, + {enc, "WPA2"}, + {cipher, "TKIP"}, + {auth, "PSK"}, + } + + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11IsDataFor(t *testing.T) { + mac, _ := net.ParseMAC("00:00:00:00:00:00") + seq := uint16(0) + _, bytes := Serialize( + &layers.RadioTap{}, + &layers.Dot11{ + Address1: mac, + Address2: mac, + Address3: mac, + Type: layers.Dot11TypeData, + SequenceNumber: seq, + }, + ) + packet := gopacket.NewPacket(bytes, layers.LayerTypeRadioTap, gopacket.Default) + station, _ := net.ParseMAC("00:00:00:00:00:00") + _, _, dot11 := Dot11Parse(packet) + if !Dot11IsDataFor(dot11, station) { + t.Error("unable to determine dot11 packet is for a given station") + } +} + +// TODO: add Dot11ParseDSSet test. Not sure how to build proper +// example packet to complete this test, for now. <3 +//func TestDot11ParseDSSet(t *testing.T) { +//} From d71477f502976b2a37cda3dbc5f18ad4b71023cf Mon Sep 17 00:00:00 2001 From: Kent Gruber Date: Sun, 20 May 2018 14:28:36 -0400 Subject: [PATCH 5/8] add some dot11 types tests --- packets/dot11_types_test.go | 236 ++++++++++++++++++++++++++++++++++++ 1 file changed, 236 insertions(+) create mode 100644 packets/dot11_types_test.go diff --git a/packets/dot11_types_test.go b/packets/dot11_types_test.go new file mode 100644 index 00000000..98510021 --- /dev/null +++ b/packets/dot11_types_test.go @@ -0,0 +1,236 @@ +package packets + +import ( + "reflect" + "testing" +) + +func TestDot11CipherTypes(t *testing.T) { + var units = []struct { + got interface{} + exp interface{} + }{ + {uint8(Dot11CipherWep), uint8(1)}, + {uint8(Dot11CipherTkip), uint8(2)}, + {uint8(Dot11CipherWrap), uint8(3)}, + {uint8(Dot11CipherCcmp), uint8(4)}, + {uint8(Dot11CipherWep104), uint8(5)}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11CipherTypesAsString(t *testing.T) { + var units = []struct { + got interface{} + exp interface{} + }{ + {Dot11CipherWep.String(), "WEP"}, + {Dot11CipherTkip.String(), "TKIP"}, + {Dot11CipherWrap.String(), "WRAP"}, + {Dot11CipherCcmp.String(), "CCMP"}, + {Dot11CipherWep104.String(), "WEP104"}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11AuthTypes(t *testing.T) { + var units = []struct { + got interface{} + exp interface{} + }{ + {uint8(Dot11AuthMgt), uint8(1)}, + {uint8(Dot11AuthPsk), uint8(2)}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11AuthTypesAsString(t *testing.T) { + var units = []struct { + got interface{} + exp interface{} + }{ + {Dot11AuthMgt.String(), "MGT"}, + {Dot11AuthPsk.String(), "PSK"}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11CipherSuite(t *testing.T) { + // must be three, but not currently + // implemented to really enforce [3]byte + bytes := []byte{1, 2, 3} + cs := CipherSuite{ + OUI: bytes, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {cs.OUI, bytes}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11AuthSuite(t *testing.T) { + // must be three, but not currently + // implemented to really enforce [3]byte + bytes := []byte{1, 2, 3} + cs := AuthSuite{ + OUI: bytes, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {cs.OUI, bytes}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11CipherSuiteSelector(t *testing.T) { + count := uint16(1) + cs := CipherSuiteSelector{ + Count: count, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {cs.Count, count}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11AuthSuiteSelector(t *testing.T) { + count := uint16(1) + cs := AuthSuiteSelector{ + Count: count, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {cs.Count, count}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11RSNInfo(t *testing.T) { + version := uint16(1) + rsn := RSNInfo{ + Version: version, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {rsn.Version, version}, + {rsn.Group, CipherSuite{}}, + {rsn.Pairwise, CipherSuiteSelector{}}, + {rsn.AuthKey, AuthSuiteSelector{}}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11VendorInfo(t *testing.T) { + version := uint16(1) + vendor := VendorInfo{ + WPAVersion: version, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {vendor.WPAVersion, version}, + {vendor.Multicast, CipherSuite{}}, + {vendor.Unicast, CipherSuiteSelector{}}, + {vendor.AuthKey, AuthSuiteSelector{}}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11canParse(t *testing.T) { + err := canParse("example", []byte{}, 0) + if err != nil { + t.Error("unable to check if able to parse") + } +} + +func TestDot11parsePairwiseSuite(t *testing.T) { + buf := []byte{0, 0, 1, 1} + suite, err := parsePairwiseSuite(buf) + var units = []struct { + got interface{} + exp interface{} + }{ + {suite.OUI, buf[0:3]}, + {suite.Type, Dot11CipherType(buf[3])}, + {err, nil}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestDot11parseAuthkeySuite(t *testing.T) { + buf := []byte{0, 0, 1, 1} + suite, err := parseAuthkeySuite(buf) + var units = []struct { + got interface{} + exp interface{} + }{ + {suite.OUI, buf[0:3]}, + {suite.Type, Dot11AuthType(buf[3])}, + {err, nil}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +// TODO: add test for Dot11InformationElementVendorInfoDecode +// TODO: add test for Dot11InformationElementIDDSSetDecode From f0f98bcd065c01752e0da13b1eea07d0d65ce32b Mon Sep 17 00:00:00 2001 From: Kent Gruber Date: Sun, 20 May 2018 14:28:56 -0400 Subject: [PATCH 6/8] add some krb5 tests --- packets/krb5_test.go | 208 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 packets/krb5_test.go diff --git a/packets/krb5_test.go b/packets/krb5_test.go new file mode 100644 index 00000000..afd2b139 --- /dev/null +++ b/packets/krb5_test.go @@ -0,0 +1,208 @@ +package packets + +import ( + "encoding/asn1" + "errors" + "reflect" + "testing" + "time" +) + +func TestKrb5Contants(t *testing.T) { + var units = []struct { + got interface{} + exp interface{} + }{ + {Krb5AsRequestType, 10}, + {Krb5Krb5PrincipalNameType, 1}, + {Krb5CryptDesCbcMd4, 2}, + {Krb5CryptDescCbcMd5, 3}, + {Krb5CryptRc4Hmac, 23}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestKrb5Vars(t *testing.T) { + var units = []struct { + got interface{} + exp interface{} + }{ + {ErrNoCrypt, errors.New("No crypt alg found")}, + {ErrReqData, errors.New("Failed to extract pnData from as-req")}, + {ErrNoCipher, errors.New("No encryption type or cipher found")}, + {Krb5AsReqParam, "application,explicit,tag:10"}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestKrb5PrincipalName(t *testing.T) { + str := []string{"example"} + name := Krb5PrincipalName{NameString: str} + var units = []struct { + got interface{} + exp interface{} + }{ + {name.NameType, 0}, + {name.NameString, str}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestKrb5EncryptedData(t *testing.T) { + cipher := []byte{} + data := Krb5EncryptedData{Cipher: cipher} + var units = []struct { + got interface{} + exp interface{} + }{ + {data.Cipher, cipher}, + {data.Etype, 0}, + {data.Kvno, 0}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestKrb5Ticket(t *testing.T) { + v := 0 + r := "picat" + s := Krb5PrincipalName{} + e := Krb5EncryptedData{} + + ticket := Krb5Ticket{ + TktVno: v, + Realm: r, + Sname: s, + EncPart: e, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {ticket.TktVno, v}, + {ticket.Realm, r}, + {ticket.Sname, s}, + {ticket.EncPart, e}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestKrb5Address(t *testing.T) { + x := 0 + y := []byte{} + addr := Krb5Address{ + AddrType: x, + Krb5Address: y, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {addr.AddrType, x}, + {addr.Krb5Address, y}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestKrb5PnData(t *testing.T) { + x := 0 + y := []byte{} + addr := Krb5PnData{ + Krb5PnDataType: x, + Krb5PnDataValue: y, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {addr.Krb5PnDataType, x}, + {addr.Krb5PnDataValue, y}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestKrb5ReqBody(t *testing.T) { + e := []int{} + a := []Krb5Address{} + k := []Krb5Ticket{} + req := Krb5ReqBody{ + Etype: e, + Krb5Addresses: a, + AdditionalKrb5Tickets: k, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {req.KDCOptions, asn1.BitString{}}, + {req.Cname, Krb5PrincipalName{}}, + {req.Realm, ""}, + {req.Sname, Krb5PrincipalName{}}, + {req.From, time.Time{}}, + {req.Till, time.Time{}}, + {req.Rtime, time.Time{}}, + {req.Nonce, 0}, + {req.Etype, e}, + {req.Krb5Addresses, a}, + {req.EncAuthData, Krb5EncryptedData{}}, + {req.AdditionalKrb5Tickets, k}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } + +} + +func TestKrb5Request(t *testing.T) { + p := []Krb5PnData{} + req := Krb5Request{ + Krb5PnData: p, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {req.Pvno, 0}, + {req.MsgType, 0}, + {req.Krb5PnData, p}, + {req.ReqBody, Krb5ReqBody{}}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } + +} + +// TODO: add test for func (kdc Krb5Request) String() +// TODO: add test for func (pd Krb5PnData) getParsedValue() From 8b744538428af899950dc8c9b58c9ed419e62302 Mon Sep 17 00:00:00 2001 From: Kent Gruber Date: Sun, 20 May 2018 14:29:04 -0400 Subject: [PATCH 7/8] add some ntlm tests --- packets/ntlm_test.go | 164 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 164 insertions(+) create mode 100644 packets/ntlm_test.go diff --git a/packets/ntlm_test.go b/packets/ntlm_test.go new file mode 100644 index 00000000..5fa7dad0 --- /dev/null +++ b/packets/ntlm_test.go @@ -0,0 +1,164 @@ +package packets + +import ( + "reflect" + "testing" +) + +func TestNTLMConstants(t *testing.T) { + var units = []struct { + got interface{} + exp interface{} + }{ + {NTLM_SIG_OFFSET, 0}, + {NTLM_TYPE_OFFSET, 8}, + {NTLM_TYPE1_FLAGS_OFFSET, 12}, + {NTLM_TYPE1_DOMAIN_OFFSET, 16}, + {NTLM_TYPE1_WORKSTN_OFFSET, 24}, + {NTLM_TYPE1_DATA_OFFSET, 32}, + {NTLM_TYPE1_MINSIZE, 16}, + {NTLM_TYPE2_TARGET_OFFSET, 12}, + {NTLM_TYPE2_FLAGS_OFFSET, 20}, + {NTLM_TYPE2_CHALLENGE_OFFSET, 24}, + {NTLM_TYPE2_CONTEXT_OFFSET, 32}, + {NTLM_TYPE2_TARGETINFO_OFFSET, 40}, + {NTLM_TYPE2_DATA_OFFSET, 48}, + {NTLM_TYPE2_MINSIZE, 32}, + {NTLM_TYPE3_LMRESP_OFFSET, 12}, + {NTLM_TYPE3_NTRESP_OFFSET, 20}, + {NTLM_TYPE3_DOMAIN_OFFSET, 28}, + {NTLM_TYPE3_USER_OFFSET, 36}, + {NTLM_TYPE3_WORKSTN_OFFSET, 44}, + {NTLM_TYPE3_SESSIONKEY_OFFSET, 52}, + {NTLM_TYPE3_FLAGS_OFFSET, 60}, + {NTLM_TYPE3_DATA_OFFSET, 64}, + {NTLM_TYPE3_MINSIZE, 52}, + {NTLM_BUFFER_LEN_OFFSET, 0}, + {NTLM_BUFFER_MAXLEN_OFFSET, 2}, + {NTLM_BUFFER_OFFSET_OFFSET, 4}, + {NTLM_BUFFER_SIZE, 8}, + {NtlmV1, 1}, + {NtlmV2, 2}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestNTLMChallengeResponse(t *testing.T) { + r := NTLMChallengeResponse{} + var units = []struct { + got interface{} + exp interface{} + }{ + {r.Challenge, ""}, + {r.Response, ""}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestNTLMChallengeResponseParsed(t *testing.T) { + r := NTLMChallengeResponseParsed{} + var units = []struct { + got interface{} + exp interface{} + }{ + {r.Type, 0}, + {r.ServerChallenge, ""}, + {r.User, ""}, + {r.Domain, ""}, + {r.LmHash, ""}, + {r.NtHashOne, ""}, + {r.NtHashTwo, ""}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestNTLMResponseHeader(t *testing.T) { + r := NTLMResponseHeader{} + var units = []struct { + got interface{} + exp interface{} + }{ + {r.Sig, ""}, + {r.Type, uint32(0)}, + {r.LmLen, uint16(0)}, + {r.LmMax, uint16(0)}, + {r.LmOffset, uint16(0)}, + {r.NtLen, uint16(0)}, + {r.NtMax, uint16(0)}, + {r.NtOffset, uint16(0)}, + {r.DomainLen, uint16(0)}, + {r.DomainMax, uint16(0)}, + {r.DomainOffset, uint16(0)}, + {r.UserLen, uint16(0)}, + {r.UserMax, uint16(0)}, + {r.UserOffset, uint16(0)}, + {r.HostLen, uint16(0)}, + {r.HostMax, uint16(0)}, + {r.HostOffset, uint16(0)}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestNTLMState(t *testing.T) { + r := map[uint32]string{} + p := []NTLMChallengeResponse{} + s := NTLMState{ + Responses: r, + Pairs: p, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {s.Responses, r}, + {s.Pairs, p}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func BuildExampleNTLMState() NTLMState { + return NTLMState{ + Responses: map[uint32]string{}, + Pairs: []NTLMChallengeResponse{}, + } +} + +func TestNTLMStateAddServerResponse(t *testing.T) { + s := BuildExampleNTLMState() + + s.AddServerResponse(uint32(0), "picat") + + var units = []struct { + got interface{} + exp interface{} + }{ + {s.Responses[uint32(0)], "picat"}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +// TODO: add tests for the rest of NTLM :P From d6564a5b4d9eaf174162e0f06c9a47c13a3075ea Mon Sep 17 00:00:00 2001 From: Kent Gruber Date: Sun, 20 May 2018 14:29:12 -0400 Subject: [PATCH 8/8] add some queue tests --- packets/queue_test.go | 65 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 packets/queue_test.go diff --git a/packets/queue_test.go b/packets/queue_test.go new file mode 100644 index 00000000..9b0549d1 --- /dev/null +++ b/packets/queue_test.go @@ -0,0 +1,65 @@ +package packets + +import ( + "net" + "reflect" + "testing" +) + +func TestQueueActivity(t *testing.T) { + i := net.IP{} + h := net.HardwareAddr{} + a := Activity{ + IP: i, + MAC: h, + } + var units = []struct { + got interface{} + exp interface{} + }{ + {a.IP, i}, + {a.MAC, h}, + {a.Source, false}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestQueueTraffic(t *testing.T) { + tr := Traffic{} + var units = []struct { + got interface{} + exp interface{} + }{ + {tr.Sent, uint64(0)}, + {tr.Received, uint64(0)}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +func TestQueueStats(t *testing.T) { + s := Stats{} + var units = []struct { + got interface{} + exp interface{} + }{ + {s.Sent, uint64(0)}, + {s.Received, uint64(0)}, + {s.PktReceived, uint64(0)}, + {s.Errors, uint64(0)}, + } + for _, u := range units { + if !reflect.DeepEqual(u.exp, u.got) { + t.Fatalf("expected '%v', got '%v'", u.exp, u.got) + } + } +} + +// TODO: add tests for the rest of queue.go