gopacket-ecat

README

About

This is a library for generating Ecat packets using gopacket

Required

• libpcap-dev
• gopacket

Example

send ecat packet

package main

import (
	"encoding/hex"
	"fmt"
	"log"
	"net"
	"time"

	"github.com/Aruminium/gopacket-ecat/ecat"
	"github.com/Aruminium/gopacket-ecat/ecat/command"
	"github.com/Aruminium/gopacket-ecat/ecat/datagram"

	"github.com/google/gopacket"
	"github.com/google/gopacket/layers"
	"github.com/google/gopacket/pcap"
)

var (
	device       string = "en0"
	snapshot_len int32  = 1024
	promiscuous  bool   = false
	err          error
	timeout      time.Duration = 30 * time.Second
	handle       *pcap.Handle
	buffer       gopacket.SerializeBuffer
	options      gopacket.SerializeOptions = gopacket.SerializeOptions{
		ComputeChecksums: true,
		FixLengths:       true,
	}
)

func main() {
	handle, err = pcap.OpenLive(device, snapshot_len, promiscuous, timeout)
	if err != nil {
		log.Fatal(err)
	}
	defer handle.Close()

	srcMac, _ := net.ParseMAC("00:00:00:00:00:00")
	dstMac, _ := net.ParseMAC("ff:ff:ff:ff:ff:ff")

	eth := &layers.Ethernet{
		SrcMAC:       srcMac,
		DstMAC:       dstMac,
		EthernetType: layers.EthernetTypeIPv4,
	}

	ip := &layers.IPv4{
		Version:  4,
		TTL:      64,
		SrcIP:    net.IP{127, 0, 0, 1},
		DstIP:    net.IP{255, 255, 255, 255},
		Protocol: layers.IPProtocolUDP,
	}

	udp := &layers.UDP{
		SrcPort: layers.UDPPort(34980),
		DstPort: layers.UDPPort(34980),
	}

	lrcm, err := datagram.NewLrcm(0, 0, 8)
	if err != nil {
		log.Fatal(err)
	}

	ecatDatagram := datagram.EcatDatagram{
		Command: command.APRD,
		Index:   uint8(0x29),
		Address: uint32(0xffff0008),
		LRCM:    lrcm,
		IRQ:     uint16(0x0000),
		Data:    []byte{0x00, 0x18, 0x30, 0x00, 0x26, 0x00, 0x01, 0x00},
		WKC:     uint16(0x0000),
	}

	ecat := ecat.NewEcat()
	ecat.AppendDatagram(ecatDatagram)
	udp.SetNetworkLayerForChecksum(ip)

	buffer = gopacket.NewSerializeBuffer()
	gopacket.SerializeLayers(buffer, options,
		eth,
		ip,
		udp,
		gopacket.Payload(ecat.Bytes()),
	)

	data := buffer.Bytes()

	if err = handle.WritePacketData(data); err != nil {
		fmt.Printf("[-] Error while sending: %s\n", err.Error())
		return
	}

	fmt.Println(hex.Dump(data))
}

send multiple ecat packet

package main

import (
	"encoding/hex"
	"fmt"
	"log"
	"net"
	"time"

	"github.com/Aruminium/gopacket-ecat/ecat"
	"github.com/Aruminium/gopacket-ecat/ecat/command"
	"github.com/Aruminium/gopacket-ecat/ecat/datagram"

	"github.com/google/gopacket"
	"github.com/google/gopacket/layers"
	"github.com/google/gopacket/pcap"
)

var (
	device       string = "en0"
	snapshot_len int32  = 1024
	promiscuous  bool   = false
	err          error
	timeout      time.Duration = 30 * time.Second
	handle       *pcap.Handle
	buffer       gopacket.SerializeBuffer
	options      gopacket.SerializeOptions = gopacket.SerializeOptions{
		ComputeChecksums: true,
		FixLengths:       true,
	}
)

func main() {
	handle, err = pcap.OpenLive(device, snapshot_len, promiscuous, timeout)
	if err != nil {
		log.Fatal(err)
	}
	defer handle.Close()

	srcMac, _ := net.ParseMAC("00:00:00:00:00:00")
	dstMac, _ := net.ParseMAC("ff:ff:ff:ff:ff:ff")

	eth := &layers.Ethernet{
		SrcMAC:       srcMac,
		DstMAC:       dstMac,
		EthernetType: layers.EthernetTypeIPv4,
	}

	ip := &layers.IPv4{
		Version:  4,
		TTL:      64,
		SrcIP:    net.IP{127, 0, 0, 1},
		DstIP:    net.IP{255, 255, 255, 255},
		Protocol: layers.IPProtocolUDP,
	}

	udp := &layers.UDP{
		SrcPort: layers.UDPPort(34980),
		DstPort: layers.UDPPort(34980),
	}

	lrcm1, err := datagram.NewLrcm(1, 0, 8)
	if err != nil {
		log.Fatal(err)
	}
	ecatDatagram1 := datagram.EcatDatagram{
		Command: command.APRD,
		Index:   uint8(0x29),
		Address: uint32(0xffff0008),
		LRCM:    lrcm1,
		IRQ:     uint16(0x0000),
		Data:    []byte{0x00, 0x18, 0x30, 0x00, 0x26, 0x00, 0x01, 0x00},
		WKC:     uint16(0x0000),
	}

	lrcm2, err := datagram.NewLrcm(1, 0, 8)
	if err != nil {
		log.Fatal(err)
	}
	ecatDatagram2 := datagram.EcatDatagram{
		Command: command.LRD,
		Index:   uint8(0x29),
		Address: uint32(0xffff0008),
		LRCM:    lrcm2,
		IRQ:     uint16(0x0000),
		Data:    []byte{0x00, 0x18, 0x30, 0x00, 0x26, 0x00, 0x01, 0x00},
		WKC:     uint16(0x0000),
	}

	lrcm3, err := datagram.NewLrcm(0, 0, 8)
	if err != nil {
		log.Fatal(err)
	}
	ecatDatagram3 := datagram.EcatDatagram{
		Command: command.LRW,
		Index:   uint8(0x29),
		Address: uint32(0xffff0008),
		LRCM:    lrcm3,
		IRQ:     uint16(0x0000),
		Data:    []byte{0x00, 0x18, 0x30, 0x00, 0x26, 0x00, 0x01, 0x00},
		WKC:     uint16(0x0000),
	}

	ecat := ecat.NewEcat()
	ecat.AppendDatagram(ecatDatagram1)
	ecat.AppendDatagram(ecatDatagram2)
	ecat.AppendDatagram(ecatDatagram3)
	udp.SetNetworkLayerForChecksum(ip)

	buffer = gopacket.NewSerializeBuffer()
	gopacket.SerializeLayers(buffer, options,
		eth,
		ip,
		udp,
		gopacket.Payload(ecat.Bytes()),
	)

	data := buffer.Bytes()

	if err = handle.WritePacketData(data); err != nil {
		fmt.Printf("[-] Error while sending: %s\n", err.Error())
		return
	}

	fmt.Println(hex.Dump(data))
}

License

BSD-3-Clause © 2023 Aruminium