[FREE] [RELEASE] M2Heat - Script as you need

#include <Windows.h>
#include <iostream>
#include <string>
#include <thread>
#include <chrono>
#include <TlHelp32.h>
#include <algorithm>

DWORD get_process_id(const std::wstring& process_name)
{
    DWORD process_id = 0;
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (snapshot != INVALID_HANDLE_VALUE)
    {
        PROCESSENTRY32 process_entry;
        process_entry.dwSize = sizeof(process_entry);

        if (Process32First(snapshot, &process_entry))
        {
            do
            {
                if (process_name == process_entry.szExeFile)
                {
                    process_id = process_entry.th32ProcessID;
                    break;
                }
            } while (Process32Next(snapshot, &process_entry));
        }
        CloseHandle(snapshot);
    }
    return process_id;
}

bool inject_dlls(const DWORD process_id, const std::vector<std::wstring>& dll_paths)
{
    HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, process_id);
    if (!process)
    {
        std::cerr << "Failed to open process." << std::endl;
        return false;
    }

    auto load_library_addr = reinterpret_cast<LPVOID>(GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "LoadLibraryW"));
    if (!load_library_addr)
    {
        std::cerr << "Failed to get LoadLibraryW address." << std::endl;
        CloseHandle(process);
        return false;
    }

    bool injection_success = true;

    for (const auto& dll_path : dll_paths)
    {
        auto remote_string = VirtualAllocEx(process, nullptr, (dll_path.length() + 1) * sizeof(wchar_t), MEM_COMMIT, PAGE_READWRITE);
        if (!remote_string)
        {
            std::wcerr << L"Failed to allocate memory in the target process for DLL: " << dll_path << std::endl;
            injection_success = false;
            continue;
        }

        if (!WriteProcessMemory(process, remote_string, dll_path.c_str(), (dll_path.length() + 1) * sizeof(wchar_t), nullptr))
        {
            std::wcerr << L"Failed to write the DLL path to the target process for DLL: " << dll_path << std::endl;
            VirtualFreeEx(process, remote_string, 0, MEM_RELEASE);
            injection_success = false;
            continue;
        }

        auto remote_thread = CreateRemoteThread(process, nullptr, 0, reinterpret_cast<LPTHREAD_START_ROUTINE>(load_library_addr), remote_string, 0, nullptr);
        if (!remote_thread)
        {
            std::wcerr << L"Failed to create remote thread for DLL: " << dll_path << std::endl;
            VirtualFreeEx(process, remote_string, 0, MEM_RELEASE);
            injection_success = false;
            continue;
        }

        WaitForSingleObject(remote_thread, 1000);

        if(injection_success)
			std::wcout << L"Injected DLL: " << dll_path << std::endl;
		else
			std::wcerr << L"Failed to inject DLL: " << dll_path << std::endl;

        CloseHandle(remote_thread);
        VirtualFreeEx(process, remote_string, 0, MEM_RELEASE);
    }

    CloseHandle(process);
    return injection_success;
}

const std::wstring get_path()
{
    wchar_t file_path[MAX_PATH];
    GetModuleFileNameW(NULL, file_path, MAX_PATH);

    std::wstring file_dir(file_path);
    size_t last_slash_pos = file_dir.find_last_of(L"\\/");
    if (last_slash_pos != std::wstring::npos)
    {
        file_dir = file_dir.substr(0, last_slash_pos + 1);
    }

    return file_dir;
}

std::vector<DWORD> get_process_ids_from_window(const std::wstring& window_title)
{
    std::vector<DWORD> process_ids;
    HWND window_handle = NULL;

    while ((window_handle = FindWindowExW(NULL, window_handle, NULL, window_title.c_str())) != NULL)
    {
        DWORD process_id;
        GetWindowThreadProcessId(window_handle, &process_id);
        process_ids.push_back(process_id);
    }

    return process_ids;
}

int main()
{
    const std::wstring path = get_path();
    const std::wstring target_window_title = L"METIN2";

    const std::vector<std::wstring> dll_names = { L"boost_python27-vc143-mt-x32-1_83.dll", L"m2heat.dll" };

    std::vector<std::wstring> dll_paths;
    for (const auto& dll_name : dll_names)
    {
        dll_paths.push_back(path + dll_name);
    }

    std::wcout << L"Watching for window: " << target_window_title << std::endl;

    std::vector<DWORD> injected_process_ids;

    while (true)
    {
        std::vector<DWORD> process_ids = get_process_ids_from_window(target_window_title);

        using namespace std::chrono_literals;

        for (const auto& process_id : process_ids)
        {
            if (std::find(injected_process_ids.begin(), injected_process_ids.end(), process_id) == injected_process_ids.end())
            {
                std::cout << "Target window found. Process ID: " << process_id << std::endl;

                injected_process_ids.push_back(process_id);

                std::thread injection_thread([=] {
                    std::this_thread::sleep_for(5s);
                    inject_dlls(process_id, dll_paths);
                });
                injection_thread.detach();
            }
        }

        std::this_thread::sleep_for(1s);
    }

    return 0;
}