Что нового?

Исходник C++ DefineClass Loader

werwedc
W
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K

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

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

Спасибо!

Нажмите для раскрытия...
C++: 
#include <Windows.h>
#include "auth.hpp"
#include <string>
#include "skStr.h"
#include <windows.h>
#include <jni.h>
#include <thread>
#include <utils.hpp>
#include <set>
#include <vector>
#include <psapi.h>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <memory>
#include <utility>
#include <cstdio>
#include <random>
#include <openssl/sha.h>
#include <windows.h>
#include <openssl/sha.h>
#include <openssl/evp.h>
#include <openssl/aes.h>
#include <filesystem>
#include <cryptopp/aes.h>
#include <cryptopp/modes.h>
#include <cryptopp/filters.h>
#include <cryptopp/files.h>
#include <cryptopp/hex.h>
#include <locale>

#pragma comment(lib, "psapi.lib")   

#define RESET   "\033[0m"
#define RED     "\033[31m"
#define GREEN   "\033[32m"
#define YELLOW  "\033[33m"
#define BLUE    "\033[34m"
#define MAGENTA "\033[35m"
#define CYAN    "\033[36m"
#define WHITE   "\033[37m"

std::string tm_to_readable_time(tm ctx);
static std::time_t string_to_timet(std::string timestamp);
static std::tm timet_to_tm(time_t timestamp);
const std::string compilation_date = (std::string)skCrypt(DATE);
const std::string compilation_time = (std::string)skCrypt(TIME);

using namespace KeyAuth;
using namespace CryptoPP;

auto name = skCrypt("");
auto ownerid = skCrypt("");
auto secret = skCrypt(""); // Тут свое вставьте
auto version = skCrypt("1.0");
auto url = skCrypt("https://keyauth.win/api/1.2/"); // change if you're self-hosting

api KeyAuthApp(name.decrypt(), ownerid.decrypt(), secret.decrypt(), version.decrypt(), url.decrypt());

std::wstring stringToWstring(const std::string& str)
{
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
    std::wstring wstrTo(size_needed, 0);
    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed);
    return wstrTo;
}

std::string toLowerCase(const std::string& input) {
    std::string result = input;

    for (char& c : result) {
        c = std::tolower(c);
    }

    return result;
}
BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
    char buffer[128];
    GetWindowTextA(hwnd, buffer, sizeof(buffer));
    std::string help = buffer;
    std::transform(help.begin(), help.end(), help.begin(), ::tolower);
    if (toLowerCase(std::string(help)).find(skCrypt("injector")) != std::string::npos
        toLowerCase(std::string(help)).find(skCrypt("decompiler")) != std::string::npos
        toLowerCase(std::string(help)).find(skCrypt("recaf")) != std::string::npos
        toLowerCase(std::string(help)).find(skCrypt("deobfuscator")) != std::string::npos
        toLowerCase(std::string(help)).find(skCrypt("debugger")) != std::string::npos
        toLowerCase(std::string(help)).find(skCrypt("fiddler")) != std::string::npos
        toLowerCase(std::string(help)).find(skCrypt("bytecode")) != std::string::npos
        toLowerCase(std::string(help)).find(skCrypt("hacker")) != std::string::npos
        toLowerCase(std::string(help)).find(skCrypt("v8.3")) != std::string::npos
        toLowerCase(std::string(help)).find(skCrypt("inject")) != std::string::npos)
    {
        std::cout << "SOSI HUI";
        KeyAuthApp.ban();
        exit(0);
    }
    return TRUE;
}

void CheckDllsRepeatedly(DWORD processID)
{
    while (true)
    {
        EnumWindows(EnumWindowsProc, 0);
        std::this_thread::sleep_for(std::chrono::milliseconds(5));

    }

}

constexpr int NUM_THREADS = 4;

