Можно ли улучшить этот код на C++: #include "pch.h" #include <Windows.h> #include…
- User
Можно ли улучшить этот код на C++: #include "pch.h" #include <Windows.h> #include <tlhelp32.h> #include <psapi.h> #include #include #include #include #include #include #include #include
// Класс для управления защитой памяти с помощью RAII 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)) { throw std::runtime_error("VirtualProtectEx failed to change protection."); } }
~ScopedVirtualProtect() { VirtualProtectEx(m_hProcess, m_addr, m_size, m_oldProtect, &m_oldProtect); }private: HANDLE m_hProcess; LPVOID m_addr; SIZE_T m_size; DWORD m_oldProtect; };
// Класс для логирования 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 the log file."); } }
void Log(const std::string& message) { m_logFile << message << "\n"; }private: std::ofstream m_logFile; };
Logger g_logger("patcher_log.txt");
// Функция для конвертации указателя в строку с шестнадцатеричным адресом 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(); }
// Применение патча к найденной сигнатуре 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 the patch at " + PtrToStr(addr + offset) + "."); return false; }
g_logger.Log("Patch applied successfully at " + PtrToStr(addr + offset) + "."); return true;}
// Функция для поиска и патчинга сигнатуры в памяти процесса bool PatchSignatureInProcessMemory(HANDLE hProcess, const std::vector& signature, BYTE patchByte) { MEMORY_BASIC_INFORMATION mbi{}; 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; }
std::vector<BYTE> buffer(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, addr, j + signature.size() - 1, patchByte)) { g_logger.Log("Signature found and patched at " + PtrToStr(addr + j) + "."); return true; } } } } g_logger.Log("No signature matched for patching."); return false;}
bool PatchProcess(DWORD processID, const std::vector& signature, BYTE patchByte) { HANDLE hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, processID); if (hProcess == NULL) { g_logger.Log("Failed to open the target process."); return false; }
std::unique_ptr<void, decltype(&CloseHandle)> processCloser(hProcess, CloseHandle); return PatchSignatureInProcessMemory(hProcess, 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); CreateThread(nullptr, 0, MonitorProcess, nullptr, 0, nullptr); break; case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: case DLL_PROCESS_DETACH: break; } return TRUE; }
- Assistant
Ваш код на C++ по большей части хорошо организован, но есть несколько предложений по его улучшению. Эти улучшения направлены на повышение читаемости, безопасности и эффективности:
-
Использование smart-поинтеров для управления ресурсами Windows:
- Вместо явного использования
std::unique_ptrсCloseHandleможно создать специализацию для автоматического закрытия дескрипторов Windows:
struct HandleDeleter { void operator()(HANDLE handle) { if (handle != NULL && handle != INVALID_HANDLE_VALUE) { CloseHandle(handle); } } }; using UniqueHandle = std::unique_ptr<std::remove_pointer<HANDLE>::type, HandleDeleter>; - Вместо явного использования
-
Безопасность исключений:
- В деструкторе класса
ScopedVirtualProtectследует предотвратить возможность выброса исключения, поскольку это может привести к неопределенному поведению. ЕслиVirtualProtectExв деструкторе вернет ошибку, лучше просто игнорировать ее или использовать логирование без выброса исключений.
- В деструкторе класса
-
Повышение читаемости:
- Использование
autoвместо явного типа указателя в циклах и других местах может улучшить читаемость кода, особенно при работе со сложными типами.
- Использование
-
Оптимизация работы с памятью:
- Рассмотрите возможность минимизации числа аллокаций памяти. Например, если размеры регионов памяти не сильно отличаются, можно использовать один
std::vector<BYTE>для чтения и переиспользовать его, резервируя достаточный размер памяти на основе наибольшего обнаруженного региона.
- Рассмотрите возможность минимизации числа аллокаций памяти. Например, если размеры регионов памяти не сильно отличаются, можно использовать один
-
Thread safety:
- Использование глобальной переменной
g_loggerпотенциально может вести к гонкам при одновременном доступе из нескольких потоков. Рассмотрите использование мьютекса для синхронизации доступа к этой переменной.
- Использование глобальной переменной
-
Обработка ошибок и валидация входных данных:
- Добавьте в код более строгую проверку входных параметров и возвращаемых значений функций Windows API на предмет ошибок. Это поможет избежать неопределенного поведения при работе с некорректными данными.
Пример реализации управления дескриптором с помощью
UniqueHandle:// Функция патчинга процесса с использованием UniqueHandle bool PatchProcess(DWORD processID, const std::vector<BYTE>& 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 the target process."); return false; } return PatchSignatureInProcessMemory(hProcess.get(), signature, patchByte); }Помните, что улучшения должны быть направлены на решение конкретных проблем или улучшение конкретных аспектов кода, таких как производительность, безопасность, или читаемость. Всегда взвешивайте потенциальные преимущества изменений перед их реализацией.
-
- User
Отправь полный код программы с использованием твоих советов. Не забудь про комментарии в коде.
- Assistant
Конечно! Ниже представлен исправленный код с учетом предложенных улучшений. Обратите внимание на комментарии в коде, которые поясняют внесенные изменения.
#include "pch.h" #include <Windows.h> #include <tlhelp32.h> #include <psapi.h> #include <fstream> #include <vector> #include <string> #include <memory> #include <thread> #include <array> #include <iomanip> #include <sstream> #include <mutex> // Специализация для управления HANDLE через умный указатель struct HandleDeleter { void operator()(HANDLE handle) { if (handle != NULL && handle != INVALID_HANDLE_VALUE) { CloseHandle(handle); } } }; using UniqueHandle = std::unique_ptr<std::remove_pointer<HANDLE>::type, HandleDeleter>; // Класс для управления защитой памяти с помощью RAII class ScopedVirtualProtect { public: ScopedVirtualProtect(HANDLE hProcess, LPCVOID addr, SIZE_T size, DWORD newProtect) : m_hProcess(hProcess), m_addr(const_cast<LPVOID>(addr)), m_size(size), m_oldProtect(0) { if (!VirtualProtectEx(hProcess, m_addr, m_size, newProtect, &m_oldProtect)) { throw std::runtime_error("VirtualProtectEx failed to change protection."); } } // При уничтожении объекта восстанавливаем старую защиту без выброса исключения ~ScopedVirtualProtect() noexcept { DWORD temp; VirtualProtectEx(m_hProcess, m_addr, m_size, m_oldProtect, &temp); } private: HANDLE m_hProcess; LPVOID m_addr; SIZE_T m_size; DWORD m_oldProtect; }; // Класс для логирования 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 the log file."); } } void Log(const std::string& message) { std::lock_guard<std::mutex> lock(m_mutex); // Защита от гонки потоков m_logFile << message << "\n"; } private: std::mutex m_mutex; // Mutex для синхронизации записи в log файл std::ofstream m_logFile; }; Logger g_logger("patcher_log.txt"); 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(); } 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 the patch at " + PtrToStr(addr + offset) + "."); return false; } g_logger.Log("Patch applied successfully at " + PtrToStr(addr + offset) + "."); return true; } bool PatchSignatureInProcessMemory(HANDLE hProcess, const std::vector<BYTE>& signature, BYTE patchByte) { MEMORY_BASIC_INFORMATION mbi{}; std::vector<BYTE> 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; } // Переиспользуем буфер, если он не достаточно большой if (buffer.size() < mbi.RegionSize) { 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, addr, j + signature.size() - 1, patchByte)) { g_logger.Log("Signature found and patched at " + PtrToStr(addr + j) + "."); return true; } } } } g_logger.Log("No signature matched for patching."); return false; } bool PatchProcess(DWORD processID, const std::vector<BYTE>& 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 the target process."); return false; } return PatchSignatureInProcessMemory(hProcess.get(), signature, patchByte); } void AttemptToPatch(DWORD currentPID) { std::vector<BYTE> 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); CreateThread(nullptr, 0, MonitorProcess, nullptr, 0, nullptr); break; case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: case DLL_PROCESS_DETACH: break; } return TRUE; }В этом улучшенном коде были внесены следующие изменения:
- Использование специализации
UniqueHandleдля автоматического закрытия дескрипторов HANDLE. - В
ScopedVirtualProtectдеструктор изменен для работы без выброса исключений (noexcept), тем самым повышая безопасность кода. - Добавлен
std::mutexв классLoggerдля обеспечения потокобезопасности при записи в лог-файл. - В функции
PatchSignatureInProcessMemoryдобавлена возможность переиспользования буфера для считывания памяти, что может улучшить производительность за счет уменьшения количества аллокаций.
Обратите внимание, что вам могут потребоваться доработки, в зависимости от особенностей вашего проекта и окружения, в котором он используется.
- Использование специализации
- User
исправь русские комментарии в твоем коде на английские
- Assistant
Конечно! Ниже приведён код с переведенными комментариями на английский язык.
#include "pch.h" #include <Windows.h> #include <tlhelp32.h> #include <psapi.h> #include <fstream> #include <vector> #include <string> #include <memory> #include <thread> #include <array> #include <iomanip> #include <sstream> #include <mutex> // Specialization for managing HANDLEs through smart pointer struct HandleDeleter { void operator()(HANDLE handle) { if (handle != NULL && handle != INVALID_HANDLE_VALUE) { CloseHandle(handle); } } }; using UniqueHandle = std::unique_ptr<std::remove_pointer<HANDLE>::type, HandleDeleter>; // RAII class for memory protection management class ScopedVirtualProtect { public: ScopedVirtualProtect(HANDLE hProcess, LPCVOID addr, SIZE_T size, DWORD newProtect) : m_hProcess(hProcess), m_addr(const_cast<LPVOID>(addr)), m_size(size), m_oldProtect(0) { if (!VirtualProtectEx(hProcess, m_addr, m_size, newProtect, &m_oldProtect)) { throw std::runtime_error("VirtualProtectEx failed to change protection."); } } // On object destruction, restore old protection without throwing exceptions ~ScopedVirtualProtect() noexcept { DWORD temp; VirtualProtectEx(m_hProcess, m_addr, m_size, m_oldProtect, &temp); } private: HANDLE m_hProcess; LPVOID m_addr; SIZE_T m_size; DWORD m_oldProtect; }; // Logging 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 the log file."); } } void Log(const std::string& message) { std::lock_guard<std::mutex> lock(m_mutex); // Protect from thread racing m_logFile << message << "\n"; } private: std::mutex m_mutex; // Mutex for synchronized writing to the log file std::ofstream m_logFile; }; Logger g_logger("patcher_log.txt"); 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(); } 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 the patch at " + PtrToStr(addr + offset) + "."); return false; } g_logger.Log("Patch applied successfully at " + PtrToStr(addr + offset) + "."); return true; } bool PatchSignatureInProcessMemory(HANDLE hProcess, const std::vector<BYTE>& signature, BYTE patchByte) { MEMORY_BASIC_INFORMATION mbi{}; std::vector<BYTE> 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; } // Reuse the buffer if it's not large enough if (buffer.size() < mbi.RegionSize) { 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, addr, j + signature.size() - 1, patchByte)) { g_logger.Log("Signature found and patched at " + PtrToStr(addr + j) + "."); return true; } } } } g_logger.Log("No signature matched for patching."); return false; } bool PatchProcess(DWORD processID, const std::vector<BYTE>& 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 the target process."); return false; } return PatchSignatureInProcessMemory(hProcess.get(), signature, patchByte); } void AttemptToPatch(DWORD currentPID) { std::vector<BYTE> 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); CreateThread(nullptr, 0, MonitorProcess, nullptr, 0, nullptr); break; case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: case DLL_PROCESS_DETACH: break; } return TRUE; }This version includes English comments throughout, ensuring clarity and understanding for an international audience or developers who prefer English for technical documentation and code comments.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.