WS_32 Hook nicht auf XP?

[Snify]

Hi,

Ich hab mich seit einiger Zeit mit hooken beschaeftigt und komm damit ganz klar.
Entweder moechte ich connect oder getaddrinfo hooken in einem anderen process mit einer DLL.
Ich starte einen neuen Process mit CreateProcessW (suspended), injecte meine DLL, hook API's und die DLL resumed den MainThread vom Prozess. Alles kein Problem unter Windows7 x64. Ich bekomm alle API Funktionen gehookt.
Jetzt hab ich aber das Problem dass ich gerne in Windows XP Funktionen von der ws2_32.dll hooken will, allerdings ohne Erfolg :/ Alle anderen API's funktionieren. Weiss da jemand was das sein koennte?
Sorry komm aus den USA

Danke fuer eure Hilfe schonmal.

[Aphton]

Ich weiß nichts ob es etwas damit zu tun hat, jedoch wird bei mir - Win7 - immer die ws2_32.dll geladen. Wahrscheinlich regelt das System das so, dass wenn auf wsock32 zugegriffen wird (LoadLibrary()), es intern das ganze umbridged zu ws2_32.dll

Deshalb kann ich dir da leider nicht weiterhelfen, hab hier kein XP zum Testen..

Mit diesem Code habe ich festgestellt, dass die Adressen identisch sind und somit es sich um dieselbe Dll (ws2_32.dll) handelt!

Delphi-Quellcode:

  hWinSock := LoadLibrary('wsock32.dll');
  writeln(integer(getprocaddress(hWinSock, 'connect')));

  hWinSock := LoadLibrary('ws2_32.dll');
  writeln(integer(getprocaddress(hWinSock, 'connect')));

Testen wollte ich eig. ob beide API Funktionen in Assembler von der Signatur her ähnlich sind und weiters darauf schließen, dass es evt. Probleme bei deinem Hooken gibt (soferns Code-hooking ist).

Code:

mov edi, edi
push ebp
mov ebp, esp

ws2_32.connect() hält sich an den Standard mit Strackframe Generierung - dh hier sollte es zu keinen Problemen beim Hooken kommen..

Edit: Das ist nämlich nicht immer der Fall ^^ Bei OpenGL sieht das ganze nämlich ganz anders aus xD Hat mich echt Zeit gekostet, bis ich auf die Idee kam, das zu überprüfen.

Vlt. könntest du ja genauer beschreiben, was nicht klappt.. Durch Raten alleine kann ich keine Probleme lösen.

[Snify]

Das kann wirklich daran liegen das ws2_32.dll noch nicht geladen wurde...
Ich habs jetzt nochmal probiert auf Win7. Es liegt daran dass der hook nicht anschlaegt wenn GetProcAddress(LoadLibraryA('ws2_32.dll'), 'connect') aufgerufen wird. :/

Ich mach das jetzt so aber immer noch nichts
Das ist mein Loader (um eine .exe zu starten mit nem Hook)

Code:

program Loader;

{$APPTYPE CONSOLE}

uses
  Windows;

type
  TRemoteInfo = record
  LoadLibraryA : function (lpLibFileName: PAnsiChar): HMODULE; stdcall;
  ReturnAddress : pointer;
end;

var
  SI                : TStartupInfo;
  PI                : TProcessInformation;
  Name              : String;
  CT                : TContext;
  ShellPointer      : Pointer;
  BytesWritten      : DWORD;
  RemoteInfo        : TRemoteInfo;
  ParameterPointer  : Pointer;


function InjectLibrary(lpProcessID: Cardinal; lpDllname: WideString):LongBool;
var
  hProc: Cardinal;
  oAlloc: Pointer;
  cWPM: Cardinal;
  hRemThread: Cardinal;
begin
  result := false;
  SetLastError(ERROR_SUCCESS);
  hProc := OpenProcess(PROCESS_ALL_ACCESS, false, lpProcessID);
  if hProc <> 0 then
  begin
    oAlloc := VirtualAllocEx(hProc, nil, (length(lpDllname) * 2) + 1,
    MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    if oAlloc <> nil then
    begin
      if WriteProcessMemory(hProc, oAlloc, pwidechar(lpDllName), (length(lpDllname) * 2) + 1,
      cWPM) = true then
      begin
        CreateRemoteThread(hProc, nil, 0,
        GetProcAddress(GetModuleHandle('kernel32.dll'), 'LoadLibraryW'),
        oAlloc, 0, hRemThread);
        if GetLastError = ERROR_SUCCESS then
        begin
          result := true;
        end;
      end;
    end;
  end;
  CloseHandle(hProc);
end;

function TheThread ( p : pointer ) : Integer; stdcall;
var
  Address : Pointer;
  ws2_32  : array [0..6] of char;
begin
  ws2_32[0] := 'w';
  ws2_32[1] := 's';
  ws2_32[2] := '2';
  ws2_32[3] := '_';
  ws2_32[4] := '3';
  ws2_32[5] := '2';
  ws2_32[6] := #0;
  Address := TRemoteInfo(p^).ReturnAddress;
  TRemoteInfo(p^).LoadLibraryA (ws2_32);
  asm
    jmp Address;
  end;  
end;

begin
  writeln ('Type in your filename:');
  readln (name);
  FillChar(SI, SizeOf(TStartupInfo), #0);
  FillChar(PI, SizeOf(TProcessInformation), #0);
  SI.cb := SizeOf(TStartupInfo);
  if CreateProcessW(pwidechar(WideString(Name)), NIL, nil, nil, FALSE, CREATE_SUSPENDED, nil, NIL, SI, PI) then begin
     CT.ContextFlags := CONTEXT_FULL;
     if GetThreadContext(PI.hThread, CT) then begin
      RemoteInfo.ReturnAddress := Pointer(CT.EAX);
      RemoteInfo.LoadLibraryA := GetProcAddress(LoadLibraryA('kernel32'), 'LoadLibraryA');
      ShellPointer := VirtualAllocEx (PI.hProcess, NIL, 95, MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE);
      WriteProcessMemory (PI.hProcess, ShellPointer, @TheThread, 95, BytesWritten);
      ParameterPointer := VirtualAllocEx (PI.hProcess, NIL, SizeOf(TRemoteInfo), MEM_COMMIT or MEM_RESERVE, PAGE_EXECUTE_READWRITE);
      WriteProcessMemory (PI.hProcess, ParameterPointer, @RemoteInfo, SizeOf(TRemoteInfo), BytesWritten);
      CT.Ebx := DWORD(ParameterPointer);
      CT.Eax := DWORD(ShellPointer);
      SetThreadContext(PI.hThread, CT);
     end;
    InjectLibrary (PI.dwProcessId, 'hook.dll');
  end;
end.

Meine Hook.dll:

Code:

library hook;

uses
  SysUtils,
  Windows,
  afxcodehook,
  tlhelp32,
  Winsock,
  Classes;

  var
    connectCritSect : TRTLCriticalSection;
  o_connect : function (s: Integer;
  const name: sockaddr_in; namelen: Integer):Integer;stdcall;
  
    function OpenThread (dwDesiredAccess: DWORD; bInheritHandle: Bool;
  dwThreadId: DWORD) : DWORD; stdcall; external kernel32;

function ResumeThreads(PID:Cardinal): Boolean;
var
  SnapProcHandle: THandle;
  NextProc      : Boolean;
  TThreadEntry  : TThreadEntry32;
  hThread : DWORD;
begin
  SnapProcHandle := CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
  Result := (SnapProcHandle <> INVALID_HANDLE_VALUE);
  if Result then
  try
    TThreadEntry.dwSize := SizeOf(TThreadEntry);
    NextProc := Thread32First(SnapProcHandle, TThreadEntry);
    while NextProc do begin
      if TThreadEntry.th32OwnerProcessID = PID then begin
        hThread := OpenThread ($00100000 or $0002, false,
        TThreadEntry.th32ThreadID);
        ResumeThread (hThread);
        CloseHandle (hThread);
      end;
      NextProc := Thread32Next(SnapProcHandle, TThreadEntry);
    end;
  finally
    CloseHandle(SnapProcHandle);
  end;
end;

function h_connect (s: Integer; const name: sockaddr_in;
namelen: Integer):Integer;stdcall;
begin
  Messageboxa (0, 'Someone called connect!','',0);
  //EnterCriticalSection (ConnectCritSect);
  //UnhookCode (@o_connect)
  //result := SOCKET_ERROR;
  //HookCode('ws2_32.dll', 'connect', @h_connect, @o_connect);
  LeaveCriticalSection (ConnectCritSect);
end;  

procedure DllMain(fdwReason: Cardinal);
begin
  case fdwReason of
    DLL_PROCESS_ATTACH: begin
      InitializeCriticalSection(connectCritSect);
      if not(HookCode('ws2_32.dll', 'connect', @h_connect, @o_connect)) then begin
        MessageBoxA (0, 'connect ERROR', 'ERROR', 16);
        ExitProcess (0);
      end;
       ResumeThreads (GetCurrentProcessId);
    end;
    DLL_PROCESS_DETACH: begin
      UnhookCode (@o_connect);
      DeleteCriticalSection (connectCritSect);
    end;
  end;
end;

begin
  DllProc := @DllMain;
  DllMain(DLL_PROCESS_ATTACH);
end.

TestApplication1: (ohne IAT Eintrag, funktioniert nicht :/)

Code:

program Project1;

{$APPTYPE CONSOLE}

uses
  Windows;

type
  SunB = packed record
    s_b1, s_b2, s_b3, s_b4: char;
  end;
  SunW = packed record
    s_w1, s_w2: Word;
  end;


  in_addr = record
    case integer of
      0: (S_un_b: SunB);
      1: (S_un_w: SunW);
      2: (S_addr: Longint);
  end;
  sockaddr_in = record
    case Integer of
      0: (sin_family: Word;
          sin_port: Word;
          sin_addr: in_addr;
          sin_zero: array[0..7] of Char);
      1: (sa_family: Word;
          sa_data: array[0..13] of Char)
  end;

var
 connect : function(s: Integer; var name: sockaddr_in; namelen: Integer): Integer; stdcall;
 test : sockaddr_in;

begin
  connect := GetProcAddress(LoadLibraryA('ws2_32.dll'), 'connect');
  //connect := GetProcAddress(GetModuleHandle('ws2_32.dll'), 'connect');
  connect (0, test, 0);
  while true do begin
    sleep (100);
  end;
end.

TestApplication2:

Code:

program Project2;
{$APPTYPE CONSOLE}
uses
  Winsock,
  Windows;

  var
    test : TSockAddr;

begin
  Connect (0, test, 0);
  while true do begin
    sleep (100);
  end;
end.