手遊作弊(二)-記憶體讀寫例項

語言: CN / TW / HK

關於手遊作弊的部落格我鴿的有點久了哈哈,這篇文章就和大家講解下在記憶體中資料的儲存格式,如何讀取和修改

基礎資料型別在記憶體中的儲存空間
int - 4位元組
float - 4位元組
double - 8位元組
long - 4位元組或8位元組
char - 1位元組
short - 2位元組





32位手遊地址指標在記憶體佔用4個位元組,64位手遊地址指標在記憶體中佔用8個位元組。
關於指標,我們在後面的文章會詳細講解。

在手遊中,還有一個特殊的型別:XOR
XOR型別實際是int型別,這是遊戲常用的防止玩家直接搜尋到關鍵數值的一種加密方式(地址^值),其實也很簡單

我們都知道,A ^ B = C,C ^ B = A,C ^ A = B
那麼,加密後值^地址 = 實際值

上一期我們使用C語言的pread和pwrite函式來讀取和修改記憶體,不過這樣是很容易被遊戲檢測到的。
今天我們要說的方式是系統呼叫,使用syscall來呼叫SYS_process_vm_readv和SYS_process_vm_writev,這兩個函式的引數和返回值可以在百度上直接找到,我就不詳細說明了。

這裡我直接貼上詳細的程式碼,供大家參考:

AndroidMemDebug.h

#ifndef _ANDROIDMEMDEBUG_H_
#define _ANDROIDMEMDEBUG_H_

#include <stdio.h>
#include <stdlib.h>
#include <sys/uio.h>
#include <sys/types.h>
#include <sys/syscall.h>
#include <pthread.h>
#include <unistd.h>
#include <dirent.h>
#include <fcntl.h>
#include <iostream>

// 支援的搜尋型別
enum
{
   
   
	DWORD,
	FLOAT,
	BYTE,
	WORD,
	QWORD,
	XOR,
	DOUBLE,
};

// 支援的記憶體範圍(請參考GG修改器記憶體範圍)
enum
{
   
   
	Mem_Auto,					// 所以記憶體頁
	Mem_A,
	Mem_Ca,
	Mem_Cd,
	Mem_Cb,
	Mem_Jh,
	Mem_J,
	Mem_S,
	Mem_V,
	Mem_Xa,
	Mem_Xs,
	Mem_As,
	Mem_B,
	Mem_O,
};

struct MemPage
{
   
   
	long start;
	long end;
	char flags[8];
	char name[128];
	void *buf = NULL;
};

struct AddressData
{
   
   
	long *addrs = NULL;
	int count = 0;
};

// 根據型別判斷型別所佔位元組大小
size_t judgSize(int type)
{
   
   
	switch (type)
	{
   
   
	case DWORD:
	case FLOAT:
	case XOR:
		return 4;
	case BYTE:
		return sizeof(char);
	case WORD:
		return sizeof(short);
	case QWORD:
		return sizeof(long);
	case DOUBLE:
		return sizeof(double);
	}
	return 4;
}

int memContrast(char *str)
{
   
   
	if (strlen(str) == 0)
		return Mem_A;
	if (strstr(str, "/dev/ashmem/") != NULL)
		return Mem_As;
	if (strstr(str, "/system/fonts/") != NULL)
		return Mem_B;
	if (strstr(str, "/data/app/") != NULL)
		return Mem_Xa;
	if (strstr(str, "/system/framework/") != NULL)
		return Mem_Xs;
	if (strcmp(str, "[anon:libc_malloc]") == 0)
		return Mem_Ca;
	if (strstr(str, ":bss") != NULL)
		return Mem_Cb;
	if (strstr(str, "/data/data/") != NULL)
		return Mem_Cd;
	if (strstr(str, "[anon:dalvik") != NULL)
		return Mem_J;
	if (strcmp(str, "[stack]") == 0)
		return Mem_S;
	if (strcmp(str, "/dev/kgsl-3d0") == 0)
		return Mem_V;
	return Mem_O;
}



class MemoryDebug
{
   
   
  private:
	pid_t pid = 0;			// 除錯應用的PID

  public:
  //設定除錯的應用包名,返回PID
    int setPackageName(const char* name);
    //獲取模組的基址,@name:模組名,@index:模組在記憶體中的記憶體頁位置(第幾位,從1開始,預設1)
    long getModuleBase(const char* name,int index = 1);
	//獲取模組的BSS基址
	long getBssModuleBase(const char *name);
	//讀記憶體的基礎函式
	size_t preadv(long address, void *buffer, size_t size);
	//寫記憶體的基礎函式
	size_t pwritev(long address, void *buffer, size_t size);
	
