Что нового?

Исходник HWID c++

RenderTraced
RenderTraced
Новичок
Статус
Оффлайн
Регистрация
30 Окт 2024
Сообщения
1
Реакции[?]
0
Поинты[?]
0

Перед прочтением основного контента ниже, пожалуйста, обратите внимание на обновление внутри секции Майна на нашем форуме. У нас появились:

  • бесплатные читы для Майнкрафт — любое использование на свой страх и риск;
  • маркетплейс Майнкрафт — абсолютно любая коммерция, связанная с игрой, за исключением продажи читов (аккаунты, предоставления услуг, поиск кодеров читов и так далее);
  • приватные читы для Minecraft — в этом разделе только платные хаки для игры, покупайте группу "Продавец" и выставляйте на продажу свой софт;
  • обсуждения и гайды — всё тот же раздел с вопросами, но теперь модернизированный: поиск нужных хаков, пати с игроками-читерами и другая полезная информация.

Спасибо!

Нажмите для раскрытия...
хвид на с++ проверка хвида через сайт

Полная хуйня хотел бы узнать чужое мнение и то как это можна улучшить





main.cpp: 
#include <windows.h>
#include <winternl.h>
#include <tlhelp32.h>
#include <psapi.h>
#include <iostream>
#include <string>
#include <vector>
#include <random>
#include <thread>
#include <chrono>
#include <memory>
#include <sstream>
#include <iomanip>
#include <fstream>
#include <array>
#include <map>
#include <openssl/sha.h>
#include <openssl/aes.h>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/bio.h>
#include <curl/curl.h>
#include <wincrypt.h>
#include <iphlpapi.h>
#include <intrin.h>

#pragma comment(lib, "iphlpapi.lib")
#pragma comment(lib, "wintrust.lib")
#pragma comment(lib, "crypt32.lib")


class VM {
private:
    std::vector<uint8_t> code;
    std::vector<uint8_t> stack;
    size_t ip;
    
    void executeVM() {
        while (ip < code.size()) {
            uint8_t opcode = code[ip++];
        }
    }
public:
    VM() : ip(0) {
        stack.resize(1024);
    }
    
    void loadCode(const std::vector<uint8_t>& newCode) {
        code = newCode;
        for (size_t i = 0; i < code.size(); i++) {
            code[i] ^= (uint8_t)(i * 0x7F);
        }
    }
};

class MemoryProtector {
public:
    static void protectMemoryRegion(void* addr, size_t size) {
        DWORD oldProtect;
        VirtualProtect(addr, size, PAGE_READWRITE, &oldProtect);
    }
    
    static void hideFromDebugger(void* addr, size_t size) {
        MEMORY_BASIC_INFORMATION mbi;
        VirtualQuery(addr, &mbi, sizeof(mbi));
        VirtualProtect(addr, size, PAGE_NOACCESS, &mbi.Protect);
    }
};

class AntiDebug {
private:
    static const inline std::vector<std::wstring> debuggerProcesses = {
        L"x64dbg.exe", L"x32dbg.exe", L"windbg.exe", L"ida64.exe",
        L"ida.exe", L"ollydbg.exe", L"radare2.exe", L"cheatengine-x86_64.exe"
    };
    
    static bool checkTimingDiscrepancy() {
        int64_t t1 = __rdtsc();
        Sleep(100);
        int64_t t2 = __rdtsc();
        return (t2 - t1) < 10000000;
    }
    
    static bool checkHardwareBreakpoints() {
        CONTEXT ctx = {};
        ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
        if (GetThreadContext(GetCurrentThread(), &ctx)) {
            return ctx.Dr0 != 0 || ctx.Dr1 != 0 || ctx.Dr2 != 0 || ctx.Dr3 != 0;
        }
        return false;
    }
    
