Ring3反作弊篇（基于EBP遍历调用栈及模块名）

余辉脉脉

之前自己做的一款老游戏的基于R3入门级的反作弊代码中的片段，仅供学习参考~~

通杀Win XP/7/8，哪位兄弟装了WIN10麻烦测试一下谢谢！

源码如下：

1. 
   
2. // CallStackList.cpp : 定义控制台应用程序的入口点。
   
3. 
   
4. #include "stdafx.h"
   
5. #include <Windows.h>
   
6. #include <stdio.h>
   
7. 
   
8. #include "EasyDetour.h"
   
9. 
   
10. #include <TlHelp32.h>
    
11. #include <Psapi.h>
    
12. #pragma comment(lib,"psapi.lib")
    
13. 
    
14. typedef int (WINAPI *fnMessageBoxA)(HWND hWnd,LPCSTR lpText,LPCSTR lpCaption,UINT uType);
    
15. 
    
16. fnMessageBoxA    pMessageBoxA = NULL;
    
17. 
    
18. DWORD Functiion(DWORD x, DWORD y);
    
19. 
    
20. 
    
21. //
    
22. // 提取函数
    
23. //
    
24. BOOL TiQuan()
    
25. {
    
26.     HANDLE    hToken;
    
27.     BOOL    fOk = FALSE;
    
28. 
    
29.     if(OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES,&hToken))
    
30.     {
    
31.         TOKEN_PRIVILEGES tp;
    
32.         tp.PrivilegeCount=1;
    
33.         if(!LookupPrivilegeValueA(NULL,"SeDebugPrivilege",&tp.Privileges[0].Luid))
    
34.             Sleep(1);
    
35. 
    
36.         tp.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;
    
37.         if(!AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(tp),NULL,NULL))
    
38.             Sleep(1);
    
39. 
    
40.         fOk = (GetLastError() == ERROR_SUCCESS);
    
41.         CloseHandle(hToken);
    
42.     }
    
43. 
    
44.     return fOk;
    
45. }
    
46. 
    
47. //
    
48. // 获取PE文件大小
    
49. //
    
50. DWORD GetPEImageSize(HMODULE hModule)
    
51. {
    
52.     PBYTE pInfo = (PBYTE)hModule;
    
53.     PIMAGE_DOS_HEADER pImgDos = (PIMAGE_DOS_HEADER)pInfo;
    
54.     PIMAGE_NT_HEADERS pImgNt;
    
55.     if(pImgDos->e_magic==IMAGE_DOS_SIGNATURE)
    
56.     {
    
57.         pImgNt = (PIMAGE_NT_HEADERS)&pInfo[pImgDos->e_lfanew];
    
58.         if(pImgNt)
    
59.         {
    
60.             if(pImgNt->Signature==IMAGE_NT_SIGNATURE)
    
61.             {
    
62.                 return pImgNt->OptionalHeader.SizeOfImage;
    
63.             }
    
64.         }
    
65.     }
    
66.     return NULL;
    
67. }
    
68. 
    
69. //
    
70. // Hook MessageBox for test
    
71. //
    
72. BOOL WINAPI GetCheatModuleByEBP(DWORD nEBP,char *pszPath,int nLen)
    
73. {
    
74.     TiQuan();
    
75.     if(nEBP == 0)
    
76.         return FALSE;
    
77. 
    
78.     DWORD    nPEB = nEBP;
    
79.     BOOL    bFound = FALSE;
    
80.     HMODULE hMods[1024] = {0};
    
81.     DWORD    cbNeeded = 0;
    
82.     char    szModName[MAX_PATH];
    
83. 
    
84.     HANDLE hProcess = ::OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ|PROCESS_QUERY_LIMITED_INFORMATION, FALSE, GetCurrentProcessId());
    
85.     //IsWow64Process(hProcess, &Wow64Process); //判断是32位还是64位进程
    
86.     EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded);
    
87. 
    
88.     nPEB = nEBP;
    
89.     for (UINT i = 0; i < (cbNeeded / sizeof(HMODULE)); i++ )
    
90.     {
    
91.         GetModuleFileNameExA(hProcess, hMods[i], szModName, _countof(szModName));
    
92.         if(hMods[i])
    
93.         {
    
94.             if(nPEB >= (DWORD)hMods[i] && (nPEB <= ((DWORD)hMods[i] + GetPEImageSize(hMods[i]))))
    
95.             {
    
96.                 memset(pszPath,0x00,nLen);
    
97.                 wsprintfA(pszPath,"%s",szModName);
    
98.                 bFound = TRUE;
    
99.                 break;
    
100.             }
     
101.         }
     
102.     }
     
103. 
     
104.     CloseHandle(hProcess);
     
105.     return bFound;
     
106. }
     
107. 
     
108. //
     
109. // Hook MessageBox for test
     
