Указатели

[Devil9313]

Здравствуйте уважаемые GameHacker'ы мне нужна помощь у меня есть готовый класс VAmemory 

 

using System;

using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;

public class VAMemory
{
private IntPtr baseAddress;
public static bool debugMode;
private Process[] mainProcess;
private IntPtr processHandle;
private ProcessModule processModule;

public VAMemory()
{
}

public VAMemory(string pProcessName)
{
this.processName = pProcessName;
}

public bool CheckProcess()
{
if (this.processName != null)
{
this.mainProcess = Process.GetProcessesByName(this.processName);
if (this.mainProcess.Length == 0)
{
this.ErrorProcessNotFound(this.processName);
return false;
}
this.processHandle = OpenProcess(0x1f0fff, false, this.mainProcess[0].Id);
if (this.processHandle == IntPtr.Zero)
{
this.ErrorProcessNotFound(this.processName);
return false;
}
return true;
}
MessageBox.Show("Programmer, define process name first!");
return false;
}

[DllImport("kernel32.dll")]
private static extern bool CloseHandle(IntPtr hObject);
private void ErrorProcessNotFound(string pProcessName)
{
MessageBox.Show(this.processName + " is not running or has not been found. Please check and try again", "Process Not Found", MessageBoxButtons.OK, MessageBoxIcon.Hand);
}

[DllImport("kernel32.dll")]
private static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, int dwProcessId);
public bool ReadBoolean(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToBoolean(this.ReadByteArray(pOffset, 1), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadByte" + exception.ToString());
}
return false;
}
}

public byte ReadByte(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.ReadByteArray(pOffset, 1)[0];
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadByte" + exception.ToString());
}
return 0;
}
}

public byte[] ReadByteArray(IntPtr pOffset, uint pSize)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
uint num;
VirtualProtectEx(this.processHandle, pOffset, (UIntPtr) pSize, 4, out num);
byte[] lpBuffer = new byte[pSize];
ReadProcessMemory(this.processHandle, pOffset, lpBuffer, pSize, 0);
VirtualProtectEx(this.processHandle, pOffset, (UIntPtr) pSize, num, out num);
return lpBuffer;
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadByteArray" + exception.ToString());
}
return new byte[1];
}
}

public char ReadChar(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToChar(this.ReadByteArray(pOffset, 1), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadChar" + exception.ToString());
}
return ' ';
}
}

public double ReadDouble(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToDouble(this.ReadByteArray(pOffset, 8), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadDouble" + exception.ToString());
}
return 0.0;
}
}

public float ReadFloat(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToSingle(this.ReadByteArray(pOffset, 4), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadFloat" + exception.ToString());
}
return 0f;
}
}

public short ReadInt16(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToInt16(this.ReadByteArray(pOffset, 2), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadInt16" + exception.ToString());
}
return 0;
}
}

public int ReadInt32(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToInt32(this.ReadByteArray(pOffset, 4), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadInt32" + exception.ToString());
}
return 0;
}
}

public long ReadInt64(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToInt64(this.ReadByteArray(pOffset, 8), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadInt64" + exception.ToString());
}
return 0L;
}
}

public int ReadInteger(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToInt32(this.ReadByteArray(pOffset, 4), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadInteger" + exception.ToString());
}
return 0;
}
}

public long ReadLong(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToInt64(this.ReadByteArray(pOffset, 8), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadLong" + exception.ToString());
}
return 0L;
}
}

[DllImport("kernel32.dll", SetLastError=true)]
private static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint dwSize, uint lpNumberOfBytesRead);
public short ReadShort(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToInt16(this.ReadByteArray(pOffset, 2), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadInt16" + exception.ToString());
}
return 0;
}
}

public string ReadStringASCII(IntPtr pOffset, uint pSize)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return Encoding.ASCII.GetString(this.ReadByteArray(pOffset, pSize), 0, (int) pSize);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadStringASCII" + exception.ToString());
}
return "";
}
}

