LunaTranslator/plugins/hookmagpie/hookmagpie.cpp

#include <iostream>
#include <windows.h>
#include <thread>
#include <detours.h>
#include <string>
#include <assert.h>
#include "veh_hook.h"
namespace Win32Utils
{
    static HANDLE SafeHandle(HANDLE h) noexcept { return (h == INVALID_HANDLE_VALUE) ? nullptr : h; }
    struct HandleCloser
    {
        void operator()(HANDLE h) noexcept
        {
            assert(h != INVALID_HANDLE_VALUE);
            if (h)
                CloseHandle(h);
        }
    };

    using ScopedHandle = std::unique_ptr<std::remove_pointer<HANDLE>::type, HandleCloser>;
    std::wstring GetPathOfWnd(HWND hWnd)
    {
        ScopedHandle hProc;

        DWORD dwProcId = 0;
        if (GetWindowThreadProcessId(hWnd, &dwProcId))
        {
            hProc.reset(SafeHandle(OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, dwProcId)));
            if (!hProc)
            {
            }
        }
        else
        {
        }

        if (!hProc)
        {
            static const auto getProcessHandleFromHwnd = (HANDLE(WINAPI *)(HWND))GetProcAddress(
                LoadLibraryEx(L"Oleacc.dll", NULL, 0), "GetProcessHandleFromHwnd");
            if (getProcessHandleFromHwnd)
            {
                hProc.reset(getProcessHandleFromHwnd(hWnd));
                if (!hProc)
                {
                }
            }

            if (!hProc)
            {
                return {};
            }
        }

        std::wstring fileName(MAX_PATH, 0);
        DWORD size = MAX_PATH;
        if (!QueryFullProcessImageName(hProc.get(), 0, fileName.data(), &size))
        {
            return {};
        }

        fileName.resize(size);
        return fileName;
    }
}
namespace StrUtils
{
    template <typename CHAR_T>
    static void ToLowerCase(std::basic_string<CHAR_T> &str) noexcept
    {
        for (CHAR_T &c : str)
        {
            c = tolower(c);
        }
    }
}
static std::wstring GetExeName(HWND hWnd) noexcept
{
    std::wstring exeName = Win32Utils::GetPathOfWnd(hWnd);
    exeName = exeName.substr(exeName.find_last_of(L'\\') + 1);
    StrUtils::ToLowerCase(exeName);
    return exeName;
}
bool (*IsValidSrcWindow)(HWND);

struct hook_stack
{

#ifndef _WIN64
    uintptr_t _eflags; // pushfd
    uintptr_t edi,     // pushad
        esi,
        ebp,
        esp,
        ebx,
        edx,
        ecx, // this
        eax; // 0x28

#else
    uintptr_t r15,
        r14,
        r13,
        r12,
        r11,
        r10,
        r9,
        r8,
        rdi,
        rsi,
        rbp,
        rsp,
        rdx,
        rcx,
        rbx,
        rax;
#endif
    uintptr_t eflags; // pushaf
    union
    {
        uintptr_t stack[1]; // beginning of the runtime stack
        uintptr_t retaddr;
        BYTE base[1];
    };
};

uintptr_t findEnclosingAlignedFunction_strict(uintptr_t start, uintptr_t back_range)
{
    start &= ~0xf;
    for (uintptr_t i = start, j = start - back_range; i > j; i -= 0x10)
    {
        DWORD k = *(DWORD *)(i - 4);
        if (k == 0xcccccccc || k == 0x90909090 || k == 0xccccccc3 || k == 0x909090c3)
            return i;
    }
    return 0;
}
bool checkislunawindow(HWND hwndSrc)
{
    wchar_t title[100];
    GetWindowText(hwndSrc, title, 100);
    if (wcscmp(title, L"LunaTranslator") == 0 || GetExeName(hwndSrc) == L"lunatranslator_main.exe" || GetExeName(hwndSrc) == L"lunatranslator.exe")
        return true;
    else
        return false;
}
void hookedisvalidwindow(PCONTEXT context)
{
    auto hwndSrc = (HWND)(context->Rcx);
    if (checkislunawindow(hwndSrc))
    {
        // MessageBoxW(0,GetExeName(hwndSrc).c_str(),L"",0);
        context->Rcx = (uintptr_t)FindWindow(L"Shell_TrayWnd", nullptr);
    }
}
void starthookmagpie()
{
    uintptr_t IsValidSrcWindow = 0;

    wchar_t target[] = L"Shell_TrayWnd";
    auto base = (uintptr_t)GetModuleHandle(L"Magpie.App.dll");
    BYTE lea[] = {0x48, 0x8D, 0x05};
    //.text:0000000180146AD0 48 8D 05 91 87 10 00          lea     rax, aShellTraywnd              ; "Shell_TrayWnd"
    //.rdata:000000018024F268 53 00 68 00 65 00 6C 00 6C 00+text "UTF-16LE", 'Shell_TrayWnd',0

    __try
    {
        for (int i = 0; i < 0x1000000; i++)
        {
            if (memcmp(lea, (LPVOID)(i + base), 3) == 0)
            {
                auto addr = base + i;
                auto leastr = (*(int *)(addr + 3)) + 7 + addr;
                if (IsBadReadPtr((LPVOID)leastr, sizeof(target)) == 0)
                    if (wcscmp((wchar_t *)leastr, target) == 0)
                    {
                        IsValidSrcWindow = findEnclosingAlignedFunction_strict(addr, 0x1000);
                        break;
                    }
            }
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER)
    {
        return;
    }

    if (IsValidSrcWindow == 0)
        return;

    // IsValidSrcWindow=(decltype(IsValidSrcWindow))((uintptr_t)GetModuleHandle(L"Magpie.App.dll")+0x180146860-0x180000000);
    add_veh_hook((LPVOID)IsValidSrcWindow, hookedisvalidwindow, 0);
    // DetourTransactionBegin();
    // DetourUpdateThread(GetCurrentThread());
    // DetourAttach(&(PVOID&)IsValidSrcWindow,IsValidSrcWindow_hooked);
    // DetourTransactionCommit();
}

auto GetClassNameWs = GetClassNameW;
int
    WINAPI
    GetClassNameWH(
        _In_ HWND hWnd,
        _Out_writes_to_(nMaxCount, return) LPWSTR lpClassName,
        _In_ int nMaxCount)
{
    if (checkislunawindow(hWnd))
    {
        wcscpy(lpClassName, L"ApplicationManager_ImmersiveShellWindow");
        return TRUE;
    }
    else
        return GetClassNameWs(hWnd, lpClassName, nMaxCount);
}
void starthooklossless()
{
    DetourTransactionBegin();
    DetourUpdateThread(GetCurrentThread());
    DetourAttach(&(PVOID &)GetClassNameWs, GetClassNameWH);
    DetourTransactionCommit();
}
void starthook()
{
    if (GetModuleHandle(L"Magpie.App.dll"))
        starthookmagpie();
    else if (GetModuleHandle(L"Lossless.dll"))
        starthooklossless();
}
BOOL APIENTRY DllMain(HMODULE hModule,
                      DWORD ul_reason_for_call,
                      LPVOID lpReserved)
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        starthook();
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}