int current = 0;
int total = 0;
std::string calculateSHA256(const std::string& filePath) {
    std::ifstream file(filePath, std::ios::binary);
    if (!file.is_open()) {
        return "";  // Handle file open failure
    }

    SHA256_CTX sha256;
    SHA256_Init(&sha256);

    char buffer[1024];
    while (file.read(buffer, sizeof(buffer))) {
        SHA256_Update(&sha256, buffer, file.gcount());
    }

    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_Final(hash, &sha256);

    std::string fileHash;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        char buf[3];
        snprintf(buf, sizeof(buf), "%02x", hash[i]);
        fileHash += buf;
    }

    return fileHash;
}
void processFiles(const std::vector<std::string>& files, int threadID, std::vector<std::string>& fileHashes, HANDLE hConsole) {
    for (size_t i = threadID; i < files.size(); i += NUM_THREADS) {
        std::string filePath = files[i];
        std::string fileHash = calculateSHA256(filePath);
        if (!fileHash.empty()) {
            fileHashes[i] = fileHash;
        }
        current++;
        if (current % 100 == 0  current+5 > total) {
            CONSOLE_SCREEN_BUFFER_INFO csbi;
            GetConsoleScreenBufferInfo(hConsole, &csbi);
            COORD cursorPosition;
            cursorPosition = csbi.dwCursorPosition;

            // Move the cursor to the beginning of the line
            cursorPosition.X = 0;
            SetConsoleCursorPosition(hConsole, cursorPosition);
            if ((float)current / (float)total * 100 > 99) {
                std::cout << "Stage #7: " << 100 << "%" << "                                              " << std::endl;
            }
            else {
                std::cout << "Stage #7: " << (float)current / (float)total * 100 << "%" << "                                              " <<  std::endl;
            }
            SetConsoleCursorPosition(hConsole, cursorPosition);
        }
    }
}
int countFilesInTree(const std::string& folderPath) {
    int fileCount = 0;

    for (const auto& entry : std::filesystem::recursive_directory_iterator(folderPath)) {
        if (std::filesystem::is_regular_file(entry)) {
            fileCount++;
        }
    }

    return fileCount;
}



std::string folderPath = skCrypt("C:\\werwedc\\classesDev").decrypt();
std::string folderPath2 = skCrypt("C:\\werwedc\\natives").decrypt();


void encryptFile(const std::string& fileName, const byte* key)
{
    std::ifstream inputFile(fileName, std::ios::binary | std::ios::ate);

    if (!inputFile.is_open()) {
        std::cerr << "Error opening file: " << fileName << std::endl;
        return;
    }
    
size_t fileSize = static_cast<size_t>(inputFile.tellg());
    inputFile.seekg(0, std::ios::beg);

    std::vector<byte> fileContent(fileSize);
    inputFile.read(reinterpret_cast<char*>(fileContent.data()), fileSize);
    inputFile.close();

    byte iv[AES::BLOCKSIZE];
    memset(iv, 0x00, AES::BLOCKSIZE);

    CBC_Mode<AES>::Encryption encryption(key, AES::DEFAULT_KEYLENGTH, iv);

    ArraySource(fileContent.data(), fileContent.size(), true,
        new StreamTransformationFilter(encryption,
            new FileSink(fileName.c_str(), std::ios::binary), StreamTransformationFilter::PKCS_PADDING
        )
    );
}



