Перейти к содержанию

Рекомендуемые сообщения

Небольшой класс, по работе с памятью. Может кому-то пригодится, при создания хаков на C#.

 

 

Спойлер

class ReadWriteMemory
    {

        // READ FLAGS
        public static uint PROCESS_VM_READ = 0x0010,
                           PROCESS_VM_WRITE = 0x0020,
                           PROCESS_VM_OPERATION = 0x0008,
                           PAGE_READWRITE = 0x0004;

        // WINDOW FLAGS
        public static uint WS_MAXIMIZE = 0x1000000,
                           WS_CAPTION = 0xC00000,
                           WS_BORDER = 0x800000,
                           WS_VISIBLE = 0x10000000,
                           GWL_STYLE = (-16);

        // KEYS
        public const int KEY_PRESSED = 0x8000,
                         VK_LBUTTON = 0x01,
                         VK_RBUTTON = 0x02,
                         VK_INSERT = 0x2D,
                         VK_LEFT = 0x25,
                         VK_UP = 0x26,
                         VK_RIGHT = 0x27,
                         VK_DOWN = 0x28;
  
      [StructLayout(LayoutKind.Sequential)]
      public struct RECT
      {public int Left,Top,Right,Bottom;}
  
  
        private static IntPtr pHandle = IntPtr.Zero;

        public static IntPtr OpenProcess(int pId)
        {
            pHandle = OpenProcess(PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION, false, pId);
            return pHandle;
        }

        public static IntPtr GetHandle()
        {
            return pHandle;
        }

        public static void CloseProcess()
        {
            CloseHandle(pHandle);
        }
  
        public static IntPtr GetHWND(string caption)
        {
            IntPtr hwnd = FindWindow(NULL, caption);
            return hwnd;
        }
  
        public void GetWindowSize(IntPtr hwnd)
        {
            RECT rect;
            GetWindowRect(hwnd, out rect);
            int Width = rect.Right - rect.Left;
            int Height = rect.Bottom - rect.Top;
        }
  
        public static Int64 ReadInt64(Int64 _lpBaseAddress)
        {
            byte[] Buffer = new byte[8];
            IntPtr ByteRead;
            ReadProcessMemory(pHandle, _lpBaseAddress, Buffer, 8, out ByteRead);
            return BitConverter.ToInt64(Buffer, 0);
        }

        public static Int32 ReadInt32(Int64 _lpBaseAddress)
        {
            byte[] Buffer = new byte[4];
            IntPtr ByteRead;
            ReadProcessMemory(pHandle, _lpBaseAddress, Buffer, 4, out ByteRead);
            return BitConverter.ToInt32(Buffer, 0);
        }

        public static float ReadFloat(Int64 _lpBaseAddress)
        {
            byte[] Buffer = new byte[sizeof(float)];
            IntPtr ByteRead;
            ReadProcessMemory(pHandle, _lpBaseAddress, Buffer, sizeof(float), out ByteRead);
            return BitConverter.ToSingle(Buffer, 0);
        }

        public static bool WriteMemory(Int64 MemoryAddress, byte[] Buffer)
        {
            uint oldProtect;
            VirtualProtectEx(pHandle, (IntPtr)MemoryAddress, (uint)Buffer.Length, PAGE_READWRITE, out oldProtect);
            IntPtr ptrBytesWritten;
            return WriteProcessMemory(pHandle, MemoryAddress, Buffer, (uint)Buffer.Length, out ptrBytesWritten);
        }

        public static bool WriteFloat(Int64 _lpBaseAddress, float _Value)
        {
            byte[] Buffer = BitConverter.GetBytes(_Value);
            return WriteMemory(_lpBaseAddress, Buffer);
        }

        public static bool WriteInt32(Int64 _lpBaseAddress, int _Value)
        {
            byte[] Buffer = BitConverter.GetBytes(_Value);
            return WriteMemory(_lpBaseAddress, Buffer);
        }

        public static bool WriteByte(Int64 _lpBaseAddress, byte _Value)
        {
            byte[] Buffer = BitConverter.GetBytes(_Value);
            return WriteMemory(_lpBaseAddress, Buffer);
        }

        public static byte ReadByte(Int64 _lpBaseAddress)
        {
            byte[] Buffer = new byte[sizeof(byte)];
            IntPtr ByteRead;
            ReadProcessMemory(pHandle, _lpBaseAddress, Buffer, sizeof(byte), out ByteRead);
            return Buffer[0];
        }

        public static string ReadString(Int64 _lpBaseAddress, UInt64 _Size)
        {
            byte[] buffer = new byte[_Size];
            IntPtr BytesRead;

            ReadProcessMemory(pHandle, _lpBaseAddress, buffer, _Size, out BytesRead);

            for (int i = 0; i < buffer.Length; i++)
            {
                if (buffer[i] == 0)
                {
                    byte[] _buffer = new byte[i];
                    Buffer.BlockCopy(buffer, 0, _buffer, 0, i);
                    return Encoding.ASCII.GetString(_buffer);
                }
            }
            return Encoding.ASCII.GetString(buffer);
        }

        public static string ReadString2(Int64 _lpBaseAddress, UInt64 _Size)
        {
            byte[] buffer = new byte[_Size];
            IntPtr BytesRead;

            ReadProcessMemory(pHandle, _lpBaseAddress, buffer, _Size, out BytesRead);
            return Encoding.ASCII.GetString(buffer);
        }

        public static Vector2 ReadVector2(Int64 _lpBaseAddress)
        {
            Vector2 tmp = new Vector2();

            byte[] Buffer = new byte[8];
            IntPtr ByteRead;

            ReadProcessMemory(pHandle, _lpBaseAddress, Buffer, 8, out ByteRead);
            tmp.X = BitConverter.ToSingle(Buffer, (0 * 4));
            tmp.Y = BitConverter.ToSingle(Buffer, (1 * 4));
            return tmp;
        }

        public static Vector3 ReadVector3(Int64 _lpBaseAddress)
        {
            Vector3 tmp = new Vector3();

            byte[] Buffer = new byte[12];
            IntPtr ByteRead;

            ReadProcessMemory(pHandle, _lpBaseAddress, Buffer, 12, out ByteRead);
            tmp.X = BitConverter.ToSingle(Buffer, (0 * 4));
            tmp.Y = BitConverter.ToSingle(Buffer, (1 * 4));
            tmp.Z = BitConverter.ToSingle(Buffer, (2 * 4));
            return tmp;
        }

        public static Vector4 ReadVector4(Int64 _lpBaseAddress)
        {
            Vector4 tmp = new Vector4();

            byte[] Buffer = new byte[16];
            IntPtr ByteRead;

            ReadProcessMemory(pHandle, _lpBaseAddress, Buffer, 16, out ByteRead);
            tmp.X = BitConverter.ToSingle(Buffer, (0 * 4));
            tmp.Y = BitConverter.ToSingle(Buffer, (1 * 4));
            tmp.Z = BitConverter.ToSingle(Buffer, (2 * 4));
            tmp.W = BitConverter.ToSingle(Buffer, (3 * 4));
            return tmp;
        }

        public static Matrix ReadMatrix(Int64 _lpBaseAddress)
        {
            Matrix tmp = new Matrix();

            byte[] Buffer = new byte[64];
            IntPtr ByteRead;

            ReadProcessMemory(pHandle, _lpBaseAddress, Buffer, 64, out ByteRead);

            tmp.M11 = BitConverter.ToSingle(Buffer, (0 * 4));
            tmp.M12 = BitConverter.ToSingle(Buffer, (1 * 4));
            tmp.M13 = BitConverter.ToSingle(Buffer, (2 * 4));
            tmp.M14 = BitConverter.ToSingle(Buffer, (3 * 4));

            tmp.M21 = BitConverter.ToSingle(Buffer, (4 * 4));
            tmp.M22 = BitConverter.ToSingle(Buffer, (5 * 4));
            tmp.M23 = BitConverter.ToSingle(Buffer, (6 * 4));
            tmp.M24 = BitConverter.ToSingle(Buffer, (7 * 4));

            tmp.M31 = BitConverter.ToSingle(Buffer, (8 * 4));
            tmp.M32 = BitConverter.ToSingle(Buffer, (9 * 4));
            tmp.M33 = BitConverter.ToSingle(Buffer, (10 * 4));
            tmp.M34 = BitConverter.ToSingle(Buffer, (11 * 4));

            tmp.M41 = BitConverter.ToSingle(Buffer, (12 * 4));
            tmp.M42 = BitConverter.ToSingle(Buffer, (13 * 4));
            tmp.M43 = BitConverter.ToSingle(Buffer, (14 * 4));
            tmp.M44 = BitConverter.ToSingle(Buffer, (15 * 4));
            return tmp;
        }

        public static bool IsValid(Int64 Address)
        {
            return (Address >= 0x10000 && Address < 0x000F000000000000);
        } 
  
  
  [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

        [DllImport("user32.dll")]
        public static extern short GetKeyState(int KeyStates);

        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(UInt32 dwAccess, bool inherit, int pid);

        [DllImport("kernel32.dll")]
        public static extern bool CloseHandle(IntPtr handle);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, UInt32 dwSize, uint flNewProtect, out uint lpflOldProtect);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool ReadProcessMemory(IntPtr hProcess, Int64 lpBaseAddress, [In, Out] byte[] lpBuffer, UInt64 dwSize, out IntPtr lpNumberOfBytesRead);

        [DllImport("kernel32.dll")]
        public static extern bool WriteProcessMemory(IntPtr hProcess, Int64 lpBaseAddress, [In, Out] byte[] lpBuffer, UInt64 dwSize, out IntPtr lpNumberOfBytesWritten);

        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);

        [DllImport("user32.dll", SetLastError = true)]
        public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

        [DllImport("user32.dll")]
        public static extern bool GetClientRect(IntPtr hWnd, out RECT lpRect);
}

 

 

 

 

 

Изменено пользователем JustHack
  • Плюс 1

Поделиться сообщением


Ссылка на сообщение
Поделиться на другие сайты

Интересно а как различить высокоуровневое и низкоуровневое программирование?

 

Поделиться сообщением


Ссылка на сообщение
Поделиться на другие сайты
2 часа назад, ReWanet сказал:

как различить высокоуровневое и низкоуровневое программирование?

https://ru.wikipedia.org/wiki/Высокоуровневый_язык_программирования

http://www.lcard.ru/lexicon/low_level_programming

  • Плюс 1

Поделиться сообщением


Ссылка на сообщение
Поделиться на другие сайты

Для публикации сообщений создайте учётную запись или авторизуйтесь

Вы должны быть пользователем, чтобы оставить комментарий

Создать учетную запись

Зарегистрируйте новую учётную запись в нашем сообществе. Это очень просто!

Регистрация нового пользователя

Войти

Уже есть аккаунт? Войти в систему.

Войти

×

Важная информация

Находясь на нашем сайте, Вы автоматически соглашаетесь соблюдать наши Условия использования.