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.

src/client/main.cpp

@@ -49,6 +49,9 @@ int main(int argc, char** argv) {
     auto result = options.parse(argc, argv);
     if (result.count("help")) {
         std::cout << options.help() << std::endl;
+        std::cout << "This software is licensed under the GPLv2-only license OR the GPLv3 license.\n";
+        std::cout << "Copyright (C) 2025, The ColumnLynx Contributors.\n";
+        std::cout << "This software is provided under ABSOLUTELY NO WARRANTY, to the extent permitted by law.\n";
         return 0;
     }
 
@@ -67,6 +70,8 @@ int main(int argc, char** argv) {
         log("Using virtual interface: " + tun->getName());
 
         LibSodiumWrapper sodiumWrapper = LibSodiumWrapper();
+        debug("Public Key: " + Utils::bytesToHexString(sodiumWrapper.getPublicKey(), 32));
+        debug("Private Key: " + Utils::bytesToHexString(sodiumWrapper.getPrivateKey(), 64));
 
         std::array<uint8_t, 32> aesKey = {0}; // Defualt zeroed state until modified by handshake
         uint64_t sessionID = 0;

src/client/net/tcp/tcp_client.cpp

@@ -33,9 +33,13 @@ namespace ColumnLynx::Net::TCP {
                                 std::vector<uint8_t> payload;
                                 payload.reserve(1 + crypto_box_PUBLICKEYBYTES);
                                 payload.push_back(Utils::protocolVersion());
-                                payload.insert(payload.end(),
+                                /*payload.insert(payload.end(),
                                     mLibSodiumWrapper->getXPublicKey(),
                                     mLibSodiumWrapper->getXPublicKey() + crypto_box_PUBLICKEYBYTES
+                                );*/
+                                payload.insert(payload.end(),
+                                    mLibSodiumWrapper->getPublicKey(),
+                                    mLibSodiumWrapper->getPublicKey() + crypto_sign_PUBLICKEYBYTES
                                 );
 
                                 mHandler->sendMessage(ClientMessageType::HANDSHAKE_INIT, Utils::uint8ArrayToString(payload.data(), payload.size()));

src/common/utils.cpp

@@ -113,4 +113,34 @@ namespace ColumnLynx::Utils {
 
         return out;
     }
+
+    std::unordered_map<std::string, std::string> getConfigMap(std::string path) {
+        // TODO: Currently re-reads every time.
+        std::vector<std::string> readLines;
+
+        std::ifstream file(path);
+        std::string line;
+
+        while (std::getline(file, line)) {
+            readLines.push_back(line);
+        }
+
+        // Parse them into the struct
+        std::unordered_map<std::string, std::string> config;
+        char delimiter = '=';
+
+        for (std::string str : readLines) {
+            std::stringstream ss(str);
+
+            std::string key;
+            std::string val;
+
+            std::getline(ss, key, delimiter);
+            std::getline(ss, val, delimiter);
+
+            config.insert({ key, val });
+        }
+
+        return config;
+    }
 }

src/server/main.cpp

@@ -50,6 +50,9 @@ int main(int argc, char** argv) {
         auto result = options.parse(argc, argv);
         if (result.count("help")) {
             std::cout << options.help() << std::endl;
+            std::cout << "This software is licensed under the GPLv2-only license OR the GPLv3 license.\n";
+            std::cout << "Copyright (C) 2025, The ColumnLynx Contributors.\n";
+            std::cout << "This software is provided under ABSOLUTELY NO WARRANTY, to the extent permitted by law.\n";
             return 0;
         }
 

src/server/server/net/tcp/tcp_connection.cpp

@@ -114,15 +114,24 @@ namespace ColumnLynx::Net::TCP {
 
                 Utils::log("Client protocol version " + std::to_string(clientProtoVer) + " accepted from " + reqAddr + ".");
 
-                std::memcpy(mConnectionPublicKey.data(), data.data() + 1, std::min(data.size() - 1, sizeof(mConnectionPublicKey))); // Store the client's public key (for identification)
+                PublicKey signPk;
+                std::memcpy(signPk.data(), data.data() + 1, std::min(data.size() - 1, sizeof(signPk))); // Store the client's public key (for identification)
+
+                crypto_sign_ed25519_pk_to_curve25519(mConnectionPublicKey.data(), signPk.data());
+                
+                Utils::debug("Key attempted connect: " + Utils::bytesToHexString(signPk.data(), signPk.size()));
 
                 std::vector<std::string> whitelistedKeys = Utils::getWhitelistedKeys();
 
-                if (std::find(whitelistedKeys.begin(), whitelistedKeys.end(), Utils::bytesToHexString(mConnectionPublicKey.data(), mConnectionPublicKey.size())) == whitelistedKeys.end()) {
+                if (std::find(whitelistedKeys.begin(), whitelistedKeys.end(), Utils::bytesToHexString(signPk.data(), signPk.size())) == whitelistedKeys.end()) {
                     Utils::warn("Non-whitelisted client attempted to connect, terminating. Client IP: " + reqAddr);
                     disconnect();
+
+                    return;
                 }
 
+                Utils::debug("Client " + reqAddr + " passed authorized_keys");
+
                 mHandler->sendMessage(ServerMessageType::HANDSHAKE_IDENTIFY, Utils::uint8ArrayToString(mLibSodiumWrapper->getPublicKey(), crypto_sign_PUBLICKEYBYTES)); // This public key should always exist
                 break;
             }