From 0647a586332276c08dc276001075d120c781a06b Mon Sep 17 00:00:00 2001
From: Extremelyd1 <10898310+Extremelyd1@users.noreply.github.com>
Date: Mon, 6 Jan 2025 22:18:58 +0100
Subject: [PATCH 1/9] Initial work for DTLS for connections

---
 HKMP/HKMP.csproj                              |   3 +
 .../Client/ClientDatagramTransport.cs         |  49 ++++++++
 HKMP/Networking/Client/ClientTlsClient.cs     |  37 ++++++
 HKMP/Networking/Client/ClientUpdateManager.cs |  12 +-
 HKMP/Networking/Client/DtlsClient.cs          | 104 ++++++++++++++++
 HKMP/Networking/Client/NetClient.cs           |  57 +++++----
 HKMP/Networking/Client/UdpNetClient.cs        |  68 +++++-----
 HKMP/Networking/Server/DtlsServer.cs          | 117 ++++++++++++++++++
 HKMP/Networking/Server/DtlsServerClient.cs    |   9 ++
 HKMP/Networking/Server/NetServer.cs           |  82 ++++--------
 HKMP/Networking/Server/NetServerClient.cs     |   6 +-
 .../Server/ServerDatagramTransport.cs         |  84 +++++++++++++
 HKMP/Networking/Server/ServerTlsServer.cs     | 116 +++++++++++++++++
 HKMP/Networking/Server/ServerUpdateManager.cs |   8 +-
 HKMP/Networking/UdpUpdateManager.cs           |  15 ++-
 15 files changed, 624 insertions(+), 143 deletions(-)
 create mode 100644 HKMP/Networking/Client/ClientDatagramTransport.cs
 create mode 100644 HKMP/Networking/Client/ClientTlsClient.cs
 create mode 100644 HKMP/Networking/Client/DtlsClient.cs
 create mode 100644 HKMP/Networking/Server/DtlsServer.cs
 create mode 100644 HKMP/Networking/Server/DtlsServerClient.cs
 create mode 100644 HKMP/Networking/Server/ServerDatagramTransport.cs
 create mode 100644 HKMP/Networking/Server/ServerTlsServer.cs

diff --git a/HKMP/HKMP.csproj b/HKMP/HKMP.csproj
index fe8c8da2..3961e498 100644
--- a/HKMP/HKMP.csproj
+++ b/HKMP/HKMP.csproj
@@ -99,6 +99,9 @@
             <HintPath>$(References)\MonoMod.Utils.dll</HintPath>
             <Private>False</Private>
         </Reference>
+        <Reference Include="BouncyCastle.Cryptography">
+            <HintPath>$(References)\BouncyCastle.Cryptography.dll</HintPath>
+        </Reference>
     </ItemGroup>
 
     <!-- Create an item group for the source and destination files of the copy target. This way we can specify
diff --git a/HKMP/Networking/Client/ClientDatagramTransport.cs b/HKMP/Networking/Client/ClientDatagramTransport.cs
new file mode 100644
index 00000000..7f6697bc
--- /dev/null
+++ b/HKMP/Networking/Client/ClientDatagramTransport.cs
@@ -0,0 +1,49 @@
+using System.Net.Sockets;
+using Hkmp.Logging;
+using Org.BouncyCastle.Tls;
+
+namespace Hkmp.Networking.Client;
+
+internal class ClientDatagramTransport : DatagramTransport {
+    private readonly Socket _socket;
+    
+    public ClientDatagramTransport(Socket socket) {
+        _socket = socket;
+    }
+    
+    public int GetReceiveLimit() {
+        // TODO: change to const defined somewhere
+        return 1400;
+    }
+    
+    public int GetSendLimit() {
+        // TODO: change to const defined somewhere
+        return 1400;
+    }
+
+    public int Receive(byte[] buf, int off, int len, int waitMillis) {
+        try {
+            // _socket.ReceiveTimeout = waitMillis;
+            var numReceived = _socket.Receive(
+                buf,
+                off,
+                len,
+                SocketFlags.None
+            );
+            Logger.Debug($"Client socket receive: {numReceived}");
+            return numReceived;
+        } catch (SocketException e) {
+            Logger.Error($"UDP Socket exception:\n{e}");
+        }
+
+        return -1;
+    }
+
+    public void Send(byte[] buf, int off, int len) {
+        Logger.Debug($"Client sending {len} bytes of data");
+        _socket.Send(buf, off, len, SocketFlags.None);
+    }
+
+    public void Close() {
+    }
+}
diff --git a/HKMP/Networking/Client/ClientTlsClient.cs b/HKMP/Networking/Client/ClientTlsClient.cs
new file mode 100644
index 00000000..edcb2af8
--- /dev/null
+++ b/HKMP/Networking/Client/ClientTlsClient.cs
@@ -0,0 +1,37 @@
+using Org.BouncyCastle.Tls;
+using Org.BouncyCastle.Tls.Crypto;
+
+namespace Hkmp.Networking.Client;
+
+internal class ClientTlsClient(TlsCrypto crypto) : AbstractTlsClient(crypto) {
+    private static readonly int[] SupportedCipherSuites = [
+        CipherSuite.TLS_AES_128_GCM_SHA256,
+        CipherSuite.TLS_AES_256_GCM_SHA384,
+        CipherSuite.TLS_CHACHA20_POLY1305_SHA256,
+        CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+        CipherSuite.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
+    ];
+    
+    protected override ProtocolVersion[] GetSupportedVersions() {
+        return ProtocolVersion.DTLSv12.Only();
+    }
+
+    protected override int[] GetSupportedCipherSuites() {
+        return SupportedCipherSuites;
+    }
+
+    public override TlsAuthentication GetAuthentication() {
+        return new TlsAuthenticationImpl();
+    }
+
+    private class TlsAuthenticationImpl : TlsAuthentication {
+        public void NotifyServerCertificate(TlsServerCertificate serverCertificate) {
+            // TODO: check server certificate, throw error in case of invalid cert
+        }
+
+        public TlsCredentials GetClientCredentials(CertificateRequest certificateRequest) {
+            // TODO: provide means for a client to have certificate and return it in this method
+            return null;
+        }
+    }
+}
diff --git a/HKMP/Networking/Client/ClientUpdateManager.cs b/HKMP/Networking/Client/ClientUpdateManager.cs
index 575e7988..262ff6ab 100644
--- a/HKMP/Networking/Client/ClientUpdateManager.cs
+++ b/HKMP/Networking/Client/ClientUpdateManager.cs
@@ -7,6 +7,7 @@
 using Hkmp.Math;
 using Hkmp.Networking.Packet;
 using Hkmp.Networking.Packet.Data;
+using Org.BouncyCastle.Tls;
 
 namespace Hkmp.Networking.Client;
 
@@ -18,16 +19,7 @@ internal class ClientUpdateManager : UdpUpdateManager<ServerUpdatePacket, Server
     /// Construct the update manager with a UDP net client.
     /// </summary>
     /// <param name="udpSocket">The UDP socket for the local client.</param>
