The game-helper from awsay

介绍

这是在2018年2-3月份学习windows核心编程等相关技术编写的游戏辅助。本仓库旨在介绍游戏辅助与计算机专业课程的种种联系，了解游戏辅助的工作流程以及开发方法。我当时在某个寒假的时候花了一个月学习这方面的技术，感觉很大程度的提升了我的windows编程，以及操作系统，计算机网络，汇编语言等多方面的水平（对后面的专业课打了不错的基础），所以打算将这个东西分享出来，只是作为学习（没有作为商业用途），里面的代码有很多中文函数和变量（业界流行用中文），方便阅读，现在也没有做这方面的研究了。

这方面涉及到的技术：

windows API Hook ：主要是应用层API Hook，如hook send发包函数；如果是做游戏保护方面，需要懂驱动层Hook，例如SSDT，Shadow SSDT，IDT Hook等等。这方面很重要，很多windows应用程序就是靠API Hook工作的，例如杀毒软件，病毒，以及游戏保护系统
windows 模块注入：将你编译的dll模块注入到游戏应用程序中，这方面的技术很多，有修改PE文件的方法，远程线程注入（一般游戏在Hook CreateRemoteThread函数，所以注入失败），劫持注入，输入法注入等。比较容易使用的是劫持注入和输入法注入。
软件逆向：使用olldgb等调试器调试游戏会得到汇编代码，一般需要动态调试游戏，在某些关键的语句中下断点，理清游戏的逻辑，这方面比较的困难（不过一般的计算机专业学生都有一定的汇编能力），可以说所以的功能都从这里来的。
熟悉 windows 编程中常用的api，以及懂得如何编译dll（对编译重定位链接这些流程要熟悉）。这方面可以看《windows核心编程》这本书，一开始感觉有点难以编写，后面就慢慢习惯了。。

游戏辅助的3种方法：

指定地址内存值修改(例如 *(int*)(0x1234567) = 12345 )
指定地址函数call调用（汇编实现)
发包收包(Hook send)

仓库的代码结构

DNFHelper ：编译出dll的源码，是功能实现的核心
InjectDll ：将dll注入到exe进程的实现（使用输入法注入）,是一个简单的MFC桌面应用
HelperStart ：在无图形界面下将dll注入到exe进程里，并做一些简单的处理。

功能概况

当时实现了很多功能，留了几张截图

召唤人偶

用人偶来帮你打伤害
面板（攻击力）提升

例如修改自身的力量，把自身物攻提到21w，开启这个功能很容易造成游戏数据异常。。
召唤高达

这个有点像是个人偶，不过人物可以坐在里面操控，攻击力很高
自动攻击这个是最常用的，让怪物附近自动生成技能然后攻击怪物，攻击的血量是可以指定的，如果血量足够高就是全屏秒杀了。
人物透明，3S评分
加buff 可以给自己加大量的buff让自己变得更强
自动过图，自动做任务，自动捡物，聚怪，符咒等等

可以做成一整套全自动的系统，自动升级，自动搬砖，没疲劳了自动换号等。这里录了一个1分钟的视频放在了根目录下（由于用手机录的视频有点大，压缩成一个mp4格式的，不到3MB）

相关知识解答

由于现在windows下的游戏绝大多数都是x86的，所以下面只讨论32位方面的问题，在64位下会不太一样。

1. 什么是基址？

这个概念是最常被提起的，也是最重要的。所谓基址，就是程序中某些变量的地址，这些地址是恒定不变的（在游戏被更新之前）。为什么是基址不会改变呢？可以运行下面这个简单的实例，

#include <stdio.h>

int a = 123;

int main() {
	printf("%X", &a);	
}

多次运行之后你会发现，输出的值都是不变的，因为a的地址是不变的（即使将 int a = 123 写到函数体内，输出的值也是恒定的）。

int a = 123 写在main外部：a是存储在静态存储区的（.data段），在程序编译阶段已经就确定了存储的位置(即段内偏移量是不会变的，除非程序改动后重新编译)
int a = 123 写在main里面，a的地址不变的原因：a存储在栈区，栈指针esp在编译阶段已经可以确定是如何移动的（esp初始位置也是确定的），因此a的地址不变（这里只考虑单线程程序，多线程由于有独立栈空间，输出的结果会有变化）

游戏里面的基址通常是一个指针，通过基址+偏移量的方法，定位出关键数据的位置，举个例子

#include <stdio.h>