public string ReadStringUnicode(IntPtr pOffset, uint pSize)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return Encoding.Unicode.GetString(this.ReadByteArray(pOffset, pSize), 0, (int) pSize);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadStringUnicode" + exception.ToString());
}
return "";
}
}

public ushort ReadUInt16(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToUInt16(this.ReadByteArray(pOffset, 2), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadUInt16" + exception.ToString());
}
return 0;
}
}

public uint ReadUInt32(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToUInt32(this.ReadByteArray(pOffset, 4), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadUInt32" + exception.ToString());
}
return 0;
}
}

public ulong ReadUInt64(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToUInt64(this.ReadByteArray(pOffset, 8), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadUInt64" + exception.ToString());
}
return 0L;
}
}

public uint ReadUInteger(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToUInt32(this.ReadByteArray(pOffset, 4), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadUInteger" + exception.ToString());
}
return 0;
}
}

public long ReadULong(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return (long) BitConverter.ToUInt64(this.ReadByteArray(pOffset, 8), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadULong" + exception.ToString());
}
return 0L;
}
}

public ushort ReadUShort(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return BitConverter.ToUInt16(this.ReadByteArray(pOffset, 2), 0);
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: ReadUShort" + exception.ToString());
}
return 0;
}
}

[DllImport("kernel32.dll", SetLastError=true, ExactSpelling=true)]
private static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
[DllImport("kernel32.dll")]
private static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);
public bool WriteBoolean(IntPtr pOffset, bool pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteBoolean" + exception.ToString());
}
return false;
}
}

public bool WriteByte(IntPtr pOffset, byte pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes((short) pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteByte" + exception.ToString());
}
return false;
}
}

public bool WriteByteArray(IntPtr pOffset, byte[] pBytes)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
uint num;
VirtualProtectEx(this.processHandle, pOffset, (UIntPtr) pBytes.Length, 4, out num);
bool flag = WriteProcessMemory(this.processHandle, pOffset, pBytes, (uint) pBytes.Length, 0);
VirtualProtectEx(this.processHandle, pOffset, (UIntPtr) pBytes.Length, num, out num);
return flag;
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteByteArray" + exception.ToString());
}
return false;
}
}

public bool WriteChar(IntPtr pOffset, char pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteChar" + exception.ToString());
}
return false;
}
}

public bool WriteDouble(IntPtr pOffset, double pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteDouble" + exception.ToString());
}
return false;
}
}

public bool WriteFloat(IntPtr pOffset, float pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteFloat" + exception.ToString());
}
return false;
}
}

public bool WriteInt16(IntPtr pOffset, short pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteInt16" + exception.ToString());
}
return false;
}
}

public bool WriteInt32(IntPtr pOffset, int pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteInt32" + exception.ToString());
}
return false;
}
}

public bool WriteInt64(IntPtr pOffset, long pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteInt64" + exception.ToString());
}
return false;
}
}

public bool WriteInteger(IntPtr pOffset, int pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteInt" + exception.ToString());
}
return false;
}
}

public bool WriteLong(IntPtr pOffset, long pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteLong" + exception.ToString());
}
return false;
}
}

[DllImport("kernel32.dll")]
private static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint nSize, uint lpNumberOfBytesWritten);
public bool WriteShort(IntPtr pOffset, short pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteShort" + exception.ToString());
}
return false;
}
}

public bool WriteStringASCII(IntPtr pOffset, string pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, Encoding.ASCII.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteStringASCII" + exception.ToString());
}
return false;
}
}

public bool WriteStringUnicode(IntPtr pOffset, string pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, Encoding.Unicode.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteStringUnicode" + exception.ToString());
}
return false;
}
}

public bool WriteUInt16(IntPtr pOffset, ushort pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteUInt16" + exception.ToString());
}
return false;
}
}

