Add basic tests

Author: GHOST-6

LICENSE.txt

@@ -1,10 +1,15 @@
 # go-dnp3
 
+[![GoDoc](https://godoc.org/github.com/nblair2/go-dnp3?status.svg)](https://godoc.org/github.com/nblair2/go-dnp3)
+![Go Version](https://img.shields.io/github/go-mod/go-version/nblair2/go-dnp3?filename=go.mod&style=flat-square)
+![License](https://img.shields.io/github/license/nblair2/go-dnp3?style=flat-square)
+
+
 DNP3 parsing in go.
 * **`FromBytes([]byte)`** to parse a byte slice and interpret it as DNP3
 * **`ToBytes()`** to go from a struct back to bytes (calculates length, calculates and inserts CRCs on the way)
 * **`String()`** to get packet as human-readable indented string (Reserved and CRCs not shown)
-* **`json.MarshalIndent(dnp, "", "  ")`** to get packet as machine-friendly 
+* **`json.Marshal(DNP3)`** to get packet as machine-friendly 
 
 ## Improvements
 
@@ -18,7 +23,7 @@ DNP3 parsing in go.
 
 ## Test
 
-Run `make test` to check `examples/*.pcap` for errors. Data taken from [opendnp3 conformance reports](https://dnp3.github.io/conformance/report.html) and [ITI ICS Security Tools Repository](https://github.com/ITI/ICS-Security-Tools/tree/master/pcaps/dnp3)
+Run `go test -v` to check a few different DNP3 messages. You can also use the `-args -pcaps=examples/opendnp3_test1.pcap` argument to pass in a full PCAP. Data taken from [opendnp3 conformance reports](https://dnp3.github.io/conformance/report.html).
 
 ## Spec
 

Makefile

@@ -1,4 +1,8 @@
-// partial implementation of DNP3 for gopacket
+// DNP3 (Distributed Network Protocol version 3) is a SCADA protocol used in
+// industrial automation, especially electric power and water services in
+// North America. See dnp.org, IEEE-1815.
+// The protocol consists of three layers: A data link layer, a transport layer,
+// and an application layer.
 package dnp3
 
 import (
@@ -7,11 +11,6 @@ import (
 	"github.com/google/gopacket"
 )
 
-// DNP3 (Distributed Network Protocol version 3) is a SCADA protocol used in
-// industrial automation, especially electric power and water services in
-// North America. See dnp.org, IEEE-1815.
-// The protocol consists of three layers: A data link layer, a transport layer,
-// and an application layer.
 type DNP3 struct {
 	DataLink    DataLink
 	Transport   Transport

README.md

@@ -0,0 +1,185 @@
+package dnp3
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"slices"
+	"strings"
+	"testing"
+
+	"github.com/google/gopacket"
+	"github.com/google/gopacket/layers"
+	"github.com/google/gopacket/pcap"
+)
+
+func testFromBytesToBytesStringMarshal(t *testing.T, input []byte) {
+	d := DNP3{}
+	err := d.FromBytes(input)
+	if err != nil {
+		t.Fatal("FromBytes:", err)
+	}
+
+	output, err := d.ToBytes()
+	if err != nil {
+		t.Fatal("ToBytes:", err)
+	}
+
+	if !slices.Equal(input, output) {
+		t.Fatal("Input and Output not equal")
+	}
+
+	_ = d.String()
+
+	_, err = json.MarshalIndent(d, "", "  ")
+	if err != nil {
+		t.Fatal("MarshalIndent:", err)
+	}
+}
+
+func TestDNP3(t *testing.T) {
+	tests := []struct {
+		name  string
+		input []byte
+	}{
+		{
+			"Request/ReadClass1230",
+			[]byte{
+				0x05, 0x64, 0x14, 0xc4, 0x04, 0x00, 0x03, 0x00,
+				0xc7, 0x17, 0xc4, 0xc5, 0x01, 0x3c, 0x02, 0x06,
+				0x3c, 0x03, 0x06, 0x3c, 0x04, 0x06, 0x3c, 0x01,
+				0x06, 0xa3, 0x61,
+			},
+		},
+		{
+			"Request/ReadBinaryInputChange",
+			[]byte{
+				0x05, 0x64, 0x0b, 0xc4, 0x00, 0x04, 0x01, 0x00,
+				0xca, 0x8a, 0xc0, 0xc1, 0x01, 0x02, 0x00, 0x06,
+				0x95, 0x76,
+			},
+		},
+		{
+			"Request/WriteTime",
+			[]byte{
+				0x05, 0x64, 0x12, 0xc4, 0x04, 0x00, 0x03, 0x00,
+				0x1e, 0x7c, 0xc1, 0xc1, 0x02, 0x32, 0x01, 0x07,
+				0x01, 0xeb, 0xe4, 0x5a, 0x87, 0xff, 0x00, 0x28,
+				0x01,
+			},
+		},
+		{
+			"Request/Select",
+			[]byte{
+				0x05, 0x64, 0x1a, 0xc4, 0x04, 0x00, 0x03, 0x00,
+				0xc2, 0xe6, 0xd2, 0xc3, 0x03, 0x0c, 0x01, 0x28,
+				0x01, 0x00, 0x9f, 0x86, 0x03, 0x01, 0x64, 0x00,
+				0x00, 0x00, 0xec, 0x41, 0x64, 0x00, 0x00, 0x00,
+				0x00, 0x00, 0x5b,
+			},
+		},
+		{
+			"Response/AllIINSet",
+			[]byte{
+				0x05, 0x64, 0x0a, 0x44, 0x03, 0x00, 0x04, 0x00,
+				0x7c, 0xae, 0xe7, 0xc1, 0x81, 0xff, 0x3f, 0x1c,
+				0x48,
+			},
+		},
+		{
+			"Response/GV_02-02",
+			[]byte{
+				0x05, 0x64, 0x2a, 0x44, 0x01, 0x00, 0x00, 0x04,
+				0xe5, 0x79, 0xc1, 0xe2, 0x81, 0x90, 0x00, 0x02,
+				0x02, 0x28, 0x03, 0x00, 0x00, 0x00, 0x81, 0xda,
+				0x33, 0xd2, 0xdf, 0xe5, 0x64, 0x71, 0x01, 0x00,
+				0x00, 0x01, 0xda, 0x33, 0xd2, 0x64, 0x71, 0x01,
+				0xff, 0xff, 0x81, 0xdb, 0xdd, 0x14, 0x33, 0xd2,
+				0x64, 0x71, 0x01, 0x38, 0x5d,
+			},
+		},
+		{
+			"Response/GV_01-01_10-02_20-05_21-09_30-03",
+			[]byte{
+				0x05, 0x64, 0x4e, 0x44, 0x03, 0x00, 0x04, 0x00,
+				0x6f, 0x4d, 0xc7, 0xc7, 0x81, 0x00, 0x00, 0x01,
+				0x01, 0x00, 0x00, 0x05, 0x19, 0x0a, 0x02, 0x00,
+				0x00, 0x05, 0xc3, 0x47, 0x81, 0x01, 0x81, 0x81,
+				0x01, 0x01, 0x14, 0x05, 0x00, 0x00, 0x00, 0x20,
+				0x00, 0x00, 0x00, 0x15, 0xf1, 0x7b, 0x09, 0x00,
+				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x03,
+				0x00, 0x00, 0x06, 0xca, 0x00, 0x00, 0x18, 0x7e,
+				0x00, 0xcb, 0x00, 0x00, 0x00, 0xc9, 0x00, 0x00,
+				0x00, 0xff, 0xff, 0xff, 0xff, 0x66, 0x21, 0x00,
+				0xd6, 0xf3, 0x00, 0x59, 0x21, 0x00, 0x00, 0x4b,
+				0x21, 0x00, 0x00, 0xe0, 0x51,
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			testFromBytesToBytesStringMarshal(t, tc.input)
+		})
+	}
+}
+
+var custPcaps []string
+
+func init() {
+	flag.Func("pcaps", "Comma-separated list of pcap files to read", func(val string) error {
+		if val != "" {
+			custPcaps = append(custPcaps, splitComma(val)...)
+		}
+		return nil
+	})
+}
+
+func splitComma(s string) []string {
+	var out []string
+	for _, v := range strings.Split(s, ",") {
+		v = strings.TrimSpace(v)
+		if v != "" {
+			out = append(out, v)
+		}
+	}
+	return out
+}
+
+func TestCustomPcaps(t *testing.T) {
+	flag.Parse()
+	if len(custPcaps) == 0 {
+		t.Skip("No custom pcap file provided")
+	}
+
+	for _, pcapFile := range custPcaps {
+		t.Run(pcapFile, func(t *testing.T) {
+
+			handle, err := pcap.OpenOffline(pcapFile)
+			if err != nil {
+				t.Skipf("Error opening PCAP: %v", err)
+			}
+			defer handle.Close()
+
+			pcap := gopacket.NewPacketSource(handle, handle.LinkType())
+			i := 0
+			for pkt := range pcap.Packets() {
+
+				i += 1
+				tcpLayer := pkt.Layer(layers.LayerTypeTCP)
+				if tcpLayer != nil {
+
+					tcp, _ := tcpLayer.(*layers.TCP)
+					input := tcp.Payload
+					if len(input) < 10 {
+						continue
+					}
+
+					t.Run(fmt.Sprintf("Packet%d", i), func(t *testing.T) {
+						testFromBytesToBytesStringMarshal(t, input)
+					})
+				}
+			}
+		})
+	}
+}