Textractor/host/host.cpp

260 lines
9.0 KiB
C++
Raw Normal View History

#include "host.h"
2018-08-23 11:53:23 -04:00
#include "defs.h"
2020-03-26 05:39:25 -06:00
#include "module.h"
#include "hookcode.h"
2019-03-13 11:54:19 -04:00
#include "../texthook/texthook.h"
2019-02-27 11:33:17 -05:00
extern const wchar_t* ALREADY_INJECTED;
2019-04-22 10:02:59 -04:00
extern const wchar_t* NEED_32_BIT;
extern const wchar_t* NEED_64_BIT;
2019-02-27 11:33:17 -05:00
extern const wchar_t* INJECT_FAILED;
extern const wchar_t* CONSOLE;
extern const wchar_t* CLIPBOARD;
2018-08-24 12:50:20 -04:00
namespace
2018-08-23 11:53:23 -04:00
{
class ProcessRecord
2018-08-24 12:50:20 -04:00
{
public:
ProcessRecord(DWORD processId, HANDLE pipe) :
pipe(pipe),
mappedFile(OpenFileMappingW(FILE_MAP_READ, FALSE, (ITH_SECTION_ + std::to_wstring(processId)).c_str())),
view(*(const TextHook(*)[MAX_HOOK])MapViewOfFile(mappedFile, FILE_MAP_READ, 0, 0, HOOK_SECTION_SIZE / 2)), // jichi 1/16/2015: Changed to half to hook section size
viewMutex(ITH_HOOKMAN_MUTEX_ + std::to_wstring(processId))
2019-02-04 15:18:47 -05:00
{}
~ProcessRecord()
{
UnmapViewOfFile(view);
}
TextHook GetHook(uint64_t addr)
{
2019-06-16 17:15:47 -04:00
if (!view) return {};
2019-01-09 22:35:01 -05:00
std::scoped_lock lock(viewMutex);
for (auto hook : view) if (hook.address == addr) return hook;
return {};
}
template <typename T>
void Send(T data)
{
static_assert(sizeof(data) < PIPE_BUFFER_SIZE);
std::thread([=]
{
2019-06-03 17:58:30 -04:00
WriteFile(pipe, &data, sizeof(data), DUMMY, nullptr);
}).detach();
}
Host::HookEventHandler OnHookFound = [](HookParam hp, std::wstring text)
2019-06-02 02:09:17 -04:00
{
Host::AddConsoleOutput(HookCode::Generate(hp) + L": " + text);
2019-06-02 02:09:17 -04:00
};
private:
HANDLE pipe;
AutoHandle<> mappedFile;
const TextHook(&view)[MAX_HOOK];
WinMutex viewMutex;
2018-08-24 12:50:20 -04:00
};
2019-06-10 01:49:11 -04:00
size_t HashThreadParam(ThreadParam tp) { return std::hash<int64_t>()(tp.processId + tp.addr) + std::hash<int64_t>()(tp.ctx + tp.ctx2); }
Synchronized<std::unordered_map<ThreadParam, TextThread, Functor<HashThreadParam>>> textThreadsByParams;
Synchronized<std::unordered_map<DWORD, ProcessRecord>> processRecordsByIds;
2018-08-22 21:31:15 -04:00
2019-02-04 15:18:47 -05:00
Host::ProcessEventHandler OnConnect, OnDisconnect;
Host::ThreadEventHandler OnCreate, OnDestroy;
2018-08-24 12:50:20 -04:00
void RemoveThreads(std::function<bool(ThreadParam)> removeIf)
{
2019-02-04 15:18:47 -05:00
std::vector<TextThread*> threadsToRemove;
for (auto& [tp, thread] : textThreadsByParams.Acquire().contents) if (removeIf(tp)) threadsToRemove.push_back(&thread);
2019-02-04 15:18:47 -05:00
for (auto thread : threadsToRemove)
{
OnDestroy(*thread);
textThreadsByParams->erase(thread->tp);
}
2018-08-24 12:50:20 -04:00
}
2018-11-04 01:34:49 -05:00
void CreatePipe()
2018-08-24 12:50:20 -04:00
{
2018-09-01 14:11:48 -04:00
std::thread([]
2018-08-24 12:50:20 -04:00
{
2019-01-09 22:35:01 -05:00
struct PipeCloser { void operator()(HANDLE h) { DisconnectNamedPipe(h); CloseHandle(h); } };
AutoHandle<PipeCloser>
hookPipe = CreateNamedPipeW(HOOK_PIPE, PIPE_ACCESS_INBOUND, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, PIPE_UNLIMITED_INSTANCES, 0, PIPE_BUFFER_SIZE, MAXDWORD, &allAccess),
hostPipe = CreateNamedPipeW(HOST_PIPE, PIPE_ACCESS_OUTBOUND, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, PIPE_UNLIMITED_INSTANCES, PIPE_BUFFER_SIZE, 0, MAXDWORD, &allAccess);
static AutoHandle<> pipeAvailableEvent = CreateEventW(&allAccess, FALSE, FALSE, PIPE_AVAILABLE_EVENT);
SetEvent(pipeAvailableEvent);
2018-08-24 12:50:20 -04:00
ConnectNamedPipe(hookPipe, nullptr);
BYTE buffer[PIPE_BUFFER_SIZE] = {};
2018-08-24 12:50:20 -04:00
DWORD bytesRead, processId;
ReadFile(hookPipe, &processId, sizeof(processId), &bytesRead, nullptr);
processRecordsByIds->try_emplace(processId, processId, hostPipe);
2019-02-04 15:18:47 -05:00
OnConnect(processId);
2018-08-24 12:50:20 -04:00
2018-11-04 01:34:49 -05:00
CreatePipe();
2018-09-09 22:37:48 -04:00
2018-08-24 12:50:20 -04:00
while (ReadFile(hookPipe, buffer, PIPE_BUFFER_SIZE, &bytesRead, nullptr))
2018-11-10 23:29:12 -05:00
switch (*(HostNotificationType*)buffer)
2018-08-24 12:50:20 -04:00
{
2019-06-02 02:09:17 -04:00
case HOST_NOTIFICATION_FOUND_HOOK:
{
auto info = *(HookFoundNotif*)buffer;
auto OnHookFound = processRecordsByIds->at(processId).OnHookFound;
std::wstring wide = info.text;
if (wide.size() > STRING) OnHookFound(info.hp, std::move(info.text));
info.hp.type &= ~USING_UNICODE;
if (auto converted = StringToWideString((char*)info.text, info.hp.codepage))
if (converted->size() > STRING) OnHookFound(info.hp, std::move(converted.value()));
if (auto converted = StringToWideString((char*)info.text, info.hp.codepage = CP_UTF8))
if (converted->size() > STRING) OnHookFound(info.hp, std::move(converted.value()));
2019-06-02 02:09:17 -04:00
}
break;
2018-08-24 12:50:20 -04:00
case HOST_NOTIFICATION_RMVHOOK:
{
auto info = *(HookRemovedNotif*)buffer;
2018-11-04 20:48:46 -05:00
RemoveThreads([&](ThreadParam tp) { return tp.processId == processId && tp.addr == info.address; });
2018-08-24 12:50:20 -04:00
}
break;
case HOST_NOTIFICATION_TEXT:
{
auto info = *(ConsoleOutputNotif*)buffer;
Host::AddConsoleOutput(StringToWideString(info.message));
2018-08-24 12:50:20 -04:00
}
break;
default:
{
2018-11-19 08:17:00 -05:00
auto tp = *(ThreadParam*)buffer;
2019-06-04 23:12:45 -04:00
auto textThreadsByParams = ::textThreadsByParams.Acquire();
auto thread = textThreadsByParams->find(tp);
if (thread == textThreadsByParams->end())
2019-02-04 15:18:47 -05:00
{
try { thread = textThreadsByParams->try_emplace(tp, tp, processRecordsByIds->at(tp.processId).GetHook(tp.addr).hp).first; }
2019-06-10 01:49:11 -04:00
catch (std::out_of_range) { continue; } // probably garbage data in pipe, try again
OnCreate(thread->second);
2019-02-04 15:18:47 -05:00
}
thread->second.Push(buffer + sizeof(tp), bytesRead - sizeof(tp));
2018-08-24 12:50:20 -04:00
}
break;
}
2018-08-22 18:05:45 -04:00
RemoveThreads([&](ThreadParam tp) { return tp.processId == processId; });
2019-02-04 15:18:47 -05:00
OnDisconnect(processId);
processRecordsByIds->erase(processId);
2018-08-24 12:50:20 -04:00
}).detach();
}
}
2018-07-23 12:25:02 -07:00
namespace Host
{
2019-02-04 15:18:47 -05:00
void Start(ProcessEventHandler Connect, ProcessEventHandler Disconnect, ThreadEventHandler Create, ThreadEventHandler Destroy, TextThread::OutputCallback Output)
{
2019-02-04 15:18:47 -05:00
OnConnect = Connect;
OnDisconnect = Disconnect;
OnCreate = [Create](TextThread& thread) { Create(thread); thread.Start(); };
OnDestroy = [Destroy](TextThread& thread) { thread.Stop(); Destroy(thread); };
TextThread::Output = Output;
2019-02-04 15:18:47 -05:00
textThreadsByParams->try_emplace(console, console, HookParam{}, CONSOLE);
OnCreate(GetThread(console));
textThreadsByParams->try_emplace(clipboard, clipboard, HookParam{}, CLIPBOARD);
OnCreate(GetThread(clipboard));
2018-11-04 01:34:49 -05:00
CreatePipe();
2019-01-20 09:52:35 -05:00
2019-02-16 00:33:38 -05:00
static AutoHandle<> clipboardUpdate = CreateEventW(nullptr, FALSE, TRUE, NULL);
2019-01-20 09:52:35 -05:00
SetWindowsHookExW(WH_GETMESSAGE, [](int statusCode, WPARAM wParam, LPARAM lParam)
{
2019-02-16 00:33:38 -05:00
if (statusCode == HC_ACTION && wParam == PM_REMOVE && ((MSG*)lParam)->message == WM_CLIPBOARDUPDATE) SetEvent(clipboardUpdate);
2019-01-20 09:52:35 -05:00
return CallNextHookEx(NULL, statusCode, wParam, lParam);
}, NULL, GetCurrentThreadId());
2019-02-16 00:33:38 -05:00
std::thread([]
{
while (WaitForSingleObject(clipboardUpdate, INFINITE) == WAIT_OBJECT_0)
{
2019-08-12 21:01:35 -04:00
std::optional<std::wstring> clipboardText;
for (int retry = 0; !clipboardText && retry < 3; ++retry) // retry loop in case something else is using the clipboard
{
Sleep(10);
if (!IsClipboardFormatAvailable(CF_UNICODETEXT)) continue;
if (!OpenClipboard(NULL)) continue;
if (AutoHandle<Functor<GlobalUnlock>> clipboard = GetClipboardData(CF_UNICODETEXT)) clipboardText = (wchar_t*)GlobalLock(clipboard);
CloseClipboard();
}
if (clipboardText) GetThread(clipboard).AddSentence(std::move(clipboardText.value()));
}
2019-02-16 00:33:38 -05:00
throw;
}).detach();
2018-07-23 12:25:02 -07:00
}
2019-02-16 00:33:38 -05:00
void InjectProcess(DWORD processId)
2018-07-23 12:25:02 -07:00
{
2019-02-16 00:33:38 -05:00
std::thread([processId]
2018-07-23 12:25:02 -07:00
{
2019-02-16 00:33:38 -05:00
if (processId == GetCurrentProcessId()) return;
2018-07-23 12:25:02 -07:00
2019-02-16 00:33:38 -05:00
WinMutex(ITH_HOOKMAN_MUTEX_ + std::to_wstring(processId));
if (GetLastError() == ERROR_ALREADY_EXISTS) return AddConsoleOutput(ALREADY_INJECTED);
2018-07-23 12:25:02 -07:00
2019-02-16 00:33:38 -05:00
if (AutoHandle<> process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId))
2018-08-22 15:11:58 -04:00
{
2019-02-16 00:33:38 -05:00
#ifdef _WIN64
BOOL invalidProcess = FALSE;
IsWow64Process(process, &invalidProcess);
2019-04-22 10:02:59 -04:00
if (invalidProcess) return AddConsoleOutput(NEED_32_BIT);
2018-08-22 15:11:58 -04:00
#endif
2020-03-26 05:39:25 -06:00
static std::wstring location = std::filesystem::path(GetModuleFilename().value()).replace_filename(ITH_DLL);
2019-02-16 00:33:38 -05:00
if (LPVOID remoteData = VirtualAllocEx(process, nullptr, (location.size() + 1) * sizeof(wchar_t), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE))
2018-08-22 15:11:58 -04:00
{
2019-02-16 00:33:38 -05:00
WriteProcessMemory(process, remoteData, location.c_str(), (location.size() + 1) * sizeof(wchar_t), nullptr);
if (AutoHandle<> thread = CreateRemoteThread(process, nullptr, 0, (LPTHREAD_START_ROUTINE)LoadLibraryW, remoteData, 0, nullptr)) WaitForSingleObject(thread, INFINITE);
2019-04-22 10:02:59 -04:00
else if (GetLastError() == ERROR_ACCESS_DENIED) AddConsoleOutput(NEED_64_BIT); // https://stackoverflow.com/questions/16091141/createremotethread-access-denied
VirtualFreeEx(process, remoteData, 0, MEM_RELEASE);
2019-02-16 00:33:38 -05:00
return;
2018-08-22 15:11:58 -04:00
}
}
2018-07-23 12:25:02 -07:00
2019-02-16 00:33:38 -05:00
AddConsoleOutput(INJECT_FAILED);
}).detach();
}
2018-07-23 12:25:02 -07:00
2018-08-24 14:04:23 -04:00
void DetachProcess(DWORD processId)
{
2019-02-21 13:09:44 -05:00
processRecordsByIds->at(processId).Send(HOST_COMMAND_DETACH);
2018-07-23 12:25:02 -07:00
}
void InsertHook(DWORD processId, HookParam hp)
2018-07-23 12:25:02 -07:00
{
2018-12-17 21:03:42 -05:00
processRecordsByIds->at(processId).Send(InsertHookCmd(hp));
2018-07-23 12:25:02 -07:00
}
2019-06-10 01:49:11 -04:00
void RemoveHook(DWORD processId, uint64_t address)
{
processRecordsByIds->at(processId).Send(RemoveHookCmd(address));
}
2019-06-02 02:09:17 -04:00
void FindHooks(DWORD processId, SearchParam sp, HookEventHandler HookFound)
{
if (HookFound) processRecordsByIds->at(processId).OnHookFound = HookFound;
processRecordsByIds->at(processId).Send(FindHookCmd(sp));
}
TextThread& GetThread(ThreadParam tp)
{
return textThreadsByParams->at(tp);
}
TextThread* GetThread(int64_t handle)
2018-07-23 12:25:02 -07:00
{
for (auto& [tp, thread] : textThreadsByParams.Acquire().contents) if (thread.handle == handle) return &thread;
return nullptr;
2018-07-23 12:25:02 -07:00
}
2018-12-28 12:14:56 -05:00
void AddConsoleOutput(std::wstring text)
{
2019-02-09 00:30:38 -05:00
GetThread(console).AddSentence(std::move(text));
2018-11-01 15:03:30 -04:00
}
}