public bool WriteUInt32(IntPtr pOffset, uint pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteUInt32" + exception.ToString());
}
return false;
}
}

public bool WriteUInt64(IntPtr pOffset, ulong pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteUInt64" + exception.ToString());
}
return false;
}
}

public bool WriteUInteger(IntPtr pOffset, uint pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteUInt" + exception.ToString());
}
return false;
}
}

public bool WriteULong(IntPtr pOffset, ulong pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteULong" + exception.ToString());
}
return false;
}
}

public bool WriteUShort(IntPtr pOffset, ushort pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
try
{
return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception exception)
{
if (debugMode)
{
Console.WriteLine("Error: WriteShort" + exception.ToString());
}
return false;
}
}

public long getBaseAddress
{
get
{
this.baseAddress = IntPtr.Zero;
this.processModule = this.mainProcess[0].MainModule;
this.baseAddress = this.processModule.BaseAddress;
return (long) this.baseAddress;
}
}

public string processName { get; set; }

[Flags]
private enum ProcessAccessFlags : uint
{
All = 0x1f0fff,
CreateThread = 2,
DupHandle = 0x40,
QueryInformation = 0x400,
SetInformation = 0x200,
Synchronize = 0x100000,
Terminate = 1,
VMOperation = 8,
VMRead = 0x10,
VMWrite = 0x20
}

private enum VirtualMemoryProtection : uint
{
PAGE_EXECUTE = 0x10,
PAGE_EXECUTE_READ = 0x20,
PAGE_EXECUTE_READWRITE = 0x40,
PAGE_EXECUTE_WRITECOPY = 0x80,
PAGE_GUARD = 0x100,
PAGE_NOACCESS = 1,
PAGE_NOCACHE = 0x200,
PAGE_READONLY = 2,
PAGE_READWRITE = 4,
PAGE_WRITECOPY = 8,
PROCESS_ALL_ACCESS = 0x1f0fff
}
}

как записывать по статическому адресу байты я знаю 

int No_Flash = 0x776130; 
GameName.WriteByteArray((IntPtr)No_Flash, new byte[1] { 0xC3 });

 

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

базовый адрес 6D459B

Указатель - c1

Указатель - 66c

Указатель - 37b

Указатель - 18

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

 

[keng]

Привет! Воспользуйся поиском по форуму - есть несколько, по сути, однотипных тем про работу с указателями в различных языках программирования.

 

PS: Думаю, пора создавать ЧАВО с подобными темами.

[Devil9313]

Привет! Воспользуйся поиском по форуму - есть несколько, по сути, однотипных тем про работу с указателями в различных языках программирования.

 

PS: Думаю, пора создавать ЧАВО с подобными темами.

Мне нужно именно с этим классом VAMemory

[keng]

Гм. У меня есть статья на тему указателей, вот [ссылка], там все довольно подробно расписано. Думаю, этого хватит для начала.

[Devil9313]

Мне нужно использовать функцию чтения указателей с данного класса который у меня 

[Гость]

Мне нужно использовать функцию чтения указателей с данного класса который у меня

И в чем проблема заключается? Поиск по форуму работает, эту тему подробно разбирали неоднократно (как на C++, так и на Delphi, так и на остальных языках). Все, что тебе нужно - воспользоваться поиском, прочитать сообщения, понять их смысл, и ты сможешь самостоятельно написать нужные функции (или даже модифицировать существующие).

[MasterGH]

Наверно, так

 VAM = new VAMemory("game");  IntPtr address = (IntPtr)0x6D459B; address = (IntPtr)(VAM.ReadULong(address)+0xc1) address = (IntPtr)(VAM.ReadULong(address)+0x66c) address = (IntPtr)(VAM.ReadULong(address)+0x37b) address = (IntPtr)(VAM.ReadULong(address)+0x18) VAM.WriteByteArray(address, new byte[1] { 0xC3 });

