Hooken der RecvFrom() Methode mittels uALLCollection

[C0pa]

DLL Code:

Delphi-Quellcode:

library hook;

uses
  Windows,
  uallHook;

{$R *.res}

type
  TsendMethod = function(s: DWord; Buf : Pointer; Len, Flags: Integer): Integer; stdcall;
  TsendToMethod = function(s: DWord; var Buf; len, flags: Integer; var addrto: DWord; tolen: Integer): Integer; stdcall;
  TrecvMethod = function(s: DWord; Buf : Pointer; Len, Flags: Integer): Integer; stdcall;
  TrecvFromMethod = function(s: DWord; var Buf; len, flags: Integer; var from: DWord; var fromlen: Integer): Integer; stdcall;
               
var
  orgiSend, newSend          : TsendMethod;
  orgiRecv, newRecv          : TrecvMethod;
  orgiSendto, newSendTo      : TsendToMethod;
  orgiRecvFrom, newRecvFrom  : TrecvFromMethod;


function callbackSend(s: DWord; Buf : Pointer; Len, Flags: Integer): Integer; stdcall;
begin
  Result := newSend(s, Buf, Len, Flags);
end;

function callbackSendTo(s: DWord; var Buf; len, flags: Integer; var addrto: DWord;  tolen: Integer): Integer; stdcall;  
begin
  Result := newSendTo(s, Buf, Len, Flags, addrto, tolen);
end;


function callbackRecv(s: DWord; Buf : Pointer; Len, Flags: Integer): Integer; stdcall;   
begin
  Result := newRecv(s, Buf, Len, Flags);
end;

function callbackRecvFrom(s: DWord; var Buf; len, flags: Integer; var from: DWord; var fromlen: Integer): Integer; stdcall;     
begin
    Result := newRecvFrom(s, Buf, Len, Flags, from, fromlen);
end;

procedure injectmain;
var
  h: integer;
begin
  @orgiSend := nil;
  @orgiSendto := nil;
  @orgiRecv := nil;
  @orgiRecvFrom := nil;

  h :=  GetModuleHandle('ws2_32.dll');
  if (h > 0) then
  begin
    @orgiSend := GetProcAddress(h,'send'); 
    if (@orgiSend <> nil) and
       not(HookCode(@orgiSend, @callbackSend, @newSend)) then
      MessageBox(0, 'orgiSend', 'Something went wrong!', 0);

    @orgiSendto := GetProcAddress(h,'sendto'); 
    if (@orgiSendto <> nil) and
       not(HookCode(@orgiSendto, @callbackSendto, @newSendTo)) then
      MessageBox(0, 'orgiSendto', 'Something went wrong!', 0);

    @orgiRecv := GetProcAddress(h,'recv');
    if (@orgiRecv <> nil) and
       not(HookCode(@orgiRecv, @callbackRecv, @newRecv)) then
      MessageBox(0, 'orgiRecv', 'Something went wrong!', 0);

    @orgiRecvFrom := GetProcAddress(h,'recvfrom');
    if (@orgiRecvFrom <> nil) and
       not(HookCode(@orgiRecvFrom, @callbackRecvFrom, @newRecvFrom)) then
      MessageBox(0, 'orgiRecvFrom', 'Something went wrong!', 0);
  end;
end;

procedure uninjectmain;
begin
  if (@orgiSend <> nil) and not(UnhookCode(@newSend)) then
      MessageBox(0, 'orgiSend', 'Something went wrong!', 0);
  if (@orgiSendto <> nil) and not(UnhookCode(@newSendTo)) then
      MessageBox(0, 'orgiSendto', 'Something went wrong!', 0);
  if (@orgiRecv <> nil) and not(UnhookCode(@newRecv)) then
      MessageBox(0, 'orgiRecv', 'Something went wrong!', 0);
  if (@orgiRecvFrom <> nil) and not(UnhookCode(@newRecvFrom)) then
      MessageBox(0, 'orgiRecvFrom', 'Something went wrong!', 0);
