vergleichen von zwei librarys im speicher

[Arnulf]

Hm ich habs jetzt so ausprobiert:

Delphi-Quellcode:

       pbytearray(p2)[i] := Byte(PByteArray(p2)[i] - PByteArray(p1)[i]);

hier gibts gleich range check error - ohne cheat.

Damit gibts nur mit cheat range check error

Delphi-Quellcode:

pbyte(cardinal(p2)+i)^ := pbyte(cardinal(p2)+i)^-pbyte(cardinal(p1)+i)^;

seltsam das alles :) - ich könnte das natürlich wieder mit IF machen, aber das subtrahieren ist vermutlich einfach schneller als das vergleichen.
Arnulf

[NicoDE]

Wenn es keinen anderen Weg gibt, dann deaktiviere es mit

Delphi-Quellcode:

{$RANGECHECK OFF}
//...
{$IFDEF DEBUG}
  {$RANGECHECK ON}
{$ENDIF DEBUG}

[Arnulf]

Nagut ich hab es jetzt mal so gemacht.

Delphi-Quellcode:

{$RANGECHECKS OFF}
   for i := 0 to size-1 do
      pbyte(cardinal(p2)+i)^ := pbyte(cardinal(p2)+i)^-pbyte(cardinal(p1)+i)^;
        //pbytearray(p2)[i] := Byte(PByteArray(p2)[i] - PByteArray(p1)[i]);
{$IFDEF DEBUG}
  {$RANGECHECKS ON}
{$ENDIF DEBUG}

Mal sehen was die grafikkarten treiber dazu sagen :) - warum es damit probleme gab ist mir immer noch schleierhaft.
Aber so geht es jetzt wenigstens - lustige idee range checks auszuschalten lol.
Danke jedenfalls.
Arnulf

[brechi]

hau einfach nen VirtualProtect auf beide adressen bevor du die schleife ausführst
oder teste vorher mit IsReadPtr ob du überhaupt den speicher lesen kannst bzw IsBadWritePtr scheirben kannst (das aber nur wichtig für die dll die du mit LoadLibraryA vorher lädst)

[Arnulf]

Hi
Also ich hab mal beides probiert :) aber es gibt immer noch range check errors.
LoadlibraryA verwende ich übrigens garnicht, kenn den befehl nichtmal.

Delphi-Quellcode:

virtualprotect(p1,size,PAGE_READONLY, oldprotect1);
virtualprotect(p2,size,PAGE_READWRITE, oldprotect2);
if not IsbadReadPtr(p2,size) or not isbadwritePtr(p2,size) then
   for i := 0 to size-1 do
       pbyte(cardinal(p2)+i)^ := pbyte(cardinal(p2)+i)^-pbyte(cardinal(p1)+i)^;

Auch VirtualProtect oder IsbadReadPtr hab ich noch nie verwendet :) - vielleicht ist es ja so einfach falsch.
Übrigens wollte ich dich, da du ja die source geschrieben hast zu den credits dazu schreiben.
Allerdings wollte ich dich vorher fragen, will ja deinen ruf als hacker nicht ruinieren :).

Arnulf

[brechi]

das mir bob bin eh nur bei CS bekannt

Delphi-Quellcode:

virtualprotect(p1,size,PAGE_EXECUTE_READWRITE, oldprotect1); 
   for i := 0 to size-1 do 
       pbyte(cardinal(p2)+i)^ := pbyte(cardinal(p2)+i)^-pbyte(cardinal(p1)+i)^;
virtualprotect(p1,size,oldprotect1, oldprotect1);

[Arnulf]

brrr... das geht auch nicht lol.
jedenfalls geb ich dir mal ein paar links vielleicht wird dann einiges klar.

screenshot von rangecheck error:
http://212.112.224.207/toe/rangecheck.jpg
der eigentliche cheat den ich damit checke:
http://212.112.224.207/toe/glpatc.exe
und die unit die ich aus deiner source gebastelt hab:
http://212.112.224.207/toe/uMemScanner.pas

Naja wenn das läuft und ich das veröffentlichen kann, schreib ich dich dazu :)

Arnulf

[brechi]

ich schua mir das morgen mal an, aber guck mal nach ob size überhaupt stimmt oder ob das negativ ist

[NicoDE]

Ich habe einen kleinen Detection-Code für den Target geschrieben, die darauf basiert, dass die Protection einer Speicherseite der Exporte (glBegin) PAGE_EXECUTE_READWRITE ist...

Delphi-Quellcode:

////////////////////////////////////////////////////////////////////////////////
// GetOpenGL32Infos

type
  POpenGL32Infos = ^TOpenGL32Infos;
  TOpenGL32Infos = record
    BaseOfCode: Longword;
    SizeOfCode: Longword;
  end;

function GetOpenGL32Infos(var Info: TOpenGL32Infos): Boolean;
const
  INVALID_FILE_SIZE = DWORD(-1);
  INVALID_SET_FILE_POINTER = DWORD(-1);
  opengl32lib = '\opengl32.dll';
var
  FileName: array [0..MAX_PATH + Length(opengl32lib)] of Char;
  FileHandle: THandle;
  DosHeader: TImageDosHeader;
  BytesRead: DWORD;
  NtHeaders: TImageNtHeaders;