    static bool checkProcessDebugFlags() {
        DWORD flag = 0;
        NTSTATUS(WINAPI * NtQueryInformationProcess)(HANDLE, ULONG, PVOID, ULONG, PULONG);
        [I](FARPROC[/I])&NtQueryInformationProcess = GetProcAddress(
            GetModuleHandleA("ntdll.dll"), "NtQueryInformationProcess");
        return NT_SUCCESS(NtQueryInformationProcess(
            GetCurrentProcess(), 7, &flag, sizeof(DWORD), NULL)) && flag;
    }
    
public:
    static bool isDebugged() {
        if (IsDebuggerPresent()) return true;
        if (checkTimingDiscrepancy()) return true;
        if (checkHardwareBreakpoints()) return true;
        if (checkProcessDebugFlags()) return true;
        
        BOOL remoteDebugger = FALSE;
        CheckRemoteDebuggerPresent(GetCurrentProcess(), &remoteDebugger);
        if (remoteDebugger) return true;
        
        return false;
    }
    
    static void scanForDebuggers() {
        HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        if (snapshot == INVALID_HANDLE_VALUE) return;
        
        PROCESSENTRY32W pe = { sizeof(pe) };
        if (Process32FirstW(snapshot, &pe)) {
            do {
                for (const auto& debugger : debuggerProcesses) {
                    if (_wcsicmp(pe.szExeFile, debugger.c_str()) == 0) {
                        ExitProcess(0);
                    }
                }
            } while (Process32NextW(snapshot, &pe));
        }
        CloseHandle(snapshot);
    }
};

class HWIDGenerator {
private:
    static std::string getVolumeID() {
        DWORD serialNum = 0;
        GetVolumeInformationA("C:\\", nullptr, 0, &serialNum, nullptr, nullptr, nullptr, 0);
        return std::to_string(serialNum);
    }
    
    static std::string getCPUID() {
        std::array<int, 4> cpuInfo;
        std::array<int, 4> cpuInfo2;
        __cpuid(cpuInfo.data(), 0);
        __cpuid(cpuInfo2.data(), 1);
        std::stringstream ss;
        ss << std::hex << std::setfill('0');
        for (int i = 0; i < 4; i++) {
            ss << std::setw(8) << cpuInfo[i];
        }
        ss << std::setw(8) << cpuInfo2[0];
        return ss.str();
    }
    
    static std::string getMACAddress() {
        IP_ADAPTER_INFO adapterInfo[32];
        DWORD dwBufLen = sizeof(adapterInfo);
        DWORD dwStatus = GetAdaptersInfo(adapterInfo, &dwBufLen);
        if (dwStatus != ERROR_SUCCESS) return "";
        
        std::stringstream ss;
        for (int i = 0; i < 6; i++) {
            ss << std::hex << std::setfill('0') << std::setw(2)
               << static_cast<int>(adapterInfo[0].Address[i]);
        }
        return ss.str();
    }
    
    static std::string getBIOSInfo() {
        std::array<char, 128> buffer;
        std::string result;
        std::unique_ptr<FILE, decltype(&_pclose)> pipe(_popen("wmic bios get serialnumber", "r"), _pclose);
        if (!pipe) return "";
        while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
            result += buffer.data();
        }
        return result;
    }
    
public:
    static std::string generateHWID() {
        std::string hwInfo = getVolumeID() + getCPUID() + getMACAddress() + getBIOSInfo();
        
        unsigned char hash[SHA512_DIGEST_LENGTH];
        SHA512_CTX sha512;
        SHA512_Init(&sha512);
        SHA512_Update(&sha512, hwInfo.c_str(), hwInfo.length());
        SHA512_Final(hash, &sha512);
        
        SHA512_Init(&sha512);
        SHA512_Update(&sha512, hash, SHA512_DIGEST_LENGTH);
        SHA512_Final(hash, &sha512);
        
        std::stringstream ss;
        for (int i = 0; i < SHA512_DIGEST_LENGTH; i++) {
            ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
        }
        return ss.str();
    }
};

class Cryptography {
private:
    static const std::string SERVER_PUBLIC_KEY;
    static const std::string AES_KEY;
    static const std::string AES_IV;
    
    static std::vector<unsigned char> rsaEncrypt(const std::string& data) {
        BIO* bio = BIO_new_mem_buf(SERVER_PUBLIC_KEY.c_str(), -1);
        RSA* rsa = PEM_read_bio_RSA_PUBKEY(bio, nullptr, nullptr, nullptr);
        BIO_free(bio);
        
        std::vector<unsigned char> encrypted(RSA_size(rsa));
        int encryptedLength = RSA_public_encrypt(
            data.length(),
            (unsigned char*)data.c_str(),
            encrypted.data(),
            rsa,
            RSA_PKCS1_OAEP_PADDING
        );
        
        RSA_free(rsa);
        if (encryptedLength == -1) return std::vector<unsigned char>();
        encrypted.resize(encryptedLength);
        return encrypted;
    }
    
    static std::vector<unsigned char> aesEncrypt(const std::string& data) {
        EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
        EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), nullptr,
            (unsigned char*)AES_KEY.c_str(), (unsigned char*)AES_IV.c_str());
        
        std::vector<unsigned char> encrypted(data.size() + EVP_MAX_BLOCK_LENGTH);
        int outlen1, outlen2;
        EVP_EncryptUpdate(ctx, encrypted.data(), &outlen1,
            (unsigned char*)data.c_str(), data.size());
        EVP_EncryptFinal_ex(ctx, encrypted.data() + outlen1, &outlen2);
        
        encrypted.resize(outlen1 + outlen2);
        EVP_CIPHER_CTX_free(ctx);
        return encrypted;
    }
    
public:
    static std::string encryptHWID(const std::string& hwid) {
        auto aesEncrypted = aesEncrypt(hwid);
        auto rsaEncrypted = rsaEncrypt(std::string(aesEncrypted.begin(), aesEncrypted.end()));
        
        std::stringstream ss;
        for (unsigned char byte : rsaEncrypted) {
            ss << std::hex << std::setw(2) << std::setfill('0') << (int)byte;
        }
        return ss.str();
    }
};

class NetworkManager {
private:
    static size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* userp) {
        userp->append((char*)contents, size * nmemb);
        return size * nmemb;
    }
    
public:
    static bool verifyHWID(const std::string& encryptedHWID) {
        CURL* curl = curl_easy_init();
        if (!curl) return false;
        
        std::string url = "https://fflake/verify";
        std::string postFields = "hwid=" + encryptedHWID;
        std::string response;
        
        struct curl_slist* headers = nullptr;
        headers = curl_slist_append(headers, "Content-Type: application/x-www-form-urlencoded");
        headers = curl_slist_append(headers, "User-Agent: Mozilla/5.0");
        
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postFields.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2L);
        
        CURLcode res = curl_easy_perform(curl);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
        
        if (res != CURLE_OK) return false;
        return response == "valid";
    }
};

class Loader {
private:
    VM vm;
    static bool isRunning;
    
    static void antiDebugThread() {
        while (isRunning) {
            if (AntiDebug::isDebugged()) {
                char* ptr = nullptr;
                *ptr = 1;
            }
            AntiDebug::scanForDebuggers();
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    }
    
    void initSecurity() {
        MemoryProtector::protectMemoryRegion(this, sizeof(*this));
        
        isRunning = true;
        std::thread(antiDebugThread).detach();
    }
    
public:
    Loader() {
        initSecurity();
    }
    
    bool run() {
        try {
            std::string hwid = HWIDGenerator::generateHWID();
            std::string encryptedHWID = Cryptography::encryptHWID(hwid);
            
            if (!NetworkManager::verifyHWID(encryptedHWID)) {
                std::cout << "Доступ запрещен!" << std::endl;
                return false;
            }
            
            std::cout << "HWID подтвержден!" << std::endl;
            return true;
            
        } catch (...) {
            return false;
        }
    }
    
    ~Loader() {
        isRunning = false;
    }
};

bool Loader::isRunning = false;


bool Loader::isRunning = false;

class FileIntegrityChecker {
private:
    static std::string calculateFileHash(const std::string& filename) {
        std::ifstream file(filename, std::ios::binary);
        if (!file) return "";
        
        SHA512_CTX sha512;
        SHA512_Init(&sha512);
        
        char buffer[4096];
        while (file.read(buffer, sizeof(buffer))) {
            SHA512_Update(&sha512, buffer, file.gcount());
        }
        
        unsigned char hash[SHA512_DIGEST_LENGTH];
        SHA512_Final(hash, &sha512);
        
        std::stringstream ss;
        for(int i = 0; i < SHA512_DIGEST_LENGTH; i++) {
            ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
        }
        
        return ss.str();
    }
    
public:
    static bool verifyIntegrity() {
        char path[MAX_PATH];
        GetModuleFileNameA(NULL, path, MAX_PATH);
        std::string currentHash = calculateFileHash(path);
        
        const std::string ORIGINAL_HASH = "";
        
        return currentHash == ORIGINAL_HASH;
    }
};

class DLLProtector {
private:
    static std::vector<std::wstring> getLoadedModules() {
        std::vector<std::wstring> modules;
        HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32,
                                                 GetCurrentProcessId());
        
        if (snapshot != INVALID_HANDLE_VALUE) {
            MODULEENTRY32W moduleEntry = { sizeof(moduleEntry) };
            if (Module32FirstW(snapshot, &moduleEntry)) {
                do {
                    modules.push_back(moduleEntry.szModule);
                } while (Module32NextW(snapshot, &moduleEntry));
            }
            CloseHandle(snapshot);
        }
        
        return modules;
    }
};

class VMDetector {
public:
    static bool isRunningInVM() {
        if (checkVMwareArtifacts()) return true;
        if (checkVirtualBoxArtifacts()) return true;
        if (checkHyperVArtifacts()) return true;
        return false;
    }
    
private:
    static bool checkVMwareArtifacts() {
        HKEY hKey;
        if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
            "SOFTWARE\\VMware, Inc.\\VMware Tools", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
            RegCloseKey(hKey);
            return true;
        }
        return false;
    }
    
    static bool checkVirtualBoxArtifacts() {
        HKEY hKey;
        if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
            "SOFTWARE\\Oracle\\VirtualBox Guest Additions", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
            RegCloseKey(hKey);
            return true;
        }
        return false;
    }
    
    static bool checkHyperVArtifacts() {
        HKEY hKey;
        if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
            "SOFTWARE\\Microsoft\\Virtual Machine\\Guest\\Parameters",
            0, KEY_READ, &hKey) == ERROR_SUCCESS) {
            RegCloseKey(hKey);
            return true;
        }
        return false;
    }
};

int main() {
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    
    try {
        
        std::unique_ptr<Loader> loader = std::make_unique<Loader>();
        if (!loader->run()) {
            return 1;
        }
        

        std::cout << "Нажмите Enter для выхода...";
        std::cin.get();
        
    } catch (...) {
        MessageBoxA(NULL, "Критическая ошибка!", "Ошибка", MB_ICONERROR);
        return 1;
    }
    
    return 0;
}
 
Войдите или зарегистрируйтесь для ответа.
Похожие темы
invokegpt
Исходник HWID loader C++
2
Ответы
27
Просмотры
2K
OXXXYMlRON
OXXXYMlRON
L
Куплю Loader x injector c++
Ответы
0
Просмотры
433
legeonty1
L
Sexemen
Исходник Cheat hider на питоне + hwid защита
Ответы
19
Просмотры
1K
krinj12
K
ganas
Исходник Loader No Hwid No Obf [c]
Ответы
14
Просмотры
906
f1nk175
f1nk175
K
Вопрос SQL сервер в c++
Ответы
6
Просмотры
732
lom4ik tap
L
Немного о главном
Полезные мелочи
О нас

Проект предоставляет различный материал, относящийся к сфере киберспорта, программирования, ПО для игр, а также позволяет его участникам общаться на многие другие темы. Почта для жалоб: admin@yougame.biz

Поделиться страницей
Сверху Снизу