110. //
     
111. int WINAPI newMessageBoxA(HWND hWnd,LPCSTR lpText,LPCSTR lpCaption,UINT uType)
     
112. {
     
113.     Functiion(0,0);
     
114.     return pMessageBoxA(hWnd,lpText,lpCaption,uType);
     
115. }
     
116. 
     
117. //
     
118. // 回调函数
     
119. //
     
120. DWORD BackCall(DWORD Address)
     
121. {
     
122.     char    szDllPath[MAX_PATH] = {0x00};
     
123.     if(GetCheatModuleByEBP(Address,szDllPath,MAX_PATH))
     
124.         printf("检测地址:0x%08x  %s\n", Address, szDllPath);
     
125.     else
     
126.         printf("检测地址:0x%08x  未知模块\n", Address, szDllPath);
     
127. 
     
128.     //
     
129.     // 在这里添加白名单 黑名单匹配的代码 (黑名单返回1 白名单返回0)
     
130.     //
     
131. 
     
132.     return 0;
     
133. }
     
134. 
     
135. //
     
136. // 检测呼叫者调用连
     
137. //
     
138. BOOL __declspec(naked)  Check(void)
     
139. {
     
140.     __asm push ebp;
     
141.     __asm mov ebp, esp;
     
142.     __asm sub esp, 0x8;
     
143. 
     
144.     __asm push edi;
     
145.     __asm push ecx;
     
146. 
     
147.     //
     
148.     // 查询次数
     
149.     __asm mov ecx, dword ptr[ebp + 0x8];
     
150. 
     
151.     //
     
152.     // 设置堆栈指针
     
153.     __asm mov edi, dword ptr[ebp];
     
154. 
     
155. __Loop:
     
156. 
     
157.     //
     
158.     // 保存当前堆栈的返回地址 也就是呼叫这个函数的上一层函数的内存空间
     
159.     __asm mov eax, dword ptr[edi + 0x4];
     
160. 
     
161.     //
     
162.     // 调用匹配规则函数
     
163.     __asm push eax;
     
164.     __asm call dword ptr[ebp + 0xc];
     
165.     __asm add esp, 0x4;
     
166.      
     
167.     //
     
168.     // 获取上一个堆栈的指针
     
169.     __asm mov edi, dword ptr[edi];
     
170. 
     
171.     __asm cmp eax, 0x1;
     
172.     __asm je __Out;
     
173. 
     
174.     //
     
175.     // 如果已经为空了 则直接退出
     
176.      
     
177.     __asm cmp edi, 0x0;
     
178.     __asm je __Out;
     
179. 
     
180.     __asm loop __Loop;
     
181. 
     
182. __Out:
     
183. 
     
184.     __asm pop ecx;
     
185.     __asm pop edi;
     
186.     __asm add esp, 0x8;
     
187.     __asm pop ebp;
     
188.     __asm ret;
     
189. }
     
190. 
     
191. 
     
192. 
     
193. //
     
194. // 测试函数
     
195. //
     
196. DWORD Functiion(DWORD x, DWORD y)
     
197. {
     
198. 
     
199.     //
     
200.     // 设置回调函数
     
201.     __asm mov edx, dword ptr[BackCall];
     
202.     __asm push edx;
     
203. 
     
204.     //
     
205.     // 设置最大检测深度
     
206.     __asm push 0x50;
     
207.     __asm call dword ptr[Check];
     
208.     __asm add esp, 0x8;
     
209. 
     
210.     return x + y;
     
211. }
     
212. 
     
213. // 这里是测试函数
     
214. DWORD Function(DWORD x,DWORD y)
     
215. {
     
216.     //x += y;
     
217.     __asm mov edx,dword ptr[x];
     
218.     __asm add edx,0x10;                // 深度检测10个
     
219.     __asm mov dword ptr[x],edx;
     
220.     return x;
     
221. }
     
222. 
     
223. int MsgBox()
     
224. {
     
225.     return MessageBoxA(NULL,"Hello World by Koma !","Test",MB_OK);
     
226. }
     
227. 
     
228. int _tmain(int argc, _TCHAR* argv[])
     
229. {
     
230.     pMessageBoxA = MessageBoxA;
     
231.     DetourHook((void**)&pMessageBoxA,newMessageBoxA);
     
232.     MsgBox();
     
233.     while(getchar() != 'a')
     
234.         Sleep(0);
     
235.     DetourUnHook((void**)&pMessageBoxA,newMessageBoxA);
     
236.     return 0;
     
237. }

复制代码

1. 
   
2. // 暴力搜索R3断链隐藏模块
   
3. BOOL WINAPI GetCheatModuleByEBP(const DWORD nEBP,const char *pszPath,const int nLen,DWORD & nCRC,DWORD & nFileSize);
   
