Hooken der RecvFrom() Methode mittels uALLCollection

[C0pa]

Ich sitze jetzt schon mehr als 20h an einem Funktionshook.

Delphi-Quellcode:

library hook;

uses
  SysUtils,
  Classes,
  Windows,
  uallHook,
  WinSock,
  Messages,
  Variants,
  WinSock2 in 'WinSock2.pas',
  IPC in 'IPC.pas';

{$R *.res}

type
  TsendMethod = function(s: TSocket; Buf : Pointer; Len, Flags: Integer): Integer; stdcall;
  TsendToMethod = function(s: TSocket; var Buf; len, flags: Integer; var addrto: TSockAddr;  tolen: Integer): Integer; stdcall;
  TrecvMethod = function(s: TSocket; Buf : Pointer; Len, Flags: Integer): Integer; stdcall;
  TrecvFromMethod = function(s: TSocket; var Buf; len, flags: Integer; var from: TSockAddr; var fromlen: Integer): Integer; stdcall;

var
  orgiSend      : TsendMethod;
  orgiRecv      : TrecvMethod;
  orgiSendto    : TsendToMethod;
  orgiRecvFrom  : TrecvFromMethod;

procedure informMaster(func:Integer);
var
  data: TIPCData;
begin
  data.s := '';
  data.func := func;
  IPC.sendData(data);
end;

function callbackSend(s: TSocket; Buf : Pointer; Len, Flags: Integer): Integer; stdcall;
begin
  Result := orgiSend(s, Buf, Len, Flags);
  informMaster(1);
end;

function callbackSendTo(s: TSocket; var Buf; len, flags: Integer; var addrto: TSockAddr;  tolen: Integer): Integer; stdcall;  
begin
  Result := orgiSendTo(s, Buf, Len, Flags, addrto, tolen);   
  informMaster(2);
end;


function callbackRecv(s: TSocket; Buf : Pointer; Len, Flags: Integer): Integer; stdcall;
begin
  Result := orgiRecv(s, Buf, Len, Flags); 
  informMaster(3);
end;

function callbackRecvFrom(s: TSocket; var Buf; len, flags: Integer; var from: TSockAddr; var fromlen: Integer): Integer; stdcall;
begin
  Result := orgiRecvFrom(s, Buf, Len, Flags, from, fromlen);
  informMaster(4);
end;

procedure injectmain;
begin
  //MessageBox(0, 'Its me', '', 0);     
  if not(HookApiIAT('ws2_32.dll', 'recvfrom',@callbackRecvFrom, @orgiRecvFrom)) then
  begin
    MessageBox(0, 'RecvFrom', '', 0);
  end;

  if not(HookApiIAT('ws2_32.dll', 'send',@callbackSend, @orgiSend)) then
  begin
    MessageBox(0, 'Send', '', 0);
  end;

  if not(HookApiIAT('ws2_32.dll', 'sendto',@callbackSendTo, @orgiSendTo)) then
  begin
    MessageBox(0, 'SendTo', '', 0);
  end;
  if not(HookApiIAT('ws2_32.dll', 'recv',@callbackRecv, @orgiRecv)) then
  begin
    MessageBox(0, 'Recv', '', 0);
  end;
end;

procedure uninjectmain;
begin
  //MessageBox(0, 'Bye!', '', 0);
  uallHook.UnHookApiIAT(@callbackSend, @orgiSend);
  uallHook.UnHookApiIAT(@callbackSendTo, @orgiSendTo);
  uallHook.UnHookApiIAT(@callbackRecv, @orgiRecv);
  uallHook.UnHookApiIAT(@callbackRecvfrom, @orgiRecvFrom);
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.

Das ist die DLL. Also ich habe mit dem AppSniffer herrausgefunden, dass alle obenstehenden Funktionen genutzt werden, diese zeigt auch sämtliche nutzung mit Parametern etc an. Nun habe ich gedacht "hookste halt mal". Ein Mann ein Wort. Send(), SendTo() und Recv() werden erfolgreich gehookt. Das entnehme ich daraus, das bei meiner Hauptanwendung dieses "inform" ankommt. Aber recvFrom zickt total rum. Ich weis dass es definitiv ausgeführt wird, aber warum bekommt meine Hauptanwendung dies nicht mit?!

Grüße

[Zacherl]

Versuchs mal mit inline Hooks. Die IAT Hooks arbeiten bei solchen Dingen öfters mal nicht zuverlässig. :)

[C0pa]

Damit gehts :D - aber auch nur teilweise.

Delphi-Quellcode:

library hook;

