1. #include "ProcMem.h"
2.  
3.  
4. using namespace std;
5.  
6. #pragma region Misc Functions
7.  
8. ProcMem::ProcMem() {
9.  
10. }
11.  
12. ProcMem::~ProcMem() {
13.         CloseHandle(hProcess);
14. }
15.  
16. int ProcMem::chSizeOfArray(char* chArray) {
17.         for (int iLength = 1; iLength < MAX_PATH; iLength++)
18.                 if (chArray[iLength] == '*')
19.                         return iLength;
20.  
21.         cout << "\nLENGTH: Failed To Read Length Of Array\n";
22.         return 0;
23. }
24.  
25. int ProcMem::iSizeOfArray(char* iArray) {
26.         for (int iLength = 1; iLength < MAX_PATH; iLength++)
27.                 if (iArray[iLength] == '*')
28.                         return iLength;
29.  
30.         cout << "\nLENGTH: Failed To Read Length Of Array\n";
31.         return 0;
32. }
33.  
34. bool ProcMem::iFind(int* iAry, int iVal) {
35.  
36.         for (int i = 0; i < 64; i++)
37.                 if (iVal == iAry[i] && iVal != 0)
38.                         return true;
39.  
40.         return false;
41. }
42.  
43. #pragma endregion
44.  
45. #pragma region Memory Functions
46.  
47. void ProcMem::Process(char* ProcessName)
48. {
49.         HANDLE hPID = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
50.         PROCESSENTRY32 ProcEntry;
51.         ProcEntry.dwSize = sizeof(ProcEntry);
52.         do
53.                 if (!strcmp(ProcEntry.szExeFile, ProcessName))
54.                 {
55.                         dwPID = ProcEntry.th32ProcessID;
56.                         CloseHandle(hPID);
57.                         hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPID);
58.                         return;
59.                 }
60.         while (Process32Next(hPID, &ProcEntry));
61.  
62.         cout << "\nCouldn't find game\n";
63.         system("pause");
64.         exit(0);
65. }
66.  
67. void ProcMem::Patch(DWORD dwAddress, char* Patch_Bts, char* Default_Bts)
68. {
69.         int iSize = chSizeOfArray(Default_Bts);
70.  
71.         if (!bPOn)
72.                 for (int i = 0; i < iSize; i++)
73.                         Write<BYTE>(dwAddress + i, Patch_Bts[i]);
74.         else
75.                 for (int i = 0; i < iSize; i++)
76.                         Write<BYTE>(dwAddress + i, Default_Bts[i]);
77.  
78.         bPOn = !bPOn;
79. }
80.  
81. void ProcMem::Inject(DWORD dwAddress, char* Inj_Bts, char* Def_Bts, BOOL Type)
82. {
83.         int i_ISize = chSizeOfArray(Inj_Bts);
84.         int i_DSize = chSizeOfArray(Def_Bts);
85.  
86.         if (!bIOn)
87.         {
88.                 if (i_DSize > 5)
89.                         for (int i = 6; i < i_DSize; i++)
90.                                 Write<BYTE>(dwAddress + i, 0x90);
91.                 else { cout << "\nINJECTION: Default Bytes Must Be More Than 5\n"; return; }
92.  
93.                 dwCaveAddress = (DWORD)VirtualAllocEx(hProcess, NULL, i_ISize + 5, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
94.  
95.                 DWORD dwRetJmp = (dwAddress + i_DSize) - dwCaveAddress - 5;
96.                 DWORD dwBaseJmp = dwCaveAddress - dwAddress - 5;
97.  
98.                 for (int i = 0; i <= i_ISize; i++)
99.                         Write<BYTE>(dwCaveAddress + i, Inj_Bts[i]);
100.  
101.                 Write<BYTE>(dwCaveAddress + i_ISize, Type ? 0xE9 : 0xE8);
102.                 Write<DWORD>(dwCaveAddress + i_ISize + 1, dwRetJmp);
103.  
104.                 Write<BYTE>(dwAddress, Type ? 0xE9 : 0xE8);
105.                 Write<DWORD>(dwAddress + 1, dwBaseJmp);
106.  
107.         }
108.         else
109.         {
110.                 for (int i = 0; i < i_DSize; i++)
111.                         Write<BYTE>(dwAddress + i, Def_Bts[i]);
112.                 VirtualFreeEx(hProcess, (LPVOID)dwCaveAddress, i_ISize + 5, MEM_DECOMMIT);
113.         }
114.         bIOn = !bIOn;
115. }
116.  
117. DWORD ProcMem::AOB_Scan(DWORD dwAddress, DWORD dwEnd, char* Bytes)
118. {
119.         int iBytesToRead = 0, iTmp = 0;
120.         int length = chSizeOfArray(Bytes);
121.         bool bTmp = false;
122.  
123.         if (Bytes[0] == '?')
124.         {
125.                 for (; iBytesToRead < MAX_PATH; iBytesToRead++)
126.                         if (Bytes[iBytesToRead] != '?')
127.                         {
128.                                 iTmp = (iBytesToRead + 1);
129.                                 break;
130.                         }
131.         }
132.  
133.         for (; dwAddress < dwEnd; dwAddress++)
134.         {
135.                 if (iBytesToRead == length)
136.                         return dwAddress - iBytesToRead;
137.  
138.                 if (Read<BYTE>(dwAddress) == Bytes[iBytesToRead] || (bTmp && Bytes[iBytesToRead] == '?'))
139.                 {
140.                         iBytesToRead++;
141.                         bTmp = true;
142.                 }
143.                 else
144.                 {
145.                         iBytesToRead = iTmp;
146.                         bTmp = false;
147.                 }
148.         }
149.  
150.         cout << "\nAOB_SCAN: No Byte Pattern found\n";
151.         return 0;
152. }
153.  
154. DWORD ProcMem::Module(LPSTR ModuleName)
155. {
156.         HANDLE hModule = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID);
157.         MODULEENTRY32 mEntry;
158.         mEntry.dwSize = sizeof(mEntry);
159.  
160.         do
161.                 if (!strcmp(mEntry.szModule, ModuleName))
162.                 {
163.                         CloseHandle(hModule);
164.                         return (DWORD)mEntry.modBaseAddr;
165.                 }
166.         while (Module32Next(hModule, &mEntry));
167.  
168.         cout << "\nCouldn't find client.dll, retrying...\n";
169.         return 0;
170. }
171.  
172. #pragma endregion