4. {
   
5. DWORD ModuleBase = 0;
   
6. DWORD ModuleSize = 0;
   
7. WCHAR szModuleName[MAX_PATH] = {0};
   
8. WCHAR szPathName[MAX_PATH] = {0};
   
9. HANDLE hProcess = INVALID_HANDLE_VALUE;
   
10.   
    
11. memset(pszPath,0x00,nLen);
    
12. nCRC = nFileSize = 0;
    
13. if(nProcessID == 0)
    
14.   return FALSE;
    
15.   hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, GetCurrentProcessId());
    
16. if(!hProcess)
    
17.   return FALSE;
    
18.   for(int i=-1, BaseAddress=0; BaseAddress<0x80000000; BaseAddress+=0x1000)
    
19. {
    
20.   MEMORY_BASIC_INFORMATION mbi;
    
21.   if(NT_SUCCESS(ZwQueryVirtualMemory(hProcess, (PVOID)BaseAddress, MemoryBasicInformation, &mbi, sizeof(mbi), 0)))
    
22.   {
    
23.    if(ModuleBase && ModuleBase != (DWORD)mbi.AllocationBase && ModuleSize)
    
24.     ModuleBase = ModuleSize = 0;
    
25.     if(mbi.Type != MEM_IMAGE)
    
26.     continue;
    
27.     ModuleBase = (DWORD)mbi.AllocationBase;
    
28.    if(ModuleBase && mbi.BaseAddress == (PVOID)BaseAddress)
    
29.     ModuleSize = (DWORD)mbi.BaseAddress + mbi.RegionSize - (DWORD)mbi.AllocationBase;
    
30.     if(mbi.AllocationBase != (PVOID)BaseAddress)
    
31.     continue;
    
32.    
    
33.    if(ModuleBase == 0 || ModuleSize == 0)
    
34.     continue;
    
35.     if((ModuleBase <= nEBP) && (ModuleBase + ModuleSize) >= nEBP)
    
36.    {
    
37.     ULONG  NameSize = 0x100;
    
38.     LPVOID  pBuffer = malloc(NameSize);
    
39.     if(!pBuffer)
    
40.     {
    
41.      ASSERT(FALSE);
    
42.      continue;
    
43.     }
    
44.      
    
45.     NTSTATUS status = ZwQueryVirtualMemory(hProcess, (PVOID)mbi.AllocationBase, MemorySectionName, pBuffer, NameSize, &NameSize);
    
46.     if(status == STATUS_INFO_LENGTH_MISMATCH || status == STATUS_BUFFER_OVERFLOW)
    
47.     {
    
48.      free(pBuffer);
    
49.      pBuffer = malloc(NameSize);
    
50.      status = ZwQueryVirtualMemory(hProcess, (PVOID)mbi.AllocationBase, MemorySectionName, pBuffer, NameSize, 0);
    
51.     }
    
52.      
    
53.     if(!pBuffer) continue;
    
54.      if(!NT_SUCCESS(status))
    
55.     {
    
56.      free(pBuffer);
    
57.      continue;
    
58.     }
    
59.      POBJECT_NAME_INFORMATION SectionName = (POBJECT_NAME_INFORMATION)pBuffer;
    
60.     ANSI_STRING  tmpAS;
    
61.      PUNICODE_STRING usSectionName;
    
62.     char   *pTemp = NULL;
    
63.      usSectionName = (PUNICODE_STRING)pBuffer;
    
64.     _wcsnicmp(szModuleName, usSectionName->Buffer, usSectionName->Length / sizeof(WCHAR));
    
65.     wcsncpy(szModuleName, usSectionName->Buffer, usSectionName->Length / sizeof(WCHAR) );
    
66.     szModuleName[usSectionName->Length / sizeof(WCHAR)] = UNICODE_NULL;
    
67.     DeviceName2PathName(szPathName, szModuleName);
    
68.     pTemp = (char *)malloc(sizeof(char)*(2*wcslen(szPathName)+1));
    
69.     memset(pTemp , 0 , 2 * wcslen(szPathName)+1);
    
70.     W2C(pTemp,szPathName,2 * wcslen(szPathName)+1) ;
    
71.      memcpy(pszPath,pTemp,strlen(pTemp));
    
72.     delete [] pTemp;
    
73.     pTemp = NULL;
    
74.      nFileSize = mbi.RegionSize;
    
75.     nCRC   = GetFileCRC(pszPath);
    
76.      free(pBuffer);
    
77.     pBuffer = NULL;
    
78.     CloseHandle(hProcess);
    
79.     return TRUE;
    
80.    }
    
81.   } else if(ModuleBase && ModuleSize)
    
82.   {
    
83.    ModuleBase = ModuleSize = 0;
    
84.   }
    
85. }
    
86.   CloseHandle(hProcess);
    
87. return FALSE;
    
88. }

复制代码