Tastendruck im Hintergrund registrieren und Loggen

[Astat]

Zitat:

Zitat von alzaimar

Muss ein globaler Keyboard-Hook nicht in einer DLL liegen?

Jupp, dll sendet an Host-Application, _hwndTarget wird z.B. aus Mapped File oder Registry oder.. ausgelesen.

[T.E.]

Zitat:

Zitat von Astat

Hallo T.E., ich hoffe nicht, dass ich mal das Teil in einer Signatur eines Virenscanners finden werde!!

Erstens einmal Danke! Und zu deiner Hoffnugn: ich selbst und auch mein Betrieb sind nicht gerade die Förder illegaler Machenschaften, der Hook soll also wie eingagns beschrieben lediglich der Funktionsanalyse eines ControlPanels dienen und wird auch nur manuell gestartet.

Zitat:

Zitat von alzaimar

Muss ein globaler Keyboard-Hook nicht in einer DLL liegen?

Wie Astat schon sagte ja, ist in diesem Fall auch getan worden, auch wenn das bisher nicht explizit gesagt worden war.

[Helmi]

Hallo,

weil ich mich heute mit einem Kollegen über Hotkeys unterhalten habe, möcht ich mal schnell diesen Link in den Raum werfen.

Man könnte ja die F-Tasten hotkeyen und bräuchte nicht im Vordergrund sein.

[T.E.]

Soo.... ich bin heute wieder dazu gekommen mit dem Tool weiterzumachen, allerdings gibt es dabei ein paar Fragen die sich aufgetan haben.
1. TForm.WndProc in der Server Anwendung ja folgendermaßen aufgerufen:

Delphi-Quellcode:

procedure TForm1.WndProc(var message: TMessage);

wird von Delphi mit einer Warnung beehrt:

Zitat:

Zitat von Delphi Hilfe

W1010: Methode 'WndProc' verbirgt virtuelle Methode vom Basistyp 'TCustomForm'

Ich habe daraufhin einfach mal Testweise TForm.HookWndProc daraus gemacht und die Meldung war weg, so weit so gut. Nun geht es mir aber darumist dieser Schritt richtig oder hätte ich einfach WndProc mit override deklarieren müssen?

2. Was mir mehr Kopfzerbrechen bereitet: Ich habe die Prozedur KeyboardHookProc in der DLL stehen und exportiere um Sie in der Serveranwendung aufrufen zu können. Seit ich diesen Schritt vollführt habe, wird die Anwendung kurz gestartet und gleich wieder beendet... Warum? Ich habe so weit ich weiß keinen Code in der Anwendung, der diese Beendet ohne, das nicht wenigstens der Button schließen oder halt das Kreuz verwendet wird.

Kann mir dazu jemand was sagen, oder muss ic hdoch erst mal den gesamten Code posten?
Besten Dank im voraus!!

[Hobby-Programmierer]

Hast du F1 benutzt und geschaut was dir damit gesagt wird?

[T.E.]

Jop dort wurde als mögliche Lösung dieses Problems das umbenennen vorgeschlagen.

Aber hier mal die vorgeschlagenen Lösungsmöglichkeiten:

Zitat:

Zum einen können Sie override angeben und auf diese Weise die Prozedur der abgeleiteten Klasse ebenfalls virtuell machen, sodass geerbte Aufrufe sich immer noch auf die ursprüngliche Prozedur beziehen können.

Zweitens könnten Sie auch die Bezeichnung der Prozedur in der Deklaration der abgeleiteten Klasse ändern. In diesem Beispiel werden beide Methoden gezeigt.

Drittens können Sie die Direktive reintroduce in die Deklaration der Prozedur einfügen, um die Warnung für diese Methode zu unterdrücken.

Aber aus meiner Sicht war halt die Frage: welche der Lösungen am intelligentesten ist. Bzw. ob man bei der einen oder der anderen was beachten muss.

[Hobby-Programmierer]

Moin ...,
ich hatte das Bsp. von Astat auch gestestet - vorwiegend aber um das mal mit ner MMf zu testen - und es lief bei mir mit

Delphi-Quellcode:

override

[T.E.]

Okay das ist doch schon mal gut zu wissen ;)
Aber nun zu der anderen Frage:

Zitat:

Zitat von T.E.

Was mir mehr Kopfzerbrechen bereitet: Ich habe die Prozedur KeyboardHookProc in der DLL stehen und exportiere diese um Sie in der Serveranwendung aufrufen zu können. Seit ich diesen Schritt vollführt habe, wird die Anwendung kurz gestartet und gleich wieder beendet... Warum? Ich habe so weit ich weiß keinen Code in der Anwendung, der diese Beendet ohne, das nicht wenigstens der Button schließen oder halt das Kreuz verwendet wird.

Ergänzend noch: ich installiere und deinstalliere den Hook über zwei Buttons in der Serveranwendung.


Hat auch hierzu jemand einen Geistesblitz?

[T.E.]

So jetzt bin ich schon mal einen kleinen Schritt weiter:
und zwar scheint das Problem darin zu liegen, das mein Programm damit nicht klarkommt, das ich die Funktion aus der DLL Exportiere und dann in der Server App aufrufe:
Export aus der DLL sieht folgendermaßen aus:

Delphi-Quellcode:

exports
InstallHook,
UninstallHook,
KeyboardHookProc;

Und der Import so:

Delphi-Quellcode:

function KeyboardHookProc(Code: Integer; wParam: WPARAM; lParam: LPARAM): LResult; stdcall; external 'Keyboard_Hook_Dll.dll';

Wenn ich die Funktion nun in die Server App packe, dann geht alles, bis auf das nichts mitgeschrieben wird, wenn ich aber auslagere, dann wird die anwendung gleich nach dem start gleich wieder beendet.
Wo liegt da das Problem?

Im folgenden einfahc mal die Funktionen um die es geht:

Delphi-Quellcode:

function GetHandle(HKEY: DWORD; const SubKey, ValueName: String; CanCreate: Boolean = false): DWORD;
var
  Reg : TRegistry;
begin
  result := DWORD(-1);
  Reg := TRegistry.create;
  Reg.RootKey := HKey;
  if Reg.OpenKey(SubKey,CanCreate) then
    if Reg.ValueExists(ValueName) then
      result := Reg.ReadInteger(ValueName);
  Reg.CloseKey;
  Reg.Free;
end;

function KeyboardHookProc(Code: Integer; wParam: WPARAM; lParam: LPARAM): LResult; stdcall;
var
  LastKey: Char;
  KeyState: TKeyboardState;
  KeyboardLayout: HKL;
  Key: Word;
begin
  Result := CallNextHookEx(HookHandle, Code, wParam, lParam);
  if Code < 0 then Exit
  else
    begin
      KeyboardLayout := GetKeyboardLayout(0);
      GetKeyboardState(KeyState);
      if ToAsciiEx(wParam, MapVirtualKeyEx(wParam, 2, KeyboardLayout), KeyState, @LastKey, 0, KeyboardLayout) > 0 then
        Key := Ord(LastKey)
      else
      begin
        Key := wParam;
        if (lParam and $80000000) = 0 then
        begin
          if not (wParam in [16, 17, 18]) then
          begin
            PostMessage(GetHandle(HKEY_CURRENT_USER, 'Software\eTiT-Solutions', 'KeyVue_AppHandle_hwndTarget', False), WM_USER + 8888, Key, GetActiveWindow);
          end;
        end;
      end;
    end;
end;

Wäre für einen klärenden Blick äußerst dankbar.... :roll:

[Astat]

Hi, T.E!

lg. Astat

Delphi-Quellcode:

library dicthook;

  {$IMAGEBASE $56000000}

uses
  Windows,
  Messages;

type
  PHWND = ^HWND;

const
  WM_KEYBOARD_HOOK = WM_USER + 1024;
  FILEMAPPING_NAME = '{08864E9D-08A9-4118-8FAC-AA0931E7ECAA}';

var
  hHook: LongWord = 0;
  Key: Word;
  KeyboardLayout: HKL;
  GetShiftKeys: Boolean;
  hWndBuffer: PHWND;
  hMMF: THandle;

function KeyboardProc(nCode: Integer; wParam: LongWord;
  lParam: LongWord): LongWord; stdcall;
var
  LastKey: Char;
  KeyState: TKeyboardState;
begin
  Result := CallNextHookEx(hHook, nCode, wParam, lParam);
  if nCode < 0 then Exit
  else begin
    GetKeyboardState(KeyState);
    if ToAsciiEx(wParam, MapVirtualKeyEx(wParam, 2, KeyboardLayout), KeyState,
      @LastKey, 0, KeyboardLayout) > 0 then Key := Ord(LastKey)
    else
      Key:=wParam;
    if (lParam and $80000000) = 0 then
      if not (wParam in [16, 17, 18]) or GetShiftKeys then
        PostMessage(hwndBuffer^, WM_KEYBOARD_HOOK, Key, GetActiveWindow);
  end;
end;

function CreateHook(hWnd: HWND; ShiftKeys: Boolean): Boolean; stdcall;
var
  bHWND: PHWND;
begin
  hMMF := CreateFileMapping($FFFFFFFF, nil, PAGE_READWRITE or SEC_COMMIT, 0,
    SizeOf(hWnd), FILEMAPPING_NAME);

  bHWND := MapViewOfFile(hMMF, FILE_MAP_WRITE, 0, 0, SizeOf(HWND));
  bHWND^ := hWnd;
  UnmapViewOfFile(bHWND);
  GetMem(hWndBuffer, SizeOf(HWND));
  hWndBuffer^ := hWnd;
  GetShiftKeys := ShiftKeys;
  if hHook = 0 then
    hHook := SetWindowsHookEx(WH_KEYBOARD, @KeyboardProc, hInstance, 0);
  Result := hHook <> 0;
end;

function DeleteHook: Boolean; stdcall;
begin
  FreeMem(hWndBuffer);
  CloseHandle(hMMF);
  Result := UnhookWindowsHookEx(hHook);
  hHook := 0;
end;

procedure DLLEntryProc(EntryCode: integer);
var
  hFM: THandle;
begin
  case EntryCode of
    DLL_PROCESS_DETACH:
      begin
      end;
    DLL_PROCESS_ATTACH:
      begin
        KeyboardLayout := GetKeyboardLayout(0);

        hFM := OpenFileMapping(FILE_MAP_READ, false, FILEMAPPING_NAME);
        if hFM <> 0 then begin
          hWndBuffer := MapViewOfFile(hFM, FILE_MAP_READ, 0, 0, SizeOf(HWND));
          CloseHandle(hFM);
        end;
      end;
  end;
end;

exports
  CreateHook,
  DeleteHook;

begin
  DisableThreadLibraryCalls(hInstance);
  DLLProc := @DLLEntryProc;
  DLLEntryProc(DLL_PROCESS_ATTACH);
end.

Zu verwenden:

Delphi-Quellcode:

const
  WM_KEYBOARD_HOOK = WM_USER + 1024;
  KBHOOKDLL = 'dicthook.dll';

type
  TfrmHookHostMain = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    procedure WMONKeyMsg(var Msg: TMessage); message WM_KEYBOARD_HOOK;
  end;

var
  frmHookHostMain: TfrmHookHostMain;

implementation

{$R *.dfm}

type
  TFNCreateHook = function(hWnd: HWND; ShiftKeys: Boolean): Boolean; stdcall;
  TFNDeleteHook = function: Boolean; stdcall;
  TFNGetLastKey = function: Word; stdcall;

var
  hLib: THandle = 0;
  CreateHookFtn: TFNCreateHook = nil;
  DeleteHookFtn: TFNDeleteHook = nil;

procedure TfrmHookHostMain.WMONKeyMsg(var Msg: TMessage);
var
  sKey: string;
begin
  if msg.LParam <> handle then sKey := string(Chr(msg.wParam);
  inherited;
end;


procedure TfrmHookHostMain.FormCreate(Sender: TObject);
begin
  hLib := LoadLibrary(PChar(ADestPath + KBHOOKDLL));

  if hLib <> 0 then begin
    @CreateHookFtn := GetProcAddress(hLib, 'CreateHook');
    @DeleteHookFtn := GetProcAddress(hLib, 'DeleteHook');
    if not (Assigned(CreateHookFtn) and Assigned(DeleteHookFtn)) then
      raise exception.Create('ERROR Hooking Keys!');
  end else
    raise exception.Create('ERROR HookDLL konte nicht geladen werden!');

  if not CreateHookFtn(handle, true) then
    raise exception.Create('ERROR Hookfunction konnte nicht gestartet werden!');

end;

procedure TfrmHookHostMain.FormDestroy(Sender: TObject);
begin
  if hLib <> 0 then begin
    DeleteHookFtn;
    FreeLibrary(hLib);
  end;
end;