void decryptData(const byte* encryptedData, size_t dataSize, const byte* key, byte*& decryptedData, size_t& decryptedSize)
{
    byte iv[AES::BLOCKSIZE];
    memset(iv, 0x00, AES::BLOCKSIZE);

    CBC_Mode<AES>::Decryption decryption(key, AES::DEFAULT_KEYLENGTH, iv);
    decryptedSize = dataSize;
    decryptedData = new byte[decryptedSize];

    ArraySource(encryptedData, dataSize, true,
        new StreamTransformationFilter(decryption,
            new ArraySink(decryptedData, decryptedSize)
        )
    );

    // Remove PKCS7 padding
    size_t paddingSize = static_cast<size_t>(decryptedData[decryptedSize - 1]);
    if (paddingSize <= decryptedSize) {
        decryptedSize -= paddingSize;
    }
    else {
        // Invalid padding, handle accordingly (e.g., throw an exception or log an error)
        std::cerr << "Invalid padding size!" << std::endl;
        // Optionally, you might want to return or handle the error in another way
    }
}
void writeBytesToFile(const byte* data, size_t dataSize, const std::string& fileName) {
    std::ofstream outputFile(fileName, std::ios::binary | std::ios::trunc);
    if (!outputFile.is_open()) {
        std::cerr << "Error opening output file: " << fileName << std::endl;
        return;
    }

    // Write the data to the file
    outputFile.write(reinterpret_cast<const char*>(data), dataSize);

    outputFile.close();
}
int main()
{

    std::locale::global(std::locale("en_US.utf8"));
    std::wcout.imbue(std::locale());
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleTextAttribute(hConsole, FOREGROUND_RED);
    std::wcout <<
        L"░██╗░░░░░░░██╗███████╗██████╗░░██╗░░░░░░░██╗███████╗██████╗░░█████╗░" << std::endl <<
        L"░██║░░██╗░░██║██╔════╝██╔══██╗░██║░░██╗░░██║██╔════╝██╔══██╗██╔══██╗" << std::endl <<
        L"░╚██╗████╗██╔╝█████╗░░██████╔╝░╚██╗████╗██╔╝█████╗░░██║░░██║██║░░╚═╝" << std::endl <<
        L"░░████╔═████║░██╔══╝░░██╔══██╗░░████╔═████║░██╔══╝░░██║░░██║██║░░██╗" << std::endl <<
        L"░░╚██╔╝░╚██╔╝░███████╗██║░░██║░░╚██╔╝░╚██╔╝░███████╗██████╔╝╚█████╔╝" << std::endl <<
        L"░░░╚═╝░░░╚═╝░░╚══════╝╚═╝░░╚═╝░░░╚═╝░░░╚═╝░░╚══════╝╚═════╝░░╚════╝░" << std::endl;
    SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_GREEN);

    const std::string folderPathE = skCrypt("C:\\werwedc\\classesDev").decrypt();
    std::string shlapa = skCrypt("").decrypt(); // ключ придумайте
    const unsigned char* key = reinterpret_cast<const unsigned char*>(shlapa.c_str());
    
    /*for (const auto& entry : std::filesystem::recursive_directory_iterator("C:\\werwedc\\classesDev\\ua\\werwedc"))
    {
        if (std::filesystem::is_regular_file(entry))
        {
            if (entry.path().string().find(".class") == std::string::npos) {
                continue;
            }
            const std::string inputFileName = entry.path().string();

            // Encrypt the file
            encryptFile(inputFileName, key);
            std::cout << "encrypted: " << inputFileName << std::endl;
        }
    }*/
    
    KeyAuthApp.init();
    std::cout << "Stage #2" << std::endl;
    std::string consoleTitle = (std::string)skCrypt("Loader - Built at:  ") + compilation_date + " " + compilation_time;
    SetConsoleTitleA(consoleTitle.c_str());
    std::cout << "Stage #3" << std::endl;
    
    if (KeyAuthApp.checkblack()) {
        abort();
    }
    
    
