[Delphi] Modificação da Memória Tutorial & Modelo

Primeiramente, você tem que ter uma noção intermediáriado de Delphi para que possa executar e entender corretamente os codigos do Tutorial . Em breve criarei um Tutorial para Iniciantes.

Trechos úteis para robôs criação do jogo, formadores e outros programas com capacidade de ler e escrever na memória do processo selecionado.

Código Recursos focalizados para usar de modelo de memória:


ToolHelp função Win32 API:
- Argumentos para recuperar o PID de seu jogo
- Variáveis ​​para chamar a função

Escrever Procedimentos Memória
- Argumentos para escrever para a memória
- Variável para passar o ProcessID para WriteMemoryProcess
- Chamar o procedimento para a WriteMemoryProcess:
-1 Byte (byte)
-2 Bytes (word)
-4 Bytes (Cardeal)
-Byte Array (Array de Bytes)


Timer Procedimentos
-Configuração de velocidade Interval Timer
Usando códigos de teclas virtuais para ativar a tecla de atalho

Instruções para operar este modelo de alteração de memória. e Funcional Trainer Delphi Memória com Modificação anexada.

Vamos começar direito, eu estou trabalhando com Delphi 2005, Delphi 7 não deve ser
muito diferente, então abra Delphi Ir para>
File> New> VCL Forms Application-Delphi para Win32

Você será apresentado com um formulário de GUI em branco e este código esqueleto

Codigo:

Código:

unit Unit1;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;
type
  TForm1 = class(TForm)
  private
    { Private declarations }
  public
    { Public declarations }
  end;
var
  Form1: TForm1;
implementation
{$R *.dfm}
end.

Agora, antes que você pode usar a função API temos de dizer Delphi estaremos utilizando o ToolHelp 32 API assim adicioná-lo à cláusula USES

Código:

uses
 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
 Dialogs, StdCtrls, tlhelp32;

Vamos começar dando uma olhada nos argumentos Toolhelp função da API que iremos utilizar.

Código:

function GetProcessID(Const ExeFileName: string; var ProcessId: integer): boolean;

Primeiro iremos acrescentando as variáveis, precisamos usar a função toolhelp32 que retreives
o ProcessID pelo loop seus processos correndo procurando o processo de destino "SOME_GAME.exe".

Vamos precisar de uma String Const (Some_Game.exe) e uma variável inteira (para a realização da identificação do processo inteiro) para
chamar esta função, Boolean significa apenas que a sua verdadeira ou falsa (SOME_GAME.exe está funcionando ou não)

Então, adicioná-los.

Código:

var
  Form1: TForm1;
  PidID : integer;
Const
  ProgramName = ' SOME_GAME.exe';

Vamos dar uma olhada em toda a função que você apenas tem de se concentrar nos argumentos de agora.

Código:

function GetProcessID(Const ExeFileName: string; var ProcessId: integer): boolean;
var
  ContinueLoop: BOOL;
  FSnapshotHandle: THandle;
  FProcessEntry32: TProcessEntry32;
begin
  result := false;
  FSnapshotHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  FProcessEntry32.dwSize := Sizeof(FProcessEntry32);
  ContinueLoop := Process32First(FSnapshotHandle, FProcessEntry32);
  while integer(ContinueLoop) <> 0 do begin
    if (StrIComp(PChar(ExtractFileName(FProcessEntry32.sz  ExeFile)), PChar(ExeFileName)) = 0)
      or (StrIComp(FProcessEntry32.szExeFile, PChar(ExeFileName)) = 0)  then begin
      ProcessId:= FProcessEntry32.th32ProcessID;
      result := true;
      break;
    end;
    ContinueLoop := Process32Next(FSnapshotHandle, FProcessEntry32);
  end;
  CloseHandle(FSnapshotHandle);
end;

Agora vamos fazer os procedimentos que você pode chamar facilmente que escreve para a memória de jogos.
Lembre-se:
byte = 1 byte
word = 2 bytes
cardinal = 4 bytes
Então vamos usar comprimentos esses tipos de dados para fazer rápida pokes

Este procedimento irá gravar um byte para a memória dos jogos

Código:

procedure poke1(Address: Cardinal; Data: Byte);
var
  Written: Cardinal;
