magic

client/golang/utils/file_transfer.go

@@ -0,0 +1,92 @@
+package utils
+
+import (
+        "log"
+
+        "github.com/google/gopacket"
+
+        "client/structs"
+)
+
+func (c*SocketCall) BuildFileTransferPacket(Header structs.SaprusHeaderFrame,
+                                Data structs.SaprusFileTransfer) gopacket.SerializeBuffer {
+        eth, ip, udp := basePacket(c)
+
+        sapHeader := structs.SaprusHeaderFrame {
+                PacketType:     Header.PacketType,
+                Length:         c.saprusPayloadLength(Data.Bytes()),
+                Payload:        Data.Bytes(),
+        }
+
+        buf := gopacket.NewSerializeBuffer()
+        opts := gopacket.SerializeOptions {
+                ComputeChecksums:       true,
+                FixLengths:             true,
+        }
+
+        udp.SetNetworkLayerForChecksum(&ip)
+        err := gopacket.SerializeLayers(buf, opts, &eth, &ip, &udp, gopacket.Payload(sapHeader.Bytes()))
+
+        if err != nil {
+                log.Panic(err)
+        }
+
+        return buf
+}
+
+func (c* SocketCall) FileTransferPacket(message string, seqNum uint16) gopacket.SerializeBuffer {
+        sapFile := structs.SaprusFileTransfer {
+                Flag:           [1]byte{0x11},
+                Sequence:       [2]byte{byte(seqNum >> 8), byte(seqNum & 0xFF)},
+                Checksum:       [2]byte{0x44, 0x44},
+                Payload:        []byte(message),
+        }
+
+        sapHeader := structs.SaprusHeaderFrame {
+                PacketType:     [2]byte{0x88, 0x88},
+                Length:         c.saprusPayloadLength(sapFile.Bytes()),
+                Payload:        sapFile.Bytes(),
+        }
+
+        buf := c.BuildFileTransferPacket(sapHeader, sapFile)
+
+        return buf
+}
+
+func (c* SocketCall) InitFileTransferPacket() gopacket.SerializeBuffer {
+        sapFile := structs.SaprusFileTransfer {
+                Flag:           [1]byte{0x01},
+                Sequence:       [2]byte{0x00, 0x00},
+                Checksum:       [2]byte{0x00, 0x00},
+                Payload:        []byte{},
+        }
+
+        sapHeader := structs.SaprusHeaderFrame {
+                PacketType:     [2]byte{0x00, 0x00},
+                Length:         c.saprusPayloadLength(sapFile.Bytes()),
+                Payload:        sapFile.Bytes(),
+        }
+
+        buf := c.BuildFileTransferPacket(sapHeader, sapFile)
+
+        return buf
+}
+
+func (c* SocketCall) EndFileTransferPacket() gopacket.SerializeBuffer {
+        sapFile := structs.SaprusFileTransfer {
+                Flag:           [1]byte{0x02},
+                Sequence:       [2]byte{0x00, 0x00},
+                Checksum:       [2]byte{0x00, 0x00},
+                Payload:        []byte{},
+        }
+
+        sapHeader := structs.SaprusHeaderFrame {
+                PacketType:     [2]byte{0x00, 0x00},
+                Length:         c.saprusPayloadLength(sapFile.Bytes()),
+                Payload:        sapFile.Bytes(),
+        }
+
+        buf := c.BuildFileTransferPacket(sapHeader, sapFile)
+
+        return buf
+}

client/golang/utils/packet_helper.go

@@ -0,0 +1,27 @@
+package utils
+
+import (
+	"github.com/google/gopacket/layers"
+)
+
+func basePacket(c* SocketCall) (layers.Ethernet, layers.IPv4, layers.UDP) {
+        eth := layers.Ethernet {
+                EthernetType:   layers.EthernetTypeIPv4,
+                SrcMAC:         c.Iface.HardwareAddr,
+                DstMAC:         layers.EthernetBroadcast,
+        }
+        ip := layers.IPv4 {
+                Version:        4,
+                TTL:            64,
+                SrcIP:          []byte{0, 0, 0, 0},
+                DstIP:          []byte{255, 255, 255, 255},
+                Protocol:       layers.IPProtocolUDP,
+        }
+        udp := layers.UDP {
+                SrcPort:        8850,
+                DstPort:        8888,
+        }
+
+        return eth, ip, udp
+}
+

client/golang/utils/raw.go

@@ -0,0 +1,88 @@
+package utils
+
+import (
+        "encoding/binary"
+        "log"
+        "time"
+
+        "net"
+        "unicode/utf8"
+
+        "github.com/google/gopacket"
+        "github.com/google/gopacket/layers"
+        "github.com/mdlayher/packet"
+)
+
+type SocketCall struct {
+        conn    *packet.Conn
+        Iface   *net.Interface
+}
+
+
+func splitData(message string) []string {
+        data := []string{}
+        maxPacketLength := 1449
+
+        var i, j int
+
+        for i, j = 0, maxPacketLength; j < len(message); i, j = j, j+maxPacketLength {
+                for !utf8.RuneStart(message[j]) {
+                        j--
+                }
+                data = append(data, message[i:j])
+        }
+        data = append(data, message[i:])
+
+        return data
+}
+
+func GetAdapter() string {
+	inetInterface := ""
+	inetInterfaces, _ := net.Interfaces()
+	if inetInterfaces[0].Name == "lo" {
+		inetInterface = inetInterfaces[1].Name
+	} else {
+		inetInterface = inetInterfaces[0].Name
+	}
+	return inetInterface
+}
+
+func (c* SocketCall) SendPackage(buf gopacket.SerializeBuffer) error {
+        _, err := c.conn.WriteTo(buf.Bytes(), &packet.Addr{HardwareAddr: layers.EthernetBroadcast})
+        return err
+}
+
+func (c* SocketCall)SendData(message string) {
+        iface, _ := net.InterfaceByName(GetAdapter())
+        c.Iface = iface
+
+        conn, err := packet.Listen(iface, packet.Raw, int(layers.EthernetTypeIPv4), nil)
+        c.conn = conn
+
+        if err != nil {
+                log.Panic(err)
+        }
+
+        splitMessage := splitData(message)
+
+        for i := 0; i < len(splitMessage); i++ {
+                c.SendPackage(c.FileTransferPacket(splitMessage[i], uint16(i)))
+                time.Sleep(20 * time.Microsecond)
+
+        time.Sleep(200 * time.Microsecond)
+
+        return
+	}
+}
+
+func (c* SocketCall) saprusPayloadLength(pkt []byte) [2]byte{
+        payloadLength := make([]byte, 2)
+        var length [2]byte
+        binary.BigEndian.PutUint16(payloadLength, uint16(len(pkt)))
+
+        length[0] = payloadLength[0]
+        length[1] = payloadLength[1]
+
+        return length
+}
+