Tutorial: Piano virtual en Lenguaje C (Primer vistazo a los keylogger)


En esta publicación se va a hacer una aplicación totalmente sana y blanca donde a muchos les ayudará a volar la imaginación sobre como crear sencillos Keylogger caseros, digo caseros porque no estamos accediendo directamente al teclado mediante hooks ni cosas por el estilo (que espero hacer una publicación pronto sobre eso).

Buscando unos archivos encontré unos códigos que había hecho hace bastante tiempo y creo que es bueno compartirlos con todos ustedes para que se vallan internando en el mundo del Malware y toda la cosa. Para otros para que vean el Lenguaje C o la programación desde otro punto de vista más interesante. Y para otros que están buscando como hacer keyloggers y comenzar con este interesante tipo de Malware tan fácil de implementar y tan sencillo de introducir en un usuario común.

El programa que desarrollo es un piano virtual donde se presiona una tecla numérica o una letra y el sistema operativo emite un Beep. Uso el API de Windows para hacer posible este piano sencillo y fácil de hacer.

Sin más comencemos, copia el código:

#include
#include
#include

int piano();

int main()
{
    SetConsoleTitle("Piano");//Cambiamos el nombre de la consola
    //FreeConsole(); //Ocultar consola
    piano();
    return 0;
}

int piano()
{
   printf("Digite una numero o una letra: ");
   while(!GetAsyncKeyState(VK_ESCAPE)) //Mientras la tecla pulsada no sea ESC
    {
        if(GetAsyncKeyState('1')==-32767)
        {
            Beep(600,200);
            Sleep(10);
            Beep(670,200);
            Sleep(10);
            Beep(700,200);
            Sleep(10);
            Beep(650,200);
            Sleep(10);
            Beep(700,200);
            Sleep(10);
            Beep(600,200);
            Sleep(10);
            Beep(600,200);
            Sleep(10);
        }
        if(GetAsyncKeyState('2')==-32767)
            Beep(110,100);
        if(GetAsyncKeyState('3')==-32767)
            Beep(123,100);
        if(GetAsyncKeyState('4')==-32767)
            Beep(130,100);
        if(GetAsyncKeyState('5')==-32767)
            Beep(171,100);
        if(GetAsyncKeyState('6')==-32767)
            Beep(231,100);
        if(GetAsyncKeyState('7')==-32767)
            Beep(292,100);
        if(GetAsyncKeyState('8')==-32767)
            Beep(346,100);
        if(GetAsyncKeyState('9')==-32767)
            Beep(398,100);
        if(GetAsyncKeyState('0')==-32767)
            Beep(442,100);
        if(GetAsyncKeyState('¿')==-32767)
            Beep(460,100);
        if(GetAsyncKeyState('O')==-32767)
            Beep(485,100);
        if(GetAsyncKeyState('P')==-32767)
            Beep(511,100);
        if(GetAsyncKeyState('A')==-32767)
            Beep(523,100);
        if(GetAsyncKeyState('S')==-32767)
            Beep(587,100);
        if(GetAsyncKeyState('D')==-32767)
            Beep(659,100);
        if(GetAsyncKeyState('F')==-32767)
            Beep(698,100);
        if(GetAsyncKeyState('G')==-32767)
            Beep(784,100);
        if(GetAsyncKeyState('H')==-32767)
            Beep(876,100);
        if(GetAsyncKeyState('J')==-32767)
            Beep(982,100);
        if(GetAsyncKeyState('K')==-32767)
            Beep(1050,100);
        if(GetAsyncKeyState('L')==-32767)
            Beep(1151, 100);
        if(GetAsyncKeyState('Z')==-32767)
            Beep(1191, 100);
        if(GetAsyncKeyState('X')==-32767)
            Beep(1271, 100);
        if(GetAsyncKeyState('C')==-32767)
            Beep(1329, 100);
        if(GetAsyncKeyState('V')==-32767)
            Beep(1387, 100);
        if(GetAsyncKeyState('B')==-32767)
            Beep(1462, 100);
        if(GetAsyncKeyState('N')==-32767)
            Beep(1524, 100);
        if(GetAsyncKeyState('M')==-32767)
            Beep(1616, 100);
        Sleep(10);
    }
 }

Ahora vamos a explicar el código, obviamente para los más rigurosos hay métodos más rápidos y más eficientes para ejecutar este mismo código, pero lo hice así para que sea compresible. En la función main vemos que cambio el nombre de la consola, el comando SetConsoleTitle recibe como un parámetro una cadena de carácteres en el que cambia el título de la consola local, esto se hace para mejorar varias cosas:

  1. El aspecto visual de nuestra consola.
  2. Autolocalización de la ventana sin uso del TaskManager.
  3. Manejo de Handlers más fácilmente.

En otro post me entro en más detalles de lo que son las variables Handle y para que se usan (para los que no saben).

Luego vemos otra función FreeConsole(); que está declarada en Windows.h así como la función anteriormente explicada, donde FreeConsole(); libera la consola del sistema operativo y en palabras más sencillas la destruye, esto es muy útil en nuestros Malware . Así quedará nuestra aplicación totalmente oculta a los ojos de un usuario inexperto. Hay que tener cuidado con los programadores acostumbrados a usar funciones como system(“”); debido a que si usamos un comando de estos, se generará una consola en una fracción de segundo y dará un parpadeo, y esto si que asusta a una víctima.

En mi caso, como es una aplicación sin nada “malo” comento esta función porque no es necesaria. Si yo por X o Y motivos decidí ocultar la consola en una sección de mi programa pero más adelante deseo mostrar al usuario una información o algo así por el estilo debo usar la función que se llama AllocConsole(void); .

Más adelante en la función piano() vemos que hay un ciclo con una condición en particular:

while(!GetAsyncKeyState(VK_ESCAPE))

donde traducimos al lenguaje español, mientras no se presione la tecla ESC, donde capturamos los eventos del teclado con la función GetASyncKeyState y como parámetro usamos las Virtual Key Codes.

Luego vemos el primer condicional con diferentes cosas interesantes:

if(GetAsyncKeyState('1')==-32767) 

  1. Capturamos el evento del teclado.
  2. Enviamos el parámetro del Virtual Key Code (VKC) como un carácter.
  3. Para un condicional debemos hacer una igualdad entre presionado o no presionado, el equivalente en entero es 32767 (en algunos casos sirve sin esa comparación, pero para cubrir errores de compatibilidad es mejor colocarlo) .

Finalmente en el bloque de código del condicional hago todo lo que necesite hacer, en este caso, como es un piano :p haré un Beep que es una función que como su nombre lo dice emite un sonido el Sistema Operativo. En el primer condicional pongo diferentes sonidos y pausas del sistema para hacer una “melodía” jeje.

La función Beep recibe como parámetros una frecuencia y una duración y el tipo de dato es DWORD.

Hasta aquí este tutorial sobre ¿cómo hacer un piano virtual en Lenguaje C? y hecharle un primer vistazo a los keylogger. Debido al flujo de visitas a este tipo de post, iré publicando más programas de este estilo.

4 comentarios en “Tutorial: Piano virtual en Lenguaje C (Primer vistazo a los keylogger)

Los comentarios están cerrados.