vergleichen von zwei librarys im speicher

[brechi]

stimmt bei dem add könnte durch ne reclocation geändert worden sein
die ersten 6 bytes müssen (64A118000000) aber stimmen und wenn instruction 2 nen ADD ist musst halt schaun ob der wert in der opengl32.dll liegt

das eigentlich bei jeder gl funktion bei 9x + einigen bei 2k und XP SP < 2
XP SP4 hat hingegen noch en veränderte form davon

ums hier mla zu zeigen:

glBegin ( ALLE NT systeme )

693A29C0 > 64:A1 18000000 MOV EAX,DWORD PTR FS:[18]
693A29C6 FFA0 CC070000 JMP DWORD PTR DS:[EAX+7CC]

glShadeModel (9x + alle NT ausser XP SP2)

693A38B4 > 64:A1 18000000 MOV EAX,DWORD PTR FS:[18]
693A38BA 8BD0 MOV EDX,EAX
693A38BC 0315 28F84569 ADD EDX,DWORD PTR DS:[6945F828] // die adresse is überall anders
693A38C2 8B12 MOV EDX,DWORD PTR DS:[EDX]
693A38C4 FFA2 C4020000 JMP DWORD PTR DS:[EDX+2C4] //adresse kann anders sein auch von länge des opcodes her

das glBegin unter 9x hat den selben aufbau wie das glShadeModel (oben) auch mit dem selben jmp 7CC

da ich gerade net XP SP 2 hab kann ich dir die 3. variante aber net zeigen
die bezieht sich aber auch nur auf die funktion wie glShadeModel die gibt es da nicht mehr sondern sieht wieder ander aus

jedefalls ist es wirklich leicht das zu erkennen wenn da nen zusätzlicher jump ist / der aufbau nicht simmt

um nochmal zu vervollständigen, pharlaps openglhack sowie der OGC SE von mir ändern direkt die adresse bei
JMP DWORD PTR DS:[EAX+7CC] ab

das ist nicht so leicht zu erkennen, da das der treiber unter umständen auch mal öfters macht und diese adresse auch net zwingen in den treiber zeigen muss, bei den eneuren allociert der treiber selbst speicher und schreibt einige funktionen da rein

[NicoDE]

Nützliches Zeug für das Einlesen der exportierten Funktionen aus der DLL (MMF) und der geladenen Version im Speicher (ohne GetProcAddress):

MMF: (todo: Anpassungen und spezielle Validierungen für dieses Projekt)
TDLLInfo.ReadExportDirectory

Mem: (todo: spezielle Validierungen für dieses Projekt)

Delphi-Quellcode:

function GetProcAddressPE32(Module: HMODULE; ProcName: LPCSTR): TFarProc;
type
  PWordArray = ^TWordArray;
  TWordArray = array [Word] of WORD;
  PDWordArray = ^TDWordArray;
  TDWordArray = array [Word] of DWORD;
var
  NtHeaders: PImageNtHeaders;
  ExpDatDir: PImageDataDirectory;
  ExportDir: PImageExportDirectory;
  Functions: PDWordArray;
  FuncIndex: DWORD;
  Ordinals: PWordArray;
  OrdIndex: DWORD;
  Names: PDWordArray;
  ModName: array [0..MAX_PATH] of AnsiChar;
  OrdStrLo: DWORD;
  OrdStrHi: DWORD;
  SCompare: Integer;
  function RvaToVa(Rva: DWORD): Pointer;
  begin
    Result := Pointer(Cardinal(Module) + Rva);
  end;
  function IsForwarderRva(Rva: DWORD): Boolean;
  begin
    Result := (Rva >= ExpDatDir.VirtualAddress) and
      (Rva < ExpDatDir.VirtualAddress + ExpDatDir.Size);
  end;
begin
  Result := nil;
  if HMODULE(nil) = Module then
  begin
    SetLastError(ERROR_INVALID_PARAMETER);
    Exit;
  end;
  with PImageDosHeader(Module)^ do
    if (IMAGE_DOS_SIGNATURE = e_magic) and (e_lfanew > 0) then
      NtHeaders := PImageNtHeaders(Cardinal(Module) + DWORD(e_lfanew))
    else
      NtHeaders := PImageNtHeaders(Module);
  with NtHeaders^, FileHeader, OptionalHeader do
    if (IMAGE_NT_SIGNATURE = Signature) and
      (SizeOfOptionalHeader >= SizeOf(TImageOptionalHeader) -
        SizeOf(DataDirectory) + SizeOf(TImageDataDirectory)) and
      (IMAGE_NT_OPTIONAL_HDR_MAGIC = Magic) then
    begin
      ExpDatDir := Addr(DataDirectory[0]);
      ExportDir := RvaToVa(ExpDatDir.VirtualAddress);
    end
    else
    begin
      SetLastError(ERROR_INVALID_DATA);
      Exit;
    end;
  if (0 = ExpDatDir.Size) or (nil = ExportDir) then
  begin
    SetLastError(ERROR_PROC_NOT_FOUND);
    Exit;
  end;
  Functions := RvaToVa(Cardinal(ExportDir.AddressOfFunctions));
  Ordinals := RvaToVa(Cardinal(ExportDir.AddressOfNameOrdinals));
  Names := RvaToVa(Cardinal(ExportDir.AddressOfNames));
  if nil = Functions then
  begin
    SetLastError(ERROR_PROC_NOT_FOUND);
    Exit;
  end;
  // Checks done ;)
  if Cardinal(ProcName) <= MAXWORD then
  begin
    // Import by Oridinal
    FuncIndex := Cardinal(ProcName) - Cardinal(ExportDir.Base);
    if (FuncIndex >= ExportDir.NumberOfFunctions) or
      (0 = Functions[FuncIndex]) then
      SetLastError(ERROR_PROC_NOT_FOUND)
    else
    begin
      if IsForwarderRva(Functions[FuncIndex]) then
      begin
        // Forwarder
        ProcName := lstrcpynA(PAnsiChar(Addr(ModName[0])),
          PAnsiChar(RvaToVa(Functions[FuncIndex])), MAX_PATH);
        while ProcName[0] <> #0 do
          if ProcName[0] <> '.' then
            Inc(ProcName)
          else
          begin
            ProcName[0] := #0;
            Break;
          end;
        ProcName := PAnsiChar(Cardinal(RvaToVa(Functions[FuncIndex])) +
          Cardinal(lstrlenA(PAnsiChar(Addr(ModName[0])))));
        if ProcName[0] <> '.' then
          SetLastError(ERROR_INVALID_DATA)
        else
        begin
          Inc(ProcName);
          Module := HMODULE(GetModuleHandleA(PAnsiChar(Addr(ModName[0]))));
          if HMODULE(nil) = Module then
            SetLastError(ERROR_MOD_NOT_FOUND)
          else
            Result := GetProcAddressPE32(Module, ProcName);
        end;
      end
      else
        // Function RVA
        Result := TFarProc(RvaToVa(Functions[FuncIndex]));
    end;
  end
  else
  begin
    // Import by Name
    OrdStrLo := 0;
    OrdStrHi := DWORD(Integer(ExportDir.NumberOfNames) - 1);
    while OrdStrLo <= OrdStrHi do
    begin
      OrdIndex := (OrdStrHi - OrdStrLo) div 2 + OrdStrLo;
      SCompare := lstrcmpA(ProcName, PAnsiChar(RvaToVa(Names[OrdIndex])));
      if 0 = SCompare then
      begin
        // Resolve by Ordinal
        Result := GetProcAddressPE32(Module,
          PAnsiChar(Ordinals[OrdIndex] + ExportDir.Base));
        Exit;
      end;
      if SCompare < 0 then
        OrdStrHi := OrdIndex - 1
      else
        OrdStrLo := OrdIndex + 1;
    end;
    SetLastError(ERROR_PROC_NOT_FOUND);
  end;
end;

Die beiden dürften als Vorlage relativ nützlich sein (der Code unterstützt auch Forwarder). Das ganze Projekt kann ich nicht veröffentlichen, da ich nicht das alleinige Copyright darauf habe... könnte also sein, dass ein paar Typen und Konstanten fehlen (sollten alle im MSDN/PSDK zu finden sein).

Gruß Nico

[brechi]

wüßte aber nicht warum man extra nen ProcAddres bauen muss, da der check eh im eigenen Programm gemacht wird und wenn man die dll mir LoadLibrary lädt + die gleiche aus dem zielprozess holt, müsste ja die Exportierte funktion in relation stehen zu den beiden basen.

[NicoDE]

Zitat:

Zitat von brechi

wüßte aber nicht warum man extra nen ProcAddres bauen muss, [...]

Um den Inhalt der DLL mit der Version im Speicher zu vergleichen. Und um GetProcAddress zu validieren (könnte umgeleitet worden sein)...

[brechi]

ja moment

umgeleitet in der eigene exe nicht
im zielprozess würde sie dann nur durch die importtabelle umgeleitet worden sein, weil die änderungen an der export tabelle keine auswirkungen auf die engine haben wenn diese einmal die daten geladen hat.

eigentlich reicht das checken der importtabelle von der engine (bei hl z.b. die hw.dll [hardware.dll])
sowie das setzen eines jumpes

exporttabelle checken ist eher optional, wenn dann würd ich lieber nen relocation check machen (hab ich mal für jemanden geproggd, weil nen importtablehook nicht die funktionen catched die synamisch mit GPA geladen wurden)

[NicoDE]

Es gibt so viele Möglichkeiten (hast ja bereits etliche aufgezählt)...
Ich meinte konkret den Fall, dass jemand Code in die OpenGL32.dll eingeschleust hat (in das Code-Segment; ein Check auf 'außerhalb' würde nichts finden) bzw, dass man auf generischem Wege a) den Code binär vergleichen oder b) den Offset der Funktion in der Jump-Tabelle ermitteln möchte...

[brechi]

hier mal ne detection für die codeoverwrite hooks

www.uall.info/sources/detect1.dpr

[Arnulf]

mami - da komm ich mit nachdenken und lesen nimmern nach....
die detect1.dpr hab ich mir auch schon zusammen gebastelt (auch aus brechis source) - aber wenns schon so serviert wird :)

das sollte mal mein problem lösen mit dem range check error.
und es ist richtig - es gibt noch cheats die über importtable hooken - die werden natürlich so nicht erkannt.

was oben mal erwähnt wurde, die tables der engine zu checken ist mir nicht ganz klar, weil ich bisher so einen cheat noch nicht gesehen hab. Ich hab mich ja nur mit bekannten cheats beschäftigt. Aber das game muß ja die openg gl funktionen auch benutzen also ergibt es nachtürlich sinn das auch von der seite aufzurollen.

Ich versuch das mal zusammen zu stellen und zu testen, dann zu veröffentlichen, einige leute warten schon sehr auf eine funktionierende version - hab leider die fehlerhafte veröffentlicht.
nicode - deine source muß ich auch noch durchackern :) - aber dafür brauch ich nen gemütlichen abend und ein bier....

Arnulf

[Arnulf]

Also ich habs mir jetzt einfach gemacht, und aus detect1.dpr einfach eine unit gemacht und die ins programm compiliert.
Funktioniert laut meinen testern sehr gut und ich hab das update fertig ( endlich ).
Danke und brechi steht selbstverständlich als creator von dem check in den credits.

Jedenfalls gehts es jetzt darum import/export und relocation table zu checken.
Ich hab das früher schon mal probiert und auch gefragt ob das zu grundsätzlich richtig ist:
http://www.delphipraxis.net/internal...t=import+table

Ich weiß einfach nicht, ob das völliger unsinn ist oder so funktioniert.
Relocation Table ist da nicht dabei, weil ich mir einfach nicht ganz im klaren darüber bin was das genau ist.
Im sinne eines dos headers ist mir Relocation ein begriff, aber hier kenn ich die einfach nicht.

Könnte das so funktionieren?

Arnulf