struct people {
	char* name;
	int age;
	int power; //攻击力	
    // ...
};
 
people *instance; // 人物指针

int main() {
	instance = (people*)malloc(sizeof(people));
	// ... 后面对任务进行初始化等 
}

由于基址是不变的，所以instance这个变量的地址其实在编译阶段就已经确定了，假设我们通过某种方法获取到instance的地址0x12345678。我们可以通过 *(int*)(0x12345678) 获取到people实际的存储地址，如果我们想要修改人物的攻击力，可以通过*(int*)(*(int*)(0x12345678) + 8) = 12345678 这里8为人物攻击力的偏移量，得到该地址后取指针就可以得到人物攻击力的真实存储地址了。

游戏中的结构体一般都比较复杂，有多级偏移，一般就是 [[[[基址]+偏移1]+偏移2]+偏移3] ... 这种模式([]为去变量的地址)

如果想了解更多，可以去看虚拟地址，操作系统的分段和分页机制，加深对C语言的指针的理解

2. 什么是模块注入？

简单理解：就是在正常运行的程序中注入你编写的模块（dll后缀名），然后让正常运行的程序执行你模块中的代码。通常模块注入后会在模块入口中创建一个后台的工作线程，线程可以共享进程内的全局变量，而且分配和读写内存也不会受到种种限制。

模块注入成功是一切的基础。模块注入的方法很多，大家在网上可以寻找相关的资料学习。我在仓库中提供了我比较常用的输入法注入的源码，稳定性还可以。

远程线程注入：进程A对进程B创建一个线程（进程A拥有权限的情况下），然后在线程调用了LoadLibrary函数，使得模块被加载（这里分享一段远程线程注入的代码，核心函数RemoteInject）

#include <Windows.h>
#include <TlHelp32.h>
#include <tchar.h>
#include <stdio.h>
#include <winsock.h>
#include <string.h>
#include <io.h>
#pragma comment(lib, "ws2_32.lib")

//将单字节char*转化为宽字节wchar_t*  
wchar_t* AnsiToUnicode(const char* szStr)
{
	int nLen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szStr, -1, NULL, 0);
	if (nLen == 0)
	{
		return NULL;
	}
	wchar_t* pResult = new wchar_t[nLen];
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szStr, -1, pResult, nLen);
	return pResult;
}

//将宽字节wchar_t*转化为单字节char*  
inline char* UnicodeToAnsi(const wchar_t* szStr)
{
	int nLen = WideCharToMultiByte(CP_ACP, 0, szStr, -1, NULL, 0, NULL, NULL);
	if (nLen == 0)
	{
		return NULL;
	}
	char* pResult = new char[nLen];
	WideCharToMultiByte(CP_ACP, 0, szStr, -1, pResult, nLen, NULL, NULL);
	return pResult;
}


BOOL Is64BitOS()
{
	typedef VOID(WINAPI *LPFN_GetNativeSystemInfo)(__out LPSYSTEM_INFO lpSystemInfo);
	LPFN_GetNativeSystemInfo fnGetNativeSystemInfo = (LPFN_GetNativeSystemInfo)GetProcAddress(GetModuleHandleW(L"kernel32"), "GetNativeSystemInfo");
	if (fnGetNativeSystemInfo)
	{
		SYSTEM_INFO stInfo = { 0 };
		fnGetNativeSystemInfo(&stInfo);
		if (stInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64
			|| stInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
		{
			return TRUE;
		}
	}
	return FALSE;
}

BOOL Is64BitPorcess(HANDLE hProcess)
{
	if (!Is64BitOS())
		return FALSE;
	else
	{
		if (hProcess)
		{
			typedef BOOL(WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
			LPFN_ISWOW64PROCESS fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandleW(L"kernel32"), "IsWow64Process");
			if (NULL != fnIsWow64Process)
			{
				BOOL bIsWow64 = FALSE;
				fnIsWow64Process(hProcess, &bIsWow64);
				if (bIsWow64)
					return FALSE;
				else
					return TRUE;
			}
		}
	}
	return FALSE;
}

void EnableDebugPriv()
{
	HANDLE hToken;
	LUID luid;
	TOKEN_PRIVILEGES tkp;

	OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken);

	LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid);

	tkp.PrivilegeCount = 1;
	tkp.Privileges[0].Luid = luid;
	tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

	AdjustTokenPrivileges(hToken, false, &tkp, sizeof(tkp), NULL, NULL);

	CloseHandle(hToken);
}