	//根據值搜尋記憶體,並返回相應地址
	template < class T > AddressData search(T value, int type, int mem, bool debug = false);
	//修改記憶體地址值,返回-1,修改失敗,返回1,修改成功
	template < class T > int edit(T value,long address,int type,bool debug = false);
	
	//讀取一個DWORD(int)數值
	int ReadDword(long address);
	//讀取一個int指標地址數值
	long ReadDword64(long address);
	//讀取一個float型別數值
	float ReadFloat(long address);
	//讀取一個long型別數值
	long ReadLong(long address);
};

#include "AndroidMemDebug.cpp"

#endif

AndroidMemDebug.cpp



int MemoryDebug::setPackageName(const char* name)
{
   
   
	int id = -1;
	DIR *dir;
	FILE *fp;
	char filename[32];
	char cmdline[256];
	struct dirent *entry;
	dir = opendir("/proc");
	while ((entry = readdir(dir)) != NULL)
	{
   
   
		id = atoi(entry->d_name);
		if (id != 0)
		{
   
   
			sprintf(filename, "/proc/%d/cmdline", id);
			fp = fopen(filename, "r");
			if (fp)
			{
   
   
				fgets(cmdline, sizeof(cmdline), fp);
				fclose(fp);
				if (strcmp(name, cmdline) == 0)
				{
   
   
					pid = id;
					return id;
				}
			}
		}
	}
	closedir(dir);
	return -1;
}

long MemoryDebug::getModuleBase(const char* name,int index)
{
   
   
	int i = 0;
	long start = 0,end = 0;
    char line[1024] = {
   
   0};
    char fname[128];
	sprintf(fname, "/proc/%d/maps", pid);
    FILE *p = fopen(fname, "r");
    if (p)
    {
   
   
        while (fgets(line, sizeof(line), p))
        {
   
   
            if (strstr(line, name) != NULL)
            {
   
   
                i++;
                if(i==index){
   
   
                    sscanf(line, "%lx-%lx", &start,&end);
                    break;
                }
            }
        }
        fclose(p);
    }
    return start;
}

long MemoryDebug::getBssModuleBase(const char *name)
{
   
   
	FILE *fp;
	int cnt = 0;
	long start;
	char tmp[256];
	fp = NULL;
	char line[1024];
	char fname[128];
	sprintf(fname, "/proc/%d/maps", pid);
	fp = fopen(fname, "r");
	while (!feof(fp))
	{
   
   
		fgets(tmp, 256, fp);
		if (cnt == 1)
		{
   
   
			if (strstr(tmp, "[anon:.bss]") != NULL)
			{
   
   
				sscanf(tmp, "%lx-%*lx", &start);
				break;
			}
			else
			{
   
   
				cnt = 0;
			}
		}
		if (strstr(tmp, name) != NULL)
		{
   
   
			cnt = 1;
		}
	}
	return start;
}

size_t MemoryDebug::pwritev(long address, void *buffer, size_t size)
{
   
   
	struct iovec iov_WriteBuffer, iov_WriteOffset;
	iov_WriteBuffer.iov_base = buffer;
	iov_WriteBuffer.iov_len = size;
	iov_WriteOffset.iov_base = (void *)address;
	iov_WriteOffset.iov_len = size;
	return syscall(SYS_process_vm_writev, pid, &iov_WriteBuffer, 1, &iov_WriteOffset, 1, 0);
}


size_t MemoryDebug::preadv(long address, void *buffer, size_t size)
{
   
   
	struct iovec iov_ReadBuffer, iov_ReadOffset;
	iov_ReadBuffer.iov_base = buffer;
	iov_ReadBuffer.iov_len = size;
	iov_ReadOffset.iov_base = (void *)address;
	iov_ReadOffset.iov_len = size;
	return syscall(SYS_process_vm_readv, pid, &iov_ReadBuffer, 1, &iov_ReadOffset, 1, 0);
}

