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

Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
о каких уязвимостях может идти речь, если в этом решении даже защиты нет?
Хорошо, допустим защиты нету.
Расскажи как запустить чит использующий это без лицензии, или же получить исходный код модулей на джаве
 
Пользователь
Статус
Оффлайн
Регистрация
20 Дек 2022
Сообщения
194
Реакции[?]
66
Поинты[?]
36K
Хорошо, допустим защиты нету.
Расскажи как запустить чит использующий это без лицензии, или же получить исходный код модулей на джаве
Покажи мне парт кода где у тебя находится "защита", мб я не вижу его:whyRly:
На счёт запуска кошмарной хуйни(твоего чита), то я увидел только "лицензию" на стороне лаунчера, то есть твою кошмарную хуйню можно запустить через любой майнкрафт лаунчер имея сам модуль и его зависимости
 
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
Покажи мне парт кода где у тебя находится "защита", мб я не вижу его:whyRly:
На счёт запуска кошмарной хуйни(твоего чита), то я увидел только "лицензию" на стороне лаунчера, то есть твою кошмарную хуйню можно запустить через любой майнкрафт лаунчер имея сам модуль и его зависимости
ты код читал? как ты запустишь классы зашифрованые обычным лаунчером?
C++:
byte* decryptedData;
size_t decryptedSize;
decryptData(byteBuffer, fileSize, key, decryptedData, decryptedSize);

jclass defined = env->DefineClass(NULL, classLoader, (jbyte*)decryptedData, decryptedSize);
 
read only ambassador
Пользователь
Статус
Оффлайн
Регистрация
28 Июн 2022
Сообщения
633
Реакции[?]
110
Поинты[?]
14K
ты код читал? как ты запустишь классы зашифрованые обычным лаунчером?
C++:
byte* decryptedData;
size_t decryptedSize;
decryptData(byteBuffer, fileSize, key, decryptedData, decryptedSize);

jclass defined = env->DefineClass(NULL, classLoader, (jbyte*)decryptedData, decryptedSize);
они у тебя буквально в рантайме декриптятся без какой либо защиты :D
 
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
Начинающий
Статус
Оффлайн
Регистрация
28 Июл 2020
Сообщения
40
Реакции[?]
2
Поинты[?]
2K
говно ебучее, ты просто с раздела кубов не выходишь. По сути его работа не сильно отличается от того, что было в разделе майнкрафта
Чо, я с юг не единой строки кода не взял. Мои слова про то что появилось что то на первый взгляд годное - лишь мое поверхносное мнение ибо со всего этого раздела это единственный запуск не через батник.

UPD: Перечитал твое сообщение, поход чот не так понял но все же
 
Начинающий
Статус
Оффлайн
Регистрация
26 Июл 2022
Сообщения
122
Реакции[?]
2
Поинты[?]
2K
Нет не ломали, софт с ~50 юзерами видимо не стоит таких усилий, пастеры не осилят эту защиту, а нормальные люди тратить время не будут
Так ты сливаешься с факта того что KeyAuth можно подменить.
 
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
Так ты сливаешься с факта того что KeyAuth можно подменить.
Все что угодно можно подменить. Не думаю что кейауф хуже какого-нибудь аргентоза
Пожалуйста, авторизуйтесь для просмотра ссылки.
отмахивайся попкорном своим дальше
 
Пользователь
Статус
Оффлайн
Регистрация
20 Дек 2022
Сообщения
194
Реакции[?]
66
Поинты[?]
36K
Все что угодно можно подменить. Не думаю что кейауф хуже какого-нибудь аргентоза

отмахивайся попкорном своим дальше
просто знай что я срал тебе в рот и то что эти 2 defineclass'a проходят через один и тот же уровень абстракции
1722454823298.png
 
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
просто знай что я срал тебе в рот и то что эти 2 defineclass'a проходят через один и тот же уровень абстракции
Посмотреть вложение 282447
Проходят через один и тот же уровень абстракции, но это разные функции и твоя штука с гитхаба работать не будет. А типичный долбаеб против которого сделана эта защита не сможет перебилдить хук
 
40, 40, 40 blackout XD
Read Only
Статус
Оффлайн
Регистрация
15 Янв 2020
Сообщения
456
Реакции[?]
228
Поинты[?]
24K
ты код читал? как ты запустишь классы зашифрованые обычным лаунчером?
C++:
byte* decryptedData;
size_t decryptedSize;
decryptData(byteBuffer, fileSize, key, decryptedData, decryptedSize);

jclass defined = env->DefineClass(NULL, classLoader, (jbyte*)decryptedData, decryptedSize);
ты единственный человек который выжил после аборта!
 
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
Начинающий
Статус
Оффлайн
Регистрация
26 Июл 2022
Сообщения
122
Реакции[?]
2
Поинты[?]
2K
Все что угодно можно подменить. Не думаю что кейауф хуже какого-нибудь аргентоза

отмахивайся попкорном своим дальше
Аргентоз это что или кто?
KeyAuth буквально дичь. для начального проекта
 
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
Начинающий
Статус
Оффлайн
Регистрация
21 Фев 2022
Сообщения
112
Реакции[?]
10
Поинты[?]
9K
Давайте побьем рекорд югейма по попкронам в теме
 
Начинающий
Статус
Оффлайн
Регистрация
12 Июн 2024
Сообщения
470
Реакции[?]
1
Поинты[?]
1K
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;
}
Screenshot 2024-08-03 110713.pngтак и должно быть? :roflanPominki:
 
Сверху Снизу