Tastatur/Maus-Hook: Internet Explorer stürzt wegen DLL ab

[blackdrake]

Hallo.

Ich habe mit Unterstützung des Forums und Tutorials einen Maus/Tastaturhook geschrieben, der Tastaturereignisse erkennt und die Maus für eine gewisse Zeit sperrt.

Ich habe jetzt ein großes Problem gefunden: Bei meinem Testsystem - Vista - stürzt Internet Explorer aufgrund der Hook-DLL ab.

Die Fehlermeldung scheint irgendetwas mit Buffer-Overrun zu tun zu haben (was bei Delphi aber unwahrscheinlich ist) und ich weiß echt nicht, woran es liegt. Weiß jemand weiter?

Zitat:

Produkt
Internet Explorer

Problem
Funktioniert nicht mehr

Datum
01.12.2008 17:52

Status
Bericht gesendet

Problemsignatur
Problemereignisame: APPCRASH
Anwendungsname: iexplore.exe
Anwendungsversion: 7.0.6001.18000
Anwendungszeitstempel: 47918f11
Fehlermodulname: atl_hooks.dll
Fehlermodulversion: 0.0.0.0
Fehlermodulzeitstempel: 2a425e19
Ausnahmecode: c0000005
Ausnahmeoffset: 00003c5e
Betriebsystemversion: 6.0.6001.2.1.0.768.3
Gebietsschema-ID: 1031
Zusatzinformation 1: 6718
Zusatzinformation 2: 3fab1118733fd991e6b3f07ef0d90511
Zusatzinformation 3: 7591
Zusatzinformation 4: 18cb549cf9e0d1d27b18034a323f5b99

Die DLL:

Delphi-Quellcode:

library atl_hooks;

uses
  Windows,
  Messages;

var
  Mouse_HookHandle:    Cardinal = 0;
  Keyboard_HookHandle: Cardinal = 0;

  WM_ANYKEYPRESSED:   Cardinal = 0;
  WM_LMB_KEY_CONFIRM: Cardinal = 0;
  WM_RMB_KEY_CONFIRM: Cardinal = 0;

  TargetHandle, hMapping: Cardinal;
  pView: pointer;

const
  MappingGUID    = '{C8B1CCD2-4B00-45F1-9B96-9B82E086D473}';
  MsgTimeOut     = 10;
  RES_LMB_LOCKED = 10;
  RES_RMB_LOCKED = 11;

type
  ULONG_PTR = ^DWORD;

  PKBDLLHOOKSTRUCT = ^TKBDLLHOOKSTRUCT;
  TKBDLLHOOKSTRUCT = packed record
    vkCode      : DWORD;
    scanCode    : DWORD;
    flags       : DWORD;
    time        : DWORD;
    dwExtraInfo : ULONG_PTR;
  end;

const
  WH_KEYBOARD_LL = 13; // WINUSER.H