begin
  WriteProcessMemory(?, Pointer(Address), @Data, SizeOf(Data), Written);
end;

Vamos dar uma olhada no argumento da função:
procedimento poke1 (Address: Cardinal; Data: Byte);

Então, vamos chamá-lo com o endereço (offset) e os dados (opcodes) modificá-lo para.
O tipo de dados, neste caso "Byte" dita o tamanho.

Vamos dar uma olhada na parte WriteProcessMemory da função.

Código:

WriteProcessMemory(?, Pointer(Address), @Data, SizeOf(Data), Written);

O compilador não vai gostar disso ponto de interrogação lá, eu só colocá-lo lá para que você iria notar.
Precisamos de um processo de identificação para escrever, não sei o ID do processo até que nosso GetProcessID função API, então vamos precisar de uma variável global lá. Dê sua variável global, a minha é PidHandle .

Código:

var
 Form1: TForm1;
 PidHandle: integer;
 PidID : integer;

Então teremos

Código:

procedure poke1(Address: Cardinal; Data: Byte);
var
  Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;

Dados "Word" para 2 bytes

Código:

procedure poke2(Address: Cardinal; Data: Word);
var
Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;

Dados "cardeal" de 4 bytes

Código:

procedure poke4(Address: Cardinal; Data: Cardinal);
var
Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;

Então, a única diferença destes procedimentos é o comprimento dos dados sendo escrito, bytes 1, 2 e 4.
Grande para um NOPs poucos ou pequenos puxões, mas escrever uma série de opcodes usando tipos de dados pequeno seria muito chato, então lidar com opcodes muitos iremos especificar os dados como sendo um "array de byte".

Código:

procedure pokeX(Address: Cardinal; Data: array of Byte);
var
Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;

Agora que temos são funções de configuração, temos de chamá-los.
Mude para o modo de formulário, olhe para sua Tool Palette> Categorias> simples> TButton.
Coloque um botão no seu fórum, dê um duplo clique no formulário para entrar Código vista de dentro da
procedimento de botão.

Ele grava automaticamente os tipos de necessidade que têm de acrescentar aqui:

Código:

type
 TForm1 = class(TForm)
  Button1: TButton;
  procedure Button1Click(Sender: TObject);

E o procedimento de início clique no botão é gerado na seção de código.

Código:

procedure TForm1.Button1Click(Sender: TObject);
begin
end;

Agora o nosso "ProgramName" Const String é igual a 'SOME_GAME.exe' e nós declarado 'PidId' uma variável inteira para armazenar ProcessID quando a função é chamada.
Vamos chamá-lo com uma declaração Se tão somente se o "SOME_GAME.exe" Processo encontra-se o código dentro do if continuar a executar

Código:

if GetProcessID(ProgramName, PidId) then begin

Agora lembre-se que PidHandle variável Integer, declaramos e uso para WriteMemoryProcess? O PidId pode agora passar a processID verdade.
Então agora podemos preparar o SOME_GAME.exe memória do processo a ser modificado

Código:

PidHandle  :=  OpenProcess(PROCESS_ALL_ACCESS,False,PidId);

E podemos chamar nossos procedimentos poke agora com o endereço e
opcodes sua escrita, em seguida, feche PidHandle.

Código:

Poke1($401000, $90);
poke2($401001, $9090);
poke4($401003, $90909090);
closehandle(PidHandle);

Vamos dar uma olhada em todo o Button Processo

Código:

procedure TForm1.Button1Click(Sender: TObject);
begin
if GetProcessID(ProgramName, PidId) then
  begin
    PidHandle  :=  OpenProcess(PROCESS_ALL_ACCESS,False,PidId);
    poke1($401000, $90);
    poke2($401001, $9090);
    poke4($401003, $90909090);
    closehandle(PidHandle);
  end;
end;

Ótimo, então vamos dar uma olhada em tudo o que temos até agora.

Código:

unit Unit1;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, tlhelp32, StdCtrls;
type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
var
  Form1: TForm1;
  PidHandle: integer;
  PidID : integer;
Const
  ProgramName = ' SOME_GAME.exe';
implementation
{$R *.dfm}
function GetProcessID(Const ExeFileName: string; var ProcessId: integer): boolean;
var
  ContinueLoop: BOOL;
  FSnapshotHandle: THandle;
  FProcessEntry32: TProcessEntry32;
