ibrahim_elsakka

MemoryHelper Updated

Sep 27th, 2020
703
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using Memory.Utils;
  2. using System;
  3. using System.Diagnostics;
  4. using System.Runtime.InteropServices;
  5. using System.Text;
  6.  
  7. namespace Memory.Win32
  8. {
  9.     class MemoryHelper32
  10.     {
  11.         Process process;
  12.         public MemoryHelper32(Process TargetProcess)
  13.         {
  14.             process = TargetProcess;
  15.         }
  16.  
  17.         public uint GetBaseAddress(uint StartingAddress)
  18.         {
  19.             return (uint)process.MainModule.BaseAddress + StartingAddress;
  20.         }
  21.  
  22.         public byte[] ReadMemoryBytes(uint MemoryAddress, uint Bytes)
  23.         {
  24.             byte[] data = new byte[Bytes];
  25.             ReadProcessMemory(process.Handle, MemoryAddress, data, data.Length, IntPtr.Zero);
  26.             return data;
  27.         }
  28.  
  29.         public T ReadMemory<T>(uint MemoryAddress)
  30.         {
  31.             byte[] data = ReadMemoryBytes(MemoryAddress, (uint)Marshal.SizeOf(typeof(T)));
  32.  
  33.             T t;
  34.             GCHandle PinnedStruct = GCHandle.Alloc(data, GCHandleType.Pinned);
  35.             try { t = (T)Marshal.PtrToStructure(PinnedStruct.AddrOfPinnedObject(), typeof(T)); }
  36.             catch (Exception ex) { throw ex; }
  37.             finally { PinnedStruct.Free(); }
  38.  
  39.             return t;
  40.         }
  41.  
  42.         public bool WriteMemory<T>(uint MemoryAddress, T Value)
  43.         {
  44.             IntPtr bw = IntPtr.Zero;
  45.  
  46.             int sz = ObjectType.GetSize<T>();
  47.             byte[] data = ObjectType.GetBytes<T>(Value);
  48.             bool result = WriteProcessMemory(process.Handle, MemoryAddress, data, sz, out bw);
  49.             return result && bw != IntPtr.Zero;
  50.         }
  51.  
  52.         public void Close()
  53.         {
  54.             CloseHandle(process.Handle);
  55.         }
  56.  
  57.         #region PInvoke
  58.         [DllImport("kernel32.dll", SetLastError = true)]
  59.         private static extern bool ReadProcessMemory(
  60.             IntPtr hProcess,
  61.             uint lpBaseAddress,
  62.             byte[] lpBuffer,
  63.             int nSize,
  64.             IntPtr lpNumberOfBytesRead);
  65.  
  66.         [DllImport("kernel32.dll", SetLastError = true)]
  67.         private static extern bool WriteProcessMemory(
  68.             IntPtr hProcess,
  69.             uint lpBaseAddress,
  70.             byte[] lpBuffer,
  71.             int nSize,
  72.             out IntPtr lpNumberOfBytesWritten
  73.             );
  74.  
  75.         [DllImport("kernel32.dll")]
  76.         private static extern Int32 CloseHandle(IntPtr hProcess);
  77.         #endregion
  78.     }
  79. }
  80.  
  81. namespace Memory.Win64
  82. {
  83.     class MemoryHelper64
  84.     {
  85.         Process process;
  86.  
  87.         public MemoryHelper64(Process TargetProcess)
  88.         {
  89.             process = TargetProcess;
  90.         }
  91.  
  92.         public ulong GetBaseAddress(ulong StartingAddress)
  93.         {
  94.             return (ulong)process.MainModule.BaseAddress.ToInt64() + StartingAddress;
  95.         }
  96.  
  97.         public byte[] ReadMemoryBytes(ulong MemoryAddress, int Bytes)
  98.         {
  99.             byte[] data = new byte[Bytes];
  100.             ReadProcessMemory(process.Handle, MemoryAddress, data, data.Length, IntPtr.Zero);
  101.             return data;
  102.         }
  103.  
  104.         public T ReadMemory<T>(ulong MemoryAddress)
  105.         {
  106.             byte[] data = ReadMemoryBytes(MemoryAddress, Marshal.SizeOf(typeof(T)));
  107.  
  108.             T t;
  109.             GCHandle PinnedStruct = GCHandle.Alloc(data, GCHandleType.Pinned);
  110.             try { t = (T)Marshal.PtrToStructure(PinnedStruct.AddrOfPinnedObject(), typeof(T)); }
  111.             catch (Exception ex) { throw ex; }
  112.             finally { PinnedStruct.Free(); }
  113.  
  114.             return t;
  115.         }
  116.  
  117.         public bool WriteMemory<T>(ulong MemoryAddress, T Value)
  118.         {
  119.             IntPtr bw = IntPtr.Zero;
  120.  
  121.             int sz = ObjectType.GetSize<T>();
  122.             byte[] data = ObjectType.GetBytes<T>(Value);
  123.             bool result = WriteProcessMemory(process.Handle, MemoryAddress, data, sz, out bw);
  124.             return result && bw != IntPtr.Zero;
  125.         }
  126.  
  127.         public void Close()
  128.         {
  129.             CloseHandle(process.Handle);
  130.         }
  131.  
  132.         #region PInvoke
  133.         [DllImport("kernel32.dll", SetLastError = true)]
  134.         private static extern bool ReadProcessMemory(
  135.             IntPtr hProcess,
  136.             ulong lpBaseAddress,
  137.             byte[] lpBuffer,
  138.             int nSize,
  139.             IntPtr lpNumberOfBytesRead);
  140.  
  141.         [DllImport("kernel32.dll", SetLastError = true)]
  142.         private static extern bool WriteProcessMemory(
  143.             IntPtr hProcess,
  144.             ulong lpBaseAddress,
  145.             byte[] lpBuffer,
  146.             int nSize,
  147.             out IntPtr lpNumberOfBytesWritten
  148.             );
  149.  
  150.         [DllImport("kernel32.dll")]
  151.         private static extern Int32 CloseHandle(IntPtr hProcess);
  152.         #endregion
  153.     }
  154. }
  155.  
  156. namespace Memory.Utils
  157. {
  158.     static class MemoryUtils
  159.     {
  160.         public static uint OffsetCalculator(Win32.MemoryHelper32 TargetMemory, uint BaseAddress, int[] Offsets)
  161.         {
  162.             var address = BaseAddress;
  163.             foreach (uint offset in Offsets)
  164.             {
  165.                 address = TargetMemory.ReadMemory<uint>(address) + offset;
  166.             }
  167.             return address;
  168.         }
  169.  
  170.         public static ulong OffsetCalculator(Win64.MemoryHelper64 TargetMemory, ulong BaseAddress, int[] Offsets)
  171.         {
  172.             var address = BaseAddress;
  173.             foreach (uint offset in Offsets)
  174.             {
  175.                 address = TargetMemory.ReadMemory<ulong>(address) + offset;
  176.             }
  177.             return address;
  178.         }
  179.     }
  180.  
  181.     public static class ObjectType
  182.     {
  183.         public static int GetSize<T>()
  184.         {
  185.             return Marshal.SizeOf(typeof(T));
  186.         }
  187.  
  188.         public static byte[] GetBytes<T>(T Value)
  189.         {
  190.             string typename = typeof(T).ToString();
  191.             Console.WriteLine(typename);
  192.             switch (typename)
  193.             {
  194.                 case "System.Single":
  195.                     return BitConverter.GetBytes((float)Convert.ChangeType(Value, typeof(float)));
  196.                 case "System.Int32":
  197.                     return BitConverter.GetBytes((int)Convert.ChangeType(Value, typeof(int)));
  198.                 case "System.Int64":
  199.                     return BitConverter.GetBytes((long)Convert.ChangeType(Value, typeof(long)));
  200.                 case "System.Double":
  201.                     return BitConverter.GetBytes((double)Convert.ChangeType(Value, typeof(double)));
  202.                 case "System.Byte":
  203.                     return BitConverter.GetBytes((byte)Convert.ChangeType(Value, typeof(byte)));
  204.                 case "System.String":
  205.                     return Encoding.Unicode.GetBytes((string)Convert.ChangeType(Value, typeof(string)));
  206.                 default:
  207.                     return new byte[0];
  208.             }
  209.         }
  210.     }
  211. }
RAW Paste Data