Cliente problema di monitoraggio keylogger

Question

Prima di tutto, il keylogger che sto sviluppando non è affatto per scopi offensivi e distruttivi. :)

Sto sviluppando un'applicazione di monitoraggio client in C # .NET. Keylogging è una delle caratteristiche della mia applicazione. Anche se ho sviluppato il codice per il keylogger, non sono stato in grado di attuare correttamente nella mia applicazione.

Ci sono due progetti in mia soluzione. L'UserInterface - per il lato server. Il Tracker - per PC lato client. Il Keylogger modulo di keylogging è nel progetto Tracker.

Ho utilizzato le classi di supporto per la programmazione socket -. TcpClient, TcpListener e NetworkStream per aiutarli

Inoltre, sto usando la modalità asincrona per la comunicazione.

Vi metto la parte di codice con cui sto affrontando il problema:

//This code resides on the server-side monitoring interface.When //the administrator hits a btnKeyLog button, a 

message //"StartKeyLog" is sent to the respective client, and the keylogging //is handled on the client.

private void btnKeyLog_Click (object sender, EventArgs e) {         MessageBuffer = new byte [100];

    if ( btnKeyLog1.Text == "Start Keylogging" )
    {
        btnKeyLog1.Text = "Stop Keylogging";
        message = "StartKeyLog";

        messageBuffer = Encoding.ASCII.GetBytes ( message );
        try
        {
                //begin writing on the stream.
        clientConnections[0].networkStream.BeginWrite (messageBuffer, 0, messageBuffer.Length, new 

AsyncCallback ( onDataWrite ), null );
        }
        catch ( Exception exc )
        {
            MessageBox.Show ( exc.Message + exc.StackTrace );
        }
    }
    else
    {
        btnKeyLog1.Text = "Start Keylogging";
        message = "StopKeyLog";

        messageBuffer = Encoding.ASCII.GetBytes ( message );
        try
        {
        clientConnections[0].networkStream.BeginWrite ( messageBuffer, 0, messageBuffer.Length, new 

AsyncCallback ( onDataWrite ), null );
        }
        catch ( Exception exc )
        {
            MessageBox.Show ( exc.Message + exc.StackTrace );
        }
    }
}

Ora, il codice lato client:

public void onDataReceived ( IAsyncResult ar )
{
    int nBytesRead = 0;
    try
    {
        nBytesRead = clientConnection.networkStream.EndRead ( ar );
    }
    catch ( Exception exc )
    {
        MessageBox.Show ( exc.Message + exc.StackTrace );
    }
    message = Encoding.ASCII.GetString ( messageBuffer,0, nBytesRead);
    switch (message)
    {
        case "StartKeyLog" :
            MessageBox.Show ( "Keylogger started." );
                       //the following static method wraps the Win32 //implementation of SetWindowsHookEx - all given in Keylogger //module
            KeyboardHook.installHook ( );
                       //after this method is called, the hook is //actually installed; the callback function KeyboardHookProc is also //called.        

    Here, keylogger seems to be working fine, except that the //system slows down considerably when i type keystrokes.
        break;

        case "StopKeyLog":
            MessageBox.Show ( "Keylogger stopped." );
                        // the following method releases the hook
            KeyboardHook.releaseHook ( );
        break;
    }

    try
    {
        messageBuffer = new byte[100];
        clientConnection.networkStream.BeginRead ( messageBuffer, 0, messageBuffer.Length, new AsyncCallback ( onDataReceived ), null );
    }
    catch ( Exception exc )
    {
        MessageBox.Show ( exc.Message + exc.StackTrace );
    }
    //MessageBox.Show ( "Stop" );
//as soon as this function ends, however, the callback function of //the keyboard hook stops being called; keystrokes are not //processed.
//the keystrokes are caught until this function the control is in this //function. i assume that it has to do something with the thread.
}

Sto cercando di spiegare la situazione qui. Per iniziare keylogging, l'interfaccia utente del server avrebbe mandato un messaggio "StartKeyLog" al client. Alla ricezione del messaggio, il client elaborarlo nella funzione di callback "onDataReceived" .In questa funzione, il messaggio viene elaborato e il

Metodo

installHook () viene chiamato, che installare il gancio.

Quando ho fatto funzionare l'applicazione, il gancio ha ottenuto installato; Inoltre, il KeyboardHookProc () di callback stato chiamato correttamente, e le sequenze di tasti sono stati elaborati. Ma questo

era il caso solo fino al metodo di callback onDataReceived era vivo. Non appena il metodo che si è conclusa, il KeyboardHookProc () smesso di ottenere chiamato; Tasti

non sono stati elaborati, come se il gancio è mai stato installato.

Un altro problema era che dopo il gancio ottenuto installato, il sistema ha ottenuto notevolmente rallentare quando ho colpito un tasto qualsiasi.

La mia ipotesi è che entrambe le cose hanno a che fare con la filettatura che accade qui. Ma, io non sono in grado di ottenere l'esatto problema. Ho fatto del mio meglio per spiegare la situation.Still, tutte le domande sono i benvenuti. Qualcuno potrebbe fornirmi la soluzione ??

Answer 1

bene, sono riuscito a risolvere il mio problema. Il problema era che ero installando il gancio di un filo che il filo principale della mia domanda aveva invocato. Infatti, i aveva iniziato quel filo solo installare il gancio. Ho appena ristrutturato il mio codice in modo che il gancio è stato installato sul thread principale. E 'risolto il problema intero. :)

Answer 2

Si dovrebbe aggiungere il codice della tua KeyboardHook.