public void SafeReadWriteRaw(Reloaded.Memory.Sources.IMemory memorySource) { // Prepare int arrayElements = 13432; IMemoryTools.SwapExternalMemorySource(ref memorySource, _helloWorldProcess); IntPtr pointer = memorySource.Allocate(arrayElements); /* Start Test */ // Generate random int struct to read/write to. var randomByteArray = RandomByteArray.GenerateRandomByteArray(arrayElements); // Run the change permission function to deny read/write access. try { memorySource.ChangePermission(pointer, arrayElements, Kernel32.Kernel32.MEM_PROTECTION.PAGE_NOACCESS); } catch (NotImplementedException) { return; } // ChangePermission is optional to implement // Throws corrupted state exception if operations fail until restore. memorySource.SafeWriteRaw(pointer, randomByteArray.Array); memorySource.SafeReadRaw(pointer, out byte[] randomByteArrayCopy, randomByteArray.Array.Length); // Restore or NETCore execution engine will complain. try { memorySource.ChangePermission(pointer, arrayElements, Kernel32.Kernel32.MEM_PROTECTION.PAGE_EXECUTE_READWRITE); } catch (NotImplementedException) { return; } // ChangePermission is optional to implement // Compare before exiting test. Assert.Equal(randomByteArray.Array, randomByteArrayCopy); // Cleanup memorySource.Free(pointer); }
/// <summary> /// If the memory source is of type ExternalMemory, give it a new instance of this process. /// </summary> public static void SwapExternalMemorySource(ref Reloaded.Memory.Sources.IMemory memorySource, Process newProcess = null) { // While running tests with xUnit, dotnet can seemingly restart itself causing for the old handle set in // the IMemoryGenerator class to be invalid. // This is a hack which replaces the ExternalMemory instance such that the tests run on the correct handle. if (memorySource.GetType() == typeof(ExternalMemory)) { if (newProcess != null) { memorySource = new Reloaded.Memory.Sources.ExternalMemory(newProcess); } else { memorySource = new Reloaded.Memory.Sources.ExternalMemory(Process.GetCurrentProcess()); } } }
public void SafeReadWrite(Reloaded.Memory.Sources.IMemory memorySource) { // Prepare int structSize = Struct.GetSize <RandomIntStruct>(); IMemoryTools.SwapExternalMemorySource(ref memorySource, _helloWorldProcess); IntPtr pointer = memorySource.Allocate(structSize); /* Start Test */ // Generate random int struct to read/write to. var randomIntStruct = RandomIntStruct.BuildRandomStruct(); // Run the change permission function to deny read/write access. try { memorySource.ChangePermission(pointer, structSize, Kernel32.Kernel32.MEM_PROTECTION.PAGE_NOACCESS); } catch (NotImplementedException) { return; } // ChangePermission is optional to implement // Throws corrupted state exception if operations fail until restore. memorySource.SafeWrite(pointer, ref randomIntStruct, false); memorySource.SafeRead(pointer, out RandomIntStruct randomIntStructOldOverload, false); memorySource.SafeRead(pointer, out RandomIntStruct randomIntStructNewOverload); Assert.Equal(randomIntStructOldOverload, randomIntStructNewOverload); // New overloads in 1.4.0 memorySource.SafeWrite(pointer, ref randomIntStruct); memorySource.SafeRead(pointer, out randomIntStructOldOverload, false); memorySource.SafeRead(pointer, out randomIntStructNewOverload); Assert.Equal(randomIntStructOldOverload, randomIntStructNewOverload); // We test both read functions against each write function. // Restore or NETCore execution engine will complain. try { memorySource.ChangePermission(pointer, structSize, Kernel32.Kernel32.MEM_PROTECTION.PAGE_EXECUTE_READWRITE); } catch (NotImplementedException) { return; } // ChangePermission is optional to implement // Compare before exiting test. Assert.Equal(randomIntStruct, randomIntStructNewOverload); // Cleanup memorySource.Free(pointer); }