begin
  result := false;
  FSnapshotHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  FProcessEntry32.dwSize := Sizeof(FProcessEntry32);
  ContinueLoop := Process32First(FSnapshotHandle, FProcessEntry32);
  while integer(ContinueLoop) <> 0 do begin
    if (StrIComp(PChar(ExtractFileName(FProcessEntry32.sz  ExeFile)), PChar(ExeFileName)) = 0)
      or (StrIComp(FProcessEntry32.szExeFile, PChar(ExeFileName)) = 0)  then begin
      ProcessId:= FProcessEntry32.th32ProcessID;
      result := true;
      break;
    end;
    ContinueLoop := Process32Next(FSnapshotHandle, FProcessEntry32);
  end;
  CloseHandle(FSnapshotHandle);
end;
//1byte
procedure poke1(Address: Cardinal; Data: Byte);
var
  Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;
//2bytes
procedure poke2(Address: Cardinal; Data: Word);
var
Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;
//4bytes
procedure poke4(Address: Cardinal; Data: Cardinal);
var
Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;
//escrito em array da memoria
procedure pokeX(Address: Cardinal; Data: Array of Byte);
var
Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;
//Examplo da Funcao que chama 1
procedure TForm1.Button1Click(Sender: TObject);
begin
 if GetProcessID(ProgramName, PidId) then
  begin
  PidHandle  :=  OpenProcess(PROCESS_ALL_ACCESS,False,PidId);
  poke1($401000, $90);
  poke2($401001, $9090);
  poke4($401003, $90909090);
  closehandle(PidHandle);
 end;
end;
end.

Se você precisa escrever em uma longa seqüência de opcodes declarar a matriz de byte

Código:

Var
Form1: TForm1;
  PidHandle: integer;
  PidID : integer;
  byteArr : Array of byte;

E este é um exemplo de uma matriz de bytes em um novo botão que foi adicionado.

Código:

procedure TForm1.Button2Click(Sender: TObject);
begin
 if GetProcessID(ProgramName, PidId) then
  begin
  PidHandle  :=  OpenProcess(PROCESS_ALL_ACCESS,False,PidId);
    SetLength(byteArr, 16);
    byteArr[0] := $8B;
    byteArr[1] := $71;
    byteArr[2] := $10;
    byteArr[3] := $0F;
    byteArr[4] := $85;
    byteArr[5] := $6A;
    byteArr[6] := $9D;
    byteArr[7] := $FD;
    byteArr[8] := $FF;
    byteArr[9] := $83;
    byteArr[10] := $7E;
    byteArr[11] := $0C;
    byteArr[12] := $00;
    byteArr[13] := $0F;
    byteArr[14] := $85;
    byteArr[15] := $60;
    pokeX($401007, byteArr);
    SetLength(byteArr, 15)
closehandle(PidHandle);
 end;
end;

Para o temporizador e Hotkeys, Vista Alternar para ver o formulário Categorias Tool Palette> novamente,
desta vez escolha do sistema e escolher Ttimer, cair no seu formulário.
Selecione o Timer1 no seu formulário, vá até o Object Inspector> Propriedades, defina o intervalo de timer para
200 ms. Dê um duplo clique no formulário para saltar no âmbito do processo do timer.
Escolha a sua chave virtual
Eu vou usar F1 (VK_F1)
Estamos apenas indo verificar GetAsyncKeyState, se o atalho é pressionada e clique no botão.

Código:

procedure TForm1.Timer1Timer(Sender: TObject);
begin
if
(GetAsyncKeyState(VK_F1) <> 0)
then Button1.Click;
end;

Uma última coisa, como este, se o processo SOME_GAME.exe não for encontrado, ele não fará nada
pois todo o código está dentro do if, permite criar uma mensagem de que o processo não é
localizado.

Código:

procedure TForm1.Button1Click(Sender: TObject);
begin
  if GetProcessID(ProgramName, PidId) then
  begin
    PidHandle  :=  OpenProcess(PROCESS_ALL_ACCESS,False,PidId);
    poke1($401000, $90);
    poke2($401001, $9090);
    poke4($401003, $90909090);
    closehandle(PidHandle);
  end else
  begin
    MessageDlg('Start  SOME_GAME First.', mtwarning, [mbOK],0);
  end;
