1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
#pragma once
#include <windows.h>
#include <psapi.h>
#include <tlhelp32.h>
#include <Security/FnvHash.hpp>
#include <Security/SyscallManager.hpp>
namespace RemoteCode
{
// The module wrapper.
class RemoteProcess;
class RemoteModule
{
HANDLE m_Module;
public:
RemoteModule() = default;
RemoteModule(HANDLE Module);
~RemoteModule() { CloseHandle(m_Module); }
// Fuck This , #Lol
//uintptr_t FindOccurence(const char *Pattern);
// Allow us to access the module by just passing the
// handle as a parameter.
operator HANDLE() { return m_Module; }
};
// The process wrapper.
class RemoteProcess
{
HANDLE m_Process;
int32_t m_ProcessId;
// Exposing the syscalls in a convenient way to use with templating.
void ReadMemoryWrapper_Internal(void *Address, void *Data, size_t SizeOfData);
void WriteMemoryWrapper_Internal(void *Address, void *Data, size_t SizeOfData);
public:
RemoteProcess() = default;
// For portability, will ignore exceptions.
RemoteProcess(const char *ProcessName)
{
Start(ProcessName);
}
// Release the handle when the process goes out of scope.
//~RemoteProcess()
//{
// if(m_Process)
// CloseHandle(m_Process);
//}
// Find the process ID and initialise the process.
bool Start(const char *ProcessName);
// Writes to the process memory.
template <typename T>
void Write(void *Address, T Data)
{
WriteMemoryWrapper_Internal(Address, (void *)&Data, sizeof T);
}
void Write(void *Address, uint8_t *Data, size_t SizeOfData)
{
WriteMemoryWrapper_Internal(Address, (void *)&Data, SizeOfData);
}
// Reads from the process memory.
template <typename T>
T Read(void *Address)
{
T Buffer{};
ReadMemoryWrapper_Internal(Address, (void *)&Buffer, sizeof T);
return Buffer;
}
void Read(void *Address, uint8_t *Data, size_t SizeOfData)
{
ReadMemoryWrapper_Internal(Address, &Data, SizeOfData);
}
// Allocates a memory region in the process.
void *Allocate(size_t AllocationSize);
// Finds a module in the process.
RemoteModule FindModule(const char *ModuleName);
// Allow us to access the process by just passing the
// handle as a parameter.
operator HANDLE() { return m_Process; }
};
}
|
