Devil9313

Что передаешь в ESP_Name? Как работает процедура WriteBytes? 

Расскажи подробней, как пытаешься писать в память.

procedure WriteBytes(Address: Integer; WriteValue: array of Byte);var pHandle: LongInt; NumWritten: DWORD_PTR;begin pHandle := OpenProcess(PROCESS_VM_READ or PROCESS_VM_WRITE or PROCESS_VM_OPERATION,False,GameID); VirtualProtectEx(pHandle,Ptr(Address),SizeOf(WriteValue),PAGE_EXECUTE_READWRITE,old_Protect_ON); WriteProcessMemory(pHandle,Ptr(Address),@WriteValue,SizeOf(WriteValue),NumWritten); VirtualProtectEx(pHandle,Ptr(Address),SizeOf(WriteValue),old_Protect_OFF,old_Protect_ON); CloseHandle(pHandle);end;

Кто поможет реализовать в Delphi поиск адреса по сигнатуре мой Skype: gm..4game

Вот кусочек кода трейнера 

 if CheckBox1.Checked then    DebugPrivilege;    GameID := ProcessID('PointBlank.exe');  if GameID = 0 then     Label1.Caption := 'ID процесса не найден, запустите игру!' else Label1.Caption := 'ID процесса:' + #32 + IntTostr(GameID);

procedure TTrainer.CheckBox20Click(Sender: TObject);const A: Array [1..2] of Byte = ($0F, $84); B: Array [1..2] of Byte = ($0F, $85);begin if CheckBox20.Checked then WriteBytes(ESP_Name,A) else WriteBytes(ESP_Name,;end;

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

А причем тут версия и название игры речь идет не об игре а о том как работать с модулями игры то как изменять значение в памяти exe я знаю проблема в том что я не знаю как работать с модулем который подгружает играть нужный мне адрес находится не в exe игры а в её модуле game.dll

Доброго времени суток ребят у меня возникла проблема мне нужно изменить значение по адресу который находится в модуле game.dll

Trainer  не меняет значение по адресу в этом модуле помогите решить проблему если вам не трудно

Спасибо ребят за помощь!!!

Здравствуйте у  меня такой вопрос кто объяснить как работать с VIrtualProtectEx 

функция чтения 

function Read(Pattern: Cardinal): Cardinal;var pHandle: LongInt; P: Cardinal; NumRead: DWORD_PTR;begin pHandle := OpenProcess(PROCESS_VM_READ or PROCESS_VM_WRITE or PROCESS_VM_OPERATION,False,GameID); if ReadProcessMemory(pHandle, Ptr(Pattern),@P,SizeOf(P),NumRead) then Result := P; CloseHandle(pHandle);end;

procedure WriteValue(Address: integer; Value: Cardinal);var pHandle: LongInt; NumWritten: DWORD_PTR;begin pHandle := OpenProcess(PROCESS_VM_READ or PROCESS_VM_WRITE or PROCESS_VM_OPERATION,False,GameID); WriteProcessMemory(pHandle,Ptr(Address),@Value,SizeOf(Value),NumWritten); CloseHandle(pHandle);end;procedure WriteBytes(Adress: Integer; Value: array of Byte);var pHandle: LongInt; NumWritten: DWORD_PTR;begin pHandle := OpenProcess(PROCESS_VM_READ or PROCESS_VM_WRITE or PROCESS_VM_OPERATION,False,GameID); WriteProcessMemory(pHandle,Ptr(Adress),@Value,SizeOf(Value),NumWritten); CloseHandle(pHandle);end;

Devil9313, минус не за помощь, а за то, что мат у тебя был, я видел твоё сообщение до редакции NullAlex. 

Минус бы тебе не поставили за мат, но ты написал:

 

вот за это и получил.

NullAlex: Ты меня понял)

Я кого-то оскорбил или что ?

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

NullAlex: Я смотрю, намеков ты не понимаешь.

Ребят кто нибудь поможет решить эту проблему ?

не понял а за что репу минусуем ? 

Ну что за каждую помощь репу минусуют ? 

Мда

Или на худой конец вот этим https://www.hex-rays.com/products/ida/debugger/cross-win-linux/win32towin64.shtml   Да и матом ругаться не хорошо... Алекс данное не видит 

