fork/m-overlay

git clone https://git.julia.blue/fork/m-overlay

BkacjiosFixed a possible issue where we could possibly detect an invalid memory region.bc297e6

settings-overhaul
9.1 KiB368 linesraw
1local ffi = require("ffi")
2local log = require("log")
3
4local format = string.format
5
6local cast = ffi.cast
7local cdef = ffi.cdef
8local load = ffi.load
9local metatype = ffi.metatype
10local new = ffi.new
11local typeof = ffi.typeof
12local sizeof = ffi.sizeof
13local string = ffi.string
14
15local lshift = bit.lshift
16local rshift = bit.rshift
17local bswap = bit.bswap
18local band = bit.band
19local bor = bit.bor
20
21local kernel = load("Kernel32.dll")
22local psapi = load("Psapi.dll")
23
24local libc = ffi.C
25
26cdef [[
27// Stupid Windows typenames..
28
29//#define MAX_PATH 260
30
31typedef int BOOL;
32typedef unsigned long DWORD;
33typedef long LONG;
34
35typedef void *PVOID;
36typedef PVOID HANDLE;
37
38typedef void *LPVOID;
39typedef const void *LPCVOID;
40
41typedef DWORD *LPDWORD;
42
43typedef char CHAR;
44
45typedef unsigned __int64 ULONG_PTR; // 64-bit
46// typedef unsigned long ULONG_PTR; // 32-bit
47
48typedef ULONG_PTR SIZE_T;
49
50typedef struct {
51	HANDLE process_handle;
52	ULONG_PTR dolphin_base_addr;
53	ULONG_PTR dolphin_addr_size;
54} MEMORY_STRUCT;
55
56typedef struct tagPROCESSENTRY32 {
57	DWORD dwSize;
58	DWORD cntUsage;
59	DWORD th32ProcessID;
60	ULONG_PTR th32DefaultHeapID; // DWORD on 32-bit
61	DWORD th32ModuleID;
62	DWORD cntThreads;
63	DWORD th32ParentProcessID;
64	LONG pcPriClassBase;
65	DWORD dwFlags;
66	CHAR  szExeFile[260];
67} PROCESSENTRY32,*PPROCESSENTRY32,*LPPROCESSENTRY32;
68
69HANDLE CreateToolhelp32Snapshot(
70	DWORD dwFlags,
71	DWORD th32ProcessID
72);
73
74BOOL Process32First(
75	HANDLE           hSnapshot,
76	LPPROCESSENTRY32 lppe
77);
78
79BOOL Process32Next(
80	HANDLE           hSnapshot,
81	LPPROCESSENTRY32 lppe
82);
83
84HANDLE OpenProcess(
85	DWORD dwDesiredAccess,
86	BOOL  bInheritHandle,
87	DWORD dwProcessId
88);
89
90BOOL ReadProcessMemory(
91	HANDLE  hProcess,
92	LPCVOID lpBaseAddress,
93	LPVOID  lpBuffer,
94	SIZE_T  nSize,
95	SIZE_T  *lpNumberOfBytesRead
96);
97
98BOOL WriteProcessMemory(
99	HANDLE  hProcess,
100	LPVOID  lpBaseAddress,
101	LPCVOID lpBuffer,
102	SIZE_T  nSize,
103	SIZE_T  *lpNumberOfBytesWritten
104);
105
106BOOL CloseHandle(
107	HANDLE hObject
108);
109
110typedef struct _MEMORY_BASIC_INFORMATION {
111	PVOID  BaseAddress;
112	PVOID  AllocationBase;
113	DWORD  AllocationProtect;
114	SIZE_T RegionSize;
115	DWORD  State;
116	DWORD  Protect;
117	DWORD  Type;
118} MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION;
119
120typedef union _PSAPI_WORKING_SET_EX_BLOCK {
121	ULONG_PTR Flags;
122	/*union {
123		struct {
124			ULONG_PTR Valid : 1;
125			ULONG_PTR ShareCount : 3;
126			ULONG_PTR Win32Protection : 11;
127			ULONG_PTR Shared : 1;
128			ULONG_PTR Node : 6;
129			ULONG_PTR Locked : 1;
130			ULONG_PTR LargePage : 1;
131			ULONG_PTR Reserved : 7;
132			ULONG_PTR Bad : 1;
133			ULONG_PTR ReservedUlong : 32;
134		};
135		struct {
136			ULONG_PTR Valid : 1;
137			ULONG_PTR Reserved0 : 14;
138			ULONG_PTR Shared : 1;
139			ULONG_PTR Reserved1 : 15;
140			ULONG_PTR Bad : 1;
141			ULONG_PTR ReservedUlong : 32;
142		} Invalid;
143	};*/
144} PSAPI_WORKING_SET_EX_BLOCK, *PPSAPI_WORKING_SET_EX_BLOCK;
145
146typedef struct _PSAPI_WORKING_SET_EX_INFORMATION {
147	PVOID                      VirtualAddress;
148	PSAPI_WORKING_SET_EX_BLOCK VirtualAttributes;
149} PSAPI_WORKING_SET_EX_INFORMATION, *PPSAPI_WORKING_SET_EX_INFORMATION;
150
151SIZE_T VirtualQueryEx(
152	HANDLE                    hProcess,
153	LPCVOID                   lpAddress,
154	PMEMORY_BASIC_INFORMATION lpBuffer,
155	SIZE_T                    dwLength
156);
157
158BOOL QueryWorkingSetEx(
159	HANDLE hProcess,
160	PVOID  pv,
161	DWORD  cb
162);
163
164BOOL GetExitCodeProcess(
165	HANDLE  hProcess,
166	LPDWORD lpExitCode
167);
168
169DWORD WaitForSingleObject(
170	HANDLE hHandle,
171	DWORD  dwMilliseconds
172);
173
174DWORD GetLastError();
175]]
176
177local MEMORY = {}
178MEMORY.__index = MEMORY
179MEMORY.init = metatype("MEMORY_STRUCT", MEMORY)
180
181local TH32CS_SNAPPROCESS = 0x02
182
183local PROCESS_QUERY_INFORMATION = 0x0400
184local PROCESS_VM_OPERATION = 0x0008
185local PROCESS_VM_READ = 0x0010
186local PROCESS_VM_WRITE = 0x0020
187
188local MEM_MAPPED = 0x40000
189
190local STILL_ACTIVE = 259
191
192local function NOTWITHINMEMRANGE(addr)
193	return addr < 0x80000000 or addr > 0x81800000
194end
195
196local PROCESSENTRY32_PTR = typeof("PROCESSENTRY32[1]")
197local MEMORY_BASIC_INFORMATION_PTR = typeof("MEMORY_BASIC_INFORMATION[1]")
198local PSAPI_WORKING_SET_EX_INFORMATION_PTR = typeof("PSAPI_WORKING_SET_EX_INFORMATION[1]")
199
200function MEMORY:hasPermissions()
201	-- Windows doesn't need any special permissions to read memory from another process
202	return true
203end
204
205local valid_process_names = {
206	["Dolphin.exe"] = true,
207	["Slippi Dolphin.exe"] = true,
208	["DolphinWx.exe"] = true,
209	["DolphinQt2.exe"] = true,
210}
211
212do
213	local status = new("DWORD[1]")
214
215	function MEMORY:findprocess()
216		if self:hasProcess() then return false end
217
218		local handle
219		local snapshot = kernel.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0) -- Create the snapshot
220
221		local pe32 = PROCESSENTRY32_PTR()[0] -- Will store the info about the process
222		pe32.dwSize = sizeof(pe32)
223
224		repeat
225			local name = string(pe32.szExeFile)
226			if valid_process_names[name] then
227				local handle = kernel.OpenProcess(PROCESS_VM_OPERATION + PROCESS_VM_READ + PROCESS_QUERY_INFORMATION, false, pe32.th32ProcessID)
228
229				-- Check if the process is active, we don't want to rehook the closing application
230				if handle ~= nil and kernel.GetExitCodeProcess(handle, status) and status[0] == STILL_ACTIVE then
231					-- We have an active process that matches, let's use it
232					self.process_handle = handle
233					break
234				elseif handle then
235					-- Dolphin is closing.. ignore and close the handle..
236					kernel.CloseHandle(handle)
237				end
238			end
239		until kernel.Process32Next(snapshot, pe32) == 0
240		
241		kernel.CloseHandle(snapshot)
242
243		return self:hasProcess()
244	end
245end
246
247do
248	local status = new("DWORD[1]")
249	
250	function MEMORY:isProcessActive()
251		return self.process_handle ~= nil and kernel.GetExitCodeProcess(self.process_handle, status) and status[0] == STILL_ACTIVE
252	end
253end
254
255function MEMORY:hasProcess()
256	return self.process_handle ~= nil
257end
258
259function MEMORY:clearGamecubeRAMOffset()
260	self.dolphin_base_addr = nil
261end
262
263function MEMORY:hasGamecubeRAMOffset()
264	return self.dolphin_base_addr ~= nil
265end
266
267function MEMORY:getGamecubeRAMOffset()
268	return tonumber(self.dolphin_base_addr)
269end
270
271function MEMORY:getGamecubeRAMSize()
272	return tonumber(self.dolphin_addr_size)
273end
274
275function MEMORY:close()
276	if self:hasProcess() then
277		kernel.CloseHandle(self.process_handle)
278		self.process_handle = nil
279		self.dolphin_base_addr = nil
280	end
281end
282
283function MEMORY:__gc()
284	self:close()
285end
286
287local regionptr = new("unsigned char*[1]", nil)
288
289local NULL = cast("uint32_t", 0x00000000)
290
291function MEMORY:findGamecubeRAMOffset()
292	local info = MEMORY_BASIC_INFORMATION_PTR()[0]
293
294	local p = regionptr[0]
295
296	while kernel.VirtualQueryEx(self.process_handle, p, info, sizeof(info)) == sizeof(info) do
297		p = p + info.RegionSize
298
299		if (info.RegionSize >= 0x2000000 and info.Type == MEM_MAPPED) then
300			local wsinfo = PSAPI_WORKING_SET_EX_INFORMATION_PTR()[0]
301			wsinfo.VirtualAddress = info.BaseAddress
302
303			if psapi.QueryWorkingSetEx(self.process_handle, wsinfo, sizeof(wsinfo)) == 1 then
304				local flags = tonumber(wsinfo.VirtualAttributes.Flags)
305
306				local base = cast("ULONG_PTR", info.BaseAddress)
307				local region = cast("ULONG_PTR", info.RegionSize)
308
309				if band(flags, lshift(1, 0)) == 1 and cast("uint32_t", info.BaseAddress) ~= NULL then -- Check if the Valid flag is set
310					--log.debug("%08X %x", tonumber(base), tonumber(region))
311					self.dolphin_base_addr = base
312					self.dolphin_addr_size = region
313					return true
314				end
315			end
316		end
317	end
318
319	return false
320end
321
322local GC_RAM_START = cast("uint32_t", 0x80000000)
323local GC_RAM_END = cast("uint32_t", 0x81800000)
324local WII_RAM_START = cast("uint32_t", 0x90000000)
325local WII_RAM_END = cast("uint32_t", 0x94000000)
326
327local WII_RAM_LOCAL_START = cast("uint32_t", 0x02000000)
328
329local CAST_ADDR = ffi.new("uint32_t", 0x00000000)
330local memread = ffi.new("SIZE_T[1]") -- How many bytes are read from memory
331
332function MEMORY:read(addr, output, size)
333	if not self:hasProcess() or not self:hasGamecubeRAMOffset() then return false end
334
335	CAST_ADDR = cast("uint32_t", addr)
336
337	if CAST_ADDR >= WII_RAM_START and CAST_ADDR <= WII_RAM_END then
338		CAST_ADDR = cast("uint32_t", WII_RAM_LOCAL_START + (CAST_ADDR % WII_RAM_START))
339	elseif CAST_ADDR >= GC_RAM_START and CAST_ADDR <= GC_RAM_END then
340		CAST_ADDR = cast("uint32_t", CAST_ADDR % GC_RAM_START)
341	else
342		log.warn("[MEMORY] Attempt to read from invalid address %08X", tonumber(CAST_ADDR))
343		return false
344	end
345
346	local raddr = cast("LPCVOID", self.dolphin_base_addr + CAST_ADDR)
347	local success = kernel.ReadProcessMemory(self.process_handle, raddr, output, size, memread)
348	if not success then
349		log.debug("[MEMORY] Failed reading from address [%08X] ERROR #%d", CAST_ADDR, tonumber(kernel.GetLastError()))
350	--else
351	--	log.debug("[MEMORY] read 0x%X size 0x%X bytes from 0x%08X = %q", tonumber(memread[0]), size, tonumber(CAST_ADDR), tohex(ffi.string(output, memread[0])))
352	end
353	return success and memread[0] == size
354end
355
356local memwritten = ffi.new("SIZE_T[1]")
357
358function MEMORY:write(addr, input, size)
359	if not self:hasProcess() or not self:hasGamecubeRAMOffset() then return false end
360	local waddr = cast("LPVOID", self.dolphin_base_addr + (addr % 0x80000000))
361	local success = kernel.WriteProcessMemory(self.process_handle, waddr, input, size, memwritten)
362	if not success then
363		log.debug("[MEMORY] Failed writing to address [%08X = %08X] ERROR #%d", addr, tonumber(input), tonumber(kernel.GetLastError()))
364	end
365	return success and memwritten[0] == size
366end
367
368return MEMORY