Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· OpenAIAi2 WildChat-4.8M (AI2)

Всё ли в порядке с этим кодом DLL на C++, который будет инжектится в процесс: #include…

  1. User

    Всё ли в порядке с этим кодом DLL на C++, который будет инжектится в процесс: #include "pch.h" #include <Windows.h> #include <tlhelp32.h> #include <psapi.h> #include #include #include #include #include #include #include #include #include #include

    // Wrapper for automatic HANDLE closing struct HandleDeleter { void operator()(HANDLE handle) { if (handle != NULL && handle != INVALID_HANDLE_VALUE) { CloseHandle(handle); } } };

    using UniqueHandle = std::unique_ptr<void, HandleDeleter>;

    // RAII class for safe memory protection setting class ScopedVirtualProtect { public: ScopedVirtualProtect(HANDLE hProcess, LPCVOID addr, SIZE_T size, DWORD newProtect) : m_hProcess(hProcess), m_addr(const_cast(addr)), m_size(size), m_oldProtect(0) { if (!VirtualProtectEx(hProcess, m_addr, m_size, newProtect, &m_oldProtect)) { g_logger.Log("VirtualProtectEx failed to change protection at address " + PtrToStr(addr) + "."); } }

    ~ScopedVirtualProtect() noexcept {
        DWORD temp;
        if (!VirtualProtectEx(m_hProcess, m_addr, m_size, m_oldProtect, &temp)) {
            g_logger.Log("Failed to revert protection at address " + PtrToStr(m_addr) + ".");
        }
    }
    

    private: HANDLE m_hProcess; LPVOID m_addr; SIZE_T m_size; DWORD m_oldProtect; };

    // Thread-safe logger class class Logger { public: explicit Logger(const std::string& filename) : m_logFile(filename, std::ios::app) { if (!m_logFile.is_open()) { throw std::runtime_error("Failed to open log file."); } }

    void Log(const std::string& message) {
        std::lock_guard<std::mutex> lock(m_mutex);
        auto now = std::chrono::system_clock::now();
        auto now_time_t = std::chrono::system_clock::to_time_t(now);
        std::tm localtm;
        localtime_s(&localtm, &now_time_t);
    
        m_logFile << std::put_time(&localtm, " %H:%M:%S") << " > " << message << "\n";
    }
    

    private: std::mutex m_mutex; std::ofstream m_logFile; };

    Logger g_logger("patcher_log.txt");

    // Converts a pointer to a string representation std::string PtrToStr(const void* ptr) { std::stringstream ss; ss << "0x" << std::hex << std::uppercase << std::setw(8) << std::setfill('0') << reinterpret_cast<uintptr_t>(ptr); return ss.str(); }

    // Apply a patch to a process bool ApplyPatch(HANDLE hProcess, BYTE* addr, size_t offset, BYTE patchByte) { ScopedVirtualProtect protect(hProcess, addr + offset, 1, PAGE_EXECUTE_READWRITE); SIZE_T bytesWritten; if (!WriteProcessMemory(hProcess, addr + offset, &patchByte, 1, &bytesWritten)) { g_logger.Log("Failed to write patch to " + PtrToStr(addr + offset) + "."); return false; }

    g_logger.Log("Patch successfully applied at " + PtrToStr(addr + offset) + ".");
    return true;
    

    }

    // Search and apply a patch to a signature in process memory bool PatchSignatureInProcessMemory(HANDLE hProcess, const std::vector& signature, BYTE patchByte) { MEMORY_BASIC_INFORMATION mbi{}; std::vector buffer; for (BYTE* addr = nullptr; VirtualQueryEx(hProcess, addr, &mbi, sizeof(mbi)) && reinterpret_cast<uintptr_t>(addr) < 0x7FFFFFFF; addr += mbi.RegionSize) { if (mbi.State != MEM_COMMIT || (mbi.Protect != PAGE_EXECUTE_READWRITE && mbi.Protect != PAGE_EXECUTE_READ)) { continue; }

        buffer.resize(mbi.RegionSize);
        SIZE_T bytesRead;
        if (!ReadProcessMemory(hProcess, mbi.BaseAddress, buffer.data(), mbi.RegionSize, &bytesRead)) {
            continue;
        }
    
        for (size_t j = 0; j <= bytesRead - signature.size(); ++j) {
            if (memcmp(buffer.data() + j, signature.data(), signature.size()) == 0) {
                if (ApplyPatch(hProcess, reinterpret_cast<BYTE*>(mbi.BaseAddress), j + signature.size() - 1, patchByte)) {
                    g_logger.Log("Signature found and patched at " + PtrToStr(reinterpret_cast<BYTE*>(mbi.BaseAddress) + j) + ".");
                    return true;
                }
            }
        }
    }
    
    g_logger.Log("No signature found for patching.");
    return false;
    

    }

    // Entry point for patching process bool PatchProcess(DWORD processID, const std::vector& signature, BYTE patchByte) { UniqueHandle hProcess(OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, processID)); if (!hProcess) { g_logger.Log("Failed to open target process."); return false; }

    return PatchSignatureInProcessMemory(hProcess.get(), signature, patchByte);
    

    }

    void AttemptToPatch(DWORD currentPID) { std::vector signature = { 0x85, 0xC0, 0x74, 0x57, 0x5F, 0xB8, 0x01 }; BYTE patchByte = 0x00;

    g_logger.Log("Attempting to patch the current process.");
    if (PatchProcess(currentPID, signature, patchByte)) {
        g_logger.Log("Process patched successfully.");
    }
    else {
        g_logger.Log("Failed to patch the process.");
    }
    

    }

    DWORD WINAPI MonitorProcess(LPVOID lpParam) { DWORD currentPID = GetCurrentProcessId(); AttemptToPatch(currentPID); return 0; }

    BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) { switch (ul_reason_for_call) { case DLL_PROCESS_ATTACH: DisableThreadLibraryCalls(hModule); std::thread(MonitorProcess).detach(); break; case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: case DLL_PROCESS_DETACH: break; } return TRUE; }

  2. Assistant

    В целом, данный код кажется выполненным качественно с учётом предназначения DLL на C++ для инъекции в процесс. Он включает в себя ряд современных практик C++, такие как RAII (Resource Acquisition Is Initialization) для управления системными ресурсами (HANDLE) и std::unique_ptr для автоматического закрытия дескрипторов. Подход с использованием классов для управления состоянием памяти и выводом в лог также весьма грамотный. Однако, есть несколько моментов, на которые стоит обратить внимание:

    1. Потенциальная проблема с точностью адресации памяти: При работе с памятью вы используете тип BYTE* для адресации. Это корректно, однако, в современных системах с большим объёмом адресуемой памяти (особенно в 64-битных) возможно было бы использовать uintptr_t для избежания любого неявного предположения о размерности адресуемого пространства.

    2. Использование localtime_s без проверки платформы: Вы используете localtime_s, которая является более безопасной версией функции localtime, доступной в MSVC. Если ваш код предназначен только для Windows, это в порядке. В противном случае, на других платформах (например, Linux или macOS) потребуется использовать альтернативные подходы, такие как localtime_r или соответствующие проверки наличия функции localtime_s.

    3. Проблемы с безопасностью и надёжностью: Как и любая операция, которая изменяет память других процессов, данный код должен использоваться с особой осторожностью и только в законных целях. Инъекция DLL и модификация памяти других процессов могут быть использованы злоумышленниками для распространения вредоносного ПО или создания векторов атак на ПО и системы. Также, модификация кода в процессе может привести к его нестабильной работе или сбоям.

    4. Зависимость от жёстко закодированных сигнатур: Поиск и замена определённой последовательности байтов (signature) в памяти процесса - это весьма специфическая операция, которая может не сработать если целевое ПО изменится (например, будет обновлено). Важно понимать, что механизмы обнаружения и модификация такого рода требуют регулярного обновления для поддержания своей актуальности и точности.

    В заключение, приведённый код показывает глубокие знания как современного C++, так и работы с Windows API для достижения конкретных целей взаимодействия с процессами ОС. Однако, при его использовании важно помнить о соображениях безопасности и этики.

  3. User

    При компиляции у меня появляется ошибка: "Error C2065 'g_logger': undeclared identifier" Как это исправить?

  4. Assistant

    Ошибка "C2065 'g_logger': undeclared identifier" указывает на то, что компилятор не может найти определение для g_logger. Это происходит из-за того, что либо переменная не была объявлена до момента её использования, либо она объявлена в таком месте, которое не доступно из кода, где вы пытаетесь её использовать.

    В вашем случае, g_logger является глобальной переменной типа Logger, и в коде вы её используете до того, как она объявлена. Для исправления этой проблемы убедитесь, что объявление g_logger находится до первого использования этой переменной в файле. Переменная должна быть объявлена в глобальной области видимости, чтобы она была доступна во всём файле или проекте.

    Если объявление Logger g_logger("patcher_log.txt"); уже присутствует в коде, как показано в вашем примере, убедитесь, что оно произведено до первого вызова метода Log или любой другой ссылки на g_logger. Соблюдение правильной последовательности объявлений и определений в C++ критически важно для успешной компиляции.

    Также возможно, что проблема связана с разбиением кода на несколько файлов, и объявление находится в другом файле. В этом случае убедитесь, что вы использовали объявление extern, чтобы указать, что переменная g_logger будет определена в другом месте. Например, если объявление Logger g_logger("patcher_log.txt"); находится в одном файле исходного кода (C++), а использовать вы её хотите в другом, во втором файле вы можете сделать следующее объявление в глобальной области видимости:

    extern Logger g_logger;
    

    Это указывает компилятору, что объект g_logger будет определён где-то ещё, что позволяет избежать ошибки о неразрешённой ссылке.

    Если вы всё ещё сталкиваетесь с ошибкой после проверки вышеперечисленных пунктов, возможно, стоит внимательно проверить код на наличие опечаток или проблем с областью видимости переменных.