std::cout << "Stage #4" << std::endl;
    if (!KeyAuthApp.data.success)
    {
        std::cout << skCrypt("\n Status: ") << KeyAuthApp.data.message;
        Sleep(1500);
        exit(0);
    }
    if (std::filesystem::exists("test.json"))
    {
        if (!CheckIfJsonKeyExists("test.json", "username"))
        {
            std::string key = ReadFromJson("test.json", "license");
            KeyAuthApp.license(key);
            if (!KeyAuthApp.data.success)
            {
                std::remove("test.json");
                std::cout << skCrypt("\n Status: ") << KeyAuthApp.data.message;
                Sleep(1500);

                exit(0);
            }
            std::cout << skCrypt("Successfully Automatically Logged In\n");
        }
        else
        {
            std::string username = ReadFromJson("test.json", "username");
            std::string password = ReadFromJson("test.json", "password");
            KeyAuthApp.login(username, password);
            if (!KeyAuthApp.data.success)
            {
                std::remove("test.json");
                std::cout << skCrypt("\n Status: ") << KeyAuthApp.data.message;
                Sleep(1500);

                exit(0);
            }
            std::cout << skCrypt("Successfully Automatically Logged In\n");
        }
    }
    else
    {
        std::string key;
        std::cout << skCrypt("\n Enter license: ");
        std::cin >> key;
        KeyAuthApp.license(key);

        if (!KeyAuthApp.data.success)
        {
            std::cout << skCrypt("\n Status: ") << KeyAuthApp.data.message;
            Sleep(1500);
            exit(0);
        }

        WriteToJson("test.json", "license", key, false, "", "");
        std::cout << skCrypt("Successfully Created File For Auto Login");
    }
    std::cout << "Stage #5" << std::endl;

    for (int i = 0; i < KeyAuthApp.data.subscriptions.size(); i++) {
        auto sub = KeyAuthApp.data.subscriptions.at(i);
        std::cout << skCrypt("Client till: ") << tm_to_readable_time(timet_to_tm(string_to_timet(sub.expiry)));
    }
    
    DWORD processID = GetCurrentProcessId();
    std::thread t234234(CheckDllsRepeatedly, processID);


    std::cout << "Stage #6" << std::endl;
    std::vector<std::string> files;
    for (const auto& entry : std::filesystem::recursive_directory_iterator(folderPath)) {
        if (std::filesystem::is_regular_file(entry)) {
            files.push_back(entry.path().string());
        }
    }
    for (const auto& entry : std::filesystem::recursive_directory_iterator(folderPath2)) {
        if (std::filesystem::is_regular_file(entry)) {
            files.push_back(entry.path().string());
        }
    }
    for (const auto& entry : std::filesystem::recursive_directory_iterator(skCrypt("C:\\jdk-17.0.2").decrypt())) {
        if (std::filesystem::is_regular_file(entry)) {
            files.push_back(entry.path().string());
        }
    }
    total = files.size();
    std::vector<std::string> fileHashes(files.size());

    std::vector<std::thread> threads;
    for (int i = 0; i < NUM_THREADS; i++) {
        threads.emplace_back(processFiles, std::ref(files), i, std::ref(fileHashes), hConsole);
    }

    for (std::thread& thread : threads) {
        thread.join();
    }

    SHA256_CTX combinedSha256;
    SHA256_Init(&combinedSha256);

    for (size_t i = 0; i < files.size(); i++) {
        if (!fileHashes[i].empty()) {
            SHA256_Update(&combinedSha256, fileHashes[i].c_str(), fileHashes[i].length());
        }
    }

    unsigned char combinedHash[SHA256_DIGEST_LENGTH];
    SHA256_Final(combinedHash, &combinedSha256);
