🔑 Release WinRAR Keygen

Release WinRAR Keygen

BigInteger.hpp

@@ -0,0 +1,324 @@
+#pragma once
+#include <stddef.h>
+#include <stdint.h>
+#include <gmp.h>
+#include <vector>
+#include <string>
+#include <type_traits>
+#include <stdexcept>
+
+class BigInteger {
+private:
+    mpz_t _Value;
+public:
+
+    BigInteger() noexcept {
+        mpz_init(_Value);
+    }
+
+    template<typename __IntegerType>
+    BigInteger(__IntegerType SmallInteger) noexcept {
+        // __IntegerType must be a integer type, i.e. char, int, unsigned long...
+        static_assert(std::is_integral<__IntegerType>::value);
+
+        if constexpr (std::is_signed<__IntegerType>::value) {
+            mpz_init_set_sx(_Value, SmallInteger);
+        } else {
+            mpz_init_set_ux(_Value, SmallInteger);
+        }
+    }
+
+    BigInteger(bool IsNegative, const void* lpBuffer, size_t cbBuffer, bool UseLittleEndian) noexcept {
+        mpz_init(_Value);
+        mpz_import(_Value, cbBuffer, UseLittleEndian ? -1 : 1, sizeof(unsigned char), 0, 0, lpBuffer);
+        if (IsNegative)
+            mpz_neg(_Value, _Value);
+    }
+
+    BigInteger(bool IsNegative, const std::vector<uint8_t>& Buffer, bool UseLittleEndian) noexcept {
+        mpz_init(_Value);
+        mpz_import(_Value, Buffer.size(), UseLittleEndian ? -1 : 1, sizeof(unsigned char), 0, 0, Buffer.data());
+        if (IsNegative)
+            mpz_neg(_Value, _Value);
+    }
+
+    BigInteger(const char* lpszValue) noexcept {
+        mpz_init_set_str(_Value, lpszValue, 0);
+    }
+
+    BigInteger(const std::string& szValue) noexcept {
+        mpz_init_set_str(_Value, szValue.c_str(), 0);
+    }
+
+    BigInteger(const BigInteger& Other) noexcept {
+        mpz_init(_Value);
+        mpz_set(_Value, Other._Value);
+    }
+
+    BigInteger(BigInteger&& Other) noexcept {
+        mpz_init(_Value);
+        mpz_swap(_Value, Other._Value);
+    }
+
+    BigInteger& operator=(const BigInteger& Other) noexcept {
+        if (this != &Other) {
+            mpz_set(_Value, Other._Value);
+        }
+        return *this;
+    }
+
+    BigInteger& operator=(BigInteger&& Other) noexcept {
+        if (this != &Other) {
+            mpz_swap(_Value, Other._Value);
+            mpz_clear(Other._Value);
+        }
+        return *this;
+    }
+
+    template<typename __IntegerType>
+    BigInteger& operator=(__IntegerType SmallInteger) noexcept {
+        // __IntegerType must be a integer type, i.e. char, int, unsigned long...
+        static_assert(std::is_integral<__IntegerType>::value);
+
+        if constexpr (std::is_signed<__IntegerType>::value) {
+            mpz_set_sx(_Value, SmallInteger);
+        } else {
+            mpz_set_ux(_Value, SmallInteger);
+        }
+
+        return *this;
+    }
+
+    BigInteger& operator=(const char* lpszValue) noexcept {
+        mpz_init_set_str(_Value, lpszValue, 0);
+        return *this;
+    }
+
+    bool operator==(const BigInteger& Other) const noexcept {
+        return mpz_cmp(_Value, Other._Value) == 0;
+    }
+
+    bool operator!=(const BigInteger& Other) const noexcept {
+        return mpz_cmp(_Value, Other._Value) != 0;
+    }
+
+    bool operator<(const BigInteger& Other) const noexcept {
+        return mpz_cmp(_Value, Other._Value) < 0;
+    }
+
+    bool operator<=(const BigInteger& Other) const noexcept {
+        auto d = mpz_cmp(_Value, Other._Value);
+        return d < 0 || d == 0;
+    }
+
+    bool operator>(const BigInteger& Other) const noexcept {
+        return mpz_cmp(_Value, Other._Value) > 0;
+    }
+
+    bool operator>=(const BigInteger& Other) const noexcept {
+        auto d = mpz_cmp(_Value, Other._Value);
+        return d > 0 || d == 0;
+    }
+
+    BigInteger operator-() const noexcept {
+        BigInteger Result;
+        mpz_neg(Result._Value, _Value);
+        return Result;
+    }
+
+    BigInteger operator+(const BigInteger& Other) const noexcept {
+        BigInteger Result;
+        mpz_add(Result._Value, _Value, Other._Value);
+        return Result;
+    }
+
+    BigInteger& operator+=(const BigInteger& Other) noexcept {
+        mpz_add(_Value, _Value, Other._Value);
+        return *this;
+    }
+
+    BigInteger operator-(const BigInteger& Other) const noexcept {
+        BigInteger Result;
+        mpz_sub(Result._Value, _Value, Other._Value);
+        return Result;
+    }
+
+    BigInteger& operator-=(const BigInteger& Other) noexcept {
+        mpz_sub(_Value, _Value, Other._Value);
+        return *this;
+    }
+
+    BigInteger operator*(const BigInteger& Other) const noexcept {
+        BigInteger Result;
+        mpz_mul(Result._Value, _Value, Other._Value);
+        return Result;
+    }
+
+    BigInteger& operator*=(const BigInteger& Other) noexcept {
+        mpz_mul(_Value, _Value, Other._Value);
+        return *this;
+    }
+
+    BigInteger operator/(const BigInteger& Other) const noexcept {
+        BigInteger Result;
+        mpz_fdiv_q(Result._Value, _Value, Other._Value);
+        return Result;
+    }
+
+    BigInteger& operator/=(const BigInteger& Other) noexcept {
+        mpz_fdiv_q(_Value, _Value, Other._Value);
+        return *this;
+    }
+
+    BigInteger operator%(const BigInteger& Other) const noexcept {
+        BigInteger Result;
+        mpz_fdiv_r(Result._Value, _Value, Other._Value);
+        return Result;
+    }
+
+    BigInteger& operator%=(const BigInteger& Other) noexcept {
+        mpz_fdiv_r(_Value, _Value, Other._Value);
+        return *this;
+    }
+
+    BigInteger operator~() const noexcept {
+        BigInteger Result;
+        mpz_com(Result._Value, _Value);
+        return Result;
+    }
+
+    BigInteger operator&(const BigInteger& Other) const noexcept {
+        BigInteger Result;
+        mpz_and(Result._Value, _Value, Other._Value);
+        return Result;
+    }
+
+    BigInteger& operator&=(const BigInteger& Other) noexcept {
+        mpz_and(_Value, _Value, Other._Value);
+        return *this;
+    }
+
+    BigInteger operator|(const BigInteger& Other) const noexcept {
+        BigInteger Result;
+        mpz_ior(Result._Value, _Value, Other._Value);
+        return Result;
+    }
+
+    BigInteger& operator|=(const BigInteger& Other) noexcept {
+        mpz_ior(_Value, _Value, Other._Value);
+        return *this;
+    }
+
+    BigInteger operator^(const BigInteger& Other) const noexcept {
+        BigInteger Result;
+        mpz_xor(Result._Value, _Value, Other._Value);
+        return Result;
+    }
+
+    BigInteger& operator^=(const BigInteger& Other) noexcept {
+        mpz_xor(_Value, _Value, Other._Value);
+        return *this;
+    }
+
+    BigInteger& operator++() noexcept {
+        mpz_add_ui(_Value, _Value, 1);
+        return *this;
+    }
+
+    BigInteger operator++(int) noexcept {
+        BigInteger Result(*this);
+        mpz_add_ui(_Value, _Value, 1);
+        return Result;
+    }
+
+    BigInteger& operator--() noexcept {
+        mpz_sub_ui(_Value, _Value, 1);
+        return *this;
+    }
+
+    BigInteger operator--(int) noexcept {
+        BigInteger Result(*this);
+        mpz_sub_ui(_Value, _Value, 1);
+        return Result;
+    }
+
+    bool IsZero() const noexcept {
+        return mpz_sgn(_Value) == 0;
+    }
+
+    bool IsPositive() const noexcept {
+        return mpz_sgn(_Value) > 0;
+    }
+
+    bool IsNegative() const noexcept {
+        return mpz_sgn(_Value) < 0;
+    }
+
+    bool IsOne() const noexcept {
+        return mpz_cmp_si(_Value, 1) == 0;
+    }
+
+    BigInteger& Load(bool IsNegative, const void* lpBuffer, size_t cbBuffer, bool UseLittleEndian) noexcept {
+        mpz_import(_Value, cbBuffer, UseLittleEndian ? -1 : 1, sizeof(uint8_t), 0, 0, lpBuffer);
+        if (IsNegative)
+            mpz_neg(_Value, _Value);
+        return *this;
+    }
+
+    BigInteger& Load(bool IsNegative, const std::vector<uint8_t> Buffer, bool UseLittleEndian) noexcept {
+        mpz_import(_Value, Buffer.size(), UseLittleEndian ? -1 : 1, sizeof(uint8_t), 0, 0, Buffer.data());
+        if (IsNegative)
+            mpz_neg(_Value, _Value);
+        return *this;
+    }
+
+    void DumpAbs(void* lpBuffer, size_t cbBuffer, bool UseLittleEndian) const {
+        size_t bit_size = mpz_sizeinbase(_Value, 2);
+        size_t storage_size = (bit_size + 7) / 8;
+        if (cbBuffer >= storage_size) {
+            size_t bytes_written;
+            mpz_export(lpBuffer, &bytes_written, UseLittleEndian ? -1 : 1, sizeof(uint8_t), 0, 0, _Value);
+            memset(reinterpret_cast<unsigned char*>(lpBuffer) + bytes_written, 0, cbBuffer - bytes_written);
+        } else {
+            throw std::length_error("Insufficient buffer.");
+        }
+    }
+
+    std::vector<uint8_t> DumpAbs(bool UseLittleEndian) const noexcept {
+        size_t bit_size = mpz_sizeinbase(_Value, 2);
+        size_t storage_size = (bit_size + 7) / 8;
+        std::vector<uint8_t> bytes(storage_size);
+        mpz_export(bytes.data(), nullptr, UseLittleEndian ? -1 : 1, sizeof(uint8_t), 0, 0, _Value);
+        return bytes;
+    }
+
+    size_t BitLength() const noexcept {
+        return mpz_sizeinbase(_Value, 2);
+    }
+
+    bool TestBit(size_t i) const noexcept {
+        return mpz_tstbit(_Value, i) != 0;
+    }
+
+    void SetBit(size_t i) noexcept {
+        mpz_setbit(_Value, i);
+    }
+
+    std::string ToString(size_t Base, bool LowerCase) const {
+        if (2 <= Base && Base <= 10 + 26) {
+            int base = LowerCase ? static_cast<int>(Base) : -static_cast<int>(Base);
+            std::string s(mpz_sizeinbase(_Value, base) + 2, '\x00');
+            
+            mpz_get_str(s.data(), base, _Value);
+
+            while (s.back() == '\x00') {
+                s.pop_back();
+            }
+
+            return s;
+        } else {
+            throw std::invalid_argument("Invalid base value.");
+        }
+    }
+};
+