-    public ClientUpdateManager(Socket udpSocket) : base(udpSocket) {
-    }
-
-    /// <inheritdoc />
-    protected override void SendPacket(Packet.Packet packet) {
-        if (!UdpSocket.Connected) {
-            return;
-        }
-
-        UdpSocket?.SendAsync(new ArraySegment<byte>(packet.ToArray()), SocketFlags.None);
+    public ClientUpdateManager(DtlsTransport dtlsTransport) : base(dtlsTransport) {
     }
 
     /// <inheritdoc />
diff --git a/HKMP/Networking/Client/DtlsClient.cs b/HKMP/Networking/Client/DtlsClient.cs
new file mode 100644
index 00000000..05598c0f
--- /dev/null
+++ b/HKMP/Networking/Client/DtlsClient.cs
@@ -0,0 +1,104 @@
+using System;
+using System.IO;
+using System.Net.Sockets;
+using System.Threading;
+using Hkmp.Logging;
+using Org.BouncyCastle.Tls;
+using Org.BouncyCastle.Tls.Crypto.Impl.BC;
+
+namespace Hkmp.Networking.Client;
+
+internal class DtlsClient {
+    private Socket _socket;
+    private ClientTlsClient _tlsClient;
+    private ClientDatagramTransport _clientDatagramTransport;
+
+    private CancellationTokenSource _updateTaskTokenSource;
+
+    public DtlsTransport DtlsTransport { get; set; }
+    public event Action<byte[], int> DataReceivedEvent;
+    
+    public void Connect(string address, int port) {
+        if (_socket != null || 
+            _tlsClient != null ||
+            _clientDatagramTransport != null || 
+            DtlsTransport != null ||
+            _updateTaskTokenSource != null
+        ) {
+            Disconnect();
+        }
+        
+        _socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+        // _socket.DualMode = true;
+
+        try {
+            _socket.Connect(address, port);
+        } catch (SocketException e) {
+            Logger.Error($"Socket exception when connecting UDP socket:\n{e}");
+            
+            _socket.Close();
+
+            throw;
+        }
+        
+        var clientProtocol = new DtlsClientProtocol();
+        _tlsClient = new ClientTlsClient(new BcTlsCrypto());
+        _clientDatagramTransport = new ClientDatagramTransport(_socket);
+
+        try {
+            DtlsTransport = clientProtocol.Connect(_tlsClient, _clientDatagramTransport);
+        } catch (IOException e) {
+            Logger.Error($"IO exception when connecting DTLS client:\n{e}");
+
+            _clientDatagramTransport.Close();
+
+            throw;
+        }
+        
+        Logger.Debug($"Successfully connected DTLS client to endpoint: {address}:{port}");
+
+        _updateTaskTokenSource = new CancellationTokenSource();
+        var cancellationToken = _updateTaskTokenSource.Token;
+        new Thread(() => ReceiveLoop(cancellationToken)).Start();
+    }
+
+    public void Disconnect() {
+        _updateTaskTokenSource?.Cancel();
+        _updateTaskTokenSource?.Dispose();
+        _updateTaskTokenSource = null;
+        
+        DtlsTransport?.Close();
+        DtlsTransport = null;
+        
+        _clientDatagramTransport?.Close();
+        _clientDatagramTransport = null;
+        
+        _tlsClient?.Cancel();
+        _tlsClient = null;
+        
+        _socket?.Close();
+        _socket = null;
+    }
+
+    public void SendPacket(Packet.Packet packet) {
+        if (DtlsTransport == null) {
+            Logger.Error("DTLS transport instance is null, cannot send packet");
+            return;
+        }
+        
+        var buffer = packet.ToArray();
+
+        DtlsTransport.Send(buffer, 0, buffer.Length);
+    }
+
+    private void ReceiveLoop(CancellationToken cancellationToken) {
+        while (!cancellationToken.IsCancellationRequested && DtlsTransport != null) {
+            // TODO: change to const define somewhere central
+            var buffer = new byte[1400];
+            var length = DtlsTransport.Receive(buffer, 0, buffer.Length, 5);
+            if (length >= 0) {
+                DataReceivedEvent?.Invoke(buffer, length);
+            }
+        }
+    }
+}
diff --git a/HKMP/Networking/Client/NetClient.cs b/HKMP/Networking/Client/NetClient.cs
index 88c7d010..c62ff2f1 100644
--- a/HKMP/Networking/Client/NetClient.cs
+++ b/HKMP/Networking/Client/NetClient.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Net.Sockets;
 using System.Threading;
 using Hkmp.Api.Client;
@@ -26,11 +27,6 @@ internal class NetClient : INetClient {
     /// </summary>
     private readonly PacketManager _packetManager;
 
-    /// <summary>
-    /// The underlying UDP net client for networking.
-    /// </summary>
-    private readonly UdpNetClient _udpNetClient;
-
     /// <summary>
     /// The client update manager for this net client.
     /// </summary>
@@ -71,6 +67,13 @@ internal class NetClient : INetClient {
     /// </summary>
     private CancellationTokenSource _updateTaskTokenSource;
 
+    private DtlsClient _dtlsClient;
+    
+    /// <summary>
+    /// Byte array containing received data that was not included in a packet object yet.
+    /// </summary>
+    private byte[] _leftoverData;
+
     /// <summary>
     /// Construct the net client with the given packet manager.
     /// </summary>
@@ -78,10 +81,9 @@ internal class NetClient : INetClient {
     public NetClient(PacketManager packetManager) {
         _packetManager = packetManager;
 
-        _udpNetClient = new UdpNetClient();
+        _dtlsClient = new DtlsClient();
 
-        // Register the same function for both TCP and UDP receive callbacks
-        _udpNetClient.RegisterOnReceive(OnReceiveData);
+        _dtlsClient.DataReceivedEvent += OnReceiveData;
     }
 
     /// <summary>
@@ -132,7 +134,12 @@ private void OnConnectFailed(ConnectFailedResult result) {
     /// Callback method for when the net client receives data.
     /// </summary>
     /// <param name="packets">A list of raw received packets.</param>
-    private void OnReceiveData(List<Packet.Packet> packets) {
+    private void OnReceiveData(byte[] buffer, int length) {
+        // TODO: check if this is the correct place to make this call
+        UpdateManager.ProcessUpdate();
+        
+        var packets = PacketManager.HandleReceivedData(buffer, length, ref _leftoverData);
+        
         foreach (var packet in packets) {
             // Create a ClientUpdatePacket from the raw packet instance,
             // and read the values into it
@@ -209,38 +216,30 @@ public void Connect(
         List<AddonData> addonData
     ) {
         IsConnecting = true;
-        
+
         try {
-            _udpNetClient.Connect(address, port);
+            _dtlsClient.Connect(address, port);
         } catch (SocketException e) {
             Logger.Error($"Failed to connect due to SocketException:\n{e}");
 
+            OnConnectFailed(new ConnectFailedResult {
+                Type = ConnectFailedResult.FailType.SocketException
+            });
+            return;
+        } catch (IOException e) {
+            Logger.Error($"Failed to connect due to IOException:\n{e}");
+
             OnConnectFailed(new ConnectFailedResult {
                 Type = ConnectFailedResult.FailType.SocketException
             });
             return;
         }
 
-        UpdateManager = new ClientUpdateManager(_udpNetClient.UdpSocket);
+        UpdateManager = new ClientUpdateManager(_dtlsClient.DtlsTransport);
         // During the connection process we register the connection failed callback if we time out
         UpdateManager.OnTimeout += OnConnectTimedOut;
         UpdateManager.StartUpdates();
 
-        // Start a thread that will process the updates for the update manager
-        // Also make a cancellation token source so we can cancel the thread on demand
-        _updateTaskTokenSource = new CancellationTokenSource();
-        var cancellationToken = _updateTaskTokenSource.Token;
-        new Thread(() => {
-            while (!cancellationToken.IsCancellationRequested) {
-                UpdateManager.ProcessUpdate();
-
-                // TODO: figure out a good way to get rid of the sleep here
-                // some way to signal when clients should be updated again would suffice
-                // also see NetServer#StartClientUpdates
-                Thread.Sleep(5);
-            }
-        }).Start();
-
         UpdateManager.SetLoginRequestData(username, authKey, addonData);
         Logger.Debug("Sending login request");
     }
@@ -250,8 +249,8 @@ List<AddonData> addonData
     /// </summary>
     public void Disconnect() {
         UpdateManager.StopUpdates();
-
-        _udpNetClient.Disconnect();
+        
+        _dtlsClient.Disconnect();
 
         IsConnected = false;
 
diff --git a/HKMP/Networking/Client/UdpNetClient.cs b/HKMP/Networking/Client/UdpNetClient.cs
index 397df0c6..e7720c51 100644
--- a/HKMP/Networking/Client/UdpNetClient.cs
+++ b/HKMP/Networking/Client/UdpNetClient.cs
@@ -3,13 +3,14 @@
 using System.Threading;
 using Hkmp.Logging;
 using Hkmp.Networking.Packet;
+using Org.BouncyCastle.Tls;
 
 namespace Hkmp.Networking.Client;
 
 /// <summary>
 /// NetClient that uses the UDP protocol.
 /// </summary>
-internal class UdpNetClient {
+internal class UdpNetClient : DatagramTransport {
     /// <summary>
     /// Maximum size of a UDP packet in bytes.
     /// </summary>
@@ -60,49 +61,50 @@ public void Connect(string address, int port) {
 
             throw;
         }
-
-        Logger.Debug($"Starting receiving UDP data on endpoint {UdpSocket.LocalEndPoint}");
-
-        // Start a thread to receive network data and create a corresponding cancellation token
-        _receiveTokenSource = new CancellationTokenSource();
-        new Thread(() => ReceiveData(_receiveTokenSource.Token)).Start();
     }
 
     /// <summary>
-    /// Continuously receive network UDP data and queue it for processing.
+    /// Disconnect the UDP client and clean it up.
     /// </summary>
-    /// <param name="token">The cancellation token for checking whether this method is requested to cancel.</param>
-    private void ReceiveData(CancellationToken token) {
-        EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
+    public void Disconnect() {
+        // Request cancellation of the receive thread
+        _receiveTokenSource.Cancel();
 
-        while (!token.IsCancellationRequested) {
-            var numReceived = 0;
-            var buffer = new byte[MaxUdpPacketSize];
+        UdpSocket?.Close();
+        UdpSocket = null;
+    }
 
-            try {
-                numReceived = UdpSocket.ReceiveFrom(
-                    buffer,
-                    SocketFlags.None,
-                    ref endPoint
-                );
-            } catch (SocketException e) {
-                Logger.Error($"UDP Socket exception:\n{e}");
-            }
+    public int GetReceiveLimit() {
+        return 1400;
+    }
+    
+    public int GetSendLimit() {
+        return 1400;
+    }
 
-            var packets = PacketManager.HandleReceivedData(buffer, numReceived, ref _leftoverData);
+    public int Receive(byte[] buf, int off, int len, int waitMillis) {
+        EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
 
-            _onReceive?.Invoke(packets);
+        try {
+            return UdpSocket.ReceiveFrom(
+                buf,
+                off,
+                len,
+                SocketFlags.None,
+                ref endPoint
+            );
+        } catch (SocketException e) {
+            Logger.Error($"UDP Socket exception:\n{e}");
         }
+
+        return -1;
     }
 
-    /// <summary>
-    /// Disconnect the UDP client and clean it up.
-    /// </summary>
-    public void Disconnect() {
-        // Request cancellation of the receive thread
-        _receiveTokenSource.Cancel();
+    public void Send(byte[] buf, int off, int len) {
+        UdpSocket.Send(buf, off, len, SocketFlags.None);
+    }
 
-        UdpSocket?.Close();
-        UdpSocket = null;
+    public void Close() {
+        throw new System.NotImplementedException();
     }
 }
diff --git a/HKMP/Networking/Server/DtlsServer.cs b/HKMP/Networking/Server/DtlsServer.cs
new file mode 100644
index 00000000..416d1dc3
--- /dev/null
+++ b/HKMP/Networking/Server/DtlsServer.cs
@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using Hkmp.Logging;
+using Org.BouncyCastle.Tls;
+using Org.BouncyCastle.Tls.Crypto.Impl.BC;
+
+namespace Hkmp.Networking.Server;
+
+internal class DtlsServer {
+    private DtlsServerProtocol _serverProtocol;
+    private ServerTlsServer _tlsServer;
+
+    private Socket _currentAcceptSocket;
+    private ServerDatagramTransport _currentDatagramTransport;
+
+    private CancellationTokenSource _acceptTaskTokenSource;
+    private CancellationTokenSource _clientUpdateTaskTokenSource;
+
+    private readonly List<DtlsServerClient> _acceptedDtlsClients;
+
+    public event Action<DtlsServerClient, byte[], int> DataReceivedEvent;
+
+    private int _port;
+
+    public DtlsServer() {
+        _acceptedDtlsClients = new List<DtlsServerClient>();
+    }
+    
+    public void Start(int port) {
+        _port = port;
+        
+        _serverProtocol = new DtlsServerProtocol();
+        _tlsServer = new ServerTlsServer(new BcTlsCrypto());
+
+        _acceptTaskTokenSource = new CancellationTokenSource();
+        _clientUpdateTaskTokenSource = new CancellationTokenSource();
+        
+        var cancellationToken = _acceptTaskTokenSource.Token;
+        new Thread(() => AcceptLoop(cancellationToken)).Start();
+    }
+
+    public void Stop() {
+        _acceptTaskTokenSource?.Cancel();
+        _acceptTaskTokenSource?.Dispose();
+        _acceptTaskTokenSource = null;
+        
+        _clientUpdateTaskTokenSource?.Cancel();
+        _clientUpdateTaskTokenSource?.Dispose();
+        _clientUpdateTaskTokenSource = null;
+    }
+
+    private void AcceptLoop(CancellationToken cancellationToken) {
+        while (!cancellationToken.IsCancellationRequested) {
+            Logger.Debug("Creating new socket for accepting connection");
+            
+            _currentAcceptSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+            // _currentAcceptSocket.DualMode = true;
+            _currentAcceptSocket.Bind(new IPEndPoint(IPAddress.Any, _port));
+            // Logger.Debug("Setting socket to listening mode");
+            // _currentAcceptSocket.Listen(1);
+            // Logger.Debug("Accepting connections for socket");
+            // var socket = _currentAcceptSocket.Accept();
+            // Logger.Debug($"Connection accepted, remote endpoint: {socket.RemoteEndPoint}");
+
+            _currentDatagramTransport = new ServerDatagramTransport(_currentAcceptSocket);
+
+            DtlsTransport dtlsTransport;
+            try {
+                dtlsTransport = _serverProtocol.Accept(_tlsServer, _currentDatagramTransport);
+            } catch (IOException e) {
+                Logger.Error($"IOException while accepting DTLS connection:\n{e}");
+                break;
+            }
+
+            Logger.Debug($"Accepted DTLS connection on socket, endpoint: {_currentAcceptSocket.RemoteEndPoint}");
+
+            var dtlsServerClient = new DtlsServerClient {
+                DtlsTransport = dtlsTransport,
+                EndPoint = _currentAcceptSocket.RemoteEndPoint as IPEndPoint
+            };
+
+            _acceptedDtlsClients.Add(dtlsServerClient);
+
+            var clientCancellationToken = _clientUpdateTaskTokenSource.Token;
+            new Thread(() => ReceiveClientLoop(dtlsServerClient, clientCancellationToken)).Start();
+        }
+
+        _currentAcceptSocket?.Close();
+        _currentAcceptSocket = null;
+        
+        _currentDatagramTransport?.Close();
+        _currentDatagramTransport = null;
+
+        _serverProtocol = null;
+
+        foreach (var dtlsServerClient in _acceptedDtlsClients) {
+            dtlsServerClient.DtlsTransport?.Close();
+        }
+        
+        _acceptedDtlsClients.Clear();
+    }
+
+    private void ReceiveClientLoop(DtlsServerClient dtlsServerClient, CancellationToken cancellationToken) {
+        while (!cancellationToken.IsCancellationRequested) {
+            // TODO: change to const defined somewhere central
+            var buffer = new byte[1400];
+            var length = dtlsServerClient.DtlsTransport.Receive(buffer, 0, buffer.Length, 5);
+            if (length >= 0) {
+                DataReceivedEvent?.Invoke(dtlsServerClient, buffer, length);
+            }
+        }
+    }
+}
diff --git a/HKMP/Networking/Server/DtlsServerClient.cs b/HKMP/Networking/Server/DtlsServerClient.cs
new file mode 100644
index 00000000..b0844299
--- /dev/null
+++ b/HKMP/Networking/Server/DtlsServerClient.cs
@@ -0,0 +1,9 @@
+using System.Net;
+using Org.BouncyCastle.Tls;
+
+namespace Hkmp.Networking.Server;
+
+internal class DtlsServerClient {
+    public DtlsTransport DtlsTransport { get; init; }
+    public IPEndPoint EndPoint { get; init; }
+}
diff --git a/HKMP/Networking/Server/NetServer.cs b/HKMP/Networking/Server/NetServer.cs
index 4d12a987..55c3d4e5 100644
--- a/HKMP/Networking/Server/NetServer.cs
+++ b/HKMP/Networking/Server/NetServer.cs
@@ -3,7 +3,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Net;
-using System.Net.Sockets;
 using System.Threading;
 using Hkmp.Api.Server;
 using Hkmp.Api.Server.Networking;
@@ -58,11 +57,6 @@ internal class NetServer : INetServer {
     /// </summary>
     private readonly ConcurrentDictionary<IPAddress, Stopwatch> _throttledClients;
 
-    /// <summary>
-    /// The underlying UDP socket.
-    /// </summary>
-    private Socket _udpSocket;
-
     private readonly ConcurrentQueue<ReceivedData> _receivedQueue;
 
     /// <summary>
@@ -80,6 +74,11 @@ internal class NetServer : INetServer {
     /// </summary>
     private ManualResetEventSlim _processingWaitHandle;
 
+    /// <summary>
+    /// Underlying DTLS server instance.
+    /// </summary>
+    private DtlsServer _dtlsServer;
+
     /// <summary>
     /// Event that is called when a client times out.
     /// </summary>
@@ -107,6 +106,8 @@ public NetServer(PacketManager packetManager) {
         _throttledClients = new ConcurrentDictionary<IPAddress, Stopwatch>();
 
         _receivedQueue = new ConcurrentQueue<ReceivedData>();
+
+        _dtlsServer = new DtlsServer();
     }
 
     /// <summary>
@@ -114,14 +115,14 @@ public NetServer(PacketManager packetManager) {
     /// </summary>
     /// <param name="port">The networking port.</param>
     public void Start(int port) {
+        if (IsStarted) {
+            Stop();
+        }
+        
         Logger.Info($"Starting NetServer on port {port}");
         IsStarted = true;
-
-        // Initialize the UDP socket
-        _udpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
-
-        // Bind the socket to the given port and allow incoming packets on any address
-        _udpSocket.Bind(new IPEndPoint(IPAddress.Any, port));
+        
+        _dtlsServer.Start(port);
 
         _processingWaitHandle = new ManualResetEventSlim();
 
@@ -134,43 +135,14 @@ public void Start(int port) {
         // Start a thread for sending updates to clients
         new Thread(() => StartClientUpdates(_taskTokenSource.Token)).Start();
 
-        // Start a thread to receive network data from the socket
-        new Thread(() => ReceiveData(_taskTokenSource.Token)).Start();
-    }
-
-    /// <summary>
-    /// Continuously receive network UDP data and queue it for processing.
-    /// </summary>
-    /// <param name="token">The cancellation token for checking whether this method is requested to cancel.</param>
-    private void ReceiveData(CancellationToken token) {
-        // Take advantage of pre-pinned memory here using pinned object heap
-        // var buffer = GC.AllocateArray<byte>(65527, true);
-        // var bufferMem = buffer.AsMemory();
-
-        EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
-
-        while (!token.IsCancellationRequested) {
-            var numReceived = 0;
-            var buffer = new byte[MaxUdpPacketSize];
-
-            try {
-                // This will block until data is available
-                numReceived = _udpSocket.ReceiveFrom(
-                    buffer,
-                    SocketFlags.None,
-                    ref endPoint
-                );
-            } catch (SocketException e) {
-                Logger.Error($"UDP Socket exception:\n{e}");
-            }
-
+        _dtlsServer.DataReceivedEvent += (dtlsServerClient, buffer, length) => {
             _receivedQueue.Enqueue(new ReceivedData {
+                DtlsServerClient = dtlsServerClient,
                 Buffer = buffer,
-                NumReceived = numReceived,
-                EndPoint = endPoint as IPEndPoint
+                NumReceived = length
             });
             _processingWaitHandle.Set();
-        }
+        };
     }
 
     /// <summary>
@@ -194,7 +166,8 @@ private void StartProcessing(CancellationToken token) {
                     ref _leftoverData
                 );
 
-                var endPoint = receivedData.EndPoint;
+                var dtlsServerClient = receivedData.DtlsServerClient;
+                var endPoint = dtlsServerClient.EndPoint;
 
                 if (!_clients.TryGetValue(endPoint, out var client)) {
                     // If the client is throttled, check their stopwatch for how long still
@@ -214,7 +187,7 @@ ref _leftoverData
 
                     // We didn't find a client with the given address, so we assume it is a new client
                     // that wants to connect
-                    client = CreateNewClient(endPoint);
+                    client = CreateNewClient(dtlsServerClient);
 
                     HandlePacketsUnregisteredClient(client, packets);
                 } else {
@@ -229,12 +202,12 @@ ref _leftoverData
     /// </summary>
     /// <param name="endPoint">The endpoint of the new client.</param>
     /// <returns>A new net server client instance.</returns>
-    private NetServerClient CreateNewClient(IPEndPoint endPoint) {
-        var netServerClient = new NetServerClient(_udpSocket, endPoint);
+    private NetServerClient CreateNewClient(DtlsServerClient dtlsServerClient) {
+        var netServerClient = new NetServerClient(dtlsServerClient.DtlsTransport, dtlsServerClient.EndPoint);
         netServerClient.UpdateManager.OnTimeout += () => HandleClientTimeout(netServerClient);
         netServerClient.UpdateManager.StartUpdates();
 
-        _clients.TryAdd(endPoint, netServerClient);
+        _clients.TryAdd(dtlsServerClient.EndPoint, netServerClient);
 
         return netServerClient;
     }
@@ -390,8 +363,6 @@ public void Stop() {
         _registeredClients.Clear();
         _throttledClients.Clear();
 
-        _udpSocket.Close();
-
         _leftoverData = null;
 
         IsStarted = false;
@@ -526,6 +497,8 @@ Func<TPacketId, IPacketData> packetInstantiator
 /// Data class for storing received data from a given IP end-point.
 /// </summary>
 internal class ReceivedData {
+    public DtlsServerClient DtlsServerClient { get; init; }
+    
     /// <summary>
     /// Byte array of the buffer containing received data.
     /// </summary>
@@ -535,9 +508,4 @@ internal class ReceivedData {
     /// The number of bytes in the buffer that were received. The rest of the buffer is empty.
     /// </summary>
     public int NumReceived { get; init; }
-
-    /// <summary>
-    /// The IP end-point of the client from which we received the data.
-    /// </summary>
-    public IPEndPoint EndPoint { get; init; }
 }
diff --git a/HKMP/Networking/Server/NetServerClient.cs b/HKMP/Networking/Server/NetServerClient.cs
index 3ec9af8b..7a0f61d5 100644
--- a/HKMP/Networking/Server/NetServerClient.cs
+++ b/HKMP/Networking/Server/NetServerClient.cs
@@ -1,6 +1,6 @@
 using System.Collections.Concurrent;
 using System.Net;
-using System.Net.Sockets;
+using Org.BouncyCastle.Tls;
 
 namespace Hkmp.Networking.Server;
 
@@ -44,12 +44,12 @@ internal class NetServerClient {
     /// </summary>
     /// <param name="udpSocket">The underlying UDP socket.</param>
     /// <param name="endPoint">The endpoint.</param>
-    public NetServerClient(Socket udpSocket, IPEndPoint endPoint) {
+    public NetServerClient(DtlsTransport dtlsTransport, IPEndPoint endPoint) {
         // Also store endpoint with TCP address and TCP port
         EndPoint = endPoint;
 
         Id = GetId();
-        UpdateManager = new ServerUpdateManager(udpSocket, EndPoint);
+        UpdateManager = new ServerUpdateManager(dtlsTransport, EndPoint);
     }
 
     /// <summary>
diff --git a/HKMP/Networking/Server/ServerDatagramTransport.cs b/HKMP/Networking/Server/ServerDatagramTransport.cs
new file mode 100644
index 00000000..d17ec8f2
--- /dev/null
+++ b/HKMP/Networking/Server/ServerDatagramTransport.cs
@@ -0,0 +1,84 @@
+using System.Net;
+using System.Net.Sockets;
+using Hkmp.Logging;
+using Org.BouncyCastle.Tls;
+
+namespace Hkmp.Networking.Server;
+
+internal class ServerDatagramTransport : DatagramTransport {
+    private readonly Socket _socket;
+
+    private bool _hasReceived;
+
+    public ServerDatagramTransport(Socket socket) {
+        _socket = socket;
+    }
+    
+    public int GetReceiveLimit() {
+        // TODO: change to const defined somewhere
+        return 1400;
+    }
+    
+    public int GetSendLimit() {
+        // TODO: change to const defined somewhere
+        return 1400;
+    }
+
+    public int Receive(byte[] buf, int off, int len, int waitMillis) {
+        if (!_hasReceived) {
+            EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
+            
+            try {
+                Logger.Debug("Blocking on first receive");
+            
+                // _socket.ReceiveTimeout = waitMillis;
+                var numReceived = _socket.ReceiveFrom(
+                    buf,
+                    off,
+                    len,
+                    SocketFlags.None,
+                    ref endPoint
+                );
+            
+                _socket.Connect(endPoint);
+                _hasReceived = true;
+                
+                Logger.Debug($"First receive finished ({numReceived}), connecting socket to endpoint: {endPoint}");
+                return numReceived;
+            } catch (SocketException e) {
+                Logger.Error($"UDP Socket exception:\n{e}");
+            }
+        } else {
+            try {
+                Logger.Debug("Non-first blocking receive called");
+                // _socket.ReceiveTimeout = waitMillis;
+                var numReceived = _socket.Receive(
+                    buf,
+                    off,
+                    len,
+                    SocketFlags.None
+                );
+                Logger.Debug($"End of non-first blocking receive: {numReceived}");
+                return numReceived;
+            } catch (SocketException e) {
+                Logger.Error($"UDP Socket exception:\n{e}");
+            }
+        }
+
+        return -1;
+    }
+
+    public void Send(byte[] buf, int off, int len) {
+        if (!_hasReceived) {
+            Logger.Error("Cannot send because socket has not received yet");
+            return;
+        }
+        
+        Logger.Debug($"Server sending {len} bytes of data");
+        
+        _socket.Send(buf, off, len, SocketFlags.None);
+    }
+
+    public void Close() {
+    }
+}
diff --git a/HKMP/Networking/Server/ServerTlsServer.cs b/HKMP/Networking/Server/ServerTlsServer.cs
new file mode 100644
index 00000000..03aaae7d
--- /dev/null
+++ b/HKMP/Networking/Server/ServerTlsServer.cs
@@ -0,0 +1,116 @@
+using System;
+using Hkmp.Logging;
+using Org.BouncyCastle.Asn1.Pkcs;
+using Org.BouncyCastle.Asn1.Sec;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Asn1.X9;
+using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Crypto.Generators;
+using Org.BouncyCastle.Crypto.Operators;
+using Org.BouncyCastle.Crypto.Parameters;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Security;
+using Org.BouncyCastle.Tls;
+using Org.BouncyCastle.Tls.Crypto;
+using Org.BouncyCastle.Tls.Crypto.Impl.BC;
+using Org.BouncyCastle.X509;
+
+namespace Hkmp.Networking.Server;
+
+internal class ServerTlsServer : AbstractTlsServer {
+    private static readonly int[] SupportedCipherSuites = [
+        CipherSuite.TLS_AES_128_GCM_SHA256,
+        CipherSuite.TLS_AES_256_GCM_SHA384,
+        CipherSuite.TLS_CHACHA20_POLY1305_SHA256,
+        CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+        // CipherSuite.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
+    ];
+
+    private readonly AsymmetricCipherKeyPair _keyPair;
+    private readonly X509Certificate _certificate;
+
+    public ServerTlsServer(TlsCrypto crypto) : base(crypto) {
+        _keyPair = GenerateECDHKeyPair(GetECBuiltInBinaryDomainParameters());
+        _certificate = GenerateCertificate(
+            new X509Name("CN=TestCA"),
+            new X509Name("CN=TestEE"),
+            _keyPair.Private,
+            _keyPair.Public
+        );
+    }
+
+    static X509Certificate GenerateCertificate(
+        X509Name issuer, X509Name subject,
+        AsymmetricKeyParameter issuerPrivate,
+        AsymmetricKeyParameter subjectPublic
+    ) {
+        ISignatureFactory signatureFactory;
+        if (issuerPrivate is ECPrivateKeyParameters) {
+            signatureFactory = new Asn1SignatureFactory(
+                X9ObjectIdentifiers.ECDsaWithSha256.ToString(),
+                issuerPrivate);
+        } else {
+            signatureFactory = new Asn1SignatureFactory(
+                PkcsObjectIdentifiers.Sha256WithRsaEncryption.ToString(),
+                issuerPrivate);
+        }
+
+        var certGenerator = new X509V3CertificateGenerator();
+        certGenerator.SetIssuerDN(issuer);
+        certGenerator.SetSubjectDN(subject);
+        certGenerator.SetSerialNumber(BigInteger.ValueOf(1));
+        certGenerator.SetNotAfter(DateTime.UtcNow.AddHours(1));
+        certGenerator.SetNotBefore(DateTime.UtcNow);
+        certGenerator.SetPublicKey(subjectPublic);
+        return certGenerator.Generate(signatureFactory);
+    }
+
+    private ECDomainParameters GetECBuiltInBinaryDomainParameters() {
+        var ecParams = ECNamedCurveTable.GetByName("K-283");
+
+        return new ECDomainParameters(ecParams.Curve, ecParams.G, ecParams.N, ecParams.H, ecParams.GetSeed());
+    }
+
+    private AsymmetricCipherKeyPair GenerateECDHKeyPair(ECDomainParameters ecParams) {
+        var ecKeyGenParams = new ECKeyGenerationParameters(ecParams, new SecureRandom());
+        var ecKeyPairGen = new ECKeyPairGenerator();
+        ecKeyPairGen.Init(ecKeyGenParams);
+        var ecKeyPair = ecKeyPairGen.GenerateKeyPair();
+
+        return ecKeyPair;
+    }
+    
+    
+
+    protected override ProtocolVersion[] GetSupportedVersions() {
+        return ProtocolVersion.DTLSv12.Only();
+    }
+    
+    protected override int[] GetSupportedCipherSuites() {
+        return SupportedCipherSuites;
+    }
+
+    public override TlsCredentials GetCredentials() {
+        var keyExchangeAlgorithm = TlsUtilities.GetKeyExchangeAlgorithm(m_selectedCipherSuite);
+        Logger.Debug($"keyExchangeAlgorithm: {keyExchangeAlgorithm}");
+
+        if (keyExchangeAlgorithm != KeyExchangeAlgorithm.ECDHE_ECDSA) {
+            throw new TlsFatalAlert(AlertDescription.internal_error);
+        }
+
+        var bcTlsCrypto = new BcTlsCrypto(new SecureRandom());
+
+        return new DefaultTlsCredentialedSigner(
+            new TlsCryptoParameters(m_context), 
+            new BcTlsECDsaSigner(
+                bcTlsCrypto,
+                (ECPrivateKeyParameters) _keyPair.Private
+            ), 
+            new Certificate([new BcTlsCertificate(bcTlsCrypto, _certificate.CertificateStructure)]), 
+            SignatureAndHashAlgorithm.GetInstance(
+                HashAlgorithm.sha384,
+                SignatureAlgorithm.ecdsa
+            )
+        );
+    }
+}
diff --git a/HKMP/Networking/Server/ServerUpdateManager.cs b/HKMP/Networking/Server/ServerUpdateManager.cs
index 6e2a6bf0..9e758453 100644
--- a/HKMP/Networking/Server/ServerUpdateManager.cs
+++ b/HKMP/Networking/Server/ServerUpdateManager.cs
@@ -8,6 +8,7 @@
 using Hkmp.Math;
 using Hkmp.Networking.Packet;
 using Hkmp.Networking.Packet.Data;
+using Org.BouncyCastle.Tls;
 
 namespace Hkmp.Networking.Server;
 
@@ -25,15 +26,10 @@ internal class ServerUpdateManager : UdpUpdateManager<ClientUpdatePacket, Client
     /// </summary>
     /// <param name="udpSocket">The underlying UDP socket for this client.</param>
     /// <param name="endPoint">The endpoint of the client.</param>
-    public ServerUpdateManager(Socket udpSocket, IPEndPoint endPoint) : base(udpSocket) {
+    public ServerUpdateManager(DtlsTransport dtlsTransport, IPEndPoint endPoint) : base(dtlsTransport) {
         _endPoint = endPoint;
     }
 
-    /// <inheritdoc />
-    protected override void SendPacket(Packet.Packet packet) {
-        UdpSocket.SendToAsync(new ArraySegment<byte>(packet.ToArray()), SocketFlags.None, _endPoint);
-    }
-
     /// <inheritdoc />
     public override void ResendReliableData(ClientUpdatePacket lostPacket) {
         lock (Lock) {
diff --git a/HKMP/Networking/UdpUpdateManager.cs b/HKMP/Networking/UdpUpdateManager.cs
index 810954c6..7f891d43 100644
--- a/HKMP/Networking/UdpUpdateManager.cs
+++ b/HKMP/Networking/UdpUpdateManager.cs
@@ -4,6 +4,7 @@
 using Hkmp.Logging;
 using Hkmp.Networking.Packet;
 using Hkmp.Networking.Packet.Data;
+using Org.BouncyCastle.Tls;
 
 namespace Hkmp.Networking;
 
@@ -43,7 +44,7 @@ internal abstract class UdpUpdateManager<TOutgoing, TPacketId> : UdpUpdateManage
     /// <summary>
     /// The Socket instance to use to send packets.
     /// </summary>
-    protected readonly Socket UdpSocket;
+    protected readonly DtlsTransport DtlsTransport;
 
     /// <summary>
     /// The UDP congestion manager instance.
@@ -109,8 +110,8 @@ internal abstract class UdpUpdateManager<TOutgoing, TPacketId> : UdpUpdateManage
     /// Construct the update manager with a UDP socket.
     /// </summary>
     /// <param name="udpSocket">The UDP socket instance.</param>
-    protected UdpUpdateManager(Socket udpSocket) {
-        UdpSocket = udpSocket;
+    protected UdpUpdateManager(DtlsTransport dtlsTransport) {
+        DtlsTransport = dtlsTransport;
 
         _udpCongestionManager = new UdpCongestionManager<TOutgoing, TPacketId>(this);
 
@@ -202,7 +203,7 @@ public void OnReceivePacket<TIncoming, TOtherPacketId>(TIncoming packet)
     /// Create and send the current update packet.
     /// </summary>
     private void CreateAndSendUpdatePacket() {
-        if (UdpSocket == null) {
+        if (DtlsTransport == null) {
             return;
         }
 
@@ -292,7 +293,11 @@ private bool IsSequenceGreaterThan(ushort sequence1, ushort sequence2) {
     /// Send the given packet over the corresponding medium.
     /// </summary>
     /// <param name="packet">The raw packet instance.</param>
-    protected abstract void SendPacket(Packet.Packet packet);
+    private void SendPacket(Packet.Packet packet) {
+        var buffer = packet.ToArray();
+        
+        DtlsTransport?.Send(buffer, 0, buffer.Length);
+    }
 
     /// <summary>
     /// Either get or create an AddonPacketData instance for the given addon.

From 6271a26d102793c3a0548685082bcfb4ce51adba Mon Sep 17 00:00:00 2001
From: Extremelyd1 <10898310+Extremelyd1@users.noreply.github.com>
Date: Thu, 9 Jan 2025 23:03:05 +0100
Subject: [PATCH 2/9] Fix server-side to a single socket

---
 HKMP/Networking/Server/DtlsServer.cs          | 144 ++++++++++++------
 HKMP/Networking/Server/DtlsServerClient.cs    |   4 +
 .../Server/ServerDatagramTransport.cs         |  90 ++++++-----
 3 files changed, 151 insertions(+), 87 deletions(-)

diff --git a/HKMP/Networking/Server/DtlsServer.cs b/HKMP/Networking/Server/DtlsServer.cs
index 416d1dc3..b71c3289 100644
--- a/HKMP/Networking/Server/DtlsServer.cs
+++ b/HKMP/Networking/Server/DtlsServer.cs
@@ -14,20 +14,19 @@ internal class DtlsServer {
     private DtlsServerProtocol _serverProtocol;
     private ServerTlsServer _tlsServer;
 
-    private Socket _currentAcceptSocket;
+    private Socket _socket;
     private ServerDatagramTransport _currentDatagramTransport;
 
-    private CancellationTokenSource _acceptTaskTokenSource;
-    private CancellationTokenSource _clientUpdateTaskTokenSource;
+    private CancellationTokenSource _cancellationTokenSource;
 
-    private readonly List<DtlsServerClient> _acceptedDtlsClients;
+    private readonly Dictionary<IPEndPoint, DtlsServerClient> _dtlsClients;
 
     public event Action<DtlsServerClient, byte[], int> DataReceivedEvent;
 
     private int _port;
 
     public DtlsServer() {
-        _acceptedDtlsClients = new List<DtlsServerClient>();
+        _dtlsClients = new Dictionary<IPEndPoint, DtlsServerClient>();
     }
     
     public void Start(int port) {
@@ -36,37 +35,81 @@ public void Start(int port) {
         _serverProtocol = new DtlsServerProtocol();
         _tlsServer = new ServerTlsServer(new BcTlsCrypto());
 
-        _acceptTaskTokenSource = new CancellationTokenSource();
-        _clientUpdateTaskTokenSource = new CancellationTokenSource();
+        _cancellationTokenSource = new CancellationTokenSource();
+
+        _socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
+        _socket.Bind(new IPEndPoint(IPAddress.Any, _port));
         
-        var cancellationToken = _acceptTaskTokenSource.Token;
-        new Thread(() => AcceptLoop(cancellationToken)).Start();
+        new Thread(() => AcceptLoop(_cancellationTokenSource.Token)).Start();
+        new Thread(() => SocketReceiveLoop(_cancellationTokenSource.Token)).Start();
     }
 
     public void Stop() {
-        _acceptTaskTokenSource?.Cancel();
-        _acceptTaskTokenSource?.Dispose();
-        _acceptTaskTokenSource = null;
+        _cancellationTokenSource?.Cancel();
+        _cancellationTokenSource?.Dispose();
+        _cancellationTokenSource = null;
+    }
+
+    public void DisconnectClient(IPEndPoint endPoint) {
+        if (!_dtlsClients.TryGetValue(endPoint, out var dtlsServerClient)) {
+            Logger.Warn("Could not find DtlsServerClient to disconnect");
+            return;
+        }
+
+        dtlsServerClient.ReceiveLoopTokenSource?.Cancel();
+        dtlsServerClient.ReceiveLoopTokenSource?.Dispose();
         
-        _clientUpdateTaskTokenSource?.Cancel();
-        _clientUpdateTaskTokenSource?.Dispose();
-        _clientUpdateTaskTokenSource = null;
+        dtlsServerClient.DatagramTransport?.Close();
+        dtlsServerClient.DtlsTransport?.Close();
+    }
+
+    private void SocketReceiveLoop(CancellationToken cancellationToken) {
+        while (!cancellationToken.IsCancellationRequested) {
+            EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
+
+            Logger.Debug("Blocking on server socket receive");
+            var numReceived = 0;
+            var buffer = new byte[1400];
+
+            try {
+                numReceived = _socket.ReceiveFrom(
+                    buffer,
+                    SocketFlags.None,
+                    ref endPoint
+                );
+            } catch (SocketException e) {
+                Logger.Error($"UDP server socket exception:\n{e}");
+            }
+
+            var ipEndPoint = (IPEndPoint) endPoint;
+
+            ServerDatagramTransport serverDatagramTransport;
+            if (!_dtlsClients.TryGetValue(ipEndPoint, out var dtlsServerClient)) {
+                Logger.Debug("Received data on server socket from unknown IP");
+
+                serverDatagramTransport = _currentDatagramTransport;
+                // Set the IP endpoint of the datagram transport instance so it can send data to the correct IP
+                serverDatagramTransport.IPEndPoint = ipEndPoint;
+            } else {
+                serverDatagramTransport = dtlsServerClient.DatagramTransport;
+            }
+
+            try {
+                serverDatagramTransport.ReceivedDataCollection.Add(new ServerDatagramTransport.ReceivedData {
+                    Buffer = buffer,
+                    Length = numReceived
+                }, cancellationToken);
+            } catch (OperationCanceledException) {
+                break;
+            }
+        }
     }
 
     private void AcceptLoop(CancellationToken cancellationToken) {
         while (!cancellationToken.IsCancellationRequested) {
-            Logger.Debug("Creating new socket for accepting connection");
+            Logger.Debug("Creating new ServerDatagramTransport for handling new connection");
             
-            _currentAcceptSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
-            // _currentAcceptSocket.DualMode = true;
-            _currentAcceptSocket.Bind(new IPEndPoint(IPAddress.Any, _port));
-            // Logger.Debug("Setting socket to listening mode");
-            // _currentAcceptSocket.Listen(1);
-            // Logger.Debug("Accepting connections for socket");
-            // var socket = _currentAcceptSocket.Accept();
-            // Logger.Debug($"Connection accepted, remote endpoint: {socket.RemoteEndPoint}");
-
-            _currentDatagramTransport = new ServerDatagramTransport(_currentAcceptSocket);
+            _currentDatagramTransport = new ServerDatagramTransport(_socket);
 
             DtlsTransport dtlsTransport;
             try {
@@ -76,42 +119,53 @@ private void AcceptLoop(CancellationToken cancellationToken) {
                 break;
             }
 
-            Logger.Debug($"Accepted DTLS connection on socket, endpoint: {_currentAcceptSocket.RemoteEndPoint}");
+            var endPoint = _currentDatagramTransport.IPEndPoint;
 
+            Logger.Debug($"Accepted DTLS connection on socket, endpoint: {endPoint}");
+
+            if (_dtlsClients.ContainsKey(endPoint)) {
+                Logger.Error($"DtlsClient with endpoint ({endPoint}) already exists, cannot add");
+                continue;
+            }
+            
             var dtlsServerClient = new DtlsServerClient {
                 DtlsTransport = dtlsTransport,
-                EndPoint = _currentAcceptSocket.RemoteEndPoint as IPEndPoint
+                DatagramTransport = _currentDatagramTransport,
+                EndPoint = endPoint,
+                ReceiveLoopTokenSource = new CancellationTokenSource()
             };
-
-            _acceptedDtlsClients.Add(dtlsServerClient);
-
-            var clientCancellationToken = _clientUpdateTaskTokenSource.Token;
-            new Thread(() => ReceiveClientLoop(dtlsServerClient, clientCancellationToken)).Start();
+            
+            _dtlsClients.Add(endPoint, dtlsServerClient);
+            
+            Logger.Debug("Starting receive loop for client");
+            new Thread(() => ClientReceiveLoop(
+                dtlsServerClient.ReceiveLoopTokenSource.Token, 
+                dtlsServerClient)
+            ).Start();
         }
 
-        _currentAcceptSocket?.Close();
-        _currentAcceptSocket = null;
-        
         _currentDatagramTransport?.Close();
         _currentDatagramTransport = null;
 
         _serverProtocol = null;
 
-        foreach (var dtlsServerClient in _acceptedDtlsClients) {
+        foreach (var dtlsServerClient in _dtlsClients.Values) {
             dtlsServerClient.DtlsTransport?.Close();
+            dtlsServerClient.DatagramTransport?.Close();
         }
         
-        _acceptedDtlsClients.Clear();
+        _dtlsClients.Clear();
     }
 
-    private void ReceiveClientLoop(DtlsServerClient dtlsServerClient, CancellationToken cancellationToken) {
+    private void ClientReceiveLoop(CancellationToken cancellationToken, DtlsServerClient dtlsServerClient) {
+        var dtlsTransport = dtlsServerClient.DtlsTransport;
+        
         while (!cancellationToken.IsCancellationRequested) {
-            // TODO: change to const defined somewhere central
-            var buffer = new byte[1400];
-            var length = dtlsServerClient.DtlsTransport.Receive(buffer, 0, buffer.Length, 5);
-            if (length >= 0) {
-                DataReceivedEvent?.Invoke(dtlsServerClient, buffer, length);
-            }
+            var buffer = new byte[dtlsTransport.GetReceiveLimit()];
+
+            var numReceived = dtlsTransport.Receive(buffer, 0, dtlsTransport.GetReceiveLimit(), 5);
+            
+            DataReceivedEvent?.Invoke(dtlsServerClient, buffer, numReceived);
         }
     }
 }
diff --git a/HKMP/Networking/Server/DtlsServerClient.cs b/HKMP/Networking/Server/DtlsServerClient.cs
index b0844299..09759bdd 100644
--- a/HKMP/Networking/Server/DtlsServerClient.cs
+++ b/HKMP/Networking/Server/DtlsServerClient.cs
@@ -1,9 +1,13 @@
 using System.Net;
+using System.Threading;
 using Org.BouncyCastle.Tls;
 
 namespace Hkmp.Networking.Server;
 
 internal class DtlsServerClient {
     public DtlsTransport DtlsTransport { get; init; }
+    public ServerDatagramTransport DatagramTransport { get; init; }
     public IPEndPoint EndPoint { get; init; }
+    
+    public CancellationTokenSource ReceiveLoopTokenSource { get; init; }
 }
diff --git a/HKMP/Networking/Server/ServerDatagramTransport.cs b/HKMP/Networking/Server/ServerDatagramTransport.cs
index d17ec8f2..319175a5 100644
--- a/HKMP/Networking/Server/ServerDatagramTransport.cs
+++ b/HKMP/Networking/Server/ServerDatagramTransport.cs
@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using System.Net;
 using System.Net.Sockets;
 using Hkmp.Logging;
@@ -8,10 +9,14 @@ namespace Hkmp.Networking.Server;
 internal class ServerDatagramTransport : DatagramTransport {
     private readonly Socket _socket;
 
-    private bool _hasReceived;
+    public IPEndPoint IPEndPoint { get; set; }
+    
+    public BlockingCollection<ReceivedData> ReceivedDataCollection { get; }
 
     public ServerDatagramTransport(Socket socket) {
         _socket = socket;
+
+        ReceivedDataCollection = new BlockingCollection<ReceivedData>();
     }
     
     public int GetReceiveLimit() {
@@ -25,60 +30,61 @@ public int GetSendLimit() {
     }
 
     public int Receive(byte[] buf, int off, int len, int waitMillis) {
-        if (!_hasReceived) {
-            EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
-            
-            try {
-                Logger.Debug("Blocking on first receive");
-            
-                // _socket.ReceiveTimeout = waitMillis;
-                var numReceived = _socket.ReceiveFrom(
-                    buf,
-                    off,
-                    len,
-                    SocketFlags.None,
-                    ref endPoint
-                );
-            
-                _socket.Connect(endPoint);
-                _hasReceived = true;
-                
-                Logger.Debug($"First receive finished ({numReceived}), connecting socket to endpoint: {endPoint}");
-                return numReceived;
-            } catch (SocketException e) {
-                Logger.Error($"UDP Socket exception:\n{e}");
+        if (!ReceivedDataCollection.TryTake(out var data, waitMillis)) {
+            return -1;
+        }
+
+        // If there is more data in the entry we received from the blocking collection than space in the buffer
+        // from the method, we need to add as much data into the buffer and put the rest back in the collection
+        if (len < data.Length) {
+            // Fill the buffer from the method with as much data from the entry as possible
+            for (var i = off; i < off + len; i++) {
+                buf[i] = data.Buffer[i - off];
             }
-        } else {
-            try {
-                Logger.Debug("Non-first blocking receive called");
-                // _socket.ReceiveTimeout = waitMillis;
-                var numReceived = _socket.Receive(
-                    buf,
-                    off,
-                    len,
-                    SocketFlags.None
-                );
-                Logger.Debug($"End of non-first blocking receive: {numReceived}");
-                return numReceived;
-            } catch (SocketException e) {
-                Logger.Error($"UDP Socket exception:\n{e}");
+
+            // Calculate the length of the leftover buffer and instantiate it
+            var leftoverLength = data.Length - len;
+            var leftoverBuffer = new byte[leftoverLength];
+
+            // Fill the leftover buffer with the leftover data from the entry
+            for (var i = 0; i < leftoverLength; i++) {
+                leftoverBuffer[i] = data.Buffer[len + i];
             }
+
+            // Add the leftover buffer and its length back to the collection
+            ReceivedDataCollection.Add(new ReceivedData {
+                Buffer = leftoverBuffer,
+                Length = leftoverLength
+            });
+
+            return len;
+        }
+
+        // In this case, the space in the buffer from the method is large enough, so we fill it with all the data
+        // from the collection entry
+        for (var i = 0; i < data.Length; i++) {
+            buf[off + i] = data.Buffer[i];
         }
 
-        return -1;
+        return data.Length;
     }
 
     public void Send(byte[] buf, int off, int len) {
-        if (!_hasReceived) {
-            Logger.Error("Cannot send because socket has not received yet");
+        if (IPEndPoint == null) {
+            Logger.Error("Cannot send because transport has no endpoint");
             return;
         }
         
-        Logger.Debug($"Server sending {len} bytes of data");
+        Logger.Debug($"Server sending {len} bytes of data to: {IPEndPoint}");
         
-        _socket.Send(buf, off, len, SocketFlags.None);
+        _socket.SendTo(buf, off, len, SocketFlags.None, IPEndPoint);
     }
 
     public void Close() {
     }
+
+    public class ReceivedData {
+        public byte[] Buffer { get; set; }
+        public int Length { get; set; }
+    }
 }

From f3cf34970b5d4645cd02229b4e74e8fa361f4d9b Mon Sep 17 00:00:00 2001
From: Extremelyd1 <10898310+Extremelyd1@users.noreply.github.com>
Date: Fri, 10 Jan 2025 14:46:26 +0100
Subject: [PATCH 3/9] Split packet sending for client update manager to
 different thread

---
 HKMP/Networking/Client/NetClient.cs  | 20 ++++++++++++++++----
 HKMP/Networking/Server/DtlsServer.cs | 14 ++++++++++++--
 2 files changed, 28 insertions(+), 6 deletions(-)

diff --git a/HKMP/Networking/Client/NetClient.cs b/HKMP/Networking/Client/NetClient.cs
index c62ff2f1..6bb79075 100644
--- a/HKMP/Networking/Client/NetClient.cs
+++ b/HKMP/Networking/Client/NetClient.cs
@@ -81,6 +81,7 @@ internal class NetClient : INetClient {
     public NetClient(PacketManager packetManager) {
         _packetManager = packetManager;
 
+        _updateTaskTokenSource = new CancellationTokenSource();
         _dtlsClient = new DtlsClient();
 
         _dtlsClient.DataReceivedEvent += OnReceiveData;
@@ -135,9 +136,6 @@ private void OnConnectFailed(ConnectFailedResult result) {
     /// </summary>
     /// <param name="packets">A list of raw received packets.</param>
     private void OnReceiveData(byte[] buffer, int length) {
-        // TODO: check if this is the correct place to make this call
-        UpdateManager.ProcessUpdate();
-        
         var packets = PacketManager.HandleReceivedData(buffer, length, ref _leftoverData);
         
         foreach (var packet in packets) {
@@ -238,6 +236,20 @@ List<AddonData> addonData
         UpdateManager = new ClientUpdateManager(_dtlsClient.DtlsTransport);
         // During the connection process we register the connection failed callback if we time out
         UpdateManager.OnTimeout += OnConnectTimedOut;
+        
+        new Thread(() => {
+            var cancellationToken = _updateTaskTokenSource.Token;
+
+            while (!cancellationToken.IsCancellationRequested) {
+                UpdateManager.ProcessUpdate();
+
+                // TODO: figure out a good way to get rid of the sleep here
+                // some way to signal when clients should be updated again would suffice
+                // also see NetServer#StartClientUpdates
+                Thread.Sleep(5);
+            }
+        }).Start();
+        
         UpdateManager.StartUpdates();
 
         UpdateManager.SetLoginRequestData(username, authKey, addonData);
@@ -255,7 +267,7 @@ public void Disconnect() {
         IsConnected = false;
 
         // Request cancellation for the update task
-        _updateTaskTokenSource.Cancel();
+        _updateTaskTokenSource?.Cancel();
 
         // Clear all client addon packet handlers, because their IDs become invalid
         _packetManager.ClearClientAddonPacketHandlers();
diff --git a/HKMP/Networking/Server/DtlsServer.cs b/HKMP/Networking/Server/DtlsServer.cs
index b71c3289..84b37bc4 100644
--- a/HKMP/Networking/Server/DtlsServer.cs
+++ b/HKMP/Networking/Server/DtlsServer.cs
@@ -85,12 +85,13 @@ ref endPoint
 
             ServerDatagramTransport serverDatagramTransport;
             if (!_dtlsClients.TryGetValue(ipEndPoint, out var dtlsServerClient)) {
-                Logger.Debug("Received data on server socket from unknown IP");
+                Logger.Debug($"Received data on server socket from unknown IP ({ipEndPoint}), length: {numReceived}");
 
                 serverDatagramTransport = _currentDatagramTransport;
                 // Set the IP endpoint of the datagram transport instance so it can send data to the correct IP
                 serverDatagramTransport.IPEndPoint = ipEndPoint;
             } else {
+                Logger.Debug($"Received data on server socket from existing client ({ipEndPoint}), length: {numReceived}");
                 serverDatagramTransport = dtlsServerClient.DatagramTransport;
             }
 
@@ -164,8 +165,17 @@ private void ClientReceiveLoop(CancellationToken cancellationToken, DtlsServerCl
             var buffer = new byte[dtlsTransport.GetReceiveLimit()];
 
             var numReceived = dtlsTransport.Receive(buffer, 0, dtlsTransport.GetReceiveLimit(), 5);
+            if (numReceived <= 0) {
+                continue;
+            }
             
-            DataReceivedEvent?.Invoke(dtlsServerClient, buffer, numReceived);
+            Logger.Debug($"DtlsServerClient ({dtlsServerClient.EndPoint}) received {numReceived} bytes of data, invoking event");
+
+            try {
+                DataReceivedEvent?.Invoke(dtlsServerClient, buffer, numReceived);
+            } catch (Exception e) {
+                Logger.Error($"Error occurred while invoking DataReceivedEvent:\n{e}");
+            }
         }
     }
 }

From 2dda47c5556a5864a162a5f3eb01d635d9a78bf3 Mon Sep 17 00:00:00 2001
From: Extremelyd1 <10898310+Extremelyd1@users.noreply.github.com>
Date: Sat, 18 Jan 2025 20:06:28 +0100
Subject: [PATCH 4/9] Document the newly added classes, fix various issues

---
 .../Client/ClientDatagramTransport.cs         |  52 +++++++--
 HKMP/Networking/Client/ClientTlsClient.cs     |  77 +++++++++++-
 HKMP/Networking/Client/ClientUpdateManager.cs |   7 +-
 HKMP/Networking/Client/DtlsClient.cs          |  60 +++++++---
 HKMP/Networking/Client/NetClient.cs           |  23 ++--
 HKMP/Networking/Client/UdpNetClient.cs        | 110 ------------------
 HKMP/Networking/Server/DtlsServer.cs          | 101 ++++++++++++++--
 HKMP/Networking/Server/DtlsServerClient.cs    |  17 ++-
 HKMP/Networking/Server/NetServer.cs           |  27 ++---
 HKMP/Networking/Server/NetServerClient.cs     |  17 +--
 .../Server/ServerDatagramTransport.cs         |  67 +++++++++--
 HKMP/Networking/Server/ServerTlsServer.cs     |  58 +++++++--
 HKMP/Networking/Server/ServerUpdateManager.cs |  13 +--
 HKMP/Networking/UdpUpdateManager.cs           |  14 +--
 14 files changed, 416 insertions(+), 227 deletions(-)
 delete mode 100644 HKMP/Networking/Client/UdpNetClient.cs

diff --git a/HKMP/Networking/Client/ClientDatagramTransport.cs b/HKMP/Networking/Client/ClientDatagramTransport.cs
index 7f6697bc..5795c378 100644
--- a/HKMP/Networking/Client/ClientDatagramTransport.cs
+++ b/HKMP/Networking/Client/ClientDatagramTransport.cs
@@ -4,33 +4,56 @@
 
 namespace Hkmp.Networking.Client;
 
+/// <summary>
+/// Class that implements the DatagramTransport interface from DTLS. This class simply sends and receives data using
+/// a UDP socket directly.
+/// </summary>
 internal class ClientDatagramTransport : DatagramTransport {
+    /// <summary>
+    /// The socket with which to send and over which to receive data.
+    /// </summary>
     private readonly Socket _socket;
     
     public ClientDatagramTransport(Socket socket) {
         _socket = socket;
     }
-    
+
+    /// <summary>
+    /// The maximum number of bytes to receive in a single call to <see cref="Receive"/>.
+    /// </summary>
+    /// <returns>The maximum number of bytes that can be received.</returns>
     public int GetReceiveLimit() {
-        // TODO: change to const defined somewhere
-        return 1400;
+        return DtlsClient.MaxPacketSize;
     }
-    
+
+    /// <summary>
+    /// The maximum number of bytes to send in a single call to <see cref="Send"/>.
+    /// </summary>
+    /// <returns>The maximum number of bytes that can be sent.</returns>
     public int GetSendLimit() {
-        // TODO: change to const defined somewhere
-        return 1400;
+        return DtlsClient.MaxPacketSize;
     }
 
+    /// <summary>
+    /// This method is called whenever the corresponding DtlsTransport's Receive is called. The implementation
+    /// receives data from the network and store it in the given buffer. If no data is received within the given
+    /// <paramref name="waitMillis"/>, the method returns -1.
+    /// </summary>
+    /// <param name="buf">Byte array to store the received data.</param>
+    /// <param name="off">The offset at which to begin storing the bytes.</param>
+    /// <param name="len">The number of bytes that can be stored in the buffer.</param>
+    /// <param name="waitMillis">The number of milliseconds to wait for data to receive.</param>
+    /// <returns>The number of bytes that were received, or -1 if no bytes were received in the given time.</returns>
     public int Receive(byte[] buf, int off, int len, int waitMillis) {
+        // TODO: timeout after waitMillis
         try {
-            // _socket.ReceiveTimeout = waitMillis;
             var numReceived = _socket.Receive(
                 buf,
                 off,
                 len,
                 SocketFlags.None
             );
-            Logger.Debug($"Client socket receive: {numReceived}");
+            // Logger.Debug($"Client socket receive: {numReceived}");
             return numReceived;
         } catch (SocketException e) {
             Logger.Error($"UDP Socket exception:\n{e}");
@@ -39,11 +62,22 @@ public int Receive(byte[] buf, int off, int len, int waitMillis) {
         return -1;
     }
 
+    /// <summary>
+    /// This method is called whenever the corresponding DtlsTransport's Send is called. The implementation simply
+    /// sends the data in the buffer over the network.
+    /// </summary>
+    /// <param name="buf">Byte array containing the bytes to send.</param>
+    /// <param name="off">The offset in the buffer at which to start sending bytes.</param>
+    /// <param name="len">The number of bytes to send.</param>
     public void Send(byte[] buf, int off, int len) {
-        Logger.Debug($"Client sending {len} bytes of data");
+        // Logger.Debug($"Client sending {len} bytes of data");
         _socket.Send(buf, off, len, SocketFlags.None);
     }
 
+    /// <summary>
+    /// Cleanup login for when this transport channel should be closed.
+    /// Since we handle socket closing in another class (<seealso cref="DtlsClient"/>), there is nothing here.
+    /// </summary>
     public void Close() {
     }
 }
diff --git a/HKMP/Networking/Client/ClientTlsClient.cs b/HKMP/Networking/Client/ClientTlsClient.cs
index edcb2af8..649f52b9 100644
--- a/HKMP/Networking/Client/ClientTlsClient.cs
+++ b/HKMP/Networking/Client/ClientTlsClient.cs
@@ -1,9 +1,22 @@
+using System.Text;
+using Hkmp.Logging;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Security;
 using Org.BouncyCastle.Tls;
 using Org.BouncyCastle.Tls.Crypto;
+using Org.BouncyCastle.Utilities.Encoders;
 
 namespace Hkmp.Networking.Client;
 
+/// <summary>
+/// Client-side TLS client implementation that handles reporting supported cipher suites, provides client
+/// authentication and checks server certificate.
+/// </summary>
+/// <param name="crypto">TlsCrypto instance for handling low-level cryptography.</param>
 internal class ClientTlsClient(TlsCrypto crypto) : AbstractTlsClient(crypto) {
+    /// <summary>
+    /// List of supported cipher suites on the client-side.
+    /// </summary>
     private static readonly int[] SupportedCipherSuites = [
         CipherSuite.TLS_AES_128_GCM_SHA256,
         CipherSuite.TLS_AES_256_GCM_SHA384,
@@ -11,27 +24,87 @@ internal class ClientTlsClient(TlsCrypto crypto) : AbstractTlsClient(crypto) {
         CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
         CipherSuite.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
     ];
-    
+
+    /// <inheritdoc />
     protected override ProtocolVersion[] GetSupportedVersions() {
         return ProtocolVersion.DTLSv12.Only();
     }
 
+    /// <summary>
+    /// Get the supported cipher suites for this TLS client.
+    /// </summary>
+    /// <returns>An int array representing the cipher suites.</returns>
     protected override int[] GetSupportedCipherSuites() {
         return SupportedCipherSuites;
     }
 
+    /// <inheritdoc />
+    /// <summary>
+    /// Get the authentication implementation for this TLS client that handles providing client credentials and
+    /// checking server certificates.
+    /// </summary>
+    /// <returns>The TlsAuthentication instance for this TLS client.</returns>
     public override TlsAuthentication GetAuthentication() {
         return new TlsAuthenticationImpl();
     }
 
+    /// <summary>
+    /// Implementation for TLS authentication that handles providing client credentials and checking server
+    /// certificates.
+    /// </summary>
     private class TlsAuthenticationImpl : TlsAuthentication {
+        /// <summary>
+        /// Notify the TLS client of the server certificate that the server has sent. This method checks whether to
+        /// trust the server based on this certificate or not. If not, the method will throw an exception which will
+        /// subsequently abort the connection.
+        /// In the current implementation, we only log the fingerprints of the certificates in the chain from the
+        /// server.
+        /// </summary>
+        /// <inheritdoc />
+        /// <param name="serverCertificate">The server certificate instance.</param>
         public void NotifyServerCertificate(TlsServerCertificate serverCertificate) {
-            // TODO: check server certificate, throw error in case of invalid cert
+            if (serverCertificate?.Certificate == null || serverCertificate.Certificate.IsEmpty) {
+                throw new TlsFatalAlert(AlertDescription.bad_certificate);
+            }
+            
+            var chain = serverCertificate.Certificate.GetCertificateList();
+
+            Logger.Info("Server certificate fingerprint(s):");
+            for (var i = 0; i < chain.Length; i++) {
+                var entry = X509CertificateStructure.GetInstance(chain[i].GetEncoded());
+                Logger.Info($"  fingerprint:SHA256 {Fingerprint(entry)} ({entry.Subject})");
+            }
         }
 
+        /// <summary>
+        /// Get the credentials of the client so the server can verify who we are. Currently, we have no way to
+        /// provide client-side credentials, so we return null.
+        /// </summary>
+        /// <inheritdoc />
         public TlsCredentials GetClientCredentials(CertificateRequest certificateRequest) {
             // TODO: provide means for a client to have certificate and return it in this method
             return null;
         }
+
+        /// <summary>
+        /// Return a fingerprint for the given X509 certificate.
+        /// </summary>
+        /// <param name="c">The 509 certificate to fingerprint.</param>
+        /// <returns>The fingerprint as a string.</returns>
+        private static string Fingerprint(X509CertificateStructure c) {
+            var der = c.GetEncoded();
+            var hash = DigestUtilities.CalculateDigest("SHA256", der);
+            var hexBytes = Hex.Encode(hash);
+            var hex = Encoding.ASCII.GetString(hexBytes).ToUpperInvariant();
+
+            var fp = new StringBuilder();
+            var i = 0;
+            fp.Append(hex.Substring(i, 2));
+            while ((i += 2) < hex.Length) {
+                fp.Append(':');
+                fp.Append(hex.Substring(i, 2));
+            }
+            return fp.ToString();
+        }
     }
 }
diff --git a/HKMP/Networking/Client/ClientUpdateManager.cs b/HKMP/Networking/Client/ClientUpdateManager.cs
index 262ff6ab..715ba55e 100644
--- a/HKMP/Networking/Client/ClientUpdateManager.cs
+++ b/HKMP/Networking/Client/ClientUpdateManager.cs
@@ -1,8 +1,5 @@
-using System;
 using System.Collections.Generic;
-using System.Net.Sockets;
 using Hkmp.Animation;
-using Hkmp.Game;
 using Hkmp.Game.Client.Entity;
 using Hkmp.Math;
 using Hkmp.Networking.Packet;
@@ -16,9 +13,9 @@ namespace Hkmp.Networking.Client;
 /// </summary>
 internal class ClientUpdateManager : UdpUpdateManager<ServerUpdatePacket, ServerPacketId> {
     /// <summary>
-    /// Construct the update manager with a UDP net client.
+    /// Construct the update manager a DTLS transport instance.
     /// </summary>
-    /// <param name="udpSocket">The UDP socket for the local client.</param>
+    /// <param name="dtlsTransport">The DTLS transport instance for sending data.</param>
     public ClientUpdateManager(DtlsTransport dtlsTransport) : base(dtlsTransport) {
     }
 
diff --git a/HKMP/Networking/Client/DtlsClient.cs b/HKMP/Networking/Client/DtlsClient.cs
index 05598c0f..30f256e4 100644
--- a/HKMP/Networking/Client/DtlsClient.cs
+++ b/HKMP/Networking/Client/DtlsClient.cs
@@ -8,16 +8,50 @@
 
 namespace Hkmp.Networking.Client;
 
+/// <summary>
+/// DTLS implementation for a client-side peer for networking.
+/// </summary>
 internal class DtlsClient {
+    /// <summary>
+    /// The maximum packet size for sending and receiving DTLS packets.
+    /// </summary>
+    public const int MaxPacketSize = 1400;
+
+    /// <summary>
+    /// The socket instance for the underlying networking.
+    /// </summary>
     private Socket _socket;
+    /// <summary>
+    /// The TLS client for communicating supported cipher suites and handling certificates.
+    /// </summary>
     private ClientTlsClient _tlsClient;
+    /// <summary>
+    /// The client datagram transport that provides networking to the DTLS client.
+    /// </summary>
     private ClientDatagramTransport _clientDatagramTransport;
 
+    /// <summary>
+    /// Token source for cancellation tokens for the update task.
+    /// </summary>
     private CancellationTokenSource _updateTaskTokenSource;
 
-    public DtlsTransport DtlsTransport { get; set; }
-    public event Action<byte[], int> DataReceivedEvent;
+    /// <summary>
+    /// DTLS transport instance from establishing a connection to a server.
+    /// </summary>
+    public DtlsTransport DtlsTransport { get; private set; }
     
+    /// <summary>
+    /// Event that is called when data is received from the server. 
+    /// </summary>
+    public event Action<byte[], int> DataReceivedEvent;
+
+    /// <summary>
+    /// Try to establish a connection to a server with the given address and port.
+    /// </summary>
+    /// <param name="address">The address of the server.</param>
+    /// <param name="port">The port of the server.</param>
+    /// <exception cref="SocketException">Thrown when the underlying socket fails to connect to the server.</exception>
+    /// <exception cref="IOException">Thrown when the DTLS protocol fails to connect to the server.</exception>
     public void Connect(string address, int port) {
         if (_socket != null || 
             _tlsClient != null ||
@@ -29,7 +63,6 @@ public void Connect(string address, int port) {
         }
         
         _socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
-        // _socket.DualMode = true;
 
         try {
             _socket.Connect(address, port);
@@ -62,6 +95,9 @@ public void Connect(string address, int port) {
         new Thread(() => ReceiveLoop(cancellationToken)).Start();
     }
 
+    /// <summary>
+    /// Disconnect the DTLS client from the server.
+    /// </summary>
     public void Disconnect() {
         _updateTaskTokenSource?.Cancel();
         _updateTaskTokenSource?.Dispose();
@@ -80,21 +116,13 @@ public void Disconnect() {
         _socket = null;
     }
 
-    public void SendPacket(Packet.Packet packet) {
-        if (DtlsTransport == null) {
-            Logger.Error("DTLS transport instance is null, cannot send packet");
-            return;
-        }
-        
-        var buffer = packet.ToArray();
-
-        DtlsTransport.Send(buffer, 0, buffer.Length);
-    }
-
+    /// <summary>
+    /// Continuously tries to receive data from the DTLS transport until cancellation is requested.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token to cancel the loop.</param>
     private void ReceiveLoop(CancellationToken cancellationToken) {
         while (!cancellationToken.IsCancellationRequested && DtlsTransport != null) {
-            // TODO: change to const define somewhere central
-            var buffer = new byte[1400];
+            var buffer = new byte[MaxPacketSize];
             var length = DtlsTransport.Receive(buffer, 0, buffer.Length, 5);
             if (length >= 0) {
                 DataReceivedEvent?.Invoke(buffer, length);
diff --git a/HKMP/Networking/Client/NetClient.cs b/HKMP/Networking/Client/NetClient.cs
index 6bb79075..8c2d7100 100644
--- a/HKMP/Networking/Client/NetClient.cs
+++ b/HKMP/Networking/Client/NetClient.cs
@@ -12,11 +12,6 @@
 
 namespace Hkmp.Networking.Client;
 
-/// <summary>
-/// Delegate for receiving a list of packets.
-/// </summary>
-internal delegate void OnReceive(List<Packet.Packet> receivedPackets);
-
 /// <summary>
 /// The networking client that manages the UDP client for sending and receiving data. This only
 /// manages client side networking, e.g. sending to and receiving from the server.
@@ -63,11 +58,14 @@ internal class NetClient : INetClient {
     public bool IsConnecting { get; private set; }
 
     /// <summary>
-    /// Cancellation token source for the task for the update manager.
+    /// Cancellation token source for the update task.
     /// </summary>
-    private CancellationTokenSource _updateTaskTokenSource;
+    private readonly CancellationTokenSource _updateTaskTokenSource;
 
-    private DtlsClient _dtlsClient;
+    /// <summary>
+    /// The DTLS client instance for handling DTLS connections.
+    /// </summary>
+    private readonly DtlsClient _dtlsClient;
     
     /// <summary>
     /// Byte array containing received data that was not included in a packet object yet.
@@ -94,7 +92,7 @@ public NetClient(PacketManager packetManager) {
     private void OnConnect(LoginResponse loginResponse) {
         Logger.Debug("Connection to server success");
 
-        // De-register the connect failed and register the actual timeout handler if we time out
+        // De-register the "connect failed" and register the actual timeout handler if we time out
         UpdateManager.OnTimeout -= OnConnectTimedOut;
         UpdateManager.OnTimeout += () => { ThreadUtil.RunActionOnMainThread(() => { TimeoutEvent?.Invoke(); }); };
 
@@ -132,9 +130,12 @@ private void OnConnectFailed(ConnectFailedResult result) {
     }
 
     /// <summary>
-    /// Callback method for when the net client receives data.
+    /// Callback method for when the DTLS client receives data. This will update the update manager that we have
+    /// received data, handle packet creation from raw data, handle login responses, and forward received packets to
+    /// the packet manager.
     /// </summary>
-    /// <param name="packets">A list of raw received packets.</param>
+    /// <param name="buffer">Byte array containing the received bytes.</param>
+    /// <param name="length">The number of bytes in the <paramref name="buffer"/>.</param>
     private void OnReceiveData(byte[] buffer, int length) {
         var packets = PacketManager.HandleReceivedData(buffer, length, ref _leftoverData);
         
diff --git a/HKMP/Networking/Client/UdpNetClient.cs b/HKMP/Networking/Client/UdpNetClient.cs
deleted file mode 100644
index e7720c51..00000000
--- a/HKMP/Networking/Client/UdpNetClient.cs
+++ /dev/null
@@ -1,110 +0,0 @@
-using System.Net;
-using System.Net.Sockets;
-using System.Threading;
-using Hkmp.Logging;
-using Hkmp.Networking.Packet;
-using Org.BouncyCastle.Tls;
-
-namespace Hkmp.Networking.Client;
-
-/// <summary>
-/// NetClient that uses the UDP protocol.
-/// </summary>
-internal class UdpNetClient : DatagramTransport {
-    /// <summary>
-    /// Maximum size of a UDP packet in bytes.
-    /// </summary>
-    private const int MaxUdpPacketSize = 65527;
-
-    /// <summary>
-    /// The underlying UDP socket.
-    /// </summary>
-    public Socket UdpSocket;
-
-    /// <summary>
-    /// Delegate called when packets are received.
-    /// </summary>
-    private OnReceive _onReceive;
-
-    /// <summary>
-    /// Byte array containing received data that was not included in a packet object yet.
-    /// </summary>
-    private byte[] _leftoverData;
-
-    /// <summary>
-    /// Cancellation token source for the thread of receiving network data.
-    /// </summary>
-    private CancellationTokenSource _receiveTokenSource;
-
-    /// <summary>
-    /// Register a callback for when packets are received.
-    /// </summary>
-    /// <param name="onReceive">The delegate that handles the received packets.</param>
-    public void RegisterOnReceive(OnReceive onReceive) {
-        _onReceive = onReceive;
-    }
-
-    /// <summary>
-    /// Connects the UDP socket to the host at the given address and port.
-    /// </summary>
-    /// <param name="address">The address of the host.</param>
-    /// <param name="port">The port of the host.</param>
-    public void Connect(string address, int port) {
-        UdpSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
-        try {
-            UdpSocket.Connect(address, port);
-        } catch (SocketException e) {
-            Logger.Error($"Socket exception when connecting UDP socket:\n{e}");
-
-            UdpSocket.Close();
-            UdpSocket = null;
-
-            throw;
-        }
-    }
-
-    /// <summary>
-    /// Disconnect the UDP client and clean it up.
-    /// </summary>
-    public void Disconnect() {
-        // Request cancellation of the receive thread
-        _receiveTokenSource.Cancel();
-
-        UdpSocket?.Close();
-        UdpSocket = null;
-    }
-
-    public int GetReceiveLimit() {
-        return 1400;
-    }
-    
-    public int GetSendLimit() {
-        return 1400;
-    }
-
-    public int Receive(byte[] buf, int off, int len, int waitMillis) {
-        EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
-
-        try {
-            return UdpSocket.ReceiveFrom(
-                buf,
-                off,
-                len,
-                SocketFlags.None,
-                ref endPoint
-            );
-        } catch (SocketException e) {
-            Logger.Error($"UDP Socket exception:\n{e}");
-        }
-
-        return -1;
-    }
-
-    public void Send(byte[] buf, int off, int len) {
-        UdpSocket.Send(buf, off, len, SocketFlags.None);
-    }
-
-    public void Close() {
-        throw new System.NotImplementedException();
-    }
-}
diff --git a/HKMP/Networking/Server/DtlsServer.cs b/HKMP/Networking/Server/DtlsServer.cs
index 84b37bc4..f8e39d82 100644
--- a/HKMP/Networking/Server/DtlsServer.cs
+++ b/HKMP/Networking/Server/DtlsServer.cs
@@ -10,25 +10,64 @@
 
 namespace Hkmp.Networking.Server;
 
+/// <summary>
+/// DTLS implementation for a server-side peer for networking.
+/// </summary>
 internal class DtlsServer {
+    /// <summary>
+    /// The maximum packet size for sending and receiving DTLS packets.
+    /// </summary>
+    public const int MaxPacketSize = 1400;
+
+    /// <summary>
+    /// The DTLS server protocol instance from which to start establishing connections with clients.
+    /// </summary>
     private DtlsServerProtocol _serverProtocol;
+    /// <summary>
+    /// The TLS client for communicating supported cipher suites and handling certificates.
+    /// </summary>
     private ServerTlsServer _tlsServer;
 
+    /// <summary>
+    /// The socket instance for the underlying networking.
+    /// The server only uses a single socket for all connections given that with UDP, we cannot create more than one
+    /// on the same listening port.
+    /// </summary>
     private Socket _socket;
+    /// <summary>
+    /// The server datagram transport that provides networking to the DTLS server.
+    /// </summary>
     private ServerDatagramTransport _currentDatagramTransport;
 
+    /// <summary>
+    /// Token source for cancellation tokens for the accept and receive loop tasks.
+    /// </summary>
     private CancellationTokenSource _cancellationTokenSource;
 
+    /// <summary>
+    /// Dictionary mapping IP endpoints to DTLS server client instances. This keeps track of individual clients
+    /// connected to the server and their respective objects.
+    /// </summary>
     private readonly Dictionary<IPEndPoint, DtlsServerClient> _dtlsClients;
 
+    /// <summary>
+    /// Event that is called when data is received from the given DTLS server client.
+    /// </summary>
     public event Action<DtlsServerClient, byte[], int> DataReceivedEvent;
 
+    /// <summary>
+    /// The port that the server is started on.
+    /// </summary>
     private int _port;
 
     public DtlsServer() {
         _dtlsClients = new Dictionary<IPEndPoint, DtlsServerClient>();
     }
-    
+
+    /// <summary>
+    /// Start the DTLS server on the given port.
+    /// </summary>
+    /// <param name="port">The port to start listening on.</param>
     public void Start(int port) {
         _port = port;
         
@@ -44,30 +83,58 @@ public void Start(int port) {
         new Thread(() => SocketReceiveLoop(_cancellationTokenSource.Token)).Start();
     }
 
+    /// <summary>
+    /// Stop the DTLS server by disconnecting all clients and cancelling all running threads.
+    /// </summary>
     public void Stop() {
         _cancellationTokenSource?.Cancel();
         _cancellationTokenSource?.Dispose();
         _cancellationTokenSource = null;
+
+        foreach (var dtlsServerClient in _dtlsClients.Values) {
+            InternalDisconnectClient(dtlsServerClient);
+        }
+        
+        _dtlsClients.Clear();
     }
 
+    /// <summary>
+    /// Disconnect the client with the given IP endpoint from the server.
+    /// </summary>
+    /// <param name="endPoint">The IP endpoint of the client.</param>
     public void DisconnectClient(IPEndPoint endPoint) {
         if (!_dtlsClients.TryGetValue(endPoint, out var dtlsServerClient)) {
             Logger.Warn("Could not find DtlsServerClient to disconnect");
             return;
         }
 
+        _dtlsClients.Remove(endPoint);
+        
+        InternalDisconnectClient(dtlsServerClient);
+    }
+
+    /// <summary>
+    /// Disconnect the given DTLS server client from the server. This will request cancellation of the "receive loop"
+    /// for the client and close/cleanup the underlying DTLS objects.
+    /// </summary>
+    /// <param name="dtlsServerClient"></param>
+    private void InternalDisconnectClient(DtlsServerClient dtlsServerClient) {
         dtlsServerClient.ReceiveLoopTokenSource?.Cancel();
         dtlsServerClient.ReceiveLoopTokenSource?.Dispose();
-        
+
         dtlsServerClient.DatagramTransport?.Close();
         dtlsServerClient.DtlsTransport?.Close();
     }
 
+    /// <summary>
+    /// Start a loop that will continuously receive data on the socket for existing and new clients.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token to cancel the loop.</param>
     private void SocketReceiveLoop(CancellationToken cancellationToken) {
         while (!cancellationToken.IsCancellationRequested) {
             EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
 
-            Logger.Debug("Blocking on server socket receive");
+            // Logger.Debug("Blocking on server socket receive");
             var numReceived = 0;
             var buffer = new byte[1400];
 
@@ -91,7 +158,7 @@ ref endPoint
                 // Set the IP endpoint of the datagram transport instance so it can send data to the correct IP
                 serverDatagramTransport.IPEndPoint = ipEndPoint;
             } else {
-                Logger.Debug($"Received data on server socket from existing client ({ipEndPoint}), length: {numReceived}");
+                // Logger.Debug($"Received data on server socket from existing client ({ipEndPoint}), length: {numReceived}");
                 serverDatagramTransport = dtlsServerClient.DatagramTransport;
             }
 
@@ -104,8 +171,15 @@ ref endPoint
                 break;
             }
         }
+        
+        _socket?.Close();
+        _socket = null;
     }
 
+    /// <summary>
+    /// Start a loop that will continuously accept new clients on the DTLS protocol for new incoming connections.
+    /// </summary>
+    /// <param name="cancellationToken">The cancellation token to cancel the loop.</param>
     private void AcceptLoop(CancellationToken cancellationToken) {
         while (!cancellationToken.IsCancellationRequested) {
             Logger.Debug("Creating new ServerDatagramTransport for handling new connection");
@@ -139,10 +213,10 @@ private void AcceptLoop(CancellationToken cancellationToken) {
             _dtlsClients.Add(endPoint, dtlsServerClient);
             
             Logger.Debug("Starting receive loop for client");
-            new Thread(() => ClientReceiveLoop(
-                dtlsServerClient.ReceiveLoopTokenSource.Token, 
-                dtlsServerClient)
-            ).Start();
+            new Thread(() => ClientReceiveLoop( 
+                dtlsServerClient,
+                dtlsServerClient.ReceiveLoopTokenSource.Token
+            )).Start();
         }
 
         _currentDatagramTransport?.Close();
@@ -158,7 +232,14 @@ private void AcceptLoop(CancellationToken cancellationToken) {
         _dtlsClients.Clear();
     }
 
-    private void ClientReceiveLoop(CancellationToken cancellationToken, DtlsServerClient dtlsServerClient) {
+    /// <summary>
+    /// Start a loop for the given DTLS server client that will continuously check whether new data is available
+    /// on the DTLS transport for that client. Will evoke the <seealso cref="DataReceivedEvent"/> in case data is
+    /// received for that client.
+    /// </summary>
+    /// <param name="dtlsServerClient">The DTLS server client to receive data for.</param>
+    /// <param name="cancellationToken">The cancellation token to cancel to loop.</param>
+    private void ClientReceiveLoop(DtlsServerClient dtlsServerClient, CancellationToken cancellationToken) {
         var dtlsTransport = dtlsServerClient.DtlsTransport;
         
         while (!cancellationToken.IsCancellationRequested) {
@@ -169,7 +250,7 @@ private void ClientReceiveLoop(CancellationToken cancellationToken, DtlsServerCl
                 continue;
             }
             
-            Logger.Debug($"DtlsServerClient ({dtlsServerClient.EndPoint}) received {numReceived} bytes of data, invoking event");
+            // Logger.Debug($"DtlsServerClient ({dtlsServerClient.EndPoint}) received {numReceived} bytes of data, invoking event");
 
             try {
                 DataReceivedEvent?.Invoke(dtlsServerClient, buffer, numReceived);
diff --git a/HKMP/Networking/Server/DtlsServerClient.cs b/HKMP/Networking/Server/DtlsServerClient.cs
index 09759bdd..40456263 100644
--- a/HKMP/Networking/Server/DtlsServerClient.cs
+++ b/HKMP/Networking/Server/DtlsServerClient.cs
@@ -4,10 +4,25 @@
 
 namespace Hkmp.Networking.Server;
 
+/// <summary>
+/// Data class containing the related object instances for a DTLS server client.
+/// </summary>
 internal class DtlsServerClient {
+    /// <summary>
+    /// The DTLS transport instance.
+    /// </summary>
     public DtlsTransport DtlsTransport { get; init; }
+    /// <summary>
+    /// The server datagram transport. 
+    /// </summary>
     public ServerDatagramTransport DatagramTransport { get; init; }
+    /// <summary>
+    /// The IP endpoint of the client.
+    /// </summary>
     public IPEndPoint EndPoint { get; init; }
-    
+
+    /// <summary>
+    /// The cancellation token source for the "receive loop".
+    /// </summary>
     public CancellationTokenSource ReceiveLoopTokenSource { get; init; }
 }
diff --git a/HKMP/Networking/Server/NetServer.cs b/HKMP/Networking/Server/NetServer.cs
index 55c3d4e5..53c1c123 100644
--- a/HKMP/Networking/Server/NetServer.cs
+++ b/HKMP/Networking/Server/NetServer.cs
@@ -7,7 +7,6 @@
 using Hkmp.Api.Server;
 using Hkmp.Api.Server.Networking;
 using Hkmp.Logging;
-using Hkmp.Networking.Client;
 using Hkmp.Networking.Packet;
 using Hkmp.Networking.Packet.Data;
 
@@ -27,9 +26,6 @@ ServerUpdateManager updateManager
 /// Server that manages connection with clients.
 /// </summary>
 internal class NetServer : INetServer {
-    /// <inheritdoc cref="UdpNetClient.MaxUdpPacketSize"/>
-    private const int MaxUdpPacketSize = 65527;
-
     /// <summary>
     /// The time to throttle a client after they were rejected connection in milliseconds.
     /// </summary>
@@ -39,6 +35,11 @@ internal class NetServer : INetServer {
     /// The packet manager instance.
     /// </summary>
     private readonly PacketManager _packetManager;
+    
+    /// <summary>
+    /// Underlying DTLS server instance.
+    /// </summary>
+    private readonly DtlsServer _dtlsServer;
 
     /// <summary>
     /// Dictionary mapping client IDs to net server clients.
@@ -74,11 +75,6 @@ internal class NetServer : INetServer {
     /// </summary>
     private ManualResetEventSlim _processingWaitHandle;
 
-    /// <summary>
-    /// Underlying DTLS server instance.
-    /// </summary>
-    private DtlsServer _dtlsServer;
-
     /// <summary>
     /// Event that is called when a client times out.
     /// </summary>
@@ -101,13 +97,13 @@ internal class NetServer : INetServer {
     public NetServer(PacketManager packetManager) {
         _packetManager = packetManager;
 
+        _dtlsServer = new DtlsServer();
+
         _registeredClients = new ConcurrentDictionary<ushort, NetServerClient>();
         _clients = new ConcurrentDictionary<IPEndPoint, NetServerClient>();
         _throttledClients = new ConcurrentDictionary<IPAddress, Stopwatch>();
 
         _receivedQueue = new ConcurrentQueue<ReceivedData>();
-
-        _dtlsServer = new DtlsServer();
     }
 
     /// <summary>
@@ -200,7 +196,7 @@ ref _leftoverData
     /// <summary>
     /// Create a new client and start sending UDP updates and registering the timeout event.
     /// </summary>
-    /// <param name="endPoint">The endpoint of the new client.</param>
+    /// <param name="dtlsServerClient">The DTLS server client to create the client from.</param>
     /// <returns>A new net server client instance.</returns>
     private NetServerClient CreateNewClient(DtlsServerClient dtlsServerClient) {
         var netServerClient = new NetServerClient(dtlsServerClient.DtlsTransport, dtlsServerClient.EndPoint);
@@ -243,6 +239,7 @@ private void HandleClientTimeout(NetServerClient client) {
         }
 
         client.Disconnect();
+        _dtlsServer.DisconnectClient(client.EndPoint);
         _registeredClients.TryRemove(id, out _);
         _clients.TryRemove(client.EndPoint, out _);
 
@@ -357,11 +354,14 @@ public void Stop() {
         // Clean up existing clients
         foreach (var client in _clients.Values) {
             client.Disconnect();
+            _dtlsServer.DisconnectClient(client.EndPoint);
         }
 
         _clients.Clear();
         _registeredClients.Clear();
         _throttledClients.Clear();
+        
+        _dtlsServer.Stop();
 
         _leftoverData = null;
 
@@ -370,7 +370,7 @@ public void Stop() {
         // Request cancellation for the tasks that are still running
         _taskTokenSource.Cancel();
 
-        _processingWaitHandle.Dispose();
+        _processingWaitHandle?.Dispose();
 
         // Invoke the shutdown event to notify all registered parties of the shutdown
         ShutdownEvent?.Invoke();
@@ -387,6 +387,7 @@ public void OnClientDisconnect(ushort id) {
         }
 
         client.Disconnect();
+        _dtlsServer.DisconnectClient(client.EndPoint);
         _registeredClients.TryRemove(id, out _);
         _clients.TryRemove(client.EndPoint, out _);
 
diff --git a/HKMP/Networking/Server/NetServerClient.cs b/HKMP/Networking/Server/NetServerClient.cs
index 7a0f61d5..abfc6bb8 100644
--- a/HKMP/Networking/Server/NetServerClient.cs
+++ b/HKMP/Networking/Server/NetServerClient.cs
@@ -40,26 +40,15 @@ internal class NetServerClient {
     public readonly IPEndPoint EndPoint;
 
     /// <summary>
-    /// Construct the client with the given UDP socket and endpoint.
+    /// Construct the client with the given DTLS transport and endpoint.
     /// </summary>
-    /// <param name="udpSocket">The underlying UDP socket.</param>
+    /// <param name="dtlsTransport">The underlying DTLS transport.</param>
     /// <param name="endPoint">The endpoint.</param>
     public NetServerClient(DtlsTransport dtlsTransport, IPEndPoint endPoint) {
-        // Also store endpoint with TCP address and TCP port
         EndPoint = endPoint;
 
         Id = GetId();
-        UpdateManager = new ServerUpdateManager(dtlsTransport, EndPoint);
-    }
-
-    /// <summary>
-    /// Whether this client resides at the given endpoint.
-    /// </summary>
-    /// <param name="endPoint">The endpoint to test for.</param>
-    /// <returns>true if the address and port of the endpoint match the endpoint of the client; otherwise
-    /// false.</returns>
-    public bool HasAddress(IPEndPoint endPoint) {
-        return EndPoint.Address.Equals(endPoint.Address) && EndPoint.Port == endPoint.Port;
+        UpdateManager = new ServerUpdateManager(dtlsTransport);
     }
 
     /// <summary>
diff --git a/HKMP/Networking/Server/ServerDatagramTransport.cs b/HKMP/Networking/Server/ServerDatagramTransport.cs
index 319175a5..21b55bf7 100644
--- a/HKMP/Networking/Server/ServerDatagramTransport.cs
+++ b/HKMP/Networking/Server/ServerDatagramTransport.cs
@@ -6,11 +6,25 @@
 
 namespace Hkmp.Networking.Server;
 
+/// <summary>
+/// Class that implements the DatagramTransport interface from DTLS. This class simply sends and receives data based
+/// on a blocking collection that is filled by data received by the DTLS server.
+/// </summary>
 internal class ServerDatagramTransport : DatagramTransport {
+    /// <summary>
+    /// The socket instance solely used to send data.
+    /// </summary>
     private readonly Socket _socket;
 
+    /// <summary>
+    /// The IP endpoint for the client that this datagram transport belongs to.
+    /// </summary>
     public IPEndPoint IPEndPoint { get; set; }
-    
+
+    /// <summary>
+    /// A thread-safe blocking collection storing received data that is used to handle the "Receive" calls from the
+    /// DTLS transport.
+    /// </summary>
     public BlockingCollection<ReceivedData> ReceivedDataCollection { get; }
 
     public ServerDatagramTransport(Socket socket) {
@@ -18,17 +32,33 @@ public ServerDatagramTransport(Socket socket) {
 
         ReceivedDataCollection = new BlockingCollection<ReceivedData>();
     }
-    
+
+    /// <summary>
+    /// The maximum number of bytes to receive in a single call to <see cref="Receive"/>.
+    /// </summary>
+    /// <returns>The maximum number of bytes that can be received.</returns>
     public int GetReceiveLimit() {
-        // TODO: change to const defined somewhere
-        return 1400;
+        return DtlsServer.MaxPacketSize;
     }
-    
+
+    /// <summary>
+    /// The maximum number of bytes to send in a single call to <see cref="Send"/>.
+    /// </summary>
+    /// <returns>The maximum number of bytes that can be sent.</returns>
     public int GetSendLimit() {
-        // TODO: change to const defined somewhere
-        return 1400;
+        return DtlsServer.MaxPacketSize;
     }
 
+    /// <summary>
+    /// This method is called whenever the corresponding DtlsTransport's Receive is called. The implementation
+    /// obtains data from the blocking collection and store it in the given buffer. If no data is present in the
+    /// collection within the given <paramref name="waitMillis"/>, the method returns -1.
+    /// </summary>
+    /// <param name="buf">Byte array to store the received data.</param>
+    /// <param name="off">The offset at which to begin storing the data.</param>
+    /// <param name="len">The number of bytes that can be stored in the buffer.</param>
+    /// <param name="waitMillis">The number of milliseconds to wait for data to fill.</param>
+    /// <returns>The number of bytes that were received, or -1 if no bytes were received in the given time.</returns>
     public int Receive(byte[] buf, int off, int len, int waitMillis) {
         if (!ReceivedDataCollection.TryTake(out var data, waitMillis)) {
             return -1;
@@ -69,22 +99,43 @@ public int Receive(byte[] buf, int off, int len, int waitMillis) {
         return data.Length;
     }
 
+    /// <summary>
+    /// This method is called whenever the corresponding DtlsTransport's Send is called. The implementation simply
+    /// sends the data in the buffer over the network.
+    /// </summary>
+    /// <param name="buf">Byte array containing the bytes to send.</param>
+    /// <param name="off">The offset in the buffer at which to start sending bytes.</param>
+    /// <param name="len">The number of bytes to send.</param>
     public void Send(byte[] buf, int off, int len) {
         if (IPEndPoint == null) {
             Logger.Error("Cannot send because transport has no endpoint");
             return;
         }
         
-        Logger.Debug($"Server sending {len} bytes of data to: {IPEndPoint}");
+        // Logger.Debug($"Server sending {len} bytes of data to: {IPEndPoint}");
         
         _socket.SendTo(buf, off, len, SocketFlags.None, IPEndPoint);
     }
 
+    /// <summary>
+    /// Cleanup login for when this transport channel should be closed.
+    /// Since we handle socket closing in another class (<seealso cref="DtlsServer"/>), there is nothing here.
+    /// </summary>
     public void Close() {
     }
 
+    /// <summary>
+    /// Data class containing a buffer and the corresponding length of bytes stored in that buffer. Not necessarily
+    /// the length of the buffer.
+    /// </summary>
     public class ReceivedData {
+        /// <summary>
+        /// Byte array containing the data.
+        /// </summary>
         public byte[] Buffer { get; set; }
+        /// <summary>
+        /// The number of bytes in the buffer.
+        /// </summary>
         public int Length { get; set; }
     }
 }
diff --git a/HKMP/Networking/Server/ServerTlsServer.cs b/HKMP/Networking/Server/ServerTlsServer.cs
index 03aaae7d..b476102e 100644
--- a/HKMP/Networking/Server/ServerTlsServer.cs
+++ b/HKMP/Networking/Server/ServerTlsServer.cs
@@ -1,7 +1,5 @@
 using System;
-using Hkmp.Logging;
 using Org.BouncyCastle.Asn1.Pkcs;
-using Org.BouncyCastle.Asn1.Sec;
 using Org.BouncyCastle.Asn1.X509;
 using Org.BouncyCastle.Asn1.X9;
 using Org.BouncyCastle.Crypto;
@@ -14,21 +12,36 @@
 using Org.BouncyCastle.Tls.Crypto;
 using Org.BouncyCastle.Tls.Crypto.Impl.BC;
 using Org.BouncyCastle.X509;
+// ReSharper disable InconsistentNaming
 
 namespace Hkmp.Networking.Server;
 
+/// <summary>
+/// Server-side TLS client implementation that handles reporting supported cipher suites and provides the server's
+/// certificate.
+/// </summary>
 internal class ServerTlsServer : AbstractTlsServer {
+    /// <summary>
+    /// List of supported cipher suites on the server-side.
+    /// </summary>
     private static readonly int[] SupportedCipherSuites = [
         CipherSuite.TLS_AES_128_GCM_SHA256,
         CipherSuite.TLS_AES_256_GCM_SHA384,
         CipherSuite.TLS_CHACHA20_POLY1305_SHA256,
         CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-        // CipherSuite.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
+        CipherSuite.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
     ];
 
+    /// <summary>
+    /// Asymmetric key pair for the server. Used to create the server certificate.
+    /// </summary>
     private readonly AsymmetricCipherKeyPair _keyPair;
+    /// <summary>
+    /// X509 certificate for the server. Reported to clients to validate they are connecting to the correct server.
+    /// </summary>
     private readonly X509Certificate _certificate;
 
+    // TODO: use existing certificate on disk if available and store generated certificate to disk if a new one was generated
     public ServerTlsServer(TlsCrypto crypto) : base(crypto) {
         _keyPair = GenerateECDHKeyPair(GetECBuiltInBinaryDomainParameters());
         _certificate = GenerateCertificate(
@@ -39,7 +52,15 @@ public ServerTlsServer(TlsCrypto crypto) : base(crypto) {
         );
     }
 
-    static X509Certificate GenerateCertificate(
+    /// <summary>
+    /// Generate a X509 certificate with the given issuer and subject names, and with the given keys.
+    /// </summary>
+    /// <param name="issuer">The issuer name.</param>
+    /// <param name="subject">The subject name.</param>
+    /// <param name="issuerPrivate">The issuer private key.</param>
+    /// <param name="subjectPublic">The subject public key.</param>
+    /// <returns>The generated X509 certificate.</returns>
+    private static X509Certificate GenerateCertificate(
         X509Name issuer, X509Name subject,
         AsymmetricKeyParameter issuerPrivate,
         AsymmetricKeyParameter subjectPublic
@@ -65,13 +86,22 @@ AsymmetricKeyParameter subjectPublic
         return certGenerator.Generate(signatureFactory);
     }
 
-    private ECDomainParameters GetECBuiltInBinaryDomainParameters() {
+    /// <summary>
+    /// Get built-in binary domain parameters for elliptic curve crypto using curve "K-283".
+    /// </summary>
+    /// <returns>The domain parameters corresponding to "K-283".</returns>
+    private static ECDomainParameters GetECBuiltInBinaryDomainParameters() {
         var ecParams = ECNamedCurveTable.GetByName("K-283");
 
         return new ECDomainParameters(ecParams.Curve, ecParams.G, ecParams.N, ecParams.H, ecParams.GetSeed());
     }
 
-    private AsymmetricCipherKeyPair GenerateECDHKeyPair(ECDomainParameters ecParams) {
+    /// <summary>
+    /// Generate an asymmetric key pair using the given domain parameters.
+    /// </summary>
+    /// <param name="ecParams">The domain parameters for the generation.</param>
+    /// <returns>The asymmetric key pair.</returns>
+    private static AsymmetricCipherKeyPair GenerateECDHKeyPair(ECDomainParameters ecParams) {
         var ecKeyGenParams = new ECKeyGenerationParameters(ecParams, new SecureRandom());
         var ecKeyPairGen = new ECKeyPairGenerator();
         ecKeyPairGen.Init(ecKeyGenParams);
@@ -79,20 +109,28 @@ private AsymmetricCipherKeyPair GenerateECDHKeyPair(ECDomainParameters ecParams)
 
         return ecKeyPair;
     }
-    
-    
 
+    /// <inheritdoc />
     protected override ProtocolVersion[] GetSupportedVersions() {
         return ProtocolVersion.DTLSv12.Only();
     }
-    
+
+    /// <summary>
+    /// Get the supported cipher suites for this TLS client.
+    /// </summary>
+    /// <returns>An int array representing the cipher suites.</returns>
     protected override int[] GetSupportedCipherSuites() {
         return SupportedCipherSuites;
     }
 
+    /// <summary>
+    /// Get the server credentials for sending to clients to authenticate the server.
+    /// </summary>
+    /// <returns>TlsCredentials instance representing the credentials.</returns>
+    /// <exception cref="TlsFatalAlert">Thrown when the key exchange algorithm agreed upon by the server and client
+    /// does not match the expected, and we can thus not send our credentials.</exception>
     public override TlsCredentials GetCredentials() {
         var keyExchangeAlgorithm = TlsUtilities.GetKeyExchangeAlgorithm(m_selectedCipherSuite);
-        Logger.Debug($"keyExchangeAlgorithm: {keyExchangeAlgorithm}");
 
         if (keyExchangeAlgorithm != KeyExchangeAlgorithm.ECDHE_ECDSA) {
             throw new TlsFatalAlert(AlertDescription.internal_error);
diff --git a/HKMP/Networking/Server/ServerUpdateManager.cs b/HKMP/Networking/Server/ServerUpdateManager.cs
index 9e758453..9718310b 100644
--- a/HKMP/Networking/Server/ServerUpdateManager.cs
+++ b/HKMP/Networking/Server/ServerUpdateManager.cs
@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Net;
-using System.Net.Sockets;
 using Hkmp.Game;
 using Hkmp.Game.Client.Entity;
 using Hkmp.Game.Settings;
@@ -16,18 +14,11 @@ namespace Hkmp.Networking.Server;
 /// Specialization of <see cref="UdpUpdateManager{TOutgoing,TPacketId}"/> for server to client packet sending.
 /// </summary>
 internal class ServerUpdateManager : UdpUpdateManager<ClientUpdatePacket, ClientPacketId> {
-    /// <summary>
-    /// The endpoint of the client.
-    /// </summary>
-    private readonly IPEndPoint _endPoint;
-
     /// <summary>
     /// Construct the update manager with the given details.
     /// </summary>
-    /// <param name="udpSocket">The underlying UDP socket for this client.</param>
-    /// <param name="endPoint">The endpoint of the client.</param>
-    public ServerUpdateManager(DtlsTransport dtlsTransport, IPEndPoint endPoint) : base(dtlsTransport) {
-        _endPoint = endPoint;
+    /// <param name="dtlsTransport">The DTLS transport instance for the client used for sending data.</param>
+    public ServerUpdateManager(DtlsTransport dtlsTransport) : base(dtlsTransport) {
     }
 
     /// <inheritdoc />
diff --git a/HKMP/Networking/UdpUpdateManager.cs b/HKMP/Networking/UdpUpdateManager.cs
index 7f891d43..6fc6fca6 100644
--- a/HKMP/Networking/UdpUpdateManager.cs
+++ b/HKMP/Networking/UdpUpdateManager.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Net.Sockets;
 using Hkmp.Concurrency;
 using Hkmp.Logging;
 using Hkmp.Networking.Packet;
@@ -32,8 +31,9 @@ internal abstract class UdpUpdateManager<TOutgoing, TPacketId> : UdpUpdateManage
     /// The MTU (maximum transfer unit) to use to send packets with. If the length of a packet exceeds this, we break
     /// it up into smaller packets before sending. This ensures that we control the breaking of packets in most
     /// cases and do not rely on smaller network devices for the breaking up as this could impact performance.
+    /// This size is lower than the limit for DTLS packets, since there is a slight DTLS overhead for packets.
     /// </summary>
-    private const int PacketMtu = 1400;
+    private const int PacketMtu = 1200;
 
     /// <summary>
     /// The number of sequence numbers to store in the received queue to construct ack fields with and
@@ -44,7 +44,7 @@ internal abstract class UdpUpdateManager<TOutgoing, TPacketId> : UdpUpdateManage
     /// <summary>
     /// The Socket instance to use to send packets.
     /// </summary>
-    protected readonly DtlsTransport DtlsTransport;
+    private readonly DtlsTransport _dtlsTransport;
 
     /// <summary>
     /// The UDP congestion manager instance.
@@ -109,9 +109,9 @@ internal abstract class UdpUpdateManager<TOutgoing, TPacketId> : UdpUpdateManage
     /// <summary>
     /// Construct the update manager with a UDP socket.
     /// </summary>
-    /// <param name="udpSocket">The UDP socket instance.</param>
+    /// <param name="dtlsTransport">The DTLS transport instance used to send data.</param>
     protected UdpUpdateManager(DtlsTransport dtlsTransport) {
-        DtlsTransport = dtlsTransport;
+        _dtlsTransport = dtlsTransport;
 
         _udpCongestionManager = new UdpCongestionManager<TOutgoing, TPacketId>(this);
 
@@ -203,7 +203,7 @@ public void OnReceivePacket<TIncoming, TOtherPacketId>(TIncoming packet)
     /// Create and send the current update packet.
     /// </summary>
     private void CreateAndSendUpdatePacket() {
-        if (DtlsTransport == null) {
+        if (_dtlsTransport == null) {
             return;
         }
 
@@ -296,7 +296,7 @@ private bool IsSequenceGreaterThan(ushort sequence1, ushort sequence2) {
     private void SendPacket(Packet.Packet packet) {
         var buffer = packet.ToArray();
         
-        DtlsTransport?.Send(buffer, 0, buffer.Length);
+        _dtlsTransport?.Send(buffer, 0, buffer.Length);
     }
 
     /// <summary>

From e79d86141935d959b2bea964e9fb52be9a34fdd3 Mon Sep 17 00:00:00 2001
From: Extremelyd1 <10898310+Extremelyd1@users.noreply.github.com>
Date: Sun, 19 Jan 2025 10:53:36 +0100
Subject: [PATCH 5/9] Allow socket receive to time out, improve socket error
 handling

---
 .../Networking/Client/ClientDatagramTransport.cs | 16 ++++++++++------
 HKMP/Networking/Server/DtlsServer.cs             |  8 ++------
 .../Networking/Server/ServerDatagramTransport.cs |  4 +---
 3 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/HKMP/Networking/Client/ClientDatagramTransport.cs b/HKMP/Networking/Client/ClientDatagramTransport.cs
index 5795c378..bc590aef 100644
--- a/HKMP/Networking/Client/ClientDatagramTransport.cs
+++ b/HKMP/Networking/Client/ClientDatagramTransport.cs
@@ -45,18 +45,23 @@ public int GetSendLimit() {
     /// <param name="waitMillis">The number of milliseconds to wait for data to receive.</param>
     /// <returns>The number of bytes that were received, or -1 if no bytes were received in the given time.</returns>
     public int Receive(byte[] buf, int off, int len, int waitMillis) {
-        // TODO: timeout after waitMillis
         try {
+            _socket.ReceiveTimeout = waitMillis;
             var numReceived = _socket.Receive(
                 buf,
                 off,
                 len,
-                SocketFlags.None
+                SocketFlags.None,
+                out var socketError
             );
-            // Logger.Debug($"Client socket receive: {numReceived}");
-            return numReceived;
+
+            if (socketError == SocketError.Success) {
+                return numReceived;
+            }
+
+            Logger.Error($"UDP Socket Error on receive: {socketError}");
         } catch (SocketException e) {
-            Logger.Error($"UDP Socket exception:\n{e}");
+            Logger.Error($"UDP Socket exception, ErrorCode: {e.ErrorCode}, Socket ErrorCode: {e.SocketErrorCode}, Exception:\n{e}");
         }
 
         return -1;
@@ -70,7 +75,6 @@ public int Receive(byte[] buf, int off, int len, int waitMillis) {
     /// <param name="off">The offset in the buffer at which to start sending bytes.</param>
     /// <param name="len">The number of bytes to send.</param>
     public void Send(byte[] buf, int off, int len) {
-        // Logger.Debug($"Client sending {len} bytes of data");
         _socket.Send(buf, off, len, SocketFlags.None);
     }
 
diff --git a/HKMP/Networking/Server/DtlsServer.cs b/HKMP/Networking/Server/DtlsServer.cs
index f8e39d82..18df25bd 100644
--- a/HKMP/Networking/Server/DtlsServer.cs
+++ b/HKMP/Networking/Server/DtlsServer.cs
@@ -134,9 +134,8 @@ private void SocketReceiveLoop(CancellationToken cancellationToken) {
         while (!cancellationToken.IsCancellationRequested) {
             EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
 
-            // Logger.Debug("Blocking on server socket receive");
             var numReceived = 0;
-            var buffer = new byte[1400];
+            var buffer = new byte[MaxPacketSize];
 
             try {
                 numReceived = _socket.ReceiveFrom(
@@ -145,7 +144,7 @@ private void SocketReceiveLoop(CancellationToken cancellationToken) {
                     ref endPoint
                 );
             } catch (SocketException e) {
-                Logger.Error($"UDP server socket exception:\n{e}");
+                Logger.Error($"UDP Socket exception, ErrorCode: {e.ErrorCode}, Socket ErrorCode: {e.SocketErrorCode}, Exception:\n{e}");
             }
 
             var ipEndPoint = (IPEndPoint) endPoint;
@@ -158,7 +157,6 @@ ref endPoint
                 // Set the IP endpoint of the datagram transport instance so it can send data to the correct IP
                 serverDatagramTransport.IPEndPoint = ipEndPoint;
             } else {
-                // Logger.Debug($"Received data on server socket from existing client ({ipEndPoint}), length: {numReceived}");
                 serverDatagramTransport = dtlsServerClient.DatagramTransport;
             }
 
@@ -249,8 +247,6 @@ private void ClientReceiveLoop(DtlsServerClient dtlsServerClient, CancellationTo
             if (numReceived <= 0) {
                 continue;
             }
-            
-            // Logger.Debug($"DtlsServerClient ({dtlsServerClient.EndPoint}) received {numReceived} bytes of data, invoking event");
 
             try {
                 DataReceivedEvent?.Invoke(dtlsServerClient, buffer, numReceived);
diff --git a/HKMP/Networking/Server/ServerDatagramTransport.cs b/HKMP/Networking/Server/ServerDatagramTransport.cs
index 21b55bf7..d53dae63 100644
--- a/HKMP/Networking/Server/ServerDatagramTransport.cs
+++ b/HKMP/Networking/Server/ServerDatagramTransport.cs
@@ -111,9 +111,7 @@ public void Send(byte[] buf, int off, int len) {
             Logger.Error("Cannot send because transport has no endpoint");
             return;
         }
-        
-        // Logger.Debug($"Server sending {len} bytes of data to: {IPEndPoint}");
-        
+
         _socket.SendTo(buf, off, len, SocketFlags.None, IPEndPoint);
     }
 

From 421a7f066912fdc9a66b3cabf6b545e748dd5c5b Mon Sep 17 00:00:00 2001
From: Extremelyd1 <10898310+Extremelyd1@users.noreply.github.com>
Date: Sun, 19 Jan 2025 11:29:28 +0100
Subject: [PATCH 6/9] Update dependencies zip file for dotnet workflow

---
 .github/workflows/dotnet.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml
index 5a43a849..3fab34e6 100644
--- a/.github/workflows/dotnet.yml
+++ b/.github/workflows/dotnet.yml
@@ -26,7 +26,7 @@ jobs:
           ref: ${{ github.event.pull_request.head.sha }}
 
       - name: Download dependencies
-        run: wget https://files.catbox.moe/r5p6rr.gpg -O deps.zip.gpg
+        run: wget https://files.catbox.moe/t156ho.gpg -O deps.zip.gpg
 
       - name: Decrypt dependencies
         run: gpg --quiet --batch --yes --decrypt --passphrase="${{ secrets.DEPENDENCIES_ZIP_PASSPHRASE }}" --output deps.zip deps.zip.gpg

From b47e287341349f5e37a798778cdff1a5d457024c Mon Sep 17 00:00:00 2001
From: Extremelyd1 <10898310+Extremelyd1@users.noreply.github.com>
Date: Sun, 19 Jan 2025 11:37:00 +0100
Subject: [PATCH 7/9] Update dotnet version of workflow

---
 .github/workflows/dotnet.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml
index 3fab34e6..578107eb 100644
--- a/.github/workflows/dotnet.yml
+++ b/.github/workflows/dotnet.yml
@@ -44,7 +44,7 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 6.0.x
+          dotnet-version: 8.0.x
 
       - name: Restore dependencies
         run: dotnet restore ${{ github.workspace }}

From 5c40150dac5d51637df1bf2f2c60abb2d3a0c5bf Mon Sep 17 00:00:00 2001
From: Extremelyd1 <10898310+Extremelyd1@users.noreply.github.com>
Date: Sun, 19 Jan 2025 11:49:53 +0100
Subject: [PATCH 8/9] Add BouncyCastle library to artifact zip in workflow

---
 .github/workflows/dotnet.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml
index 578107eb..713acae5 100644
--- a/.github/workflows/dotnet.yml
+++ b/.github/workflows/dotnet.yml
@@ -60,6 +60,8 @@ jobs:
             ${{ github.workspace }}/HKMP/bin/Release/net472/HKMP.dll
             ${{ github.workspace }}/HKMP/bin/Release/net472/HKMP.xml
             ${{ github.workspace }}/HKMP/bin/Release/net472/HKMP.pdb
+            ${{ github.workspace }}/HKMP/bin/Release/net472/BouncyCastle.Cryptography.dll
+            ${{ github.workspace }}/HKMP/bin/Release/net472/BouncyCastle.Cryptography.xml
       
       - name: Upload HKMPServer artifact
         uses: actions/upload-artifact@v4

From b540b6c78cebab6314247ad75cdda20ad4d2da2e Mon Sep 17 00:00:00 2001
From: Extremelyd1 <10898310+Extremelyd1@users.noreply.github.com>
Date: Sun, 19 Jan 2025 15:37:27 +0100
Subject: [PATCH 9/9] Fix project file to copy dependencies to output directory

---
 HKMP/HKMP.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/HKMP/HKMP.csproj b/HKMP/HKMP.csproj
index 3961e498..5e63a951 100644
--- a/HKMP/HKMP.csproj
+++ b/HKMP/HKMP.csproj
@@ -107,7 +107,7 @@
     <!-- Create an item group for the source and destination files of the copy target. This way we can specify
        multiple paths that we want the assembly to be copied to. -->
     <ItemGroup>
-        <SourceFiles Include="$(TargetDir)$(AssemblyName).dll;$(TargetDir)$(AssemblyName).pdb;$(TargetDir)$(AssemblyName).xml" />
+        <SourceFiles Include="$(TargetDir)*.dll;$(TargetDir)*.pdb;$(TargetDir)*.xml" />
         <Dest Include="$(OutputDirectory)" />
     </ItemGroup>
     <Target Name="PostBuild" AfterTargets="PostBuildEvent">