Improve signature scanning, closes #75

Author: fs-c

lib/include/maniac/osu/signatures.h

@@ -9,8 +9,8 @@ namespace signatures {
 	constexpr auto STATE_SIG_OFFSET = 1;
 	constexpr auto STATE_SIG = "A1 ? ? ? ? A3 ? ? ? ? A1 ? ? ? ? A3 ? ? ? ? 83 3D ? ? ? ? 00 0F 84 ? ? ? ? B9 ? ? ? ? E8\0";
 
-	constexpr auto PLAYER_SIG_OFFSET = 7;
-	constexpr auto PLAYER_SIG = "FF 50 0C 8B D8 8B 15\0";
+	constexpr auto PLAYER_SIG_OFFSET = 3;
+	constexpr auto PLAYER_SIG = "33 D2 A1 ? ? ? ? 85 C0\0";
 
 	constexpr auto RULESET_SIG_OFFSET = 4;
 	constexpr auto RULESET_SIG = "73 7A 8B 0D ? ? ? ? 85 C9 74 1F\0";

lib/include/maniac/process.h

@@ -69,6 +69,8 @@ inline size_t Process::read_memory(uintptr_t address, T *out, size_t count) {
 	if (!ReadProcessMemory(handle, reinterpret_cast<LPCVOID>(address),
 		reinterpret_cast<LPVOID>(out), count * sizeof(T),
 		reinterpret_cast<SIZE_T *>(&read))) {
+        debug("failed reading memory at %x (%d)", address, GetLastError());
+
 		return 0;
 	}
 
@@ -113,7 +115,7 @@ T Process::read_memory_safe(const char *name, Any addr) {
 		throw std::runtime_error(msg);
 	}
 
-	debug_short("%s: %#x", name, (unsigned int)address);
+	debug("%s: %#x", name, (unsigned int)address);
 
 	return out;
 }

lib/osu.cpp

@@ -7,11 +7,11 @@ Osu::Osu() : Process("osu!.exe") {
 
 	// TODO: Run this in parallel.
 
-	time_address = read_memory<uintptr_t>(find_pattern(TIME_SIG) + TIME_SIG_OFFSET);
-	debug("found time address: %#x", time_address);
+    time_address = read_memory<uintptr_t>(find_pattern(TIME_SIG) + TIME_SIG_OFFSET);
+    debug("found time address: %#x", time_address);
 
-	player_pointer = read_memory<uintptr_t>(find_pattern(PLAYER_SIG) + PLAYER_SIG_OFFSET);
-	debug("found player pointer: %#x", player_pointer);
+    player_pointer = read_memory<uintptr_t>(find_pattern(PLAYER_SIG) + PLAYER_SIG_OFFSET);
+    debug("found player pointer: %#x", player_pointer);
 }
 
 Osu::~Osu() = default;

lib/process.cpp

@@ -42,7 +42,7 @@ HANDLE Process::get_handle(const std::string &name) {
 
 	debug("%s '%s' %s %lu", "found process", name.c_str(), "with id", process_id);
 
-	HANDLE handle = OpenProcess(PROCESS_VM_READ, FALSE, process_id);
+	HANDLE handle = OpenProcess(PROCESS_VM_READ | PROCESS_QUERY_INFORMATION, FALSE, process_id);
 	if (!handle || handle == INVALID_HANDLE_VALUE) {
 		throw std::runtime_error("failed opening handle to process");
 	}
@@ -53,53 +53,79 @@ HANDLE Process::get_handle(const std::string &name) {
 }
 
 uintptr_t Process::find_pattern(const char *pattern) {
-	auto pattern_bytes = std::vector<int>{ };
-
-	for (auto cur = pattern; *cur; cur++) {
-		if (*cur == '?') {
-			// If the current byte is a wildcard push a dummy byte
-			pattern_bytes.push_back(-1);
-		} else if (*cur == ' ') {
-			continue;
-		} else {
-			// This is somewhat hacky: strtol parses *as many characters as
-			// possible* and sets cur to the first character it couldn't parse.
-			// This is the reason why patterns *must* follow the structure
-			// "AB CD EF ? ? FF"; "ABCDEF??FF" would cause it to fail later (!).
-			pattern_bytes.push_back(strtol(cur, const_cast<char **>(&cur), 16));
-		}
-	}
+    const auto pattern_to_bytes = [](const char *pattern) {
+        auto pattern_bytes = std::vector<int>{ };
 
-	auto pattern_size = pattern_bytes.size();
+        for (auto cur = pattern; *cur; cur++) {
+            if (*cur == '?') {
+                // If the current byte is a wildcard push a dummy byte
+                pattern_bytes.push_back(-1);
+            } else if (*cur == ' ') {
+                continue;
+            } else {
+                // This is somewhat hacky: strtol parses *as many characters as
+                // possible* and sets cur to the first character it couldn't parse.
+                // This is the reason why patterns *must* follow the structure
+                // "AB CD EF ? ? FF"; "ABCDEF??FF" would cause it to fail later (!).
+                pattern_bytes.push_back(strtol(cur, const_cast<char **>(&cur), 16));
+            }
+        }
 
-	const size_t chunk_size = 4096;
-	std::byte chunk_bytes[chunk_size];
+        return pattern_bytes;
+    };
 
-	for (uintptr_t i = 1; i < INT_MAX; i += chunk_size - pattern_size) {
-		if (!read_memory<std::byte>(i, chunk_bytes, chunk_size)) {
-			continue;
-		}
+    const auto pattern_bytes = pattern_to_bytes(pattern);
+	const auto pattern_size = pattern_bytes.size();
+
+	uintptr_t cur_address = 0;
+    // this is an osu-specific optimization
+    uintptr_t max_address = 0x7fffffff;
+
+    while (cur_address < max_address) {
+        MEMORY_BASIC_INFORMATION info;
+
+        if (!VirtualQueryEx(handle, reinterpret_cast<void *>(cur_address), &info, sizeof(info))) {
+            debug("couldn't query at %x", cur_address);
+
+            return 0;
+        }
 
-		for (size_t j = 0; j < chunk_size; j++) {
+        bool invalidType = (info.Type != MEM_IMAGE && info.Type != MEM_PRIVATE);
+        bool invalidProtection = (info.Protect != PAGE_WRITECOPY && info.Protect != PAGE_EXECUTE_WRITECOPY
+                && info.Protect != PAGE_EXECUTE_READWRITE && info.Protect != PAGE_READWRITE);
+
+        if (info.RegionSize == 0 || info.State != MEM_COMMIT || invalidType || invalidProtection) {
+            cur_address = reinterpret_cast<uintptr_t>(info.BaseAddress) + info.RegionSize;
+
+            continue;
+        }
+
+        cur_address = reinterpret_cast<uintptr_t>(info.BaseAddress);
+
+        auto buffer = std::vector<std::byte>(info.RegionSize);
+        read_memory<std::byte>(cur_address, buffer.data(), buffer.size());
+
+        for (size_t j = 0; j < buffer.size(); j++) {
 			bool hit = true;
 
 			for (size_t k = 0; k < pattern_size; k++) {
 				if (pattern_bytes[k] == -1) {
 					continue;
 				}
 
-				if (chunk_bytes[j + k] !=
-					static_cast<std::byte>(pattern_bytes[k])) {
+				if (buffer.at(j + k) != static_cast<std::byte>(pattern_bytes[k])) {
 					hit = false;
 					break;
 				}
 			}
 
 			if (hit) {
-				return i + j;
+				return cur_address + j;
 			}
 		}
-	}
+
+        cur_address += info.RegionSize;
+    }
 
 	return 0;
 }