Да и не какого этого самого тут не было. Просто спросил как. И дал отладчики которыми попробовать можно. Самому пока что не когда проверить это. Игра не вылетает из за подключения отладчика, потому как СЕ не может подключится к ней и через 10 секунд выпадает окно(мол превышено время) На не которых играх если нажать нет - то прокатывало подключение,а тут нет... Это надо посмотреть по посже.... А пока дал ссылке чем можно посмотреть, если не лень конечно смотреть самому.

NullAlex: Вижу, но я физически не могу 24 часа в сутки быть на форуме, и замечать все своевременно. Отчитал за мат - молодец, хвалю

Я IDA пользоваться не умею!!! 

NullAlex: Без матов.

Мата и не было !!!

Давайте без [CENSORED] я реально попросил помочь потому что уже не знаю как с этим бороться

NullAlex: Без матов.

В режиме ядра тоже пробовал вылет 

Ставишь в настройках СЕ  VEH отладчик и всё. Хотя и при нем бывают вылеты в некоторых играх. Но опять же не сразу, пока игра обнаружит его, можно успеть всё задуманное сделать. Главное же инструкцию увидеть и глянуть что с ней работает. С десяток другой вылетов и сделаешь задуманное 

Ну на пример на одном вылете патроны нашел, на другом жизнь и так далее. Если всё делать быстро - то всё получится. 10_ти секунд обычно хватает на это дело. Сразу приготовился к удару или выстрелу, ставишь отладчик и смотришь. Далее записываешь или скриншотишь и всё, но вполне можно и успеть заготовку даже сделать под скрипт, хотя бы вставить данные.

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

Olldbg тоже пробовал вылет 

Может есть ещё какие нибудь способы ? 

Здравствуйте у меня такая проблема ломаю данную игру нахожу здоровье персонажа жму бряк на запись и игра сразу вылетает я так понимаю в игре есть защита от отладчика CE и т д но как её обойти ? помогите пожалуйста буду очень благодарен

  то та наверное модуль игровой библиотеки.

Странный ответ!

Trainer основан на библиотеки VAMemory это игровой модуль client.dll+1DEC17 

client.dll плюс смещение 1DEC17 я попадаю на тот адрес с которым мне нужно работать но как мне использовать данный модуль плюс смещение  в трейнере 

Здравствуйте уважаемые пользователи данного форума у меня такой вопрос  я пишу Trainer для css v84 и у меня возникла такая проблема как мне использовать данный модуль  client.dll+1DEC17 я использую библиотеку VAMemory 

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

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

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

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

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

Наверно, так

 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

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

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

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

 

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

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

Здравствуйте уважаемые 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

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

 

Это не совсем то что нужно но я уже сам сделал !

 GameID: Cardinal;Const No_Reload = $00491E4F;implementation{$R *.dfm}function GetProcess(ProcessName: string): Cardinal;var hSnap: THandle; prEntry: PROCESSENTRY32;begin Result := 0; hSnap := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0); prEntry.dwSize := SizeOf(prEntry); If Process32First(hSnap,prEntry) then begin  While Process32Next(hSnap,prEntry) do  Begin   If prEntry.szExeFile = ProcessName then      Result := Cardinal(prEntry.th32ProcessID);  End; end; CloseHandle(hSnap);end;procedure WriteSig(GameID: Cardinal; Address: Integer; Value: array of Byte);var pHandle: LongInt; NumWritten: SIZE_T;begin pHandle := OpenProcess(PROCESS_VM_READ or PROCESS_VM_WRITE or PROCESS_VM_OPERATION,False,GameID); WriteProcessMemory(pHandle,Ptr(Address),@Value,SizeOf(Value),NumWritten); CloseHandle(pHandle);end;procedure TForm1.SpeedButton1Click(Sender: TObject);const No_ReloadOn: array[0..2] of Byte = ($90, $90, $90);//Байты для записи в процесс игры No_ReloadOFF: array[0..2] of Byte = ($8B, $47, $24);//Байты для записи в процесс игрыbegin WriteSig(GameID,No_Reload,No_ReloadOn);//Пример записи байт в памятьEnd;procedure TForm1.SpeedButton2Click(Sender: TObject);begin GameID := GetProcess('PlantsVsZombies.exe');//Получаем ID процесса по названию процесса Label1.Caption := IntTostr(GameID);end; 

Вот исходник трейнер

Нужно прочитать значение с этого адреса 00491E4F

Мне кто нибудь поможет ? 

Здравствуйте у меня такой вопрос как можно прочитать значение по статическому адресу ?