Make the module name comparison less strict

Author: warbler

src/SharpMonoInjector.Gui/ViewModels/MainWindowViewModel.cs

@@ -48,7 +48,12 @@ private async void ExecuteRefreshCommand(object parameter)
 
             await Task.Run(() =>
             {
+                int cp = Process.GetCurrentProcess().Id;
+
                 foreach (Process p in Process.GetProcesses()) {
+                    if (p.Id == cp)
+                        continue;
+
                     const ProcessAccessRights flags = ProcessAccessRights.PROCESS_QUERY_INFORMATION | ProcessAccessRights.PROCESS_VM_READ;
                     IntPtr handle;
 

src/SharpMonoInjector/ExportedFunction.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace SharpMonoInjector
+{
+    public struct ExportedFunction
+    {
+        public string Name;
+
+        public IntPtr Address;
+
+        public ExportedFunction(string name, IntPtr address)
+        {
+            Name = name;
+            Address = address;
+        }
+    }
+}

src/SharpMonoInjector/Injector.cs

@@ -121,31 +121,13 @@ public void Dispose()
 
         private void ObtainMonoExports()
         {
-            int e_lfanew = _memory.ReadInt(_mono + 0x3C);
-            IntPtr ntHeaders = _mono + e_lfanew;
-            IntPtr optionalHeader = ntHeaders + 0x18;
-            IntPtr dataDirectory = optionalHeader + (Is64Bit ? 0x70 : 0x60);
-            IntPtr exportDirectory = _mono + _memory.ReadInt(dataDirectory);
-            IntPtr names = _mono + _memory.ReadInt(exportDirectory + 0x20);
-            IntPtr ordinals = _mono + _memory.ReadInt(exportDirectory + 0x24);
-            IntPtr functions = _mono + _memory.ReadInt(exportDirectory + 0x1C);
-            int count = _memory.ReadInt(exportDirectory + 0x18);
-
-            for (int i = 0; i < count; i++) {
-                int offset = _memory.ReadInt(names + i * 4);
-                string name = _memory.ReadString(_mono + offset, 32, Encoding.ASCII);
-
-                if (!Exports.ContainsKey(name))
-                    continue;
-
-                short ordinal = _memory.ReadShort(ordinals + i * 2);
-                IntPtr address = _mono + _memory.ReadInt(functions + ordinal * 4);
-
-                if (address == IntPtr.Zero)
-                    throw new InjectorException($"Failed to obtain the address of {name}()");
-
-                Exports[name] = address;
-            }
+            foreach (ExportedFunction ef in ProcessUtils.GetExportedFunctions(_handle, _mono))
+                if (Exports.ContainsKey(ef.Name))
+                    Exports[ef.Name] = ef.Address;
+
+            foreach (var kvp in Exports)
+                if (kvp.Value == IntPtr.Zero)
+                    throw new InjectorException($"Failed to obtain the address of {kvp.Key}()");
         }
 
         public IntPtr Inject(byte[] rawAssembly, string @namespace, string className, string methodName)

src/SharpMonoInjector/ProcessUtils.cs

@@ -1,46 +1,72 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
-using System.Diagnostics;
+using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
 
 namespace SharpMonoInjector
 {
     public static class ProcessUtils
     {
+        public static IEnumerable<ExportedFunction> GetExportedFunctions(IntPtr handle, IntPtr mod)
+        {
+            using (Memory memory = new Memory(handle)) {
+                int e_lfanew = memory.ReadInt(mod + 0x3C);
+                IntPtr ntHeaders = mod + e_lfanew;
+                IntPtr optionalHeader = ntHeaders + 0x18;
+                IntPtr dataDirectory = optionalHeader + (Is64BitProcess(handle) ? 0x70 : 0x60);
+                IntPtr exportDirectory = mod + memory.ReadInt(dataDirectory);
+                IntPtr names = mod + memory.ReadInt(exportDirectory + 0x20);
+                IntPtr ordinals = mod + memory.ReadInt(exportDirectory + 0x24);
+                IntPtr functions = mod + memory.ReadInt(exportDirectory + 0x1C);
+                int count = memory.ReadInt(exportDirectory + 0x18);
+
+                for (int i = 0; i < count; i++) {
+                    int offset = memory.ReadInt(names + i * 4);
+                    string name = memory.ReadString(mod + offset, 32, Encoding.ASCII);
+                    short ordinal = memory.ReadShort(ordinals + i * 2);
+                    IntPtr address = mod + memory.ReadInt(functions + ordinal * 4);
+
+                    if (address != IntPtr.Zero)
+                        yield return new ExportedFunction(name, address);
+                }
+            }
+        }
+
         public static bool GetMonoModule(IntPtr handle, out IntPtr monoModule)
         {
             int size = Is64BitProcess(handle) ? 8 : 4;
 
-            IntPtr[] modulePointers = new IntPtr[0];
+            IntPtr[] ptrs = new IntPtr[0];
 
             if (!Native.EnumProcessModulesEx(
-                handle, modulePointers, 0, out int bytesNeeded, ModuleFilter.LIST_MODULES_ALL)) {
+                handle, ptrs, 0, out int bytesNeeded, ModuleFilter.LIST_MODULES_ALL)) {
                 throw new InjectorException("Failed to enumerate process modules", new Win32Exception(Marshal.GetLastWin32Error()));
             }
 
             int count = bytesNeeded / size;
-            modulePointers = new IntPtr[count];
+            ptrs = new IntPtr[count];
 
             if (!Native.EnumProcessModulesEx(
-                handle, modulePointers, bytesNeeded, out bytesNeeded, ModuleFilter.LIST_MODULES_ALL)) {
+                handle, ptrs, bytesNeeded, out bytesNeeded, ModuleFilter.LIST_MODULES_ALL)) {
                 throw new InjectorException("Failed to enumerate process modules", new Win32Exception(Marshal.GetLastWin32Error()));
             }
 
             for (int i = 0; i < count; i++) {
                 StringBuilder path = new StringBuilder(260);
+                Native.GetModuleFileNameEx(handle, ptrs[i], path, 260);
 
-                Native.GetModuleFileNameEx(
-                    handle, modulePointers[i], path, 260);
+                if (path.ToString().IndexOf("mono", StringComparison.OrdinalIgnoreCase) > -1) {
+                    if (!Native.GetModuleInformation(handle, ptrs[i], out MODULEINFO info, (uint)(size * ptrs.Length)))
+                        throw new InjectorException("Failed to get module information", new Win32Exception(Marshal.GetLastWin32Error()));
 
-                if (path.ToString().EndsWith("mono.dll", StringComparison.OrdinalIgnoreCase)) {
-                    if (!Native.GetModuleInformation(
-                        handle, modulePointers[i], out MODULEINFO info, (uint)(size * modulePointers.Length))) {
-                        throw new InjectorException("Failed to get module information for mono.dll", new Win32Exception(Marshal.GetLastWin32Error()));
-                    }
+                    var funcs = GetExportedFunctions(handle, info.lpBaseOfDll);
 
-                    monoModule = info.lpBaseOfDll;
-                    return true;
+                    if (funcs.Any(f => f.Name == "mono_get_root_domain")) {
+                        monoModule = info.lpBaseOfDll;
+                        return true;
+                    }
                 }
             }