Здесь нет проверок на 

 

1) разрядность системы

2) на существования адреса

 

Если это 64 битное приложение, то адреса надо считать иначе.

Если указатели бывают null, то будет исключение перед попыткой добавить смещение к null

[Xipho]

Наверно, так

 

Если каждый раз предоставлять готовое решение, пользователи сами думать не будут, и ничему не научатся.

[Devil9313]

Наверно, так

 VAM = new VAMemory("game");  IntPtr address = (IntPtr)0x6D459B; address = (IntPtr)(VAM.ReadULong(address)+0xc1) address = (IntPtr)(VAM.ReadULong(address)+0x66c) address = (IntPtr)(VAM.ReadULong(address)+0x37b) address = (IntPtr)(VAM.ReadULong(address)+0x18) VAM.WriteByteArray(address, new byte[1] { 0xC3 });

Здесь нет проверок на 

 

1) разрядность системы

2) на существования адреса

 

Если это 64 битное приложение, то адреса надо считать иначе.

Если указатели бывают null, то будет исключение перед попыткой добавить смещение к null

Не работает !

А я то думал здесь помогают !

Все то мне нужно было узнать как работать с указателями исползуя данный класс VAMemory

Зачем тогда вообще учить кого то ? 

[Гость]

Не работает !

А ты к советам прислушался? Поискал причину, почему не работает? С классом разобрался, хотя-бы?

А я то думал здесь помогают !

Помогают, но конкретно тебе - ничто не поможет, почему? Потому что ты скачиваешь готовый класс, и не хочешь разобраться, как он работает, и более того - не хочешь использовать поиск по форуму, и ждешь готовый код.

Все то мне нужно было узнать как работать с указателями исползуя данный класс VAMemory

В чем проблема? Вопрос, как работать с указателями - не один десяток раз поднимался на нашем форуме, всего-то нужно использовать поиск по форуму.

Зачем тогда вообще учить кого то ?

А ты хочешь научиться? Что-то не видно.

[Xipho]

Все то мне нужно было узнать как работать с указателями исползуя данный класс VAMemory

Не обманывай. Как я вижу, тебе нужен готовый код. И учиться ты ничему не хочешь. Тебе дали вариант. Отталкиваясь от него, модифицируй под свои нужды. А ты даже не трудишься объяснить, что именно у тебя не срабатывает.

[Devil9313]

Не обманывай.

Это как понимать то ? 

Короче спасибо за помощь всем пока всем удачного разуплотнения игр 

 

[terminus]/* keng: Ненормативная лексика - это плохо и за нее нужно мыть рот с мылом. */[/terminus]

[keng]

Товарищ, подожди. Я же тебе ссылку на статью дал. Тебе всего-то ее прочитать, взять из нее готовый метод и вставить в класс, исходник которого ты привел в шапке. Что в этом сложного?

[Devil9313]

Здравствуйте keng  такой вопрос а в данном классе VAMemory получается нет функции чтения указателей или всё  таки есть ? 

Изменено 24 апреля, 2015 пользователем Devil9313

[keng]

Так. Давай я скопирую в следующем посте твой класс и будем с ним постепенно разбираться, так как там почти тысяча строк кода. Для начала я приведу в порядок форматирование, потому что в текущем виде читать его невозможно.

Исходный код класса:

