标 题：连连看修改（golang）
作 者：dinger
时 间：2020-06-10
链 接：https://blog.csdn.net/man_45_start/article/details/106764981

背景

学习golang有一段时间了，找个事情来练一下，于是针对老婆常玩的连连看游戏做一个修改器。
游戏详情是：宠物连连看可爱版，图片是这样：
游戏图示意
其中最重要的是洗牌次数，没有洗牌次数就game over了。因此针对洗牌次数做一个修改器。
说明下：如果实现这个目的，使用golang并不是最佳选择，更好的选择比如用VC，因此这个程序主要用于golang练手。

原理

利用数值及变化找出变量所在的内存地址，修改之。
约束1：变量的地址不变，（像VC编写的程序可以，像golang这种语言编写的程序，不一定行，因为有垃圾收集，会移动变量）
约束2：不加密，（意思是，你在界面上看到的就是内部的值）
约束3：无校验，（意思是，你可以修改，如果有校验，你必须同时修改校验值，但这很难办到）

代码 
//修改连连看的洗牌次数
//博客展示版本

package main

import (
	"fmt"
	"unsafe"
	"golang.org/x/sys/windows"
	"syscall"
	"strings"
)


func main() {
	fmt.Println("----start----")
	defer func() {
		fmt.Println("====end----")
	}()

	//打开连连看进程，获得进程句柄
	//建议使用IE浏览器，有些浏览器启动进程较多，不易判别是哪个进程
	//需要输入浏览器进程的PID（在任务管理器中查看）
	hp := inputPidOpenProcess()//输入PID，打开进程，得到进程句柄
	defer windows.CloseHandle(windows.Handle(hp))

	//多次输入数值，查找之，修改之
	var result []uintptr//保存含有指定数值的内存地址
	for {
		var val byte
		inputVal(&val, "input val:")

		//在进行内存中进行数值查找
		old := result
		result = memFindByte(hp, val)
		fmt.Printf("    find ok, count=%d\n", len(result))

		if len(old) > 0 {//不是第一次查找，进行相同地址的匹配
			result = getSame(old, result)//返回的result在执行后是一个新的地址,调用没问题
			fmt.Printf("    do getSame, count=%d\n", len(result))
		}
		
		if 1 == len(result) {//只有一个地址，修改一个字节的数值为99
			fmt.Printf("    only one addr:%X, %d\n", result[0], result[0])
			if !myWritePMOneByte(hp, result[0], 99) {
				myMsgBox("myWritePMOneByte fail")
				break
			}
			myMsgBox("change val to 99, ok")
			break
		}
		if 0 == len(result) {//结果为空，表示没找到，（可能是进程不对，或哪个数值输入的不对，或其他原因）
			myMsgBox("no addr, end")
			break
		}
	}
}


//输入一个整数值
//prompt为输入前的提示
func inputVal(v interface{}, prompt string) {
	for {
		fmt.Println(prompt)

		_, err := fmt.Scanf("%d", v)

		//消除unexpected newline等错误,win10平台
		for {
			var s string
			if n, _ := fmt.Scanf("%s", &s); n>0 {
				continue
			}
			break
		}
		
		if err != nil {
			fmt.Println("intput error, please input again")
			continue
		}
		break
	}
}

//输入PID，打开进程，返回句柄
func inputPidOpenProcess() uintptr {
	for {
		var pid uint32
		inputVal(&pid, "input pid of ie:")

		hp, err := windows.OpenProcess(PROCESS_ALL_ACCESS, false, pid)
		if err != nil {
			fmt.Println("pid ok, but OpenProcess fail, please input again")
			continue
		}
		return uintptr(hp)
	}
}

//在内存中查找指定的字节值，返回地址集合
func memFindByte(hp uintptr, v byte) (result []uintptr) {
	var addr uintptr
	for {
		var mbi MBI64
		if !myVQuery(hp, addr, &mbi) {
			break
		}
		
		addr += uintptr(mbi.RegionSize)

		//过滤mbi,关注的数不可能出现的内存块不进行数值查找
		if MEM_COMMIT!=mbi.State || PAGE_READWRITE!=mbi.Protect || MEM_PRIVATE!=mbi.Type{
			continue
		}
		
		//测试过，性能影响很小，因此每次都分配释放，否则只分配一次
		mem, err := windows.VirtualAlloc(0, uintptr(mbi.RegionSize), MEM_COMMIT, PAGE_READWRITE)
		if err != nil {
			fmt.Printf("in memFindByte, call VirtualAlloc fail\n")
			break
		}
		defer func () {
			if err := windows.VirtualFree(mem, 0, MEM_RELEASE); err != nil {
				fmt.Printf("in memFindByte, call VirtualFree fail\n")
			}
		}()
		//fmt.Printf("do VirtualAlloc, mem=%X\n", mem)

		if !myReadPM(hp, mbi.BaseAddress, mbi.RegionSize, mem) {
			fmt.Printf("in memFindByte, call myReadPM fail\n")
			break
		}

		//经测试，关注的数在内存中按4个字节存储，且都是小头（意思是字节序相同）
		for i:=0; i<int(mbi.RegionSize)/4; i++ {
			if uint32(v) != *(*uint32)(unsafe.Pointer(mem + uintptr(i)*4)) {
				continue
			}
			result = append(result, mbi.BaseAddress + uintptr(i)*4)
		}
	}
	return
}