VOID EnumProcess()
{
	EnableDebugPriv();
	DWORD pid = 0;
	HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	PROCESSENTRY32 process;
	ZeroMemory(&process, sizeof(process));
	process.dwSize = sizeof(process);
	printf("            进程名称   进程ID    父进程ID  32/64位\n");
	if (Process32First(snapshot, &process))
	{
		do
		{
			printf("%20.20ls    %5d       %5d  ", process.szExeFile, process.th32ProcessID, process.th32ParentProcessID);
			HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, process.th32ProcessID);
			if (Is64BitPorcess(hProcess))
				printf("   64位\n");
			else
				printf("   32位\n");
			CloseHandle(hProcess);
		} while (Process32Next(snapshot, &process));
	}
	CloseHandle(snapshot);
}

HANDLE GetProcessByName(LPCSTR name)
{
	EnableDebugPriv();
	DWORD pid = 0;
	HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	PROCESSENTRY32 process;
	ZeroMemory(&process, sizeof(process));
	process.dwSize = sizeof(process);
	if (Process32First(snapshot, &process))
	{
		do
		{
			if (stricmp(UnicodeToAnsi(process.szExeFile), name) == 0)
			{
				pid = process.th32ProcessID;
				break;
			}
		} while (Process32Next(snapshot, &process));
	}
	CloseHandle(snapshot);

	if (pid != 0)
	{
		HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
		return hProcess;
	}
	return NULL;

}

HANDLE GetProcessByWindowName(LPWSTR WindowsName)
{
	HANDLE hProcess = NULL;
	DWORD pid, ERRO;
	HWND dnf = ::FindWindow(NULL, WindowsName);
	GetWindowThreadProcessId(dnf, &pid);
	EnableDebugPriv();
	hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
	if (hProcess == NULL)
	{
		printf("找不到进程!\n");
		return 0;
	}
	return hProcess;
}