begin
  Result := False;
  GetSystemDirectory(FileName, MAX_PATH);
  StrCat(FileName, opengl32lib);
  FileHandle := CreateFile(FileName, GENERIC_READ, FILE_SHARE_READ, nil,
    OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, THandle(nil));
  if INVALID_HANDLE_VALUE = FileHandle then
    Exit;
  try
    with DosHeader, NtHeaders, NtHeaders.FileHeader, NtHeaders.OptionalHeader do
    begin
      // Get Headers
      if not ReadFile(FileHandle, DosHeader, SizeOf(TImageDosHeader), BytesRead,
          nil) or (BytesRead <> SizeOf(TImageDosHeader)) or
        (e_magic <> IMAGE_DOS_SIGNATURE) or
        (_lfanew < SizeOf(TImageDosHeader)) or
        (INVALID_SET_FILE_POINTER = SetFilePointer(FileHandle,
          _lfanew - SizeOf(TImageDosHeader), nil, FILE_CURRENT)) or
        not ReadFile(FileHandle, NtHeaders, SizeOf(TImageNtHeaders), BytesRead,
          nil) or (BytesRead <> SizeOf(TImageNtHeaders)) or
        (Signature <> IMAGE_NT_SIGNATURE) or (NumberOfSections <= 0) or
        (SizeOfOptionalHeader < SizeOf(TImageOptionalHeader)) then
        Exit;
      // Write Infos
      Info.BaseOfCode := ImageBase + BaseOfCode;
      Info.SizeOfCode := SizeOfCode;
      Result := True;
    end;
  finally
    CloseHandle(FileHandle);
  end;
end;

////////////////////////////////////////////////////////////////////////////////
// DetectOpenGL32Patch

var
  OpenGL32InfosValid: Boolean;
  OpenGL32Infos: TOpenGL32Infos;
  OpenGL32Modul: HMODULE;
  OpenGL32Begin: Pointer;

function DetectOpenGL32Patch: Boolean;
var
  Adr: Cardinal;
  Mbi: TMemoryBasicInformation;
begin
  Result := False;
  if not OpenGL32InfosValid or
    (HMODULE(nil) = OpenGL32Modul) or
    (nil = OpenGL32Begin) then
    Exit;
  Adr := Cardinal(OpenGL32Begin);
  Result :=
    // check if opengl32!glBegin is outside of the code section...
    (Adr < OpenGL32Infos.BaseOfCode) or
    (Adr > OpenGL32Infos.BaseOfCode + OpenGL32Infos.SizeOfCode) or
    // check if the memory page of opengl32!glBegin is writable...
    (
      (VirtualQuery(Pointer(Adr), Mbi, SizeOf(Mbi)) = SizeOf(Mbi)) and
      (Mbi.Protect = PAGE_EXECUTE_READWRITE)
    );
end;

function DetectOpenGL32PatchEx(ProcessId: DWORD): Boolean;
var
  Prc: THandle;
  Mbi: TMemoryBasicInformation;
begin
  Result := False;
  if not OpenGL32InfosValid or
    (HMODULE(nil) = OpenGL32Modul) or
    (nil = OpenGL32Begin) then
    Exit;
  Prc := OpenProcess(PROCESS_QUERY_INFORMATION, False, ProcessId);
  if THandle(nil) = Prc then
    Exit;
  try
    Result :=
      // check if the memory page of opengl32!glBegin is writable...
      (VirtualQueryEx(Prc, OpenGL32Begin, Mbi, SizeOf(Mbi)) = SizeOf(Mbi)) and
      (Mbi.Protect = PAGE_EXECUTE_READWRITE);
  finally
    CloseHandle(Prc);
  end;
end;

////////////////////////////////////////////////////////////////////////////////
// Check

procedure TForm1.Button1Click(Sender: TObject);
begin
  ShowMessage(BoolToStr(DetectOpenGL32Patch, True));
end;

////////////////////////////////////////////////////////////////////////////////
// Init

initialization

  OpenGL32InfosValid := GetOpenGL32Infos(OpenGL32Infos);
  OpenGL32Modul := LoadLibrary('opengl32.dll');
  OpenGL32Begin := GetProcAddress(OpenGL32Modul, 'glBegin');

Mögliches Problem: die Seite könnte absichtlich PAGE_EXECUTE_READWRITE sein (unwahrscheinlich ohne Manipulation).


Gruß Nico

[brechi]

das bringt fast agr nichts.

jeder normale cheatcoder setzt nachdem er die daten überschriebn hat die page wieder auf den alten status

wie z.b. hier:

Delphi-Quellcode:

  virtualprotect(p1,size,PAGE_EXECUTE_READWRITE, oldprotect1); 
   for i := 0 to size-1 do 
       pbyte(cardinal(p2)+i)^ := pbyte(cardinal(p2)+i)^-pbyte(cardinal(p1)+i)^; 
  virtualprotect(p1,size,oldprotect1, oldprotect1);

desweiteren ändern jeder neuere cheat nichst mehr an der opengl32.dll sondern direkt im treiber