//在两个地址列表中查找相同的项目，返回之
func getSame(a []uintptr, b []uintptr) (result []uintptr) {
	var i, j int
	for {
		if a[i] == b[j] {
			result = append(result, a[i])
			i++
			j++
		} else if a[i] < b[j] {
			i++
		} else {
			j++
		}

		if i>=len(a) || j>=len(b) {
			return
		}
	}
}



//----win32函数相关

const (
	MB_OK = 0
	PROCESS_ALL_ACCESS = 0x1F0FFF
	PAGE_NOACCESS = 0x1
	PAGE_READWRITE = 0x04
	MEM_COMMIT = 0x1000
	MEM_RELEASE = 0x8000
	MEM_PRIVATE = 0x20000
)

//_MEMORY_BASIC_INFORMATION64
type MBI64 struct {
	BaseAddress uintptr
	AllocationBase uintptr
	AllocationProtect uint32
	__alignment1 uint32
	RegionSize uint64
	State uint32
	Protect uint32
	Type uint32
	__alignment2 uint32
}//size=48

var win32Funcs = make(map[string]*windows.LazyProc)

func init() {
	// Library
	libkernel32 := windows.NewLazySystemDLL("kernel32.dll")
	libuser32 := windows.NewLazySystemDLL("user32.dll")
	
	win32Funcs["VirtualQueryEx"] = libkernel32.NewProc("VirtualQueryEx")
	win32Funcs["ReadProcessMemory"] = libkernel32.NewProc("ReadProcessMemory")
	win32Funcs["WriteProcessMemory"] = libkernel32.NewProc("WriteProcessMemory")
	win32Funcs["MessageBox"] = libuser32.NewProc("MessageBoxW")
}


//win32函数VirtualQueryEx的封装，（只支持64位，无需输入参数dwLength，返回成功与否）
func myVQuery(hp uintptr, addr uintptr, mbi *MBI64) bool {
	n, _, _ := win32Funcs["VirtualQueryEx"].Call(hp, addr, uintptr(unsafe.Pointer(mbi)), 48)
	return 48 == n
}

//win32函数ReadProcessMemory的封装，（无需输入参数nRead，返回成功与否）
func myReadPM(hp uintptr, addr uintptr, size uint64, buf uintptr) bool {
	var n uint64
	ret, _, _ := win32Funcs["ReadProcessMemory"].Call(hp, addr, buf, uintptr(size), uintptr(unsafe.Pointer(&n)))
	return 0!=ret && n==size
}

//调用win32函数WriteProcessMemory，写一个字节
//输入字节值，输出成功与否
func myWritePMOneByte(hp uintptr, addr uintptr, v byte) bool {
	ret, _, _ := win32Funcs["WriteProcessMemory"].Call(hp, addr, uintptr(unsafe.Pointer(&v)), 1)
	return 0 != ret
}

//win32函数MessageBox的封装，简化输入参数
//使用myMsgBox的目的是为了消除闪退
func myMsgBox(s string) {
	var lpText *uint16 = syscall.StringToUTF16Ptr(strings.ReplaceAll(s, "\x00", "␀"))
	win32Funcs["MessageBox"].Call(
		0,
		uintptr(unsafe.Pointer(lpText)),
		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr("information"))),
		MB_OK,
	)
}
代码说明

正常运行的流程
输入连连看进程的PID，打开进程
输入数值，在内存中查找，记录地址，
再次输入数值，在内存中查找，暂存地址，
找出两个地址序列中相同项，记录之
当只有一个地址时，这个地址就找到了，修改地址处的值

存在的问题

利用Scanf来进行数值输入，需要面对一次输入，多次读取都有内容的情况（一般情况都不是所要的），本程序利用“按字符串识别直到没有内容”的方法不一定适用所有情况（常见的情况，测试没发现问题）