UDP Socket manager for go server-side
Tags: go, gamedev, encryption, udp
Published: 2021-10-05 13:04:55

I'm working on a prototype online multiplayer game. As you know an online multiplayer game has a server-side process that manages the game state & simulates the world based on the users' inputs.

The game is fast-paced, so I used the UDP protocol to create a virtual channel between the client & the server. The UDP is a stateless protocol, which means that the server & client are not aware of a connection, they only exchange packets. Also, there is no guarantee that the packets are received in order or receive at all.

## The Security
To manage the network connections there is a major challenge, security! this challenge has two sides, the first is related to user authentication & session management & the second is secure the content of the packets around the internet.

### Session management
Each user input that is received in the server, must be authorized.

### Encryption
To secure the content of packets around the internet we need to use encryption.

So I decided to implement a simple general-purpose package for Golang to manage the incoming packets & provide security for the virtual connection between the server & the client.

---
## The `udpsocket` package
I made this package to make a virtual stateful connection between the client & server using the UDP protocol for a Golang game server (as you know the UDP protocol is stateless, packets may not arrive in order & there is no ACK). check it out on [Github](https://github.com/theredrad/udpsocket)

The `udpsocket` supports a mimic of DTLS handshake, cryptography, session management & authentication. It's responsible to make a secure channel between the client & server on UDP (handshake), authenticate & manage them, decrypt & encrypt the data & provide an API to send or broadcast data to the clients & listen to them.

### Custom Implementations
Feels free to:
* implement your auth client to authorize the users' tokens
* implement your preferred symmetric & asymmetric encryption algorithms (the RSA & AES encryption are supported as default)
* implement your preferred encoding package. (the protobuf is supported as default)

### Basic Usage
```go
package main

import (
	"context"
	"log"
	"net"
	"fmt"
	"crypto/rsa"
  
	"demo/auth"
	"demo/encoding"
	
	"github.com/theredrad/udpsocket"
	"github.com/theredrad/udpsocket/crypto"
)

var (
	pk *rsa.PrivateKey

	udpServerIP   = "127.0.0.1"
	udpServerPort = "7009"

	defaultRSAPrivateKeySize = 2048
)

func main() {
	f, err := auth.NewFirebaseClient(context.Background(), "firebase-config.json") // firebase implementation of auth client to validate firebase-issued tokens
	if err != nil {
		panic(err)
	}

	udpAddr, err = net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%s", udpServerIP, udpServerPort))
	if err != nil {
		panic(err)
	}

	udpConn, err = net.ListenUDP("udp", udpAddr)
	if err != nil {
		panic(err)
	}
	defer udpConn.Close()


	pk, err = crypto.GenerateRSAKey(defaultRSAPrivateKeySize)
	if err != nil {
		panic(err)
	}
	
	r := crypto.NewRSAFromPK(pk) // creating a new instance of the RSA implementation
	if err != nil {
		panic(err)
	}

	a := crypto.NewAES(crypto.AES_CBC) // creating a new instance of the AES implementation

	t := &encoding.MessagePack{} // an implementation of msgpack for the Transcoder
	s, err := udpsocket.NewServer(udpConn, &udpsocket.Config{
		AuthClient: f,
		Transcoder: t,
		SymmCrypto: a,
		AsymmCrypto: r,
		ReadBufferSize: 2048,
		MinimumPayloadSize: 4,
		ProtocolVersionMajor: 0,
		ProtocolVersionMinor: 1,
	})
	if err != nil {
		panic(err)
	}
	s.SetHandler(incomingHandler)

	go func() { // handling the server errors
		for {
			uerr := <- s.Errors
			if uerr != nil {
				log.Printf("errors on udp server: %s\n", uerr.Error())
			}
		}
	}()

	go s.Serve() // start to run the server, listen to incoming records

  // TODO: need to serve the public key on HTTPS (TLS) to secure the download for the client
}

func incomingHandler(id string, t byte, p []byte) {
	// handle the incoming
}
```

## Dig deeper, How it works
### Record
Each message from the client is a Record. The record has a format to parse & decryption.
```
 1   0   1   1 0 2 52 91 253 115 22 78 39 28 5 192 47 211...
|-| |-| |-|  |------------------------------------------|
 a   b   c                        d

a: record type
b: record protocol major version
c: record protocol minor version
d: record body
```

### Record Types
The first byte of record is the type & indicates how to parse the record. supported reserved types:
* ClientHello : `1`
* HelloVerify: `2`
* ServerHello: `3`
* Ping: `4`
* Pong: `5`

### Handshake
The handshake process is made base on a mimic of DTLS protocol, the client sends `ClientHello` record, this record contains a random bytes & AES key & encrypted by the server public key, which is needed to download on TLS, then the server generates a random cookie based on the client parameters, encrypts it with the client AES key (which is received by `ClientHello` & sends it as the `HelloVerify` record. The client decrypts the record & repeats the `ClientHello` message with the cookie, the record is needed to be encrypted with the server public key, then append the encrypted user token (with AES) to the record body. the server will registers the client after cookie verification & authenticates the user token & then returns a `ServerHello` record contains a random secret session ID. The handshake process is done here.

```
      Client                                   Server
      ------                                   ------
      ClientHello           ------>

                            <-----         HelloVerifyRequest
                                           (contains cookie)

      ClientHello           ------>
 (with cookie & token)
      
                            <-----           ServerHello
                                         (contains session ID)
```

### Encryption
The Server uses both symmetric & asymmetric encryptions to communicate with the client.

The `ClientHello` record (for the server) contains a secure 256 bit AES key & encrypted by the server public key, so the server could decrypt it with the private key.

The `HelloVerify` record (for the client) encrypts with the client `AES` key (which was decrypted before).
If user authentication is required, the client must send the user token with the `ClientHello` (a record which contains cookie too), but the asymmetric encryption has a limitation on size. for example, the `RSA` only is able to encrypt data to a maximum amount equal to the key size (e.g. 2048 bits = 256 bytes) & the user token size could be more, so the user token must be encrypted by the client `AES`, then the server could decrypt it after validation of `ClientHello` record.
The handshake record structure is a little different because of using hybrid encryption. the two bytes after the protocol version bytes indicates the size of the handshake body which is encrypted by the server public key. the handshake body size is passing because of the key size, the encrypted body size depends on the `RSA` key size.

```
 1   0   1   1   0   2 52 91 253 115 22 78 ... 4 22 64 91 195 37 225
|-| |-| |-| |-| |-| |---------------------|   |--------------------|
 a   b   c   d   e            f                         g

a: record type (1 => handshake)
b: record protocol major version (0 => 0.1v)
c: record protocol minor version (1 => 0.1v)
d: handshake body size ([1] 0 => 256 bytes, key size: 2048 bits) (first digit number in base of 256)
e: handshake body size (1 [0] => 256 bytes, key size: 2048 bits) (second digit number in base of 256)
f: handshake body which is encrypted by the server public key & contains the client AES key
g: user token which is encrypted by the client AES key size
```

## Possible issues
If there were any possible issues or needs, please put comments or collaborate to make it better. [Repository on the Github](https://github.com/theredrad/udpsocket)