1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

; memory read/write
PROCESS_VM_OPERATION := 0x0008
PROCESS_VM_READ := 0x0010
PROCESS_VM_WRITE := 0x0020

MEMORYOP_READ := 0x1
MEMORYOP_WRITE := 0x2

CheckProcess(processName) {
	global processHandle, processId
	Process Exist, %processName%
	; errorlevel set to pid if successful
	if (! ErrorLevel) {
		if (processHandle) {
			CloseHandle(processHandle)
			processHandle =
		}
		Process Wait, %processName%
	}

	if (! processHandle) {
		processId := ErrorLevel
		processHandle := OpenReadWrite(processId)
		if (! processHandle) {
			MsgBox Unable to open process %processName% for read & write access.
			ExitApp
		}
	}	
}

OpenProcess(processId, desiredAccess) {
	global PROCESS_VM_OPERATION
	return DllCall("OpenProcess", "int", PROCESS_VM_OPERATION|desiredAccess, "char", 0, "UInt", processId)
}

OpenRead(processId) {
	global PROCESS_VM_READ
	return OpenProcess(processId, PROCESS_VM_READ)
}

OpenWrite(processId) {
	global PROCESS_VM_WRITE
	return OpenProcess(processId, PROCESS_VM_WRITE)
}

OpenReadWrite(processId) {
	global PROCESS_VM_READ, PROCESS_VM_WRITE
	return OpenProcess(processId, PROCESS_VM_READ|PROCESS_VM_WRITE)
}

CloseHandle(hObject) {
	return DllCall("CloseHandle", Int, hObject)
}

MemoryOp(operation, ptr, varType, byteNum, value = 0) {
	global processHandle, MEMORYOP_READ, MEMORYOP_WRITE
	if (varType <> "Str")
		varType := varType . " *"

	if (operation = MEMORYOP_READ) {
		if ! DllCall("ReadProcessMemory", "UInt", processHandle, "UInt", ptr, varType, result, "UInt", byteNum, "UInt *", 0) {
			/*
			MsgBox Read error.`n
				, Handle: %processHandle%`n
				, Pointer: %ptr%`n
				, Return Type: %varType%`n
				, Number of Bytes to Read: %byteNum%
			*/
		}
		return result
	}
	else if (operation = MEMORYOP_WRITE) {
		if ! DllCall("WriteProcessMemory", "UInt", processHandle, "UInt", ptr, varType, value, "UInt", byteNum, "UInt *", 0) {
			/*
			MsgBox Write error.`n
				, Handle: %processHandle%`n
				, Pointer: %ptr%`n
				, Return Type: %varType%`n
				, Number of Bytes to Write: %byteNum%`n
				, Value: %value%
			*/
		}
	}
}

ReadMemory(ptr, varType, byteNum) {
	global MEMORYOP_READ
	return MemoryOp(MEMORYOP_READ, ptr, varType, byteNum)
}

WriteMemory(ptr, varType, byteNum, value) {
	global MEMORYOP_WRITE
	return MemoryOp(MEMORYOP_WRITE, ptr, varType, byteNum, value)
}

ReadByte(ptr) {
	return ReadMemory(ptr, "UInt", 1)
}

ReadPtr(ptr) {
	return ReadMemory(ptr, "UInt", 4)
}