Przetłumaczony kod

[Pieter]

Przetłumaczyłem sobie kod z c++ na delphi ale nie wiem czy będzie działać a nie mam jak to sprawdzić. Dam wam go tu i powiedzcie mi czy według was powinno działać

 

Kod w c++:

#include "trainer.h"

/*
Trainer
by Evremonde
*/

/* constructor and deconstructor */

CTrainer::CTrainer()
{
    //
}

CTrainer::~CTrainer()
{
    //
}

/* process */

void CTrainer::setProcess(HWND gameWindow)
{
    // get game window
    hwnd = gameWindow;

    // get process id
    ::GetWindowThreadProcessId(hwnd, &processId);

    // get process handle
    processHandle = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
}

void CTrainer::closeProcess()
{
    // close process handle
    ::CloseHandle(processHandle);
}

/* read and write memory */

void CTrainer::writeBytes(DWORD address, int value, int bytes)
{
    ::WriteProcessMemory(processHandle, reinterpret_cast<void*>(address), &value, bytes, 0);
}

int CTrainer::readBytes(DWORD address, int bytes)
{
    int buffer = 0;
    ::ReadProcessMemory(processHandle, reinterpret_cast<void*>(address), &buffer, bytes, 0);
    return buffer;
}

void CTrainer::writeString(DWORD address, std::string value)
{    
    unsigned char nullTerminator = 0x00;

    int j = 0;
    for(unsigned int i = 0; i < value.size(); i++)
    {
        ::WriteProcessMemory(processHandle, reinterpret_cast<void*>(address + j), &value[i], 1, 0);
        j++; // increment address
    }
    ::WriteProcessMemory(processHandle, reinterpret_cast<void*>(address + j), &nullTerminator, 1, 0);
}

std::string CTrainer::readString(DWORD address)
{ 
    static char buffer[255];
    ::ReadProcessMemory(processHandle, reinterpret_cast<void*>(address), &buffer, sizeof(buffer), 0);
    return buffer;
}

void CTrainer::writeNops(DWORD address, int nops)
{
    unsigned char nop = 0x90;
    
    int j = 0;
    for (int i = 0; i < nops; i++)
    {
        ::WriteProcessMemory(processHandle, reinterpret_cast<void*>(address + j), &nop, 1, 0);
        j++; // increment address
    }
}

 

a tu mój w delphim

 

unit trainer;

interface

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

var
processHandle: THandle;

procedure setProcess(gameWindow:THandle);
procedure closeProcess();
procedure WriteBytes(address:DWORD; value,bytes: integer);
function  ReadBytes(address:DWORD; bytes: integer):pchar;
procedure WriteString(address:DWORD; value: string);
function  ReadString(address:DWORD): string;
procedure WriteNops(address:DWORD; nops: integer);
function WriteProcessMemory(hProcess: THandle; const lpBaseAddress: pointer; lpBuffer: pointer;
  nSize: DWORD; var lpNumberOfBytesWritten: DWORD): BOOL; stdcall; external kernel32 name 'WriteProcessMemory';
function ReadProcessMemory(hProcess: THandle; const lpBaseAddress: Pointer; lpBuffer: Pointer;
  nSize: DWORD; var lpNumberOfBytesRead: DWORD): BOOL; external kernel32 name 'ReadProcessMemory';
implementation

procedure setProcess(gameWindow:THandle);
var
  pid:DWORD;
begin
  if IsWindow(gameWindow) then
  begin
    GetWindowThreadProcessId(gameWindow, @pid);
    processHandle := OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
  end;
end;

procedure closeProcess();
begin
  CloseHandle(processHandle);
end;

procedure WriteBytes(address:DWORD; value,bytes: integer);
var
  no:DWORD;
  buf: PChar;
begin
  no := 0;
  GetMem(buf, 1);
  buf^ := Chr(Value);
  WriteProcessMemory(processHandle, ptr(address), @buf, bytes, no);
  FreeMem(buf);
end;

function ReadBytes(address:DWORD; bytes: integer):pchar;
var
  no:DWORD;
  buf: pchar;
begin
  buf := 0;
  no := 0;
  ReadProcessMemory(processHandle, ptr(address), @buf, bytes, no);
  result := buf;
end;

procedure WriteString(address:DWORD; value: string);
const nullTerminator = $00;
var
  no:DWORD;
  i,j,len: integer;
begin
  no := 0;
  len := length(value);
  j := 0;
  for i:=0 to len do
  begin
    WriteProcessMemory(processHandle, ptr(address+j), pchar(@value[i]), 1, no);
    inc(j);
  end;
  WriteProcessMemory(processHandle, ptr(address+j), pchar(nullTerminator), 1, no);
end;

function ReadString(address:DWORD): string;
var
  no:DWORD;
  i:integer;
  s:string;
  buf: array of char;
begin
  no := 0;
  s := '';
  setlength(buf,255);
    ReadProcessMemory(processHandle, ptr(address), @buf, 1, no);
    for i:=0 to 255 do
    begin
      s := s + buf[i];
    end;
  result := s;
end;

procedure WriteNops(address:DWORD; nops: integer);
const nop = $90;
var
  no:DWORD;
  i,j:integer;
begin
  no := 0;
  j := 0;
  for i:=0 to nops do
  begin
    WriteProcessMemory(processHandle, ptr(address+j), pchar(nop), 1, no);
    inc(j);
  end;
end;



end.

[Ranmus]

A można wiedzieć co sobie tłumaczysz? Czy jest w ogóle sens? To jakiś silnik, biblioteka?

[Pieter]

poprostu napisałem że ten kod co tam jest w c++ (ten pierwszy) przetłumaczyłem na ten w delphi (ten drógi) i chce wiedzieć czy dobrze przetłumaczyłem i czy nie będzie jakiś problemów a nie mam jak tego sprawdzić :/

 

EDIT: tak tłumacze silnik dla celów osobistych. Już nie raz zdarzało mi się tłumaczyć języki na delphi np visual basica itd więc mam wprawę :P

 

EDIT

 

Dobra ostatnia sprawa bo ten kod mi nie działa co go próbowałem przetłumaczyć. CZY ZNA SIĘ KTOŚ TU NA C++ I POTRAFIŁ BY MI NAPISAĆ DLL'A Z TEJ BIBLIOTEKI? To jest mało bo tylko 5 krótkich funkcji proszę niech się ktoś tym zajmie. Dodam do credits :)

 

http://www.gmxxl.ovh.org/trainer.zip

[Pieter]

sorry za doubleposta ale powiedźcie mi chociaż czy to jest dobrze przetłumaczone:

void CTrainer::writeString(DWORD address, std::string value)
{    
    unsigned char nullTerminator = 0x00;

    int j = 0;
    for(unsigned int i = 0; i < value.size(); i++)
    {
        ::WriteProcessMemory(processHandle, reinterpret_cast<void*>(address + j), &value[i], 1, 0);
        j++; // increment address
    }
    ::WriteProcessMemory(processHandle, reinterpret_cast<void*>(address + j), &nullTerminator, 1, 0);
}

 

na

 

procedure WriteString(address:DWORD; value: string);
var
  no:DWORD;
  i,j,len: integer;
  nullTerminator:integer;
begin
  no := 0;
  nullTerminator := $00;
  len := length(value);
  j := 0;
  for i:=0 to len-1 do
  begin
    WriteProcessMemory(processHandle, ptr(address+j), @value[i], 1, no);
    inc(j);
  end;
  WriteProcessMemory(processHandle, ptr(address+j), @nullTerminator, 1, no);
end;