Global Hook Keylogger problem

Question

Registra le chiavi nella casella di testo attualmente in modo sicuro.

PROBLEMA Il problema è quando ho eseguito questo a macchina virtuale, o il mio computer portatile amici, si blocca dopo aver premuto certa quantità di chiavi (casuale) .Si corre perfettamente bene nella mia.

http://i34.tinypic.com/29o1im8.jpg

class GlobalKeyboardHook 
{ 


    #region Definition of Structures, Constants and Delegates 

    public delegate int KeyboardHookProc(int nCode, int wParam, ref GlobalKeyboardHookStruct lParam); 

    public struct GlobalKeyboardHookStruct 
    { 
     public int vkCode; 
     public int scanCode; 
     public int flags; 
     public int time; 
     public int dwExtraInfo; 
    } 

    const int WM_KEYDOWN = 0x100; 
    const int WM_KEYUP = 0x101; 
    const int WM_SYSKEYDOWN = 0x104; 
    const int WM_SYSKEYUP = 0x105; 
    const int WH_KEYBOARD_LL = 13; 

    #endregion 

    #region Events 

    public event KeyEventHandler KeyDown; 
    public event KeyEventHandler KeyUp; 

    #endregion 

    #region Instance Variables 

    public List<Keys> HookedKeys = new List<Keys>(); 
    IntPtr hookHandle = IntPtr.Zero; 

    #endregion 

    #region DLL Imports 

    [DllImport("kernel32.dll")] 
    static extern IntPtr LoadLibrary(string lpFileName); 

    [DllImport("user32.dll", CharSet = CharSet.Auto,CallingConvention = CallingConvention.StdCall, SetLastError = true)] 
    static extern IntPtr SetWindowsHookEx(int hookID, KeyboardHookProc callback, IntPtr hInstance, uint threadID); 

    [DllImport("user32.dll", CharSet = CharSet.Auto,CallingConvention = CallingConvention.StdCall, SetLastError = true)] 
    static extern bool UnhookWindowsHookEx(IntPtr hookHandle); 

    [DllImport("user32.dll", CharSet = CharSet.Auto,CallingConvention = CallingConvention.StdCall)] 
    static extern int CallNextHookEx(IntPtr hookHandle, int nCode, int wParam, ref GlobalKeyboardHookStruct lParam); 




    #endregion 

    #region Public Methods 

    public int hookProc(int nCode, int wParam, ref GlobalKeyboardHookStruct lParam) 
    { 

     if (nCode >= 0) 
     { 
      Keys key = (Keys)lParam.vkCode; 

      if (HookedKeys.Contains(key) == true) 
      { 
       KeyEventArgs kea = new KeyEventArgs(key); 

        if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && KeyUp != null) 
        { 
         KeyUp(this, kea); 
        } 
        else if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && KeyDown != null) 
        { 
         KeyDown(this, kea); 
        } 
        if (kea.Handled) return 1; 


      } 
     } 

    return CallNextHookEx(hookHandle, nCode, wParam, ref lParam); 
    } 


    public void hook() 
    { 
      IntPtr hInstance = LoadLibrary("user32"); 
      hookHandle = SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0); 
    } 


    public void unhook() 
    { 
     UnhookWindowsHookEx(hookHandle); 
    } 

    #endregion 

    #region Constructors and Destructors 

    public GlobalKeyboardHook() 
    { 
     hook(); 
    } 

    ~GlobalKeyboardHook() 
    { 
     unhook(); 
    } 

    #endregion 

Answer 1

Prova il debug dell'applicazione con il "CallbackOnCollectedDelegate" MDA acceso (Debug -> Eccezioni -> Gestito Debug Assistenti -> CHECK "CallbackOnCollectedDelegate").

Il bug comune è che il delegato per la procedura di hook viene automaticamente raccolto dal GC dopo aver impostato il hook (viene creato come parte del marshalling P/Invoke su SetWindowsHookEx). Dopo che il GC raccoglie il delegato, il programma si arresta in modo anomalo quando tenta di chiamare il callback. Questo spiegherebbe anche la casualità.

Se questo è il problema, verrà visualizzato un errore simile al seguente:

Una callback è stato effettuato su un bidone della spazzatura raccolta delegato del tipo '...'. Ciò potrebbe causare arresti anomali dell'applicazione, corruzione e perdita di dati. Quando si passano i delegati a codice non gestito, è necessario che venga mantenuto attivo dall'applicazione gestita finché non viene garantito che non verranno mai chiamati. .

provare a tenere un riferimento alla vostra routine di hook come un membro della tua classe, per es .:

public delegate int KeyboardHookProc(int nCode, int wParam, ref GlobalKeyboardHookStruct lParam); 

public int hookProc(int nCode, int wParam, ref GlobalKeyboardHookStruct lParam) 
{ 
    // ... 
} 

public void hook() 
{ 
    _hookProc = new KeyboardHookProc(hookProc); 
    IntPtr hInstance = LoadLibrary("user32"); 
    hookHandle = SetWindowsHookEx(WH_KEYBOARD_LL, _hookProc, hInstance, 0); 
} 

KeyboardHookProc _hookProc;