major refactoring: db.Player is now core.Player

- misc. cleanup
- core/db/players.go: works with core.Player types, will also grab inventory table

core/protocol/cnpeer.go

@@ -0,0 +1,148 @@
+package protocol
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"log"
+	"net"
+
+	"github.com/CPunch/gopenfusion/core/protocol/pool"
+)
+
+const (
+	USE_E = iota
+	USE_FE
+)
+
+type PeerHandler interface {
+	HandlePacket(peer *CNPeer, typeID uint32, pkt Packet) error
+	Disconnect(peer *CNPeer)
+}
+
+// CNPeer is a simple wrapper for net.Conn connections to send/recv packets over the Fusionfall packet protocol.
+type CNPeer struct {
+	conn      net.Conn
+	handler   PeerHandler
+	SzID      string
+	E_key     []byte
+	FE_key    []byte
+	AccountID int
+	whichKey  int
+	alive     bool
+}
+
+func NewCNPeer(handler PeerHandler, conn net.Conn) *CNPeer {
+	return &CNPeer{
+		conn:      conn,
+		handler:   handler,
+		SzID:      "",
+		E_key:     []byte(DEFAULT_KEY),
+		FE_key:    nil,
+		AccountID: -1,
+		whichKey:  USE_E,
+		alive:     true,
+	}
+}
+
+func (peer *CNPeer) Send(typeID uint32, data ...interface{}) error {
+	// grab buffer from pool
+	buf := pool.Get()
+	defer pool.Put(buf)
+
+	// body start
+	pkt := NewPacket(buf)
+
+	// encode type id
+	if err := pkt.Encode(typeID); err != nil {
+		return err
+	}
+
+	// encode data
+	for _, trailer := range data {
+		if err := pkt.Encode(trailer); err != nil {
+			return err
+		}
+	}
+
+	// encrypt body
+	switch peer.whichKey {
+	case USE_E:
+		EncryptData(buf.Bytes(), peer.E_key)
+	case USE_FE:
+		EncryptData(buf.Bytes(), peer.FE_key)
+	}
+
+	// write packet size
+	if err := binary.Write(peer.conn, binary.LittleEndian, uint32(buf.Len())); err != nil {
+		return err
+	}
+
+	// write packet body
+	log.Printf("Sending %#v, sizeof: %d", data, buf.Len())
+	if _, err := peer.conn.Write(buf.Bytes()); err != nil {
+		return fmt.Errorf("[FATAL] failed to write packet body! %v", err)
+	}
+
+	return nil
+}
+
+func (peer *CNPeer) Kill() {
+	if !peer.alive {
+		return
+	}
+
+	peer.alive = false
+	peer.conn.Close()
+	peer.handler.Disconnect(peer)
+}
+
+// meant to be invoked as a goroutine
+func (peer *CNPeer) Handler() {
+	defer peer.Kill()
+
+	for {
+		// read packet size, the goroutine spends most of it's time parked here
+		var sz uint32
+		if err := binary.Read(peer.conn, binary.LittleEndian, &sz); err != nil {
+			log.Printf("[FATAL] failed to read packet size! %v\n", err)
+			return
+		}
+
+		// client should never send a packet size outside of this range
+		if sz > CN_PACKET_BUFFER_SIZE || sz < 4 {
+			log.Printf("[FATAL] malicious packet size received! %d", sz)
+			return
+		}
+
+		// grab buffer && read packet body
+		if err := func() error { // we wrap this in a closure so we can easily defer the buffer return to pool
+			buf := pool.Get()
+			defer pool.Put(buf)
+			if _, err := buf.ReadFrom(io.LimitReader(peer.conn, int64(sz))); err != nil {
+				return fmt.Errorf("failed to read packet body! %v", err)
+			}
+
+			// decrypt
+			DecryptData(buf.Bytes(), peer.E_key)
+			pkt := NewPacket(buf)
+
+			// create packet && read typeID
+			var typeID uint32
+			if err := pkt.Decode(&typeID); err != nil {
+				return fmt.Errorf("failed to read packet type! %v", err)
+			}
+
+			// dispatch packet
+			log.Printf("Got packet ID: %x, with a sizeof: %d\n", typeID, sz)
+			if err := peer.handler.HandlePacket(peer, typeID, pkt); err != nil {
+				return err
+			}
+
+			return nil
+		}(); err != nil {
+			log.Printf("[FATAL] %v", err)
+			return
+		}
+	}
+}

core/protocol/encrypt.go

@@ -0,0 +1,71 @@
+package protocol
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+)
+
+const (
+	DEFAULT_KEY = "m@rQn~W#"
+	KEY_LENGTH  = 8
+)
+
+func encrypt_byte_change_A(ERSize int, data []byte) int {
+	var num, num2, num3 int
+
+	for num+ERSize <= len(data) {
+		num4 := num + num3
+		num5 := num + (ERSize - 1 - num3)
+
+		b := data[num4]
+		data[num4] = data[num5]
+		data[num5] = b
+		num += ERSize
+		num3++
+		if num3 > ERSize/2 {
+			num3 = 0
+		}
+	}
+
+	num2 = ERSize - (num + ERSize - len(data))
+	return num + num2
+}
+
+func xorData(buff, key []byte, size int) {
+	for i := 0; i < size; i++ {
+		buff[i] ^= key[i%KEY_LENGTH]
+	}
+}
+
+func EncryptData(buff, key []byte) {
+	ERSize := len(buff)%(KEY_LENGTH/2+1)*2 + KEY_LENGTH
+	xorData(buff, key, len(buff))
+	encrypt_byte_change_A(ERSize, buff)
+}
+
+func DecryptData(buff, key []byte) {
+	ERSize := len(buff)%(KEY_LENGTH/2+1)*2 + KEY_LENGTH
+	size := encrypt_byte_change_A(ERSize, buff)
+	xorData(buff, key, size)
+}
+
+func CreateNewKey(uTime uint64, iv1, iv2 uint64) []byte {
+	num := iv1 + 1
+	num2 := iv2 + 1
+
+	dEKey := uint64(binary.LittleEndian.Uint64([]byte(DEFAULT_KEY)))
+	key := dEKey * (uTime * num * num2)
+	buf := make([]byte, 8)
+	binary.LittleEndian.PutUint64(buf, uint64(key))
+	return buf
+}
+
+func GenSerialKey() (int64, error) {
+	tmp := [8]byte{}
+	if _, err := rand.Read(tmp[:]); err != nil {
+		return 0, err
+	}
+
+	// convert to uint64 && return
+	return int64(binary.LittleEndian.Uint64(tmp[:])), nil
+}

