Merge pull request #4 from Kittnz/vulkan_win

Make this compatible to build on MSVS 2022

src/game/warden_memory.cpp

@@ -182,6 +182,7 @@ void WardenMemory::patchRuntimeGlobals() {
     //   uint32 dwAllocationGranularity
     //   uint16 wProcessorLevel
     //   uint16 wProcessorRevision
+#pragma pack(push, 1)
     struct {
         uint16_t wProcessorArchitecture;
         uint16_t wReserved;
@@ -194,7 +195,7 @@ void WardenMemory::patchRuntimeGlobals() {
         uint32_t dwAllocationGranularity;
         uint16_t wProcessorLevel;
         uint16_t wProcessorRevision;
-    } __attribute__((packed)) sysInfo = {
+    } sysInfo = {
         0,          // x86
         0,
         4096,       // 4K page size
@@ -207,6 +208,7 @@ void WardenMemory::patchRuntimeGlobals() {
         6,          // P6 family
         0x3A09      // revision
     };
+#pragma pack(pop)
     static_assert(sizeof(sysInfo) == 36, "SYSTEM_INFO must be 36 bytes");
     uint32_t rva = sysInfoAddr - imageBase_;
     if (rva + 36 <= imageSize_) {

src/game/warden_module.cpp

@@ -8,6 +8,10 @@
 #include <openssl/rsa.h>
 #include <openssl/bn.h>
 #include <openssl/sha.h>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <openssl/param_build.h>
+#include <openssl/core_names.h>
 
 #ifdef _WIN32
     #ifndef WIN32_LEAN_AND_MEAN
@@ -342,37 +346,47 @@ bool WardenModule::verifyRSASignature(const std::vector<uint8_t>& data) {
 
     std::vector<uint8_t> expectedHash = auth::Crypto::sha1(dataToHash);
 
-    // Create RSA public key structure
-    RSA* rsa = RSA_new();
-    if (!rsa) {
-        std::cerr << "[WardenModule] Failed to create RSA structure" << '\n';
-        return false;
-    }
-
+    // Create RSA public key using EVP_PKEY_fromdata (OpenSSL 3.0 compatible)
     BIGNUM* n = BN_bin2bn(modulus, 256, nullptr);
     BIGNUM* e = BN_new();
     BN_set_word(e, exponent);
 
-    #if OPENSSL_VERSION_NUMBER >= 0x10100000L
-        // OpenSSL 1.1.0+
-        RSA_set0_key(rsa, n, e, nullptr);
-    #else
-        // OpenSSL 1.0.x
-        rsa->n = n;
-        rsa->e = e;
-    #endif
-
-    // Decrypt signature using public key
+    EVP_PKEY* pkey = nullptr;
+    EVP_PKEY_CTX* ctx = nullptr;
     std::vector<uint8_t> decryptedSig(256);
-    int decryptedLen = RSA_public_decrypt(
-        256,
-        signature.data(),
-        decryptedSig.data(),
-        rsa,
-        RSA_NO_PADDING
-    );
+    int decryptedLen = -1;
 
-    RSA_free(rsa);
+    {
+        OSSL_PARAM_BLD* bld = OSSL_PARAM_BLD_new();
+        OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n);
+        OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e);
+        OSSL_PARAM* params = OSSL_PARAM_BLD_to_param(bld);
+        OSSL_PARAM_BLD_free(bld);
+
+        EVP_PKEY_CTX* fromCtx = EVP_PKEY_CTX_new_from_name(nullptr, "RSA", nullptr);
+        if (fromCtx && EVP_PKEY_fromdata_init(fromCtx) > 0) {
+            EVP_PKEY_fromdata(fromCtx, &pkey, EVP_PKEY_PUBLIC_KEY, params);
+        }
+        if (fromCtx) EVP_PKEY_CTX_free(fromCtx);
+        OSSL_PARAM_free(params);
+
+        if (pkey) {
+            ctx = EVP_PKEY_CTX_new(pkey, nullptr);
+            if (ctx && EVP_PKEY_verify_recover_init(ctx) > 0 &&
+                EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_NO_PADDING) > 0) {
+                size_t outLen = decryptedSig.size();
+                if (EVP_PKEY_verify_recover(ctx, decryptedSig.data(), &outLen,
+                                            signature.data(), 256) > 0) {
+                    decryptedLen = static_cast<int>(outLen);
+                }
+            }
+        }
+    }
+
+    BN_free(n);
+    BN_free(e);
+    if (ctx) EVP_PKEY_CTX_free(ctx);
+    if (pkey) EVP_PKEY_free(pkey);
 
     if (decryptedLen < 0) {
         std::cerr << "[WardenModule] RSA public decrypt failed" << '\n';

src/game/world_packets.cpp

@@ -11,6 +11,16 @@
 #include <iomanip>
 #include <zlib.h>
 
+namespace {
+    inline uint32_t bswap32(uint32_t v) {
+        return ((v & 0xFF000000u) >> 24) | ((v & 0x00FF0000u) >> 8)
+             | ((v & 0x0000FF00u) << 8)  | ((v & 0x000000FFu) << 24);
+    }
+    inline uint16_t bswap16(uint16_t v) {
+        return static_cast<uint16_t>(((v & 0xFF00u) >> 8) | ((v & 0x00FFu) << 8));
+    }
+}
+
 namespace wowee {
 namespace game {
 
@@ -3744,10 +3754,10 @@ bool TalentsInfoParser::parse(network::Packet& packet, TalentsInfoData& data) {
 
     // These two counts are big-endian (network byte order)
     uint32_t talentCountBE = packet.readUInt32();
-    uint32_t talentCount = __builtin_bswap32(talentCountBE);
+    uint32_t talentCount = bswap32(talentCountBE);
 
     uint16_t entryCountBE = packet.readUInt16();
-    uint16_t entryCount = __builtin_bswap16(entryCountBE);
+    uint16_t entryCount = bswap16(entryCountBE);
 
     // Sanity check: prevent corrupt packets from allocating excessive memory
     if (entryCount > 64) {