std::string combinedHashString;
    for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
        char buf[3];
        snprintf(buf, sizeof(buf), "%02x", combinedHash[i]);
        combinedHashString += buf;
    }
    std::cout << std::endl << "Stage #8" << std::endl;
    if (combinedHashString != skCrypt("").decrypt()) {
        KeyAuthApp.ban();
        abort();
        exit(0);
    }
    //std::cout << "Stage #9" << std::endl;
    //std::cout << combinedHashString;
    
    int mem = 1024;
    SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN);
    std::cout << std::endl << "Enter the amount of memory(in megabytes)" << std::endl;
    std::cin >> mem;
    std::string memS = "-Xmx" + mem;
    memS = memS + "m";
    SetConsoleTextAttribute(hConsole, FOREGROUND_BLUE | FOREGROUND_GREEN);
    JavaVM* jvm;
    JNIEnv* env;
    JavaVMInitArgs vm_args;
    JavaVMOption* options = new JavaVMOption[4];
    options[0].optionString = const_cast<char*>("-Djava.class.path=C:\\werwedc\\classesDev");
    options[1].optionString = const_cast<char*>("-Djava.library.path=C:\\werwedc\\natives");
   // options[2].optionString = const_cast<char*>("-verbose:jni");
    options[3].optionString = const_cast<char*>(memS.c_str());
    options[2].optionString = const_cast<char*>("-Xverify:none");

    vm_args.version = JNI_VERSION_10;
    vm_args.nOptions = 3;
    vm_args.options = options;
    vm_args.ignoreUnrecognized = false;

    jint ret = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);

    jclass loader = env->FindClass("java/lang/ClassLoader");

    jmethodID getClassLoaderId = env->GetStaticMethodID(loader, "getSystemClassLoader", "()Ljava/lang/ClassLoader;");
    jobject classLoader = env->CallStaticObjectMethod(loader, getClassLoaderId);
    std::cout << "Stage #10" << std::endl;
    //Define Utility
    std::string filePath = skCrypt("C:\\werwedc\\classesDev\\ua\\werwedc\\utility\\Utility.class").decrypt();
    FILE* file = fopen(filePath.c_str(), "rb");

    fseek(file, 0, SEEK_END);
    long fileSize = ftell(file);
    rewind(file);
    byte* byteBuffer = (byte*)malloc(fileSize);
    fread(byteBuffer, 1, fileSize, file);
    fclose(file);

    byte* decryptedData;
    size_t decryptedSize;
    decryptData(byteBuffer, fileSize, key, decryptedData, decryptedSize);


    jclass defined = env->DefineClass(NULL, classLoader, (jbyte*)decryptedData, decryptedSize);

    //Define Custom Button
    filePath = skCrypt("C:\\werwedc\\classesDev\\ua\\werwedc\\ui\\CustomButton.class").decrypt();
    file = fopen(filePath.c_str(), "rb");

    fseek(file, 0, SEEK_END);
    fileSize = ftell(file);
    rewind(file);
    byteBuffer = (byte*)malloc(fileSize);
    fread(byteBuffer, 1, fileSize, file);
    fclose(file);

    decryptData(byteBuffer, fileSize, key, decryptedData, decryptedSize);

    defined = env->DefineClass(NULL, classLoader, (jbyte*)decryptedData, decryptedSize);

    //Define Module
    filePath = skCrypt("C:\\werwedc\\classesDev\\ua\\werwedc\\modules\\Module.class").decrypt();
    file = fopen(filePath.c_str(), "rb");

    fseek(file, 0, SEEK_END);
    fileSize = ftell(file);
    rewind(file);
    byteBuffer = (byte*)malloc(fileSize);
    fread(byteBuffer, 1, fileSize, file);
    fclose(file);

    decryptData(byteBuffer, fileSize, key, decryptedData, decryptedSize);

    defined = env->DefineClass(NULL, classLoader, (jbyte*)decryptedData, decryptedSize);
    //Define setting
    filePath = skCrypt("C:\\werwedc\\classesDev\\ua\\werwedc\\modules\\settings\\Setting.class").decrypt();
    file = fopen(filePath.c_str(), "rb");

    fseek(file, 0, SEEK_END);
    fileSize = ftell(file);
    rewind(file);
    byteBuffer = (byte*)malloc(fileSize);
    fread(byteBuffer, 1, fileSize, file);
    fclose(file);

    decryptData(byteBuffer, fileSize, key, decryptedData, decryptedSize);