end;


procedure dllmain(dwReason: integer);
begin
    case dwreason of
      DLL_PROCESS_ATTACH:
        injectmain;
      DLL_PROCESS_DETACH:
        uninjectmain;
    end;
end;

begin
  DLLProc := @DLLMain;
  DLLMain(1);
end.

Also hier das ganze ohne IPC. Ich bekomme weder beim injecten noch beim uninjecten eine der Messageboxen gezeigt.

Das ist der Code meiner Hauptanwendung

Delphi-Quellcode:

unit main;

interface

uses
  Windows, Forms, Controls, StdCtrls, Classes;

type
  TForm1 = class(TForm)
    Button2: TButton;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

const
  process = 'Garena.exe';

var
  Form1: TForm1;

implementation

{$R *.dfm}

uses
  uallHook, uallUtil, uallProcess;

procedure TForm1.Button1Click(Sender: TObject);
begin
  if (InjectLibrary(FindProcess(process), PChar(uallUtil.GetExeDirectory+'hook.dll')) ) then
    MessageBox(0, 'DLL Injected', 'Info', 0);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  if (UnloadLibrary(FindProcess(process), PChar(uallUtil.GetExeDirectory+'hook.dll')) ) then 
    MessageBox(0, 'DLL Uninjected', 'Info', 0);
end;

end.

Ich bekomme beide Nachrichten angezeigt. Also wenn das Programm startet injecte ich die DLL. Dann läuft alles wunderbar. Wenn ich nun die DLL uninjecte funktioniert alles noch so lang gut, bis bei dem Programm wieder ein Paket empfangen oder gesendet wird. Sprich wenn ich die DLL nicht uninjecte scheint alles ordnungsgemäß zu funktionieren, aber beim Uninjecten wird irgendwas falsch zurück gesetzt, wodurch beim Nächsten Eintreffen eines Pakets mir das Programm abstürzt.

[C0pa]

*push*
:duck:

[CorVu5]

Ich bin alles andere als ein Experte, aber wie wäre es, wenn du mal testweise "sharemem" als Unit hinzufügst?

[C0pa]

Daran kann es meiner Meinung nach gar nicht leigen.

[Zacherl]

Versuch testweise vielleicht mal eine andere Hooking Unit.

[mleyen]

Kannst du es evtl. an einem anderen Programm testen, ansatt direkt an einem Anticheatsystem?

[C0pa]

Aber beim AppSniffer gibt es doch auch keine Probleme.

[Zacherl]

Zitat:

Zitat von C0pa (Beitrag 1027357)

Aber beim AppSniffer gibt es doch auch keine Probleme.

Zitat:

Zitat von Zacherl (Beitrag 1027187)

Versuch testweise vielleicht mal eine andere Hooking Unit.

Was benutzt der AppSniffer denn zum hooken? Da du außer den Hook & Unhook Funktionen nichts anderes aufrufst, scheint es da wohl mit der uallHook Unit irgendwie Probleme geben. Das Teil hat früher bei mir immer gut funktioniert, aber probier einfach mal meine eigenen Hooking Funktionen aus:

Delphi-Quellcode:

function HookCodeInline(SourceFunction, CallbackFunction: Pointer;
  var OldFunction: Pointer): Boolean;
function UnhookCodeInline(var OldFunction: Pointer): Boolean;
function IsInlineHooked(Address: Pointer): Boolean;

Delphi-Quellcode:

type
  TJumpCode = packed record
    Push: Byte;
    Addr: Pointer;
    Ret: Byte;
  end;

function HookCodeInline(SourceFunction, CallbackFunction: Pointer;
  var OldFunction: Pointer): Boolean;
var
  HDE: hde32s;
  JumpCode: TJumpCode;
  dwAllocSize,
  dwOldProtect: DWord;
