Cliente problema Monitoreo keylogger

Question

En primer lugar, el keylogger que estoy desarrollando no es en absoluto para fines ofensivos y destructivas. :)

Estoy desarrollando una aplicación de supervisión del cliente en C # .NET. Keylogger es una de las características de mi solicitud. A pesar de que he desarrollado el código para el keylogger, no he sido capaz de implementar correctamente en mi solicitud.

Hay dos proyectos en la solución. El UserInterface - para el lado del servidor. El Rastreador - para PCs lado del cliente. El módulo de Keylogger keylogger está en el proyecto Tracker.

He utilizado las clases de ayuda para la programación del zócalo -. TcpClient, TcpListener y NetworkStream para ayudarles a salir

Además, estoy utilizando el modo asíncrono para la comunicación.

Estoy fijando la parte de código con el que estoy frente al 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 );
        }
    }
}

Ahora, el código del lado del cliente:

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.
}

Estoy tratando de explicar la situación aquí. Para iniciar keylogging, la interfaz de usuario del servidor enviaría un mensaje "StartKeyLog" al cliente. Al recibir el mensaje, el cliente lo procesará en la función de devolución de llamada "onDataReceived" .En esta función, el mensaje se procesa y la

método

installHook () se llama, lo que instalar el gancho.

Cuando me encontré con la aplicación, el gancho quedó instalado; También, el KeyboardHookProc () fue llamado de devolución de llamada correctamente, y se procesaron las pulsaciones de teclado. Pero esto

era el caso sólo hasta el método de devolución de llamada onDataReceived estaba vivo. Tan pronto como el método que terminó, el KeyboardHookProc () dejó de recibir llamada; teclas

ya no se procesaron, como si el gancho nunca fue instalado.

Otro problema fue que después quedó instalado el gancho, el sistema consiguió ralentizar considerablemente cuando golpeo cualquier tecla.

Mi hipótesis es que tanto las cosas tienen algo que ver con el roscado que pasa aquí. Sin embargo, no soy capaz de obtener el problema exacto. He hecho todo lo posible para explicar el situation.Still, cualquier pregunta son bienvenidos. ¿Alguien podría proporcionarle la solución ??

Answer 1

Bueno, he conseguido resolver mi problema. El problema era que yo estaba sentado en el gancho de un hilo que el hilo conductor de mi solicitud había invocado. De hecho, había comenzado ese hilo sólo para instalar el gancho. Yo sólo reestructurado mi código para que el gancho se instaló en el hilo principal. Se resolvió a cabo todo el problema. :)

Answer 2

Usted debe agregar el código de su KeyboardHook.