Switched to C++23 as the project standard.

Added a basic parser for client_config and server_config, and added some basic authorization.
Need to work on verification of the server.

include/columnlynx/client/net/tcp/tcp_client.hpp

@@ -13,6 +13,7 @@
 #include <array>
 #include <algorithm>
 #include <vector>
+#include <unordered_map>
 #include <columnlynx/common/net/protocol_structs.hpp>
 #include <columnlynx/common/net/virtual_interface.hpp>
 
@@ -42,7 +43,24 @@ namespace ColumnLynx::Net::TCP {
                 mLastHeartbeatReceived(std::chrono::steady_clock::now()),
                 mLastHeartbeatSent(std::chrono::steady_clock::now()),
                 mTun(tun)
-            {}
+            {
+                // Preload the config map
+                mRawClientConfig = Utils::getConfigMap("client_config");
+
+                if (!mRawClientConfig.empty()) {
+                    Utils::debug("Loading the keys");
+
+                    PrivateKey sk;
+                    PublicKey pk;
+                    std::copy_n(Utils::hexStringToBytes(mRawClientConfig.find("CLIENT_PRIVATE_KEY")->second).begin(), sk.size(), sk.begin()); // This is extremely stupid, but the C++ compiler has forced my hand (I would've just used to_array, but fucking asio decls)
+                    std::copy_n(Utils::hexStringToBytes(mRawClientConfig.find("CLIENT_PUBLIC_KEY")->second).begin(), pk.size(), pk.begin());
+
+                    mLibSodiumWrapper->setKeys(pk, sk);
+
+                    Utils::debug("Newly-Loaded Public Key: " + Utils::bytesToHexString(mLibSodiumWrapper->getPublicKey(), 32));
+                    Utils::debug("Newly-Loaded Private Key: " + Utils::bytesToHexString(mLibSodiumWrapper->getPrivateKey(), 64));
+                }
+            }
 
             void start();
             void sendMessage(ClientMessageType type, const std::string& data = "");
@@ -76,5 +94,6 @@ namespace ColumnLynx::Net::TCP {
             bool mIsHostDomain;
             Protocol::TunConfig mTunConfig;
             std::shared_ptr<VirtualInterface> mTun = nullptr;
+            std::unordered_map<std::string, std::string> mRawClientConfig;
     };
 }

include/columnlynx/common/libsodium_wrapper.hpp

@@ -40,6 +40,16 @@ namespace ColumnLynx::Utils {
             uint8_t* getXPublicKey() { return mXPublicKey.data(); }
             uint8_t* getXPrivateKey() { return mXPrivateKey.data(); }
 
+            // Dangerous!
+            void setKeys(PublicKey pk, PrivateKey sk) {
+                mPublicKey = pk;
+                mPrivateKey = sk;
+
+                // Convert to Curve25519 keys for encryption
+                crypto_sign_ed25519_pk_to_curve25519(mXPublicKey.data(), mPublicKey.data());
+                crypto_sign_ed25519_sk_to_curve25519(mXPrivateKey.data(), mPrivateKey.data());
+            }
+
             // Helper section
 
             // Generates a random 256-bit (32-byte) array

include/columnlynx/common/utils.hpp

@@ -11,6 +11,7 @@
 #include <sstream>
 #include <vector>
 #include <fstream>
+#include <unordered_map>
 
 #ifdef _WIN32
     #include <winsock2.h>
@@ -64,4 +65,7 @@ namespace ColumnLynx::Utils {
     inline constexpr uint64_t cbe64toh(uint64_t x) {
         return cbswap64(x);   // big-endian -> host (for little-endian hosts)
     }
+
+    // Returns the config file in an unordered_map format. This purely reads the config file, you still need to parse it manually.
+    std::unordered_map<std::string, std::string> getConfigMap(std::string path);
 };

include/columnlynx/server/net/tcp/tcp_server.hpp

@@ -31,6 +31,9 @@ namespace ColumnLynx::Net::TCP {
                   mSodiumWrapper(sodiumWrapper),
                   mHostRunning(hostRunning)
             {
+                // Preload the config map
+                mRawServerConfig = Utils::getConfigMap("server_config");
+
                 asio::error_code ec;
             
                 if (!ipv4Only) {
@@ -68,6 +71,7 @@ namespace ColumnLynx::Net::TCP {
             std::unordered_set<TCPConnection::pointer> mClients;
             Utils::LibSodiumWrapper *mSodiumWrapper;
             bool* mHostRunning;
+            std::unordered_map<std::string, std::string> mRawServerConfig;
     };
 
 }