Initial commit: wowee native WoW 3.3.5a client

src/auth/big_num.cpp

@@ -0,0 +1,152 @@
+#include "auth/big_num.hpp"
+#include "core/logger.hpp"
+#include <openssl/rand.h>
+#include <algorithm>
+
+namespace wowee {
+namespace auth {
+
+BigNum::BigNum() : bn(BN_new()) {
+    if (!bn) {
+        LOG_ERROR("Failed to create BIGNUM");
+    }
+}
+
+BigNum::BigNum(uint32_t value) : bn(BN_new()) {
+    BN_set_word(bn, value);
+}
+
+BigNum::BigNum(const std::vector<uint8_t>& bytes, bool littleEndian) : bn(BN_new()) {
+    if (littleEndian) {
+        // Convert little-endian to big-endian for OpenSSL
+        std::vector<uint8_t> reversed = bytes;
+        std::reverse(reversed.begin(), reversed.end());
+        BN_bin2bn(reversed.data(), reversed.size(), bn);
+    } else {
+        BN_bin2bn(bytes.data(), bytes.size(), bn);
+    }
+}
+
+BigNum::~BigNum() {
+    if (bn) {
+        BN_free(bn);
+    }
+}
+
+BigNum::BigNum(const BigNum& other) : bn(BN_dup(other.bn)) {}
+
+BigNum& BigNum::operator=(const BigNum& other) {
+    if (this != &other) {
+        BN_free(bn);
+        bn = BN_dup(other.bn);
+    }
+    return *this;
+}
+
+BigNum::BigNum(BigNum&& other) noexcept : bn(other.bn) {
+    other.bn = nullptr;
+}
+
+BigNum& BigNum::operator=(BigNum&& other) noexcept {
+    if (this != &other) {
+        BN_free(bn);
+        bn = other.bn;
+        other.bn = nullptr;
+    }
+    return *this;
+}
+
+BigNum BigNum::fromRandom(int bytes) {
+    std::vector<uint8_t> randomBytes(bytes);
+    RAND_bytes(randomBytes.data(), bytes);
+    return BigNum(randomBytes, true);
+}
+
+BigNum BigNum::fromHex(const std::string& hex) {
+    BigNum result;
+    BN_hex2bn(&result.bn, hex.c_str());
+    return result;
+}
+
+BigNum BigNum::fromDecimal(const std::string& dec) {
+    BigNum result;
+    BN_dec2bn(&result.bn, dec.c_str());
+    return result;
+}
+
+BigNum BigNum::add(const BigNum& other) const {
+    BigNum result;
+    BN_add(result.bn, bn, other.bn);
+    return result;
+}
+
+BigNum BigNum::subtract(const BigNum& other) const {
+    BigNum result;
+    BN_sub(result.bn, bn, other.bn);
+    return result;
+}
+
+BigNum BigNum::multiply(const BigNum& other) const {
+    BigNum result;
+    BN_CTX* ctx = BN_CTX_new();
+    BN_mul(result.bn, bn, other.bn, ctx);
+    BN_CTX_free(ctx);
+    return result;
+}
+
+BigNum BigNum::mod(const BigNum& modulus) const {
+    BigNum result;
+    BN_CTX* ctx = BN_CTX_new();
+    BN_mod(result.bn, bn, modulus.bn, ctx);
+    BN_CTX_free(ctx);
+    return result;
+}
+
+BigNum BigNum::modPow(const BigNum& exponent, const BigNum& modulus) const {
+    BigNum result;
+    BN_CTX* ctx = BN_CTX_new();
+    BN_mod_exp(result.bn, bn, exponent.bn, modulus.bn, ctx);
+    BN_CTX_free(ctx);
+    return result;
+}
+
+bool BigNum::equals(const BigNum& other) const {
+    return BN_cmp(bn, other.bn) == 0;
+}
+
+bool BigNum::isZero() const {
+    return BN_is_zero(bn);
+}
+
+std::vector<uint8_t> BigNum::toArray(bool littleEndian, int minSize) const {
+    int size = BN_num_bytes(bn);
+    if (minSize > size) {
+        size = minSize;
+    }
+
+    std::vector<uint8_t> bytes(size, 0);
+    int actualSize = BN_bn2bin(bn, bytes.data() + (size - BN_num_bytes(bn)));
+
+    if (littleEndian) {
+        std::reverse(bytes.begin(), bytes.end());
+    }
+
+    return bytes;
+}
+
+std::string BigNum::toHex() const {
+    char* hex = BN_bn2hex(bn);
+    std::string result(hex);
+    OPENSSL_free(hex);
+    return result;
+}
+
+std::string BigNum::toDecimal() const {
+    char* dec = BN_bn2dec(bn);
+    std::string result(dec);
+    OPENSSL_free(dec);
+    return result;
+}
+
+} // namespace auth
+} // namespace wowee