using System;using System.Diagnostics;using System.Runtime.CompilerServices;using System.Runtime.InteropServices;using System.Text;using System.Windows.Forms; public class VAMemory{private IntPtr baseAddress;public static bool debugMode;private Process[] mainProcess;private IntPtr processHandle;private ProcessModule processModule; public VAMemory(){} public VAMemory(string pProcessName){this.processName = pProcessName;} public bool CheckProcess(){if (this.processName != null){this.mainProcess = Process.GetProcessesByName(this.processName);if (this.mainProcess.Length == 0){this.ErrorProcessNotFound(this.processName);return false;}this.processHandle = OpenProcess(0x1f0fff, false, this.mainProcess[0].Id);if (this.processHandle == IntPtr.Zero){this.ErrorProcessNotFound(this.processName);return false;}return true;}MessageBox.Show("Programmer, define process name first!");return false;} [DllImport("kernel32.dll")]private static extern bool CloseHandle(IntPtr hObject);private void ErrorProcessNotFound(string pProcessName){MessageBox.Show(this.processName + " is not running or has not been found. Please check and try again", "Process Not Found", MessageBoxButtons.OK, MessageBoxIcon.Hand);} [DllImport("kernel32.dll")]private static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, int dwProcessId);public bool ReadBoolean(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToBoolean(this.ReadByteArray(pOffset, 1), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadByte" + exception.ToString());}return false;}} public byte ReadByte(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.ReadByteArray(pOffset, 1)[0];}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadByte" + exception.ToString());}return 0;}} public byte[] ReadByteArray(IntPtr pOffset, uint pSize){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{uint num;VirtualProtectEx(this.processHandle, pOffset, (UIntPtr) pSize, 4, out num);byte[] lpBuffer = new byte[pSize];ReadProcessMemory(this.processHandle, pOffset, lpBuffer, pSize, 0);VirtualProtectEx(this.processHandle, pOffset, (UIntPtr) pSize, num, out num);return lpBuffer;}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadByteArray" + exception.ToString());}return new byte[1];}} public char ReadChar(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToChar(this.ReadByteArray(pOffset, 1), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadChar" + exception.ToString());}return ' ';}} public double ReadDouble(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToDouble(this.ReadByteArray(pOffset, 8), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadDouble" + exception.ToString());}return 0.0;}} public float ReadFloat(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToSingle(this.ReadByteArray(pOffset, 4), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadFloat" + exception.ToString());}return 0f;}} public short ReadInt16(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToInt16(this.ReadByteArray(pOffset, 2), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadInt16" + exception.ToString());}return 0;}} public int ReadInt32(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToInt32(this.ReadByteArray(pOffset, 4), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadInt32" + exception.ToString());}return 0;}} public long ReadInt64(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToInt64(this.ReadByteArray(pOffset, 8), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadInt64" + exception.ToString());}return 0L;}} public int ReadInteger(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToInt32(this.ReadByteArray(pOffset, 4), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadInteger" + exception.ToString());}return 0;}} public long ReadLong(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToInt64(this.ReadByteArray(pOffset, 8), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadLong" + exception.ToString());}return 0L;}} [DllImport("kernel32.dll", SetLastError=true)]private static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint dwSize, uint lpNumberOfBytesRead);public short ReadShort(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToInt16(this.ReadByteArray(pOffset, 2), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadInt16" + exception.ToString());}return 0;}} public string ReadStringASCII(IntPtr pOffset, uint pSize){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return Encoding.ASCII.GetString(this.ReadByteArray(pOffset, pSize), 0, (int) pSize);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadStringASCII" + exception.ToString());}return "";}} public string ReadStringUnicode(IntPtr pOffset, uint pSize){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return Encoding.Unicode.GetString(this.ReadByteArray(pOffset, pSize), 0, (int) pSize);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadStringUnicode" + exception.ToString());}return "";}} public ushort ReadUInt16(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToUInt16(this.ReadByteArray(pOffset, 2), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadUInt16" + exception.ToString());}return 0;}} public uint ReadUInt32(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToUInt32(this.ReadByteArray(pOffset, 4), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadUInt32" + exception.ToString());}return 0;}} public ulong ReadUInt64(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToUInt64(this.ReadByteArray(pOffset, 8), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadUInt64" + exception.ToString());}return 0L;}} public uint ReadUInteger(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToUInt32(this.ReadByteArray(pOffset, 4), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadUInteger" + exception.ToString());}return 0;}} public long ReadULong(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return (long) BitConverter.ToUInt64(this.ReadByteArray(pOffset, 8), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadULong" + exception.ToString());}return 0L;}} public ushort ReadUShort(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToUInt16(this.ReadByteArray(pOffset, 2), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadUShort" + exception.ToString());}return 0;}} [DllImport("kernel32.dll", SetLastError=true, ExactSpelling=true)]private static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);[DllImport("kernel32.dll")]private static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);public bool WriteBoolean(IntPtr pOffset, bool pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteBoolean" + exception.ToString());}return false;}} public bool WriteByte(IntPtr pOffset, byte pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes((short) pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteByte" + exception.ToString());}return false;}} public bool WriteByteArray(IntPtr pOffset, byte[] pBytes){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{uint num;VirtualProtectEx(this.processHandle, pOffset, (UIntPtr) pBytes.Length, 4, out num);bool flag = WriteProcessMemory(this.processHandle, pOffset, pBytes, (uint) pBytes.Length, 0);VirtualProtectEx(this.processHandle, pOffset, (UIntPtr) pBytes.Length, num, out num);return flag;}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteByteArray" + exception.ToString());}return false;}} public bool WriteChar(IntPtr pOffset, char pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteChar" + exception.ToString());}return false;}} public bool WriteDouble(IntPtr pOffset, double pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteDouble" + exception.ToString());}return false;}} public bool WriteFloat(IntPtr pOffset, float pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteFloat" + exception.ToString());}return false;}} public bool WriteInt16(IntPtr pOffset, short pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteInt16" + exception.ToString());}return false;}} public bool WriteInt32(IntPtr pOffset, int pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteInt32" + exception.ToString());}return false;}} public bool WriteInt64(IntPtr pOffset, long pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteInt64" + exception.ToString());}return false;}} public bool WriteInteger(IntPtr pOffset, int pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteInt" + exception.ToString());}return false;}} public bool WriteLong(IntPtr pOffset, long pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteLong" + exception.ToString());}return false;}} [DllImport("kernel32.dll")]private static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint nSize, uint lpNumberOfBytesWritten);public bool WriteShort(IntPtr pOffset, short pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteShort" + exception.ToString());}return false;}} public bool WriteStringASCII(IntPtr pOffset, string pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, Encoding.ASCII.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteStringASCII" + exception.ToString());}return false;}} public bool WriteStringUnicode(IntPtr pOffset, string pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, Encoding.Unicode.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteStringUnicode" + exception.ToString());}return false;}} public bool WriteUInt16(IntPtr pOffset, ushort pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteUInt16" + exception.ToString());}return false;}} public bool WriteUInt32(IntPtr pOffset, uint pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteUInt32" + exception.ToString());}return false;}} public bool WriteUInt64(IntPtr pOffset, ulong pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteUInt64" + exception.ToString());}return false;}} public bool WriteUInteger(IntPtr pOffset, uint pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteUInt" + exception.ToString());}return false;}} public bool WriteULong(IntPtr pOffset, ulong pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteULong" + exception.ToString());}return false;}} public bool WriteUShort(IntPtr pOffset, ushort pData){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));}catch (Exception exception){if (debugMode){Console.WriteLine("Error: WriteShort" + exception.ToString());}return false;}} public long getBaseAddress{get{this.baseAddress = IntPtr.Zero;this.processModule = this.mainProcess[0].MainModule;this.baseAddress = this.processModule.BaseAddress;return (long) this.baseAddress;}} public string processName { get; set; } [Flags]private enum ProcessAccessFlags : uint{All = 0x1f0fff,CreateThread = 2,DupHandle = 0x40,QueryInformation = 0x400,SetInformation = 0x200,Synchronize = 0x100000,Terminate = 1,VMOperation = 8,VMRead = 0x10,VMWrite = 0x20} private enum VirtualMemoryProtection : uint{PAGE_EXECUTE = 0x10,PAGE_EXECUTE_READ = 0x20,PAGE_EXECUTE_READWRITE = 0x40,PAGE_EXECUTE_WRITECOPY = 0x80,PAGE_GUARD = 0x100,PAGE_NOACCESS = 1,PAGE_NOCACHE = 0x200,PAGE_READONLY = 2,PAGE_READWRITE = 4,PAGE_WRITECOPY = 8,PROCESS_ALL_ACCESS = 0x1f0fff}}

Гм. Интересное дело - форматирование кода совсем никак не работает. Возможно,
из-за спойлера. Будем разбирать код по кускам. Начнем с самого верха:
 
Директива using используется для того, чтобы подключить какие-то внешние
функции и классы в твою программу. Это все то неимоверно и жутко необходимое
для корректной работы класса.

-------------------------------------------------------------------------------

Далее у нас идет определение тела и имени класса:
Внутри будут лежать его методы и свойства.

-------------------------------------------------------------------------------

Ниже идет вот такой код:
Это, собственно, свойства, то есть некоторые переменные, к которым можно
обращаться.

У них есть (слева направо) модификатор доступа, тип и имя. Подробнее про
модификаторы доступа можно почитать на MSDN.

-------------------------------------------------------------------------------

Следующим идет вот такой чудо-кусок:
Это - конструктор класса. Он вызывается в первую очередь, когда создается
объект класса.

-------------------------------------------------------------------------------
А вот это - тоже конструктор, но с аргументом pProcessName. То есть можно
вызвать этот класс при создании объекта класса, сообщив ему аргумент. Все, что
он делает - говорит, что переменная класса processName равна аргументу.

-------------------------------------------------------------------------------

Дальше идет метод, которая возвращает значение типа bool:

using System;using System.Diagnostics;using System.Runtime.CompilerServices;using System.Runtime.InteropServices;using System.Text;using System.Windows.Forms;

public class VAMemory{}

private IntPtr baseAddress;public static bool debugMode;private Process[] mainProcess;private IntPtr processHandle;private ProcessModule processModule;

public VAMemory(){}

public VAMemory(string pProcessName){this.processName = pProcessName;}

Что этот метод делает? А вот так вот:

0. Проверяем, что у нас есть имя процесса.
1. Если есть, то:
2. Получаем идентификатор этого процесса.
3. Если не получилось, то:
4. Говорим, что произошла ошибка и выходим.
5. Если получилось, то открываем процесс для чтения\записи.
6. Если не открылся, то:
7. Выводим сообщение об ошибке и выходим.
8. Выходим, возвращая успешный результат выполнения.

-------------------------------------------------------------------------------

Дальше идет вот это:
Это - описание WinAPI-функции для закрытия идентификатора процесса. Закрывать
использованные идентификаторы - это круто!

-------------------------------------------------------------------------------

Теперь вот:
Этот метод выводит сообщение о том, что процесс с таким-то именем найден не
был.

-------------------------------------------------------------------------------
Описание другой WinAPI-функции - на этот раз, для открытия процесса.

-------------------------------------------------------------------------------

public bool CheckProcess(){if (this.processName != null){this.mainProcess = Process.GetProcessesByName(this.processName);if (this.mainProcess.Length == 0){this.ErrorProcessNotFound(this.processName);return false;}this.processHandle = OpenProcess(0x1f0fff, false, this.mainProcess[0].Id);if (this.processHandle == IntPtr.Zero){this.ErrorProcessNotFound(this.processName);return false;}return true;}MessageBox.Show("Programmer, define process name first!");return false;}

[DllImport("kernel32.dll")]private static extern bool CloseHandle(IntPtr hObject);

private void ErrorProcessNotFound(string pProcessName){MessageBox.Show(this.processName +" is not running or has not been found. Please check and try again","Process Not Found", MessageBoxButtons.OK, MessageBoxIcon.Hand);}

[DllImport("kernel32.dll")]private static extern IntPtr OpenProcess(uint dwDesiredAccess,bool bInheritHandle, int dwProcessId);

Чудо-метод для чтения значения типа bool, принимающий некий оффсет и bool
возвращающий.

0. Если у нас нет идентификатора процесса, то
1. Вызываем некий метод CheckProcess, до которого я еще не дочитал.
2. Иначе возвращаем bool, который пытаемся сделать из результата работы
метода ReadByteArray, которому мы скормили оффсет и единичку.
3. Если что-то пошло не так и свойство debugMode установлено в true, то
выводим сообщение об ошибке и выходим.

-------------------------------------------------------------------------------

О, а вот и некий метод ReadByte:

public bool ReadBoolean(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return BitConverter.ToBoolean(this.ReadByteArray(pOffset, 1), 0);}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadByte" + exception.ToString());}return false;}}

Принимает на входе оффсет, возвращает байт. Я начинаю догадываться, что оффсет
- это адрес памяти.

0. Проверка идентификатора процесса.
1. Если все ОК, то возвращаем первый результат работы метода ReadByteArray.
Судя из названия, на выходе из него приедет массив байт, а второй его аргумент
- это сколько же байт нужно прочитать.
2. Если что-то пошло не так, то все очень плохо.

-------------------------------------------------------------------------------

NullAlex: ровно месяц назад (27 апреля) я просил keng вставить теги спойлера и кода в это сообщение - он так ничего и не сделал. Почему форматирование не работает? Потому, что нужно использовать тег кода.

public byte ReadByte(IntPtr pOffset){if (this.processHandle == IntPtr.Zero){this.CheckProcess();}try{return this.ReadByteArray(pOffset, 1)[0];}catch (Exception exception){if (debugMode){Console.WriteLine("Error: ReadByte" + exception.ToString());}return 0;}}

Изменено 27 мая, 2015 пользователем NullAlex

[MasterGH]

В общем чтобы устроить тех, кто желает учиться C# и тех, кто не желает учиться C# я предоставляю на выбор два варианта. Это заглянуть под спойлер или не заглядывать под него до написания своего решения.

Актаульно для указателя [[[[00645390]+0c]+14]]+18

Для приложения Tutorial-i386.exe (Step 8) в папке с Cheat Engine 6.4

/* * Created by SharpDevelop. * User: MasterGH * Date: 25.04.2015 */using System;namespace TestReadPointer{	class Program	{		public static void Main(string[] args)		{			Console.WriteLine("Hello World!");						// TODO: Implement Functionality Here						//[[[[00645390]+0c]+14]]+18 for Cheat Engine 6.4, Tutorial-i386.exe			VAMemory VAM = new VAMemory("Tutorial-i386"); 			IntPtr address = (IntPtr)0x00645390;			address = (IntPtr)(VAM.ReadUInteger(address)+0x0c);			address = (IntPtr)(VAM.ReadUInteger(address)+0x14);			address = (IntPtr)(VAM.ReadUInteger(address));			address = (IntPtr)(VAM.ReadUInteger(address)+0x18);			VAM.WriteByteArray(address, new byte[1] { 0xff });						//Console.Write("Press any key to continue . . . ");			//Console.ReadKey(true);		}	}}

VAMemory VAM = new VAMemory("GAME"); // вместо GAME поставь свое название

IntPtr address = (IntPtr)0x6D459B;

address = (IntPtr)(VAM.ReadUInteger(address)+0xC1);

address = (IntPtr)(VAM.ReadUInteger(address)+0x66C);

address = (IntPtr)(VAM.ReadUInteger(address)+0x37B);

address = (IntPtr)(VAM.ReadUInteger(address)+0x18);

VAM.WriteByteArray(address, new byte[1] { 0xff });

Изменено 25 апреля, 2015 пользователем MasterGH