core/protocol/packet.go

@@ -0,0 +1,158 @@
+package protocol
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"reflect"
+	"strconv"
+	"unicode/utf16"
+)
+
+/*
+	this file handles serializing (and deserializing) structs to alignment-strict c structures generated via `tools/genstructs.py`.
+	see script for details on usage!
+*/
+
+type Packet struct {
+	readWriter io.ReadWriter
+}
+
+func NewPacket(readWriter io.ReadWriter) Packet {
+	return Packet{
+		readWriter: readWriter,
+	}
+}
+
+func (pkt Packet) encodeStructField(field reflect.StructField, value reflect.Value) error {
+	// log.Printf("Encoding '%s'", field.Name)
+
+	switch field.Type.Kind() {
+	case reflect.String: // all strings in fusionfall packets are encoded as utf16, we'll need to encode it
+		sz, err := strconv.Atoi(field.Tag.Get("size"))
+		if err != nil {
+			return fmt.Errorf("Failed to grab string 'size' tag!!")
+		}
+
+		buf16 := utf16.Encode([]rune(value.String()))
+
+		// len(buf16) needs to be the same size as sz
+		if len(buf16) > sz {
+			// truncate
+			buf16 = buf16[:sz]
+		} else {
+			// grow
+			// TODO: probably a better way to do this?
+			for len(buf16) < sz {
+				buf16 = append(buf16, 0)
+			}
+		}
+
+		// write
+		if err := binary.Write(pkt.readWriter, binary.LittleEndian, buf16); err != nil {
+			return err
+		}
+	default:
+		if err := pkt.Encode(value.Interface()); err != nil {
+			return err
+		}
+	}
+
+	// write padding bytes
+	pad, err := strconv.Atoi(field.Tag.Get("pad"))
+	if err == nil {
+		for i := 0; i < pad; i++ {
+			if _, err := pkt.readWriter.Write([]byte{0}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (pkt Packet) Encode(data interface{}) error {
+	rv := reflect.Indirect(reflect.ValueOf(data))
+
+	switch rv.Kind() {
+	case reflect.Struct:
+		// walk through each struct fields
+		sz := rv.NumField()
+		for i := 0; i < sz; i++ {
+			if err := pkt.encodeStructField(rv.Type().Field(i), rv.Field(i)); err != nil {
+				return err
+			}
+		}
+	default:
+		// we pass everything else to go's binary package
+		if err := binary.Write(pkt.readWriter, binary.LittleEndian, data); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (pkt Packet) decodeStructField(field reflect.StructField, value reflect.Value) error {
+	// log.Printf("Decoding '%s'", field.Name)
+
+	switch field.Type.Kind() {
+	case reflect.String: // all strings in fusionfall packets are encoded as utf16, we'll need to decode it
+		sz, err := strconv.Atoi(field.Tag.Get("size"))
+		if err != nil {
+			return fmt.Errorf("Failed to grab string 'size' tag!!")
+		}
+
+		buf16 := make([]uint16, sz)
+		if err := binary.Read(pkt.readWriter, binary.LittleEndian, buf16); err != nil {
+			return err
+		}
+
+		// find null terminator
+		var realSize int
+		for ; realSize < len(buf16); realSize++ {
+			if buf16[realSize] == 0 {
+				break
+			}
+		}
+
+		value.SetString(string(utf16.Decode(buf16[:realSize])))
+	default:
+		if err := pkt.Decode(value.Addr().Interface()); err != nil {
+			return err
+		}
+	}
+
+	// consume padding bytes
+	pad, err := strconv.Atoi(field.Tag.Get("pad"))
+	if err == nil {
+		for i := 0; i < pad; i++ {
+			if _, err := pkt.readWriter.Read([]byte{0}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (pkt Packet) Decode(data interface{}) error {
+	rv := reflect.Indirect(reflect.ValueOf(data))
+
+	switch rv.Kind() {
+	case reflect.Struct:
+		// walk through each struct fields
+		sz := rv.NumField()
+		for i := 0; i < sz; i++ {
+			if err := pkt.decodeStructField(rv.Type().Field(i), rv.Field(i)); err != nil {
+				return err
+			}
+		}
+	default:
+		if err := binary.Read(pkt.readWriter, binary.LittleEndian, data); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

core/protocol/pool/pool.go

@@ -0,0 +1,19 @@
+package pool
+
+import (
+	"bytes"
+	"sync"
+)
+
+var allocator = &sync.Pool{
+	New: func() any { return new(bytes.Buffer) },
+}
+
+func Get() *bytes.Buffer {
+	return allocator.Get().(*bytes.Buffer)
+}
+
+func Put(buf *bytes.Buffer) {
+	buf.Reset()
+	allocator.Put(buf)
+}