end;

Código:

unit Unit1;
interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, tlhelp32, StdCtrls, ExtCtrls;
type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Timer1: TTimer;
    Label1: TLabel;
    Label18: TLabel;
    Label2: TLabel;
    procedure Timer1Timer(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;
var
  Form1: TForm1;
  PidHandle: integer;
  PidID : integer;
  byteArr : Array of byte;
Const
  ProgramName = ' SOME_GAME.exe';
implementation
{$R *.dfm}
// tlhelp32 function to Loop through processes and locate your target
function GetProcessID(Const ExeFileName: string; var ProcessId: integer): boolean;
var
  ContinueLoop: BOOL;
  FSnapshotHandle: THandle;
  FProcessEntry32: TProcessEntry32;
begin
  result := false;
  FSnapshotHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  FProcessEntry32.dwSize := Sizeof(FProcessEntry32);
  ContinueLoop := Process32First(FSnapshotHandle, FProcessEntry32);
  while integer(ContinueLoop) <> 0 do begin
    if (StrIComp(PChar(ExtractFileName(FProcessEntry32.sz  ExeFile)), PChar(ExeFileName)) = 0)
      or (StrIComp(FProcessEntry32.szExeFile, PChar(ExeFileName)) = 0)  then begin
      ProcessId:= FProcessEntry32.th32ProcessID;
      result := true;
      break;
    end;
    ContinueLoop := Process32Next(FSnapshotHandle, FProcessEntry32);
  end;
  CloseHandle(FSnapshotHandle);
end;
//Write 1 byte to memory
procedure poke1(Address: Cardinal; Data: Byte);
var
  Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;
//Write 2 bytes to memory
procedure poke2(Address: Cardinal; Data: Word);
var
Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;
//Write 4 bytes to memory
procedure poke4(Address: Cardinal; Data: Cardinal);
var
Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;
//Write an Array of bytes to memory
procedure pokeX(Address: Cardinal; Data: Array of Byte);
var
Written: Cardinal;
begin
  WriteProcessMemory(PidHandle, Pointer(Address), @Data, SizeOf(Data), Written);
end;
//Example Function Call 1
procedure TForm1.Button1Click(Sender: TObject);
begin
  if GetProcessID(ProgramName, PidId) then
  begin
    PidHandle  :=  OpenProcess(PROCESS_ALL_ACCESS,False,PidId);
    poke1($401000, $90);
    poke2($401001, $9090);
    poke4($401003, $90909090);
    closehandle(PidHandle);
  end else
  begin
    MessageDlg('Start  SOME_GAME First.', mtwarning, [mbOK],0);
  end;
end;
//Example Function Call 2
procedure TForm1.Button2Click(Sender: TObject);
begin
 if GetProcessID(ProgramName, PidId) then
  begin
  PidHandle  :=  OpenProcess(PROCESS_ALL_ACCESS,False,PidId);
    SetLength(byteArr, 16);
    byteArr[0] := $8B;
    byteArr[1] := $71;
    byteArr[2] := $10;
    byteArr[3] := $0F;
    byteArr[4] := $85;
    byteArr[5] := $6A;
    byteArr[6] := $9D;
    byteArr[7] := $FD;
    byteArr[8] := $FF;
    byteArr[9] := $83;
    byteArr[10] := $7E;
    byteArr[11] := $0C;
    byteArr[12] := $00;
    byteArr[13] := $0F;
    byteArr[14] := $85;
    byteArr[15] := $60;
    pokeX($401007, byteArr);
    SetLength(byteArr, 15);
    closehandle(PidHandle);
  end else
  begin
    MessageDlg('Start  SOME_GAME First.', mtwarning, [mbOK],0);
 end;
end;
// Timer to Detect Hotkey and Execute your Buttons Code
procedure TForm1.Timer1Timer(Sender: TObject);
begin
if
(GetAsyncKeyState(VK_F1) <> 0)
then Button1.Click;
end;
end.

Se Gostou Clique em Agradecer !!!! - Primeiro estude os Termos usados no Tutorial e Depois escreva suas Dúvidas - Obrigado

otimo topico mas poe em negrito e adicione cores ai

perfeito parabéns , isso que é um tutorial bom. So esqueceu das cores!

otimo ta de Parabens
Valew
Ta Muito Bom