uses
  SysUtils,
  Classes,
  Windows,
  uallHook,
  WinSock,
  Messages,
  Variants,
  WinSock2 in 'WinSock2.pas',
  IPC in 'IPC.pas';

{$R *.res}

type
  TsendMethod = function(s: TSocket; Buf : Pointer; Len, Flags: Integer): Integer; stdcall;
  TsendToMethod = function(s: TSocket; var Buf; len, flags: Integer; var addrto: TSockAddr;  tolen: Integer): Integer; stdcall;
  TrecvMethod = function(s: TSocket; Buf : Pointer; Len, Flags: Integer): Integer; stdcall;
  TrecvFromMethod = function(s: TSocket; var Buf; len, flags: Integer; var from: TSockAddr; var fromlen: Integer): Integer; stdcall;

var
  orgiSend, newSend          : TsendMethod;
  orgiRecv, newRecv          : TrecvMethod;
  orgiSendto, newSendTo      : TsendToMethod;
  orgiRecvFrom, newRecvFrom  : TrecvFromMethod;

procedure informMaster(func:Integer);
var
  data: TIPCData;
begin
  data.s := '';
  data.func := func;
  IPC.sendData(data);
end;

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

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


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

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

procedure injectmain;
begin
  //MessageBox(0, 'Its me', '', 0);
  @orgiSend := GetProcAddress(LoadLibrary('ws2_32.dll'),'send');
  if not(HookCode(@orgiSend,@callbackSend,@newSend)) then
    MessageBox(0, 'Send()', 'Something went wrong!', 0);

  @orgiSendto := GetProcAddress(LoadLibrary('ws2_32.dll'),'sendto');
  if not(HookCode(@orgiSendto,@callbackSendto,@newSendTo)) then
    MessageBox(0, 'SendTo()', 'Something went wrong!', 0);

  @orgiRecv := GetProcAddress(LoadLibrary('ws2_32.dll'),'recv');
  if not(HookCode(@orgiRecv,@callbackRecv,@newRecv)) then
    MessageBox(0, 'Recv()', 'Something went wrong!', 0);

  @orgiRecvFrom := GetProcAddress(LoadLibrary('ws2_32.dll'),'recvfrom');
  if not(HookCode(@orgiRecvFrom,@callbackRecvFrom,@newRecvFrom)) then
    MessageBox(0, 'RecvFrom()', 'Something went wrong!', 0);
end;

procedure uninjectmain;
begin
  //MessageBox(0, 'Bye!', '', 0);
  UnhookCode(@newSend);
  UnhookCode(@newSendTo);
  UnhookCode(@newRecv);
  UnhookCode(@newRecvFrom);
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.

Jetzt wird mir zwar angezeig, dass alles ausgeführt wurde, aber wenn ich die DLL Uninjecte stürtzt das Programm ab indem sich die DLL befand.

[SirThornberry]

Kannst du deinem Beitrag bitte einen aussagekräftigen Titel geben? "Völlige Verzweiflung" sagt rein gar nichts über dein problem aus und "RecvFrom" sagt ebenso wenig über das eigentliche Problem aus. Mit einem aussagekräftigerem Titel stehen die Chancen bedeutend besser das jemand mit der Lösung auf dein Problem aufmerksam wird und Leute die später einmal das gleiche Problem haben finden über die Suchfunktion dann auch schneller dieses Thema und somit hoffentlich auch die Lösung.

[C0pa]

Aber du willst nicht helfen? :gruebel:

[brechi]

Bei welchem Aufruf stürzt denn das Programm ab? Du kannst ja mal MessageBoxes zwischen den einzelnen Unhooks machen.

[Win32.API]

Ich werfe mal FlushInstructionCache in den Raum. Es könnte auch sein, dass Du den Code änderst und das Programm den halbfertigen Code ausführt.

[C0pa]

Teilweise ist es sogar so, dass ich die Funktionen hooke, dann zigg Pakete mitschneide und bei einem Paket X stürtzt die gehookte Anwendung ab. Der Fehler ist nicht reproduzierbar, da er einfach irgendwann auftritt, sicherlich gibt es dafür irgendeinen Grund - aber ich habe ihn noch nicht gefunden.

[brechi]

Naja, ist das der komplette Code?
Und ist deine IPC auch ThreadSafe?

[C0pa]

Die Probleme treten auch dann auf, wenn ich keine Nachrichten an meine Hauptanwendung schicke. Und ja, es ist der ganze Code, nur der IPC teil wurde von mir in einer Unit ausgelagert. Den hänge ich morgen Nachmittag noch an.

[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.