Merge pull request #280 from picatz/test-packets

add some tests to the packets package

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")
+	}
+}

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)
+	}
+}

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)
+	}
+}

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) {
+//}

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

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()

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

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