defined = env->DefineClass(NULL, classLoader, (jbyte*)decryptedData, decryptedSize);
    //Define Manager
    filePath = skCrypt("C:\\werwedc\\classesDev\\ua\\werwedc\\config\\Manager.class").decrypt();
    file = fopen(filePath.c_str(), "rb");

    fseek(file, 0, SEEK_END);
    fileSize = ftell(file);
    rewind(file);
    byteBuffer = (byte*)malloc(fileSize);
    fread(byteBuffer, 1, fileSize, file);
    fclose(file);

    decryptData(byteBuffer, fileSize, key, decryptedData, decryptedSize);

    defined = env->DefineClass(NULL, classLoader, (jbyte*)decryptedData, decryptedSize);
    //Define Config Updater
    filePath = skCrypt("C:\\werwedc\\classesDev\\ua\\werwedc\\config\\ConfigUpdater.class").decrypt();
    file = fopen(filePath.c_str(), "rb");

    fseek(file, 0, SEEK_END);
    fileSize = ftell(file);
    rewind(file);
    byteBuffer = (byte*)malloc(fileSize);
    fread(byteBuffer, 1, fileSize, file);
    fclose(file);

    decryptData(byteBuffer, fileSize, key, decryptedData, decryptedSize);

    defined = env->DefineClass(NULL, classLoader, (jbyte*)decryptedData, decryptedSize);
    //Define

    filePath = skCrypt("C:\\werwedc\\classesDev\\ua\\werwedc\\config\\Config.class").decrypt();
    file = fopen(filePath.c_str(), "rb");

    fseek(file, 0, SEEK_END);
    fileSize = ftell(file);
    rewind(file);
    byteBuffer = (byte*)malloc(fileSize);
    fread(byteBuffer, 1, fileSize, file);
    fclose(file);

    decryptData(byteBuffer, fileSize, key, decryptedData, decryptedSize);

    defined = env->DefineClass(NULL, classLoader, (jbyte*)decryptedData, decryptedSize);

    for (const auto& entry : std::filesystem::recursive_directory_iterator(skCrypt("C:\\werwedc\\classesDev\\ua\\werwedc").decrypt())) {
        if (std::filesystem::is_regular_file(entry)) {

            //для дефайна ебучего класса
            const std::filesystem::path& path = entry.path();

            // Convert to string with backslashes
            std::string filePath = path.string();

            if (filePath.find(".class") == std::string::npos) {
                continue;
            }
            //filePath = "C:\\werwedc\\testDefine\\" + filePath;
            //std::cout << filePath << std::endl;
            FILE* file = fopen(filePath.c_str(), "rb");

            fseek(file, 0, SEEK_END);
            long fileSize = ftell(file);
            rewind(file);
            byte* byteBuffer = (byte*)malloc(fileSize);
            fread(byteBuffer, 1, fileSize, file);
            fclose(file);

            // Decrypt data
            byte* decryptedData;
            size_t decryptedSize;
            decryptData(byteBuffer, fileSize, key, decryptedData, decryptedSize);


            jclass defined = env->DefineClass(NULL, classLoader, (jbyte*)decryptedData, decryptedSize);
            /*if (env->ExceptionCheck()) {
                env->ExceptionDescribe();
                env->ExceptionClear();
            }*/
        }
    }
    std::cout << "Stage #11" << std::endl;
    jclass StartClass = env->FindClass(skCrypt("Start").decrypt());
    
    std::cout << "Stage #12" << std::endl;
    if (StartClass != nullptr) {
        jmethodID mid = env->GetStaticMethodID(StartClass, "main", "([Ljava/lang/String;)V");
        if (mid != nullptr) {
            jobjectArray args = env->NewObjectArray(1, env->FindClass("java/lang/String"), NULL);
            SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN);
            env->CallStaticVoidMethod(StartClass, mid, args);
        }
    }

    std::cout << skCrypt("\n\n Closing in five seconds...");
    Sleep(5000);
    exit(0);
}

std::string tm_to_readable_time(tm ctx) {
    char buffer[80];

    strftime(buffer, sizeof(buffer), "%a %m/%d/%y %H:%M:%S %Z", &ctx);

    return std::string(buffer);
}

static std::time_t string_to_timet(std::string timestamp) {
    auto cv = strtol(timestamp.c_str(), NULL, 10); // long

    return (time_t)cv;
}

