DLLInjector.cpp


#include <windows.h>
#include <Shlwapi.h>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>

#pragma comment(lib, "user32.lib")
#pragma comment(lib, "Shlwapi.lib")
#pragma comment(lib, "kernel32.lib")

HANDLE h_process = nullptr;
HANDLE h_thread = nullptr;

struct AppInfo 
{
    HWND hwnd{};
    DWORD pid{};
    std::wstring title;
    std::wstring exePath;
};

static std::wstring GetExeDirectory() 
{
    wchar_t path[MAX_PATH] = {};
    DWORD n = GetModuleFileNameW(nullptr, path, MAX_PATH);
    if (n == 0 || n >= MAX_PATH) return L"";
    PathRemoveFileSpecW(path);
    return path;
}

static bool FindFirstWildcardInAppDir(const std::wstring& wildcard, std::wstring& outPath) {
    std::wstring base = GetExeDirectory();
    if (base.empty()) return false;

    wchar_t query[MAX_PATH] = {};
    if (!PathCombineW(query, base.c_str(), wildcard.c_str())) return false;

    WIN32_FIND_DATAW fd{};
    HANDLE h = FindFirstFileW(query, &fd);
    if (h == INVALID_HANDLE_VALUE) return false;
    wchar_t full[MAX_PATH] = {};
    bool ok = false;
    if (PathCombineW(full, base.c_str(), fd.cFileName)) 
    {
        outPath.assign(full);
        ok = true;
    }
    FindClose(h);
    return ok;
}

static std::wstring GetWindowTitle(HWND h) 
{
    int len = GetWindowTextLengthW(h);
    if (len <= 0) return L"";
    std::vector<wchar_t> buf(static_cast<size_t>(len) + 1, L'\0');
    GetWindowTextW(h, buf.data(), len + 1);
    return std::wstring(buf.data());
}

static std::wstring QueryProcessImagePath(DWORD pid) 
{
    std::wstring result;
    HANDLE ph = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);
    if (!ph) return result;

    DWORD size = 32767;
    std::vector<wchar_t> buf(size, L'\0');

    if (QueryFullProcessImageNameW(ph, 0, buf.data(), &size)) result.assign(buf.data(), size);

    CloseHandle(ph);
    return result;
}

static BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam) 
{
    if (!IsWindowVisible(hwnd)) return TRUE;
    if (GetWindow(hwnd, GW_OWNER)) return TRUE;

    std::wstring title = GetWindowTitle(hwnd);
    if (title.empty()) return TRUE;

    DWORD pid = 0;
    GetWindowThreadProcessId(hwnd, &pid);

    auto list = reinterpret_cast<std::vector<AppInfo>*>(lParam);
    AppInfo info;
    info.hwnd = hwnd;
    info.pid = pid;
    info.title = std::move(title);
    info.exePath = QueryProcessImagePath(pid);
    list->push_back(std::move(info));
    return TRUE;
}

void get_proc_id(const wchar_t* window_title, DWORD& process_id)
{
    HWND h = FindWindowW(nullptr, window_title);
    GetWindowThreadProcessId(h, &process_id);
}
[[noreturn]]
void error(const char* error_title, const char* error_message)
{
    MessageBoxA(nullptr, error_message, error_title, MB_ICONERROR);
    std::exit(EXIT_FAILURE);
}

int main()
{
    char dll_path[MAX_PATH] = {};
    std::wstring dllPathW;
    if (!FindFirstWildcardInAppDir(L"*.dll", dllPathW)) error("FindExactInAppDir", "*.dll not found next to the EXE");
    int ok = WideCharToMultiByte(CP_ACP, 0, dllPathW.c_str(), -1, dll_path, MAX_PATH, nullptr, nullptr);
    if (!ok) error("WideCharToMultiByte", "Failed to convert DLL path");

    std::wcout << L"\nEnumerating open application windows...\n\n";
    std::vector<AppInfo> apps;
    apps.reserve(256);
    EnumWindows(EnumWindowsProc, reinterpret_cast<LPARAM>(&apps));

    if (apps.empty()) 
    {
        std::wcerr << L"No visible top-level windows found.\n";
        return 1;
    }

    std::stable_sort(apps.begin(), apps.end(),
        [](const AppInfo& a, const AppInfo& b) { return a.title < b.title; });

    size_t idx = 1;
    for (const auto& a : apps) 
    {
        LPCWSTR fname = a.exePath.empty() ? L"?" : PathFindFileNameW(a.exePath.c_str());
        std::wcout << std::setw(3) << idx++ << L") "
            << L"[PID " << a.pid << L"] "
            << L"[HWND 0x" << std::hex << (UINT_PTR)a.hwnd << std::dec << L"] "
            << a.title
            << L"  -  " << (fname && *fname ? fname : L"?")
            << L"\n";
    }

    std::wcout << L"\nType the # of the target window and press Enter: ";
    size_t choice = 0;
    if (!(std::wcin >> choice) || choice == 0 || choice > apps.size()) 
    {
        std::wcerr << L"Invalid choice.\n";
        return 1;
    }

    const AppInfo& sel = apps[choice - 1];
    DWORD proc_id = sel.pid;

    if (proc_id == NULL) error("get_proc_id", "Failed to get process ID");

    HANDLE h_process = OpenProcess(PROCESS_ALL_ACCESS, NULL, proc_id);
    void* allocated_memory = VirtualAllocEx(h_process, nullptr, MAX_PATH, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
    HANDLE h_thread = CreateRemoteThread(h_process, nullptr, 0, (LPTHREAD_START_ROUTINE)LoadLibraryA, allocated_memory, 0, nullptr);

    if (!h_process) error("OpenProcess", "Failed to open handle to process");
    if (!allocated_memory) error("VirtualALlocEx", "Failed to allocate memory");
    if (!WriteProcessMemory(h_process, allocated_memory, dll_path, MAX_PATH, nullptr)) error("WriteProcessMemory", "Failed to write process memory");
    if (!h_thread) error("CreateRemoteThread", "Failed to create remote thread");

    CloseHandle(h_thread);
    CloseHandle(h_process); //This should be after VirtualFreeEx, although it's just a warning ;)
    VirtualFreeEx(h_process, allocated_memory, NULL, MEM_RELEASE);

    MessageBoxA(nullptr, "Successfully Injected!", "Success", 0);

    std::wstring selected_title = sel.title;
    std::wcout << L"\nSelected:\n  Title: " << selected_title << L"\n  PID:   " << proc_id << L"\n";

    return 0;
}