template < class T > AddressData MemoryDebug::search(T value, int type, int mem, bool debug)
{
   
   
	size_t size = judgSize(type);
	MemPage *mp = NULL;
	AddressData ad;
	long * tmp, *ret = NULL;
	int count = 0;
	char filename[32];
	char line[1024];
	snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
	FILE *fp = fopen(filename, "r");
	if (fp != NULL)
	{
   
   
		//臨時儲存搜尋結果地址,空間大小可以儲存1024000條地址,如果覺得不夠可以自己加大
		tmp = (long*)calloc(1024000,sizeof(long));
		while (fgets(line, sizeof(line), fp))
		{
   
   
			mp = (MemPage *) calloc(1, sizeof(MemPage));
			sscanf(line, "%p-%p %s %*p %*p:%*p %*p   %[^\n]%s", &mp->start, &mp->end,
				   mp->flags, mp->name);
			// 判斷記憶體範圍和記憶體頁是否可讀(如果記憶體頁不可讀,此時如果去
			// 讀取這個地址,系統便會丟擲異常[訊號11,分段錯誤]並終止除錯程序)
			if ((memContrast(mp->name) == mem || mem == Mem_Auto)
				&& strstr(mp->flags, "r") != NULL)
			{
   
   
				mp->buf = (void *)malloc(mp->end - mp->start);
				preadv(mp->start, mp->buf, mp->end - mp->start);
				// 遍歷記憶體頁中地址,判斷地址值是否和想要的值相同
				for (int i = 0; i < (mp->end - mp->start) / size; i++)
				{
   
   
					// 異或型別數值有點特殊,他是遊戲防止破解者搜尋到
					// 正確陣列的一種方式,其加密方式為:值 ^ 地址
					if((type == XOR ? (*(int *) (mp->buf + i * size) ^ mp->start + i * size)
						 : *(T *) (mp->buf + i * size)) == value)
					{
   
   
						*(tmp + count) = mp->start + i * size;
						count++;
						if (debug)
						{
   
   
							std::cout
								<< "index:" << count
								<< "    value:" << (type == XOR?*(int *) (mp->buf + i * size) ^ (mp->start + i * size):*(T *) (mp->buf + i * size));
							printf("    address:%p\n", mp->start + i * size);
							
						}
					}
				}

				free(mp->buf);
			}
		}
		fclose(fp);
	}
	if(debug)
	printf("搜尋結束,共%d條結果\n", count);
	ret = (long*)calloc(count,sizeof(long));
	memcpy(ret,tmp,count*(sizeof(long)));
	free(tmp);
	ad.addrs = ret;
	ad.count = count;
	free(ret);
	return ad;
}

template < class T > int MemoryDebug::edit(T value,long address,int type,bool debug)
{
   
   
	if(-1 == pwritev(address,&value,judgSize(type)))
	{
   
   
		if(debug)
		printf("修改失敗-> addr:%p\n",address);
		return -1;
	}else
	{
   
   
		if(debug)
		printf("修改成功-> addr:%p\n",address);
		return 1;
	}
	return -1;
}

long MemoryDebug::ReadDword64(long address)
{
   
   
	long local_ptr = 0;
	preadv(address, &local_ptr, 4);
	return local_ptr;
}

int MemoryDebug::ReadDword(long address)
{
   
   
	int local_value = 0;
	preadv(address, &local_value, 4);
	return local_value;
}

float MemoryDebug::ReadFloat(long address)
{
   
   
	float local_value = 0;
	preadv(address, &local_value, 4);
	return local_value;
}

long MemoryDebug::ReadLong(long address)
{
   
   
	long local_value = 0;
	preadv(address, &local_value, 8);
	return local_value;
}

void getRoot(char **argv)
{
   
   
	char shellml[64];
	sprintf(shellml, "su -c %s", *argv);
	if (getuid() != 0)
	{
   
   
		system(shellml);
		exit(1);
	}
}

使用:

int main(int argc, char **argv)
{
   
   
	//獲取ROOT
	getRoot(argv);
	//定義記憶體除錯工具類
	MemoryDebug md;
	//設定除錯應用包名(我這裡除錯的是QQ)
	md.setPackageName("com.tencent.mobileqq");
	//搜尋記憶體,方式1,手動宣告值型別
	md.search<float>(1234, FLOAT, Mem_Ca,true);
	//搜尋記憶體,方式2,自動識別值型別
	md.search(1234, FLOAT, Mem_Ca,true);
	//搜尋記憶體,不開啟搜尋結果列印
	md.search(1234, FLOAT, Mem_Ca);
	//搜尋記憶體後修改第一個地址值
	AddressData ad = md.search(1234, FLOAT, Mem_Ca);
	md.edit<float>(8888.0,ad.addrs[0],FLOAT,true);
	return 0;
}

程式碼不是特別完善,僅供參考,有什麼不懂的可以私聊或評論區留言。

下一期我們一起來分析一下GG修改器跨程序讀寫原理和相應一些優化方案(要是我1個星期沒有更新,記得踹我~嘿嘿)