Начинающий
Начинающий
- Статус
- Оффлайн
- Регистрация
- 30 Окт 2024
- Сообщения
- 18
- Реакции
- 1
хвид на с++ проверка хвида через сайт
Полная хуйня хотел бы узнать чужое мнение и то как это можна улучшить
Полная хуйня хотел бы узнать чужое мнение и то как это можна улучшить
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;
}