static std::tm timet_to_tm(time_t timestamp) {
    std::tm context;

    localtime_s(&context, &timestamp);

    return context;
}
 
werwedc
W
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
ISoonLok написал(а):
Если я названия окна поменяю, то твоя защита наебнётся сразу :roflanEbalo:
Нажмите для раскрытия...
1) Это не единственная мера защиты, наебнется только эта проверка а не весь лоадер :roflanEbalo:
2) Пока ты догадаешься это сделать у тебя уже заберет ключ :roflanEbalo:
 
ISoonLok
ISoonLok
Начинающий
Статус
Оффлайн
Регистрация
18 Июн 2022
Сообщения
278
Реакции[?]
13
Поинты[?]
4K
werwedc написал(а):
1) Это не единственная мера защиты, наебнется только эта проверка а не весь лоадер :roflanEbalo:
2) Пока ты догадаешься это сделать у тебя уже заберет ключ :roflanEbalo:
Нажмите для раскрытия...
Обязательно в 2024 году использовать КейАутх :fearscream:?
 
werwedc
W
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
SWIITIK
S
Read Only
Статус
Оффлайн
Регистрация
31 Авг 2023
Сообщения
700
Реакции[?]
6
Поинты[?]
5K
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
хуевая работа от chat gpt :fearscream::fearscream::fearscream::fearscream::fearscream:
 
werwedc
W
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
Последнее редактирование:
FruZer
FruZer
Начинающий
Статус
Оффлайн
Регистрация
28 Июл 2020
Сообщения
40
Реакции[?]
2
Поинты[?]
2K
xnet написал(а):
это нейронка бро
Нажмите для раскрытия...
Мне чуть чуть все равно, я это использовать не планирую, чисто по быстрому глянув код выглядит как адекватный запуск не через батник
 
IgorVishevsky
IgorVishevsky
Начинающий
Статус
Оффлайн
Регистрация
26 Июл 2022
Сообщения
122
Реакции[?]
2
Поинты[?]
2K
werwedc написал(а):
1) Это не единственная мера защиты, наебнется только эта проверка а не весь лоадер :roflanEbalo:
2) Пока ты догадаешься это сделать у тебя уже заберет ключ :roflanEbalo:
Нажмите для раскрытия...
werwedc написал(а):
Обязательно в 2024 тратить кучу времени и денег на свою систему? И что не так с КейАутх?
Нажмите для раскрытия...
подменить легче легкого.
 
vmprotect
pasting corporation
vmprotect
Участник
Статус
Оффлайн
Регистрация
4 Дек 2022
Сообщения
730
Реакции[?]
216
Поинты[?]
3K
1722361589882.png
ТАК НАЗЫВАЕМЫЙ, АНТИДЕБАГГЕР
FruZer написал(а):
Хм, впервые на юг что то выглядит как +- годное
Нажмите для раскрытия...
говно ебучее, ты просто с раздела кубов не выходишь. По сути его работа не сильно отличается от того, что было в разделе майнкрафта
 
werwedc
W
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
IgorVishevsky написал(а):
подменить легче легкого.
Нажмите для раскрытия...
Ну и как?) Последний эмулятор был хуй знает когда, сам ты в жизни не подменишь игорек. Тут гораздо легче другими методами крякать чем тратить столько времени на подмен кейауфа
vmprotect написал(а):
Посмотреть вложение 282379
ТАК НАЗЫВАЕМЫЙ, АНТИДЕБАГГЕР

говно ебучее, ты просто с раздела кубов не выходишь. По сути его работа не сильно отличается от того, что было в разделе майнкрафта
Нажмите для раскрытия...
ТАК НАЗЫВАЕМАЯ ЗАЩИТА ОТ ДЕБИЛОВ. Антидебаггер можно использовать из програмного обеспечения в твоем нике, например.
Сам принцип работы лоадера не стоит того чтобы тратить больше усилий на свой антидебаггер
 