function KeyboardHookProc(nCode: Integer; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;
var
  //res: Cardinal;
  KHSp: PKBDLLHOOKSTRUCT;
  KHSd: TKBDLLHOOKSTRUCT;
begin
  Result := CallNextHookEx(Keyboard_HookHandle, nCode, wParam, lParam);
  case nCode < 0 of
    TRUE: exit;
    FALSE:
      begin
        // Strg/Shift+Maustaste ist legitim für Mehrfachselektion
        if (wParam = WM_KEYDOWN) then
        begin
          KHSp := PKBDLLHOOKSTRUCT(lParam);
          KHSd := KHSp^;
          if not
              (
                ( KHSd.vkCode = 160 ) and ( KHSd.scanCode = 42 ) or  // Shift Left
                ( KHSd.vkCode = 162 ) and ( KHSd.scanCode = 29 ) or  // Ctrl  Left
                ( KHSd.vkCode = 161 ) and ( KHSd.scanCode = 54 ) or  // Shift Right
                ( KHSd.vkCode = 163 ) and ( KHSd.scanCode = 29 )     // Ctrl  Right
              )
          then
            //SendMessageTimeOut(TargetHandle, WM_ANYKEYPRESSED, wParam, lParam,
            //                   SMTO_ABORTIFHUNG or SMTO_BLOCK, MsgTimeOut, res);
            SendMessage(TargetHandle, WM_ANYKEYPRESSED, wParam, lParam);
        end;
      end;
  end;
end;

function MouseHookProc(nCode: Integer; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;
var
  res: Cardinal;
begin
  Result := CallNextHookEx(Mouse_HookHandle, nCode, wParam, lParam);
  case nCode < 0 of
    TRUE: exit;
    FALSE:
      begin
        // Handelt es sich um einen linken Mausklick?
        if (wParam = WM_LBUTTONUP)     or (wParam = WM_NCLBUTTONUP) or
           (wParam = WM_LBUTTONDOWN)   or (wParam = WM_NCLBUTTONDOWN) or
           (wParam = WM_LBUTTONDBLCLK) or (wParam = WM_NCLBUTTONDBLCLK) then
        begin
          SendMessageTimeOut(TargetHandle, WM_LMB_KEY_CONFIRM, wParam, lParam,
                             SMTO_ABORTIFHUNG or SMTO_BLOCK, MsgTimeOut, res);

          // Host-Application verweigert den Tastenklick
          if res = RES_LMB_LOCKED then
          begin
            Result := 1; // Maustaste verwerfen
          end;
        end;

        // oder um einen rechten Mausklick?
        if (wParam = WM_RBUTTONUP)     or (wParam = WM_NCRBUTTONUP) or
           (wParam = WM_RBUTTONDOWN)   or (wParam = WM_NCRBUTTONDOWN) or
           (wParam = WM_RBUTTONDBLCLK) or (wParam = WM_NCRBUTTONDBLCLK) then
        begin
          SendMessageTimeOut(TargetHandle, WM_RMB_KEY_CONFIRM, wParam, lParam,
                             SMTO_ABORTIFHUNG or SMTO_BLOCK, MsgTimeOut, res);

          // Host-Application verweigert den Tastenklick
          if res = RES_RMB_LOCKED then
          begin
            Result := 1; // Maustaste verwerfen
          end;
        end;
      end;
  end;
end;

function InstallHooks(Hwnd: Cardinal): Boolean; stdcall;
var
  mouseh, keybh: boolean;
begin
  keybh := false;
  mouseh := false;

  case Mouse_HookHandle of
    0: begin
        Mouse_HookHandle := SetWindowsHookEx(WH_MOUSE, @MouseHookProc, HInstance, 0);
        mouseh := true;
      end;
  end;
  case Keyboard_HookHandle of
    0: begin
        Keyboard_HookHandle := SetWindowsHookEx(WH_KEYBOARD_LL, @KeyboardHookProc, HInstance, 0);
        keybh := true;
      end;
  end;

  Result := keybh and mouseh;
end;

function UninstallHooks: Boolean; stdcall;
var
  mouseh, keybh: boolean;
begin
  mouseh := UnhookWindowsHookEx(Mouse_HookHandle);
  keybh := UnhookWindowsHookEx(Keyboard_HookHandle);
  Mouse_HookHandle := 0;
  Keyboard_HookHandle := 0;
  Result := keybh and mouseh;
end;

exports
  InstallHooks,
  UninstallHooks;

procedure Initalisation(Reason: DWORD);
begin
  case Reason of
    DLL_PROCESS_ATTACH:
      begin
        hMapping := OpenFileMapping(FILE_MAP_ALL_ACCESS, False, MappingGUID);
        pView := MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);

        TargetHandle := PCardinal(pView)^;
      end;
    DLL_PROCESS_DETACH:
      begin
        // Wird das auch tatsächlich aufgerufen??
        UnmapViewOfFile(pView);
        CloseHandle(hMapping);
      end;
  end;
end;

begin
  WM_ANYKEYPRESSED   := RegisterWindowMessage('WM_ANYKEYPRESSED');
  WM_LMB_KEY_CONFIRM := RegisterWindowMessage('WM_LMB_KEY_CONFIRM');
  WM_RMB_KEY_CONFIRM := RegisterWindowMessage('WM_RMB_KEY_CONFIRM');

  Initalisation(DLL_PROCESS_ATTACH); // Ist das so OK?
end.

Anbei auch das reproduzierbare Projekt.

Gruß
blackdrake

[Relicted]

Ist bei mir unter Vista x64 auch reproduzierbar der Fehler.
Liegt vielleicht daran, dass der Iexplorer in ner speziellen abgeschotteten Umgebung läuft unter Vista? Nur ne Vermutung.

Gruß
reli

[blackdrake]

Hallo. Ja, irgendwas macht IE anders, aber trotzdem darf es keinen Fehler geben. Andere Hook-DLLs funktionieren aber irgendwie. Und meine DLL macht ja nichts großartig besonderes. Deswegen vermute ich, dass ich irgendwo etwas mit dem Speicher, z.B. der Mem-Map-File unsauber gemacht habe.

[Relicted]

kommentier mal einzelne Parts aus... Versuch mal mit nur Maushook und mit nur Keyboardhook den IE zu starten. So kannst es evtl. eingrenzen.

Gruß
reli

[Apollonius]

Prüfe mal, ob du einen gültigen Zeiger für pView erhältst. Wenn du nicht genügend Rechte hast, sollte bereits hMapping ungültig sein und MapViewOfFile gibt nil zurück.

Deine Prozedur wird übrigens nicht aufgerufen, wenn die DLL beendet wird. Dazu musst du die globale Variable DllProc setzen.

[Sir Rufo]

bzgl.

Zitat von blackdrake:

Delphi-Quellcode:

begin
  ...
  Initalisation(DLL_PROCESS_ATTACH); // Ist das so OK?
end.

schau mal hier Controling DLL loading

und ob eine bestimmter Teil in einer DLL auch ausgeführt wird, das bekommt man am einfachsten raus, wenn man in dem Teil eine Ausgabe in einer Datei produziert (Log-Datei). Wenn da, dann war die DLL auch da

cu

Oliver

[blackdrake]

Hallo.

Attach und Detach werden nun ausgeführt, nachdem ich DLLProc gesetzt habe.

Seitdem ich auf pView <> nil prüfe, stürzt Internet-Explorer nicht mehr ab.

Das Problem ist aber, dass pView = nil wird. Das ist jetzt natürlich ziemlich problematisch und auch das Schreiben in die Logdatei schlägt beim Aufruf von InternetExplorer mit dem RunTime Error 5 (File inaccessable) ab. Was kann ich tun?

Zusätzliche Frage: Wie ist es möglich, den DLL-Teilprozess zu terminieren, wenn pView doch mal nil werden sollte?

Der DLL-Code sieht nun so aus:

Delphi-Quellcode:

procedure Log(N: string); // debug
var
  f: TextFile;
begin
  AssignFile(f, 'c:\meinlog.txt');
  Append(f);
  WriteLn(f, N);
  CloseFile(f);
end;

procedure DllMain(Reason: DWORD);
begin
  case Reason of
    DLL_PROCESS_ATTACH:
      begin
        hMapping := OpenFileMapping(FILE_MAP_ALL_ACCESS, False, MappingGUID);
        pView := MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);