BOOL RemoteInject(HANDLE hProcess, LPCSTR szLibPath)
{
	HANDLE hThread;
	HMODULE modHandle = GetModuleHandle(_T("Kernel32"));
	DWORD dwsize = (strlen(szLibPath) + 1)*sizeof(CHAR);
	LPVOID pLibRemote = VirtualAllocEx(hProcess, NULL, dwsize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
	WriteProcessMemory(hProcess, pLibRemote, (LPVOID)szLibPath, dwsize, NULL);
	if (GetLastError()) return FALSE;
	LPTHREAD_START_ROUTINE func = (LPTHREAD_START_ROUTINE)GetProcAddress(modHandle, "LoadLibraryA");
	DWORD tid;
	hThread = CreateRemoteThread(hProcess, NULL, 0,
		func,
		pLibRemote,
		0,
		&tid);
	if (GetLastError()) return FALSE;
	WaitForSingleObject(hThread, INFINITE);
	CloseHandle(hThread);
	VirtualFreeEx(hProcess, pLibRemote, dwsize, MEM_DECOMMIT);
	return TRUE;
}

void usage()
{
	printf("功能1：枚举系统中的进程\n");
	printf("inject -e\n\n");
	printf("功能2：向指定进程注入代码\n");
	printf("inject {exe} {dll}\n");
	printf("inject -pid {pid} {dll}\n");
	printf("例如: inject.exe chrome.exe mydll.dll\n");
	printf("注意exe版本和dll版本以及注入的程序的版本要一致\n");
	exit(0);
}

int main(int argc, char* argv[])
{
	CHAR szLibPath[MAX_PATH] = { 0 };
	GetCurrentDirectoryA(MAX_PATH, szLibPath);
	CHAR szDllName[MAX_PATH] = { 0 };
	HANDLE hProcess = NULL;
	if (argc == 2)
	{
		if (strcmp(argv[1], "-e"))
			usage;
		EnumProcess();
		return 0;
	}
	if (argc == 4)
	{
		if (strcmp(argv[1], "-pid"))
			usage();
		else
		{
			DWORD pid = atoi(argv[2]);
			hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
		}
		strcpy(szDllName, argv[3]);
	}
	if (argc == 3)
	{
		strcpy(szDllName, argv[2]);
		hProcess = GetProcessByName(argv[1]);
	}
	if (argc != 2 && argc != 4 && argc != 3) 
		usage();
	if (hProcess == NULL)
	{
		printf("找不到进程!\n");
		return 0;
	}
	BOOL Is64_1 = Is64BitPorcess(hProcess);
	BOOL Is64_2 = Is64BitPorcess(GetCurrentProcess());
	if (Is64_1 != Is64_2)
	{
		if (Is64_1)
			printf("请运行64位版本\n");
		else
			printf("请运行32位版本\n");
		return 0;
	}
	strcpy(szLibPath + strlen(szLibPath), "\\");
	strcpy(szLibPath + strlen(szLibPath), szDllName);
	if (_access(szLibPath, 0))
	{
		printf("%s : dll不存在\n", szLibPath);
		return 0;
	}
	if (!RemoteInject(hProcess, szLibPath))
		printf("注入失败\n");
	else
		printf("注入成功\n");
	return 0;
}

3. 什么是API Hook?

简单理解：假设我现在Hook了A函数，当其他线程调用了A函数，但实际上确是执行了B函数，而调用者却完全不知情。

例如

int A() {
    // 这一个是正常的函数，一般是游戏开发者编写的
	return 1;
}

int B() {
    // 这个是恶意的函数（一般是你模块注入成功后你编写的函数）
	// 通常是先保存A的地址，然后
    return 0;
}

int main() {
    // Hook(A, B); // 在其他线程中，A函数被Hook为B函数  
    int res = A(); // 这里调用者不知情，实际上调用的是B函数
}

分享Hook MessageBox弹窗的例子。

#include <windows.h>

//定义函数原型: MessageBoxA
typedef int WINAPI OLD_MessageBoxA( __in_opt HWND hWnd, __in_opt LPCSTR lpText, __in_opt LPCSTR lpCaption, __in UINT uType);

DWORD addr1; // 保存源码MeesageBoxA的地址

__declspec(naked)   int __stdcall My_MessageBoxA( __in_opt HWND hWnd, __in_opt LPCSTR lpText, __in_opt LPCSTR lpCaption, __in UINT uType)
{
	__asm
	{
			mov edi, edi
			push ebp
			mov ebp ,esp 
	}	

	lpText="已被HOOK";  // 修改数据
	__asm
	{
		mov eax,addr1
		add eax,5 // 前5字节是我们的长jump指令
		jmp eax   // 跳到MessageBox真正的代码区域
	}			
}

int _tmain(int argc, _TCHAR* argv[])
{
	DWORD jump_code=0;
	byte  mye9 = 0xe9;
	HMODULE DLLHANDLE= LoadLibraryA("USER32.DLL");
	addr1= (DWORD)(GetProcAddress(DLLHANDLE,"MessageBoxA"));

	//改变内存读写属性 
	VirtualProtect((LPVOID)addr1,10,PAGE_EXECUTE_READWRITE,NULL);
	 	 
	//修改第一字节
	if (WriteProcessMemory(GetCurrentProcess(),(LPVOID)addr1,&mye9,1,NULL)==0)
	{
		printf("写入HOOK数据失败");
	}

	 //修改后4字节 :跳转码  JMP 1234
	 //跳转码=将要跳到的函数-原来的函数地址-5
	 //我们的跳转码=My_MessageBoxA-addr1-5
	 jump_code=(DWORD)&My_MessageBoxA-addr1-5;
	 if (WriteProcessMemory(GetCurrentProcess(),(DWORD*)(addr1+1),&jump_code,4,NULL)==0)
	 {
		 printf("写入HOOK数据失败");
	 }

	::MessageBoxA(0,"HOOK1","提示",0);
	::MessageBoxA(0,"HOOK2","提示",0);
	::MessageBoxA(0,"HOOK3","提示",0);

	 return 0;
}

运行之后调用MessageBoxA，窗口中的内容都是"已被Hook"。

这种Hook方法称为Inline Hook，因为在windows api中，如果函数被声明为__stdcall的话，汇编后的前5个字节是这样的

mov edi, edi  // 2字节
push ebp   // 1字节
mov ebp, esp // 2字节

这5个字节刚好可以组成一条长jump指令，只要修改函数代码段即可。

4. 参数入栈方式

在windows下参数一般都是从右往左入栈的，下面一个简单的程序

int fun(int a, float b, int c) {
    return 1;
}

int main() {
    ...
    func(1, 2, 3);
}

汇编之后，fun函数通常是这样的。

push        ebp  
mov         ebp,esp  // 保存esp寄存器到ebp中

sub         esp,0C0h  // 开辟栈空间

push        ebx  
push        esi  
push        edi  // 保存寄存器

lea         edi,[ebp-0C0h]  
mov         ecx,30h  
mov         eax,0CCCCCCCCh  
rep stos    dword ptr es:[edi]  // 将栈空间初始化

mov         eax,1  // 将返回值设置1，eax为返回值寄存器

pop         edi  
pop         esi  
pop         ebx  
mov         esp,ebp  // 复原esp寄存器
pop         ebp   // 复原ebp寄存器
ret // 回到调用者的位置，相当于 add esp, 4; jmp [esp-4];

调用者方汇编代码通常是这样的

push 3
push 2
push 1
call func  // 相当于 push pc; jmp esp
add esp, 0xCh // 因为push了3次，esp降低了12字节,所以需要add回来

想了解更多，可以搜索程序运行时的栈空间布局，例如func函数的第一个变量地址是ebp-8，第二个变量是ebp-12，返回值存储在eax寄存器中

5. 如何实现花里胡哨的特效（例如怪物自动扣血）？

几乎所有的辅助功能，都是调用游戏开发者写的某个函数的，比如怪物受到技能攻击，我们首先需要通过汇编找到攻击的call地址，然后在我们的dll模块中调用这个call从而实现效果，一般使用汇编来实现。

（这里源码中基本都是中文，vs支持中文）

基本流程：通过遍历取得所有怪物的坐标地址和指针，然后用技能call对怪物进行攻击，使得怪物掉血。

void 释放call(int 对象基址, int 代码, int 伤害, int X, int Y, int Z)
{
	_asm
	{
		push Z
		push Y
		push X
		push 伤害
		push 代码
		push 对象基址
		mov eax, 释放Call
		call eax
		add esp, 0x18
	}
}

void 全屏遍历()
{
	int 一级偏移 = read(人物基址);
	int 二级偏移 = read(一级偏移 + 地图偏移);
	if (二级偏移 == 0)
		return;
	int 首地址_ = read(二级偏移 + 首地址);
	int 尾地址_ = read(二级偏移 + 尾地址);
	int 怪物数量 = (尾地址_ - 首地址_) / 4;
	int 技能数量_ = 0;
	int x, y, z;
	if (技能伤害 == 0)
	{
		int sum = 0, cnt = 0;
		for (int i = 1; i <= 怪物数量; i++)
		{
			int 地址 = read(首地址_ + 4 * i);
			if (地址 <= 0)
				continue;
			int 类型 = read(地址 + 类型偏移);
			int 阵营 = read(地址 + 阵营偏移);
			int 血量 = read(地址 + 怪物血量偏移);
			if ((类型 == 529 || 类型 == 545 || 类型 == 273) && 阵营 > 0 && 血量 > 0)
			{
				cnt++;
				sum += 血量;
			}
		}
		if (cnt == 0) return;
		for (int i = 0; i < 技能代码个数; i++)
		{
			超级加密(Atk[i] + 32, sum / cnt );
		}
	}
	for (int i = 0; i <= 怪物数量; i++)
	{
		int 地址 = read(首地址_ + 4 * i);
		if (地址 <= 0)
			continue;
		int 类型 = read(地址 + 类型偏移);
		int 阵营 = read(地址 + 阵营偏移);
		int 血量 = read(地址 + 怪物血量偏移);
		int 代码 = read(地址 + 对象代码);
		x = (int)read<float>(地址 + X坐标);
		y = (int)read<float>(地址 + Y坐标);
		z = (int)read<float>(地址 + Z坐标);
		if ((类型 == 529 || 类型 == 545 || 类型 == 273) &&  阵营 > 0 && 血量 > 0 && 地址 != 一级偏移)
		{
			技能代码 = 技能代码集合[index % 技能代码个数];
			释放call(一级偏移, 技能代码, 0, x, y, z);
			技能数量_ += 1;
			index++;
			if (技能数量_ == 技能个数)
				break;
		}
		
	}
	if (index > 100)
		index = 0;
}

6. 发包相关

一般都是下send断点，然后通过调用堆栈定位关键函数，这方面需要对网络编程和调试水平非常的熟悉，发包可以实现很多功能，甚至是脱机刷图。。。

awsay / game-helper Goto Github PK

game-helper's Introduction

介绍

功能概况

相关知识解答

1. 什么是基址？

2. 什么是模块注入？

3. 什么是API Hook?

4. 参数入栈方式

5. 如何实现花里胡哨的特效（例如怪物自动扣血）？

6. 发包相关

game-helper's People

Contributors

Stargazers

Watchers

Forkers

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent