1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:

library HookDll;


uses
  SysUtils,
  Classes,windows;

var CurrentHook: HHook;
    KeyArray: array[0..19] of byte;
    KeyArrayPtr: integer;
    CurFile: file of byte;
{
GlobalKeyboardHook
------------
This is the hook procedure to be loaded from hooks.exe when you
try and create a global hook. It is similar in structure to that defined
in hook.dpr for creating a local hook, but this time it does not beep!
Instead it stores each key pressed in an array of bytes (20 long). Whenever
this array gets full, it writes it to a file, log.txt and starts again.
}
function GlobalKeyBoardHook(code: integer; wParam: word; lParam: longword): longword; stdcall;
begin
    if code<0 then begin  //if code is <0 your keyboard hook should always run CallNextHookEx instantly and
       GlobalKeyBoardHook:=CallNextHookEx(CurrentHook,code,wParam,lparam); //then return the value from it.
       Exit;
    end;
    //firstly, is the key being pressed, and is it between A and Z
    //note that wParam contains the scan code of the key (which for a-z is the same as the ascii value)
    if ((lParam and KF_UP)=0) and (wParam>=65) and (wParam<=90) then begin
         //store the keycode in the list of keys pressed and increase the pointer
         KeyArray[KeyArrayPtr]:=wParam;
         KeyArrayPtr:=KeyArrayPtr+1;
         //if 20 keys have been recorded, save them to log.txt and start again
         if KeyArrayPtr>19 then begin
            assignfile(CurFile,'log.txt');
            if fileexists('log.txt')=false then rewrite(CurFile) else reset(CurFile); //if log.txt exists, add to it, otherwise recreate it
            blockwrite(CurFile,KeyArray[0],20);
            closefile(CurFile);
            KeyArrayPtr:=0;
         end;
    end;
    CallNextHookEx(CurrentHook,code,wParam,lparam);  //call the next hook proc if there is one
    GlobalKeyBoardHook:=0; //if GlobalKeyBoardHook returns a non-zero value, the window that should get
                     //the keyboard message doesnt get it.
    Exit;
end;

{
SetHookHandle
-------------
This procedure is called by hooks.exe simply to 'inform' the dll of
the handle generated when creating the hook. This is required
if the hook procedure is to call CallNextHookEx. It also resets the
position in the key list to 0.

}
procedure SetHookHandle(HookHandle: HHook); stdcall;
begin
    CurrentHook:=HookHandle;
    KeyArrayPtr:=0;
end;

exports GlobalKeyBoardHook index 1,
        SetHookHandle index 2;
begin

end.					

1:
2:
3:
4:
5:

  if uppercase(paramstr(1)) = uppercase('-load') then
    GlobalInjectLibrary(pchar(uallUtil.GetExeDirectory+'hook3.dll')) else

  if uppercase(paramstr(1)) = uppercase('-unload') then
    GlobalUnloadLibrary(pchar('hook.dll'))					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

function msg_Hook(code: integer; wParam: word; lParam: longword): longword; stdcall;
  type  PMsg =  ^TMsg;
  var   msg:            PMsg;
    f: TextFile;

 begin
        if code < HC_ACTION then
         begin
                Result := CallNextHookEx(CurrentHook, code, wParam, lParam);
                exit;
         end;

        msg := PMsg(lParam);
        
        {Hier den entsprechenden Code einsetzen}

        Result := CallNextHookEx(CurrentHook, code, wParam, lParam);
 end;					

1:

setwindowshookex(WH_GETMESSAGE, HookProcAdd, LibHandle, 0);					

1:
2:
3:
4:
5:
6:
7:
8:

if (msg^.message = WM_KEYUP) and (msg^.lParam in ['A'..'Z']) then
 if msg^.lParam = 'E' then
  begin 
   msg^.message = WM_NULL; // Message löschen also Taste killen (Funzt übrigens logischerweise nicht mit STRG+ALT+ENTF)
   // Jetzt musst du nur noch eine 3 emulieren
  //  Dazu schaust du dir am Besten mal die Funktion SendInput() in der msdn an...
  end; 
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:

library HookDll;


uses
  SysUtils, Classes, Windows,  Messages;

var GlobalHookHandle: HHook;


procedure fakeInput(s: string);
 var i:    integer;
     send: Array of TInput;
 begin
        if Length(s) < 1 then exit;

        SetLength(send, Length(s)*2); //Alle Buchstaben * 2, weil: Erst drücken, dann loslassen = 2 Schritte

        for i := 0 to Length(s)-1 do
         begin
                send[i*2].Itype      :=  INPUT_KEYBOARD;  // Wir wollen das Keyboard emulieren
                send[i*2].ki.wVk     := ord(s[i+1]);     //  Buchstabencode auslesen
                send[i*2].ki.dwFlags := 0;              //   Taste drücken

                send[(i*2) + 1].Itype      :=  INPUT_KEYBOARD;   // Wir wollen das Keyboard emulieren
                send[(i*2) + 1].ki.wVk     := ord(s[i+1]);      //  Buchstabencode auslesen
                send[(i*2) + 1].ki.dwFlags := KEYEVENTF_KEYUP; //   Taste wieder loslassen
         end;
         SendInput(Length(send),send[0],SizeOf(send[0]));    // Abschicken
 end;

function msg_Hook(code: integer; wParam: word; lParam: longword): longword; stdcall;
  type  PMsg =  ^TMsg;
  var   msg:  PMsg;       

 begin

        if code < HC_ACTION then   // Message nur verarbeiten wenn erlaubt
         begin
                Result := CallNextHookEx(GlobalHookHandle, code, wParam, lParam);
                exit;
         end;

        msg := PMsg(lParam); // Die Message 'extrahieren'

        if msg^.message = WM_KEYDOWN then  // Wenn ne Taste gedrückt wird
         case char(msg^.wParam) of
          'E':
             begin
              fakeInput('3');
              msg^.message := WM_NULL;  // Die echte Taste (in dem Fall 'E') nicht weiterleiten
             end;
           'A':
             begin
              fakeInput('4');
              msg^.message := WM_NULL; // Die echte Taste (in dem Fall 'A') nicht weiterleiten
             end;
          end; 
        Result := CallNextHookEx(GlobalHookHandle, code, wParam, lParam);
 end;

procedure SetHookHandle(HookHandle: HHook); stdcall;
begin
    GlobalHookHandle := HookHandle;
end;

exports msg_Hook      index 1,
        SetHookHandle index 2;
begin

end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:

unit Global;

interface

uses windows;

// Struktur der SetHookHandle aus der hookdll.dll definieren
type TSetHookHandle = procedure(HookHandle: HHook); stdcall;

var LibLoaded: boolean;               // DLL geladen?
    LibHandle: HInst;                //  DLL Handle
    HookProcAdd: pointer;           //   Speicheradresse der Hookprozedur in Windows
    SetHookHandle: TSetHookHandle; //    Die Prozedur zum internen aktivieren des Hooks
    GlobalHookHandle: HHook;      //     Hook Handle

function LoadGlobalHook(DLL: string): boolean;      // DLL Laden
function InstallGlobalHook(Handle: HWND): boolean; //  Hook aktivieren
function UninstallGlobalHook: Boolean; stdcall;   //   Hook deaktivieren

implementation


function LoadGlobalHook(DLL: string): boolean;
begin
    LibHandle := LoadLibrary(PChar(DLL));
    if LibHandle = 0 then begin
       Result := false;
       exit;
    end;

    HookProcAdd := GetProcAddress(LibHandle,'msg_Hook');

    @SetHookHandle:=GetProcAddress(LibHandle,'SetHookHandle');

    if (HookProcAdd = nil)or(@SetHookHandle = nil) then
     begin
       FreeLibrary(LibHandle);
       Result := false;
       exit;
     end;

    LibLoaded := true;
    Result := true;
end;


function InstallGlobalHook(Handle: HWND): boolean;
begin
     Result := false;
     if LibLoaded = false then exit;
     CurrentHook := setwindowshookex(WH_GETMESSAGE, HookProcAdd, LibHandle, Handle);
     SetHookHandle(GlobalHookHandle);
     if GlobalHookHandle<>0  then Result := true;
end;

function UninstallGlobalHook: Boolean; stdcall;
begin
  Result := UnhookWindowsHookEx(CurrentHook);
  GlobalHookHandle := 0;
end;

end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

uses {...}, Global;

{...}

procedure TMainForm.Button1Click(Sender: TObject)
 begin
      LoadGlobalHook('C:\bla\HookDLL.dll');
      InstallGlobalHook(0); // 0 heisst alle Fenster, wenn du den Hook auf ein bestimmtes Fenster begrenzen willst, dann wähle sein Handle
 end;

procedure TMainForm.Button2Click(Sender: TObject)
 begin
      UninstallGlobalHook;
 end;