Log('Attach');
        if pView <> nil then
          TargetHandle := PCardinal(pView)^; // ToDo: Wenn nil, sollte DLL terminiert werden
if pView = nil then
log('Fehler 1');
      end;
    DLL_PROCESS_DETACH:
      begin
Log('Detach');
        if pView <> nil then
          UnmapViewOfFile(pView);
if pView = nil then
log('Fehler 2');
        CloseHandle(hMapping);
      end;
  end;
end;

begin
  WM_ANYKEYPRESSED   := RegisterWindowMessage('WM_ANYKEYPRESSED');
  WM_LMB_KEY_CONFIRM := RegisterWindowMessage('WM_LMB_KEY_CONFIRM');
  WM_RMB_KEY_CONFIRM := RegisterWindowMessage('WM_RMB_KEY_CONFIRM');

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

Nachtrag! Ignoriert man diesen Fehler, wird trotz des pView=nil das Tastaturereignis (WH_KEYBOARD_LL SendMessage) an die Host-Applikation (TargetHandle) weitergegeben. Das Maus-Ereignis (WH_MOUSE SendMessageTimeOut) wird aber nicht weitergegeben, die Maustaste kann also nicht durch die Host-Applikation gesperrt werden! Seltsamerweiße funktioniert das ähnliche Programm MTANWT einwandfrei mit Internet Explorer. Was ist das Geheimnis?