IgorVishevsky
IgorVishevsky
Начинающий
Статус
Оффлайн
Регистрация
26 Июл 2022
Сообщения
122
Реакции[?]
2
Поинты[?]
2K
werwedc написал(а):
Ну и как?) Последний эмулятор был хуй знает когда, сам ты в жизни не подменишь игорек. Тут гораздо легче другими методами крякать чем тратить столько времени на подмен кейауфа

ТАК НАЗЫВАЕМАЯ ЗАЩИТА ОТ ДЕБИЛОВ. Антидебаггер можно использовать из програмного обеспечения в твоем нике, например.
Сам принцип работы лоадера не стоит того чтобы тратить больше усилий на свой антидебаггер
Нажмите для раскрытия...
Ого как я вижу ты любитель искать готовое на гитхабе. тебе твой KeyAuth уже ломали с твоим Werwedc клиентом или не помнишь?
 
werwedc
W
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
IgorVishevsky написал(а):
Ого как я вижу ты любитель искать готовое на гитхабе. тебе твой KeyAuth уже ломали с твоим Werwedc клиентом или не помнишь?
Нажмите для раскрытия...
Нет не ломали, софт с ~50 юзерами видимо не стоит таких усилий, пастеры не осилят эту защиту, а нормальные люди тратить время не будут
 
escapefromsoul
escapefromsoul
Пользователь
Статус
Оффлайн
Регистрация
20 Дек 2022
Сообщения
194
Реакции[?]
66
Поинты[?]
36K
werwedc написал(а):
Нет не ломали, софт с ~50 юзерами видимо не стоит таких усилий, пастеры не осилят эту защиту, а нормальные люди тратить время не будут
Нажмите для раскрытия...
как ты можешь вот эту кошмарную хуйню называть защитой?
 
werwedc
W
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
escapefromsoul написал(а):
как ты можешь вот эту кошмарную хуйню называть защитой?
Нажмите для раскрытия...
очень просто, потому что она работает против малообразованых особ
если ты знаешь простой способ как это крякнуть я готов выслушать критику
 
escapefromsoul
escapefromsoul
Пользователь
Статус
Оффлайн
Регистрация
20 Дек 2022
Сообщения
194
Реакции[?]
66
Поинты[?]
36K
werwedc написал(а):
очень просто, потому что она работает против малообразованых особ
если ты знаешь простой способ как это крякнуть я готов выслушать критику
Нажмите для раскрытия...
да об это дерьмище даже руки марать никто не будет:LUL:
ты лучше обьясни давай что это за говно 1722426468581.png
 
werwedc
W
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
escapefromsoul написал(а):
да об это дерьмище даже руки марать никто не будет:LUL:
ты лучше обьясни давай что это за говно Посмотреть вложение 282423
Нажмите для раскрытия...
из openssl не используется, можно удалить
Вопросом на вопрос не отвечают, если ты такой умный расскажи про уязвимости защиты
я
escapefromsoul написал(а):
да об это дерьмище даже руки марать никто не будет:LUL:
ты лучше обьясни давай что это за говно Посмотреть вложение 282423
Нажмите для раскрытия...
я не фиксил ошибки перед тем как выложить потому что у меня проекта нету уже
 
escapefromsoul
escapefromsoul
Пользователь
Статус
Оффлайн
Регистрация
20 Дек 2022
Сообщения
194
Реакции[?]
66
Поинты[?]
36K
werwedc написал(а):
Вопросом на вопрос не отвечают, если ты такой умный расскажи про уязвимости защиты
Нажмите для раскрытия...
о каких уязвимостях может идти речь, если в этом решении даже защиты нет?
 
Войдите или зарегистрируйтесь для ответа.
Похожие темы
ZxCiii
Гайд Как защитить чит используя class loader
2
Ответы
25
Просмотры
3K
badwalk
B
peheader1337
C++ Вопрос Как дефайнить не один класс, а несколько? [C++ JNI]
Ответы
10
Просмотры
1K
JabaHacks
J
Немного о главном
Полезные мелочи
О нас

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

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