begin
  Result := false;
  if (not Assigned(SourceFunction)) or (not Assigned(CallbackFunction)) then
    Exit;
  // Anzahl der Bytes ermitteln
  dwAllocSize := 0;
  repeat
    HDE32.hde32_disasm(Pointer(Cardinal(SourceFunction) + dwAllocSize), HDE);
    Inc(dwAllocSize, HDE.len);
  until dwAllocSize >= SizeOf(TJumpCode);
  // JumpCode initialisieren
  JumpCode.Push := $68;
  JumpCode.Ret := $C3;
  // Code Protection ändern
  if not VirtualProtect(SourceFunction, dwAllocSize, PAGE_EXECUTE_READWRITE,
    dwOldProtect) then
    Exit;
  try
    // Speicher für die neue Funktion alloziieren
    OldFunction := VirtualAlloc(nil, dwAllocSize + SizeOf(TJumpCode),
      MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if not Assigned(OldFunction) then
      Exit;
    // Alte Opcodes sichern
    CopyMemory(OldFunction, SourceFunction, dwAllocSize);
    JumpCode.Addr := Pointer(DWord(SourceFunction) + dwAllocSize);
    CopyMemory(Pointer(DWord(OldFunction) + dwAllocSize), @JumpCode, SizeOf(
      TJumpCode));
    // Originalfunktion hooken
    JumpCode.Addr := CallbackFunction;
    CopyMemory(SourceFunction, @JumpCode, SizeOf(TJumpCode));
    Result := true;
  except
    // Speicher freigeben
    VirtualFree(OldFunction, dwAllocSize + SizeOf(TJumpCode), MEM_RELEASE);
  end;
  // Code Protection wiederherstellen
  VirtualProtect(SourceFunction, SizeOf(TJumpCode), dwOldProtect, dwOldProtect);
end;

function UnhookCodeInline(var OldFunction: Pointer): Boolean;
var
  HDE: hde32s;
  JumpCode: TJumpCode;
  dwAllocSize,
  dwOldProtect: DWord;
begin
  Result := false;
  if not Assigned(OldFunction) then
    Exit;
  // Anzahl der Bytes ermitteln
  dwAllocSize := 0;
  repeat
    HDE32.hde32_disasm(Pointer(Cardinal(OldFunction) + dwAllocSize), HDE);
    Inc(dwAllocSize, HDE.len);
  until dwAllocSize >= SizeOf(TJumpCode);
  // Originalfunktion ermitteln
  CopyMemory(@JumpCode, Pointer(DWord(OldFunction) + dwAllocSize), SizeOf(
    TJumpCode));
  if (JumpCode.Push <> $68) or (JumpCode.Ret <> $C3) then
    Exit;
  // Code Protection ändern
  if (not VirtualProtect(Pointer(DWord(JumpCode.Addr) - dwAllocSize), SizeOf(
    TJumpCode), PAGE_EXECUTE_READWRITE, dwOldProtect)) then
    Exit;
  // Opcode wiederherstellen
  CopyMemory(Pointer(DWord(JumpCode.Addr) - dwAllocSize), OldFunction, SizeOf(
    TJumpCode));
  // Code Protection wiederherstellen
  Result := VirtualProtect(Pointer(DWord(JumpCode.Addr) - dwAllocSize), SizeOf(
    TJumpCode), dwOldProtect, dwOldProtect);
  // Speicher freigeben
  VirtualFree(OldFunction, dwAllocSize + SizeOf(TJumpCode), MEM_RELEASE);
  OldFunction := nil;
end;

function IsInlineHooked(Address: Pointer): Boolean;
var
  JumpCode: TJumpCode;
begin
  CopyMemory(@JumpCode, Address, SizeOf(TJumpCode));
  Result := (JumpCode.Push = $68) or (JumpCode.Ret = $C3);
end;

Du brauchst außerdem noch die HDE32.pas und HDE32.obj, die du im Anhang findest.

[C0pa]

Vielen Dank ;)
Der AppSniffer benutzt die madCollection. => kostenpflichtig

Heute komme ich wahrscheinlich nicht mehr dazu, aber morgen werde ich den Ansatz gleich durchprobieren.