Gruß
blackdrake

[Apollonius]

Um die DLL in der Initialisierung abzuwürgen, reicht es, ExitCode auf einen Wert ungleich Null zu setzen.
Was du tun kannst, um das Problem zu beheben? Setze beim Erstellen des File Mappings die Rechte, sodass alle Benutzer Lesezugriff haben. Es ist übrigens auch nicht nötig, in der DLL Schreibzugriff zu verlangen.
Eine andere Frage: Warum hältst du Handle und View des Mappings so lange offen? Du kannst diese Ressourcen direkt nach dem Lesen von TargetHandle wieder freigeben. Dann brauchst du auch keine DllProc.

[blackdrake]

Hallo.

Danke für den Hinweis. Ich habe jetzt auf die DLL-Proc verzichtet und habe nun folgenden Code:

Delphi-Quellcode:

begin
  WM_ANYKEYPRESSED   := RegisterWindowMessage('WM_ANYKEYPRESSED');
  WM_LMB_KEY_CONFIRM := RegisterWindowMessage('WM_LMB_KEY_CONFIRM');
  WM_RMB_KEY_CONFIRM := RegisterWindowMessage('WM_RMB_KEY_CONFIRM');

  hMapping := OpenFileMapping(FILE_MAP_ALL_ACCESS, False, MappingGUID);
  pView := MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);

  if pView <> nil then
  begin
    TargetHandle := PCardinal(pView)^;

    UnmapViewOfFile(pView);
    CloseHandle(hMapping);
  end
  else
  begin
    ExitCode := 1;
  end;
end.

Das mit dem Schreibzugriff verstehe ich nicht ganz.

Die Host-APP legt die MemMap an mittels FILE_MAP_WRITE und schreibt das eigene WindowHandle hinein:

Delphi-Quellcode:

hMapping := CreateFileMapping(INVALID_HANDLE_VALUE, nil, PAGE_READWRITE, 0, 4, MappingGUID);
pView := MapViewOfFile(hMapping, FILE_MAP_WRITE, 0, 0, 0);

PCardinal(pView)^ := Handle;

Die DLL öffnet die MemMap mit FILE_MAP_READ und liest das Handle.

Dann habe ich doch in der DLL keinen Fehler gemacht, oder?

Und bezüglich des Exit-Code ungleich Null: Wird die DLL dann automatisch entladen, wenn in der Initialisierung der ExitCode gesetzt wurde? Die Host-Applikation müsste dann doch trotzdem die DLL-Export-Funktion InstallHooks() aufrufen, was ja bedeutet, dass die DLL trotzdem arbeitet, obwohl ein Fehler festgestellt wurde.

PS: Internet Explorer läuft nun in eine Endlosschleife.

Gruß
blackdrake

[Apollonius]

Wenn du eine DLL mit LoadLibrary lädst und die DllProc dieser DLL false zurückgibt (in Delphi wird das in System.pas über ExitCode geregelt), gibt LoadLibrary nil zurück. Wie sich das bei Hook-Dlls verhält (bedenke, dass jede Applikation ihre eigene DLL-Instanz hat!), weiß ich nicht, ich vermute aber mal, dass Windows dort pragmatisch vorgeht und die DLL nur in diesen Prozess nicht lädt.

Bezüglich der Rechte: Ausschlaggebend sind die angegebenen Rechte bei OpenFileMapping. Du solltest dir in deinem Hauptprogramm Security Attributes erstellen, die allen Benutzern Lese-Zugriff erlaubt, und diesen dann als Parameter für CreateFileMapping angeben. Eine solche Struktur lässt sich sehr elegant mit der JWSCL erzeugen; direkt über die API ist es etwas schwieriger.