Как создать драйвер для windows

Уровень сложности
Средний

Время на прочтение
10 мин

Количество просмотров 26K

Небольшая предыстория

Совсем недавно я перешёл на 3 курс технического университета, где на нашу группу вновь навалилась целая куча новых предметов. Одним из них являлся ИиУВМ(Интерфейсы и устройства вычислительных машин), на котором нам предстояло изучать, как те или иные части компьютера взаимодействуют между собой. Уже на 2 лабораторной работе нам выдали задание, суть которого заключалась в переборе всех устройств на PCI шине и получению их Vendor и Device ID через порты ввода-вывода. Для упрощения задачи преподаватель выдал ссылку на специальный драйвер и dll библиотеку под Windows XP и заявил, что это оптимальный вариант выполнения работы, так как по другому сделать её невозможно. Перспектива писать код под устаревшую OS меня не радовала, а слова про «невозможность» другой реализации лишь разожгли интерес. После недолгих поисков я выяснил, что цель может быть достигнута с помощью самописного драйвера.

В этой статье я хочу поделиться своим опытом, полученным в ходе длительных блужданий по документации Microsoft и попыток добиться от ChatGPT вменяемого ответа. Если вам интересно системное программирование под Windows — добро пожаловать под кат.

Важно знать

Современные драйвера под Windows могут быть основаны на одном из двух фреймворков: KMDF и UMDF (Kernel Mode Driver Framework и User Mode Driver Framework). В данной статье будет рассматриваться разработка KMDF драйвера, так как на него наложено меньше ограничений в отношении доступных возможностей. До UMDF драйверов я пока не добрался, как только поэкспериментирую с ними, обязательно напишу статью!

Разработка драйверов обычно происходит с помощью 2 компьютеров (или компьютера и виртуальной машины), на одном вы пишите код и отлаживаете программу (хост-компьютер), на другом вы запускаете драйвер и молитесь, чтобы система не легла после ваших манипуляций (целевой компьютер).

Перед началом работы с драйверами обязательно создайте точку восстановления, иначе вы рискуете положить свою систему так, что она перестанет запускаться. В таком случае выходом из ситуации станет откат Windows в начальное состояние (то есть в состояние при установке), что уничтожит не сохранённые заранее файлы на системном диске. Автор данной статьи наступил на эти грабли и совсем забыл скопировать свои игровые сохранения в безопасное место…

Первый запуск драйвера после добавления обработки IOCTL запросов на моём компьютере приводит к падению системы с необходимостью откатываться на точку восстановления. После этого драйвер запускается и работает без проблем. Самое странное, что если перенести тот же код в новый проект и запустить этот драйвер, то падения не происходит. Причины этого найти мне не удалось, так что прошу помощи в комментариях.

Я не профессиональный разработчик и данная статья лишь способ проложить дорогу для тех, кому так же, как и мне, стало интересно выйти за рамки привычных user mode приложений и попробовать что-то новое. Критика и дополнения приветствуются, постараюсь по возможности оперативно исправлять все ошибки. Теперь точно всё

Установка компонентов

1. В данной статье я не буду рассматривать вопрос о создании Hello world драйвера, этот вопрос полностью разобран тут. Рекомендую чётко следовать всем указаниям этого руководства, для того чтобы собрать и запустить свой первый драйвер. Это может занять некоторое время, но как можно достигнуть цели не пройдя никакого пути? Если у вас возникнут проблемы с этим процессом, я с радостью помогу вам в комментариях.

2. Полезно будет установить утилиту WinObj, которая позволяет вам просматривать имена файлов устройств и находить символические ссылки, которые на них указывают. Качаем тут.

3. Также неплохой утилитой является DebugView. Она позволяет вам просматривать отладочные сообщения, которые отправляются из ядра. Для этого необходимо включить опцию Kernel Capture на верхней панели.

   Теперь с полным баком всяких утилит и библиотек переходим к самому интересному.

Начинаем веселье

В результате выполнения всех пунктов руководства Microsoft вы должны были сформировать файл драйвера cо следующим содержимым (комментарии добавлены от меня):

#include <ntddk.h>
#include <wdf.h>

// Объявление прототипа функции входа в драйвер, аналогично main() у обычных программ
DRIVER_INITIALIZE DriverEntry;

// Объявление прототипа функции для создания экземпляра устройства
// которым будет управлять наш драйвер
EVT_WDF_DRIVER_DEVICE_ADD KmdfHelloWorldEvtDeviceAdd;

// Пометки __In__ сделаны для удобства восприятия, на выполнение кода они не влияют.
// Обычно функции в пространстве ядра не возвращают данные через return 
// (return возвращает статус операции)
// так что при большом числе аргументов такие пометки могут быть полезны
// чтобы не запутаться
NTSTATUS
DriverEntry(
  // Фреймворк передаёт нам этот объект, никаких настроек мы для него не применяем
    _In_ PDRIVER_OBJECT     DriverObject, 
    // Путь, куда наш драйвер будет помещён
    _In_ PUNICODE_STRING    RegistryPath 
)
{
    // NTSTATUS переменная обычно используется для возвращения
    // статуса операции из функции
    NTSTATUS status = STATUS_SUCCESS;

    // Создаём объект конфигурации драйвера
    // в данный момент нас не интерсует его функциональность
    WDF_DRIVER_CONFIG config;

    // Макрос, который выводит сообщения. Они могут быть просмотрены с помощью DbgView
    KdPrintEx((DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "HelloWorld: DriverEntry\n"));

    // Записываем в конфиг функцию-инициализатор устройства
    WDF_DRIVER_CONFIG_INIT(&config,
        KmdfHelloWorldEvtDeviceAdd
    );

    // Создаём объект драйвера
    status = WdfDriverCreate(DriverObject,
        RegistryPath,
        WDF_NO_OBJECT_ATTRIBUTES,
        &config,
        WDF_NO_HANDLE
    );
    return status;
}

NTSTATUS
KmdfHelloWorldEvtDeviceAdd(
    _In_    WDFDRIVER       Driver,     // Объект драйвера
    _Inout_ PWDFDEVICE_INIT DeviceInit  // Структура-иницализатор устройства
)
{
    // Компилятор ругается, если мы не используем какие-либо параметры функции 
    // (мы не используем параметр Driver)
    // Это наиболее корректный способ избежать этого предупреждения
    UNREFERENCED_PARAMETER(Driver);

    NTSTATUS status;

    // Объявляем объект устройства
    WDFDEVICE hDevice;

    // Снова вывод сообщения
    KdPrintEx((DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "KmdfHelloWorld: DeviceAdd\n"));

    // Создаём объект устройства
    status = WdfDeviceCreate(&DeviceInit,
        WDF_NO_OBJECT_ATTRIBUTES,
        &hDevice
    );

    // Утрированный пример того, как можно проверить результат выполнения операции
    if (!NT_SUCCESS(status)) {
        return STATUS_ERROR_PROCESS_NOT_IN_JOB;
    }

    return status;
}

Данный драйвер не делает ничего интересного, кроме 2-х отладочных сообщений и создания экземпляра устройства. Пока мы не можем общаться с устройством из пространства пользователя. Нужно это исправить!

Весь дальнейший код будет добавляться в функциюKmdfHelloWorldEvtDeviceAddДля достижения цели необходимо создать файл устройства и символическую ссылку на него в пространстве ядра. С этим нам помогут функции WdfDeviceInitAssignNameи WdfDeviceCreateSymbolicLinkОднако просто вызвать их, передав имена файлов, не получится, нужна подготовка.

Начнём с тех самых имён. Они представляют собой строки в кодировке UTF-8. Следующий пример показывает способ инициализации строки в пространстве ядра.

UNICODE_STRING  symLinkName = { 0 };
UNICODE_STRING deviceFileName = { 0 };


RtlInitUnicodeString(&symLinkName, L"\\DosDevices\\PCI_Habr_Link");
RtlInitUnicodeString(&deviceFileName, L"\\Device\\PCI_Habr_Dev"); 

Желательно придерживаться показанного в примере стиля именования файла устройства, то есть начинаться имя должно с префикса \Device\

Следующим шагом становится установление разрешения на доступ к устройству. Оно может быть доступно или из пространства ядра, или из системных или запущенных администратором программ. Внимание на код.

 UNICODE_STRING securitySetting = { 0 };
 RtlInitUnicodeString(&securitySetting, L"D:P(A;;GA;;;SY)(A;;GA;;;BA)");

 // SDDL_DEVOBJ_SYS_ALL_ADM_ALL
 WdfDeviceInitAssignSDDLString(DeviceInit, &securitySetting);

Комментарий капсом — это пометка какой тип разрешения на устройство здесь выставлен. В документации Microsoft описаны константы, аналогичные комментарию, однако у меня компилятор их не видел, и мне пришлось вставлять строку в сыром виде. Ссылка на типы разрешений тут.

Далее необходимо настроить дескриптор безопасности для устройства. Если коротко, то это реакция устройства на обращения к своему файлу.

// FILE_DEVICE_SECURE_OPEN означает, что устройство будет воспринимать обращения
// к файлу устройства как к себе
WdfDeviceInitSetCharacteristics(DeviceInit, FILE_DEVICE_SECURE_OPEN, FALSE);

Наконец-то мы можем создать файл устройства:

 status = WdfDeviceInitAssignName(
     DeviceInit,
     &deviceFileName
 );

// Напоминание о том, что результат критичных для драйвера функций нужно проверять
 if (!NT_SUCCESS(status)) {
     WdfDeviceInitFree(DeviceInit);
     return status;
 }

Переходим к символической ссылке, следующий код должен быть вставлен после функции WdfDeviceCreate

 status = WdfDeviceCreateSymbolicLink(
     hDevice,
     &symLinkName
 );

Итоговый код функции KmdfHelloWorldEvtDeviceAdd должен иметь следующий вид:

NTSTATUS
KmdfHelloWorldEvtDeviceAdd(
    _In_    WDFDRIVER       Driver,     // Объект драйвера
    _Inout_ PWDFDEVICE_INIT DeviceInit  // Структура-иницализатор устройства
)
{
    // Компилятор ругается, если мы не используем какие-либо параметры функции 
    // (мы не используем параметр Driver)
    // Это наиболее корректный способ избежать этого предупреждения
    UNREFERENCED_PARAMETER(Driver);

    NTSTATUS status;

    UNICODE_STRING  symLinkName = { 0 };
    UNICODE_STRING deviceFileName = { 0 };
    UNICODE_STRING securitySetting = { 0 };

    RtlInitUnicodeString(&symLinkName, L"\\DosDevices\\PCI_Habr_Link");
    RtlInitUnicodeString(&deviceFileName, L"\\Device\\PCI_Habr_Dev");
    RtlInitUnicodeString(&securitySetting, L"D:P(A;;GA;;;SY)(A;;GA;;;BA)");

    // SDDL_DEVOBJ_SYS_ALL_ADM_ALL
    WdfDeviceInitAssignSDDLString(DeviceInit, &securitySetting);

    WdfDeviceInitSetCharacteristics(DeviceInit, FILE_DEVICE_SECURE_OPEN, FALSE);

    status = WdfDeviceInitAssignName(
        DeviceInit,
        &deviceFileName
    );

    // Hезультат критичных для драйвера функций нужно проверять
    if (!NT_SUCCESS(status)) {
        WdfDeviceInitFree(DeviceInit);
        return status;
    }

    // Объявляем объект устройства
    WDFDEVICE hDevice;

    // Снова вывод сообщения
    KdPrintEx((DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL,"HelloWorld: EvtDeviceAdd\n"));

    // Создаём объект устройства
    status = WdfDeviceCreate(&DeviceInit,
        WDF_NO_OBJECT_ATTRIBUTES,
        &hDevice
    );

    status = WdfDeviceCreateSymbolicLink(
        hDevice,
        &symLinkName
    );

    // Утрированный пример того, как можно проверить результат выполнения операции
    if (!NT_SUCCESS(status)) {
        return STATUS_ERROR_PROCESS_NOT_IN_JOB;
    }

    return status;
}

После сборки и установки драйвера, в утилите WinObj по пути «GLOBAL??» вы сможете увидеть следующее:

Общаемся с устройством

Взаимодействие с устройством происходит через IOCTL запросы. В режиме пользователя есть специальная функция, которая позволяет отправлять их устройству и получать данные в ответ. Пока сконцентрируемся на обработке этих запросов на стороне драйвера.

С чего начнётся этот этап? Правильно! С инициализации необходимых компонентов. Следите за руками:

WDF_IO_QUEUE_CONFIG  ioQueueConfig;
WDFQUEUE  hQueue;

// Инициализируем настройки очереди, в которую будут помещаться запросы
// Параметр WdfIoQueueDispatchSequential говорит то, что запросы будут обрабатываться
// по одному в порядке очереди
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(
    &ioQueueConfig,
    WdfIoQueueDispatchSequential
);

// Обработчик HandleIOCTL будет вызываться в ответ на функцию DeiviceIOControl
// Уже скоро мы создадим его
ioQueueConfig.EvtIoDeviceControl = HandleIOCTL;

// Создаём очередь
status = WdfIoQueueCreate(
      hDevice,    // Объект устройства уже должен существовать
      &ioQueueConfig,
      WDF_NO_OBJECT_ATTRIBUTES,
      &hQueue
);
if (!NT_SUCCESS(status)) {
      return status;
}

Очередь есть, но нет обработчика. Работаем:

// Выглядит страшно, но по сути код может быть любым числом, этот макрос использован 
// для более подробного описания возможностей IOCTL кода для программиста
#define IOCTL_CODE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x3000, METHOD_BUFFERED, GENERIC_READ | GENERIC_WRITE)

VOID HandleIOCTL(
    _In_ WDFQUEUE Queue,   // Объект очереди, применения ему я пока не нашёл
    _In_ WDFREQUEST Request, // Из этого объекта мы извлекаем входной и выходной буферы
    _In_ size_t OutputBufferLength,
    _In_ size_t InputBufferLength,
    _In_ ULONG IoControlCode // IOCTL код, с которым к устройству обратились
)
{
    NTSTATUS status = STATUS_SUCCESS;

    UNREFERENCED_PARAMETER(Queue);
    UNREFERENCED_PARAMETER(InputBufferLength);
    UNREFERENCED_PARAMETER(OutputBufferLength);
    UNREFERENCED_PARAMETER(Request);

   switch (IoControlCode)
   {
      case IOCTL_CODE:
      {
          // Обрабатываем тут
          break;
      }
   }

    // По сути своей return из обработчика
    // Используется, если запрос не возваращает никаких данных
    WdfRequestComplete(Request, status);
}

Вот мы уже и на финишной прямой, у нас есть очередь, есть обработчик, но последний не возвращает и не принимает никаких данных. Сделаем так, чтобы обработчик возвращал нам сумму переданных чисел.

Объявим 2 структуры, из их названий будет понятно для чего они будут использоваться. В режиме ядра лучше использовать системные типы данных, такие как USHORT, UCHAR и другие.

struct DeviceRequest
{
    USHORT a;
    USHORT b;
};

struct DeviceResponse
{
    USHORT result;
};

Обновлённая функция обработки IOCTL запроса:

VOID HandleIOCTL(
    _In_ WDFQUEUE Queue,   // Объект очереди, применения ему я пока не нашёл
    _In_ WDFREQUEST Request, // Из этого объекта мы извлекаем входной и выходной буферы
    _In_ size_t OutputBufferLength,
    _In_ size_t InputBufferLength,
    _In_ ULONG IoControlCode // IOCTL код, с которым к устройству обратились
)
{
    NTSTATUS status = STATUS_SUCCESS;

    UNREFERENCED_PARAMETER(Queue);
    UNREFERENCED_PARAMETER(InputBufferLength);
    UNREFERENCED_PARAMETER(OutputBufferLength);

    size_t returnBytes = 0;

    switch (IoControlCode)
    {
    case IOCTL_CODE:
    {
        struct DeviceRequest request_data = { 0 };

        struct DeviceResponse *response_data = { 0 };

        PVOID buffer = NULL;
        PVOID outputBuffer = NULL;
        size_t length = 0;

        // Получаем указатель на буфер с входными данными
        status = WdfRequestRetrieveInputBuffer(Request, 
                                               sizeof(struct DeviceRequest),
                                               &buffer,
                                               &length);

        // Проверка на то, что мы получили буфер и он соотвествует ожидаемому размеру
        // Очень важно делать такие проверки, чтобы не положить систему :)
        if (length != sizeof(struct DeviceRequest) || !buffer)
        {
            status = STATUS_INVALID_DEVICE_REQUEST;
            break;
        }

        request_data = *((struct DeviceRequest*)buffer);

        // Получаем указатель на выходной буфер
        status = WdfRequestRetrieveOutputBuffer(Request, 
                                                sizeof(struct DeviceResponse), 
                                                &outputBuffer,
                                                &length);
        if (length != sizeof(struct DeviceResponse) || !outputBuffer)
        {
            status = STATUS_INVALID_DEVICE_REQUEST;
            break;
        }
        response_data = (struct DeviceResponse*)buffer;

        // Записываем в выходной буфер результат
        response_data->result = request_data.a + request_data.b;
        // Вычисляем сколько байт будет возвращено в ответ на данный запрос
        returnBytes = sizeof(struct DeviceResponse);

        break;
    }
    }

    // Функция-return изменилась, так как теперь мы возвращаем данные
    WdfRequestCompleteWithInformation(Request, status, returnBytes);
}

Последний шаг — программа в режиме пользователя. Cоздаём обычный С или C++ проект и пишем примерно следующее:

#include <windows.h>
#include <iostream>

//Эта часть аналогична тем же объявлениям в драйвере
//================
#define IOCTL_CODE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x3000, METHOD_BUFFERED, GENERIC_READ | GENERIC_WRITE)

struct DeviceRequest
{
    USHORT a;
    USHORT b;
};

struct DeviceResponse
{
    USHORT result;
};
// ===========================

int main()
{
	HANDLE hDevice = CreateFileW(L"\\??\\PCI_Habr_Link", 
                                 GENERIC_READ | GENERIC_WRITE,
                                 FILE_SHARE_READ, 
                                 NULL, 
                                 OPEN_EXISTING,
                                 FILE_ATTRIBUTE_NORMAL,
                                 NULL);
  
	DeviceRequest request = { 0 };
	request.a = 10;
	request.b = 15;

	LPVOID input = (LPVOID)&request;

	DeviceResponse response = {  0};
	LPVOID answer = (LPVOID)&response;
	DWORD bytes = 0;

	bool res = DeviceIoControl(hDevice, IOCTL_CODE, input, sizeof(DeviceRequest),
		answer, sizeof(DeviceResponse), &bytes, NULL);

	response = *((DeviceResponse*)answer);
	std::cout << "Sum : " << response.result << std::endl;
	char ch;
	std::cin >> ch;

	CloseHandle(hDevice);
}

При запуске вы должны получить такой результат:

Заключение

Собственно, на этом всё. В конечном итоге мы получили драйвер, способный принимать и отвечать на запросы пользовательских программ. Дальнейшие модификации проекта ограничиваются лишь вашей фантазией.

Драйверы являются неотъемлемой частью операционной системы Windows и необходимы для взаимодействия между аппаратным обеспечением компьютера и операционной системой. Создание драйвера может быть сложной задачей, требующей специализированных знаний и навыков. В этом пошаговом руководстве мы рассмотрим основные этапы создания драйвера для Windows и предоставим подробные инструкции.

Прежде чем приступить к созданию драйвера, важно иметь хорошее понимание основных принципов работы драйверов и архитектуры операционной системы Windows. Также полезно быть знакомым с языком программирования C/C++, так как большинство драйверов для Windows создается на этом языке.

Первым шагом в создании драйвера для Windows является определение типа драйвера, который вы хотите создать. Драйверы Windows могут быть классифицированы по типу устройства, с которым они взаимодействуют, такими как драйверы для звуковых карт, видеокарт, сетевых адаптеров и т.д. Выбор типа драйвера будет зависеть от ваших потребностей и целей.

Перед началом работы

Создание драйвера для операционной системы Windows является сложным процессом, требующим глубокого понимания архитектуры Windows и навыков программирования на языке С/С++. В этой статье мы рассмотрим основные шаги, необходимые для создания драйвера для Windows.

1. Определение требований

Перед тем, как начать создание драйвера, необходимо определить его требования. К какому устройству он будет подключаться? Какие функции и возможности он должен предоставлять? Какие требования по производительности у него будут? Эти и другие вопросы помогут определить необходимые компоненты и функциональность драйвера.

2. Выбор среды разработки

Для разработки драйвера для Windows можно использовать различные инструменты и среды разработки. Наиболее популярными из них являются Microsoft Visual Studio и Windows Driver Kit (WDK). Они предоставляют все необходимые инструменты и библиотеки для разработки драйверов.

3. Подготовка окружения

Перед началом разработки драйвера необходимо настроить окружение разработчика. Это включает установку среды разработки, установку необходимых компонентов, настройку сборки и отладки драйвера, создание необходимых файлов и структур проекта.

4. Описание устройства

При создании драйвера необходимо описать устройство, к которому он будет подключаться. Это включает описание интерфейсов, команд, свойств, регистров и других характеристик устройства. Это описание будет использоваться при взаимодействии с системой и другими компонентами.

5. Разработка драйвера

Фактическая разработка драйвера включает в себя написание кода, реализацию необходимой функциональности, обработку событий, обмен данными с устройством и другие операции. Для этого используются языки программирования С и С++, а также специфические библиотеки и API.

6. Отладка и тестирование

После написания кода необходимо приступить к отладке и тестированию драйвера. Для этого можно использовать отладчики и инструменты, предоставляемые средами разработки Windows. Также рекомендуется провести тестирование с реальным устройством, чтобы убедиться в правильности работы драйвера.

В данной статье мы рассмотрели основные шаги, необходимые для создания драйвера для операционной системы Windows. Надеемся, что эта информация поможет вам начать разработку своего собственного драйвера.

Сборка необходимых инструментов

Прежде чем приступить к разработке драйвера для Windows, необходимо собрать все необходимые инструменты. Эти инструменты позволят вам создавать, отлаживать и собирать код в драйвера.

Вот список основных инструментов, которые вам понадобятся:

1. Visual Studio: Интегрированная среда разработки (IDE) от Microsoft, предназначенная для создания приложений под различные платформы, включая Windows. Вы можете скачать бесплатную Community-версию с официального сайта Microsoft.
2. Windows Driver Kit (WDK): Набор инструментов для разработки драйверов под платформу Windows. WDK включает в себя компиляторы, отладчики и другие необходимые утилиты. Вы можете скачать последнюю версию WDK с официального сайта Microsoft.
3. Драйвер поддержки отладки (Debugging Tools for Windows): Сборка утилит для отладки кода драйвера. Этот набор инструментов включает в себя отладчик, профилировщик и другие полезные инструменты. Debugging Tools for Windows доступен для загрузки с официального сайта Microsoft.
4. Документация: Подробные руководства и документация от Microsoft будут полезны при разработке драйвера. Ознакомьтесь с документацией по WDK и другим связанным технологиям, чтобы лучше понять основные концепции и процессы разработки драйвера.

После установки всех необходимых инструментов вы будете готовы к разработке драйвера для Windows. Вам понадобится Visual Studio для создания проекта драйвера, WDK для сборки и проверки драйвера, а также Debugging Tools for Windows для отладки и профилирования кода драйвера.

Будьте готовы к тому, что процесс разработки драйвера может потребовать времени и терпения. Важно тщательно изучить документацию, следовать рекомендациям и быть готовым исправлять ошибки и проблемы на пути к созданию стабильного и функционального драйвера для Windows.

Шаг 1: Создание проекта

Первый шаг в создании драйвера для Windows — создание проекта. Для этого необходимо выполнить следующие действия:

1. Открыть среду разработки, такую как Visual Studio.
2. Выбрать «Создать новый проект».
3. В появившемся окне выбрать «Проект для создания драйверов Windows».

После выполнения этих шагов будет создан базовый проект для драйвера Windows, который может быть дальше настроен и расширен.

Важно отметить, что при создании проекта необходимо выбрать подходящий для вашего типа драйвера шаблон проекта. Например, для создания драйвера устройства необходимо выбрать шаблон «Драйвер устройства для Windows».

После создания проекта вы можете приступить к следующему шагу, который включает настройку основных параметров проекта, таких как версия Windows, архитектура и многое другое.

Создание папки проекта

Перед тем как начать создание драйвера для Windows, необходимо создать папку проекта, в которой будут храниться все файлы и ресурсы, связанные с драйвером.

Чтобы создать папку проекта, выполните следующие шаги:

1. Откройте проводник Windows, найдите место на вашем компьютере, где хотите создать папку проекта.
2. Щелкните правой кнопкой мыши на свободном месте и выберите пункт «Создать» в контекстном меню.
3. В появившемся подменю выберите «Папку».
4. Введите название папки проекта и нажмите клавишу «Enter».

Теперь у вас есть папка проекта, в которой вы сможете хранить все необходимые файлы для создания драйвера.

Рекомендация: Для удобства, дайте папке проекта осмысленное имя, отражающее ее содержание и назначение. Например, «MyDriverProject».

Шаг 2: Настройка окружения разработки

После того как вы установили необходимые компоненты для разработки драйвера для Windows, вам потребуется настроить ваше рабочее окружение.

Вот несколько шагов, которые помогут вам настроить окружение разработки.

1. Установите Visual Studio. Visual Studio — это интегрированная среда разработки (IDE), которая предоставляет мощные инструменты для создания драйверов для Windows.
2. Установите компоненты Windows Driver Kit (WDK). WDK содержит все необходимые инструменты и библиотеки для разработки драйверов для Windows.
3. Настройте пути для компилятора и инструментов WDK. Это позволит Visual Studio обнаружить и использовать компоненты WDK при сборке проекта.
4. Установите отладчик Windows. Он позволит вам отлаживать свой драйвер и выполнять шаг-за-шагом отладку кода.

После завершения этих шагов ваше окружение разработки будет готово к созданию драйвера для Windows.

Установка необходимых пакетов

Прежде чем приступить к созданию драйвера для Windows, вам понадобится установить несколько необходимых пакетов. В этом разделе мы разберем, какие пакеты потребуются для успешной разработки драйвера.

1. Visual Studio

Для разработки драйверов для Windows вам понадобится Visual Studio — интегрированная среда разработки (IDE), разработанная компанией Microsoft. Visual Studio предоставляет все необходимые инструменты и компиляторы для создания драйверов. Вы можете загрузить и установить Visual Studio Community Edition бесплатно с официального веб-сайта Visual Studio.

2. Windows Driver Kit (WDK)

Windows Driver Kit (WDK) — набор инструментов, документации и примеров кода, предоставляемый Microsoft для разработки драйверов для Windows. WDK включает в себя необходимые компиляторы, заголовочные файлы и библиотеки для создания драйверов. Вы можете загрузить и установить WDK с официального сайта Microsoft.

3. Документация Microsoft

Microsoft предоставляет обширную документацию, которая поможет вам разобраться в процессе создания драйвера для Windows. В документации содержится информация об основных концепциях, API и примеры кода. Большая часть документации доступна онлайн на официальном сайте Microsoft.

4. Дополнительные инструменты и библиотеки

В зависимости от требований вашего проекта, вам может потребоваться установить дополнительные инструменты и библиотеки. Например, если вы работаете с определенными устройствами или проводите тестирование драйверов, вам может понадобиться установить дополнительные инструменты, такие как Windows Driver Framework (WDF) и Universal Serial Bus (USB) development tools.

5. Регулярные обновления

Не забывайте регулярно обновлять установленные пакеты, поскольку Microsoft периодически выпускает обновления для Visual Studio, WDK и других инструментов разработки.

После установки всех необходимых пакетов вы будете готовы приступить к созданию своего собственного драйвера для Windows. Удачи!

Создание сетевого драйвера для операционной системы Windows является комплексным и ответственным процессом, который требует высокой квалификации и знаний из области программирования. В данной статье мы рассмотрим основные этапы создания сетевого драйвера для Windows, начиная от необходимых инструментов и технологий и заканчивая тестированием и отладкой драйвера.

1. Зачем нужен сетевой драйвер?

Сетевой драйвер является программным обеспечением, которое позволяет вашей операционной системе взаимодействовать с сетевым оборудованием, таким как сетевые адаптеры, маршрутизаторы и коммутаторы. Он обеспечивает стабильную и быструю передачу данных между компьютерами в локальной сети и в Интернете.

2. Необходимые инструменты

Для создания сетевого драйвера вам понадобится следующее программное обеспечение:

— Visual Studio — интегрированная среда разработки (IDE) от Microsoft, которая предоставляет широкий спектр инструментов для разработки и отладки программного обеспечения под Windows.

— Windows Driver Kit (WDK) — это пакет разработчика драйверов для Windows, включающий в себя всю необходимую документацию, инструменты и примеры кода для разработки драйверов.

— Windows Hardware Lab Kit (HLK) — это набор тестового оборудования и программного обеспечения, который позволяет проверить и довести до совершенства работу сетевого драйвера.

— Драйверы сетевого оборудования Windows — драйверы сетевых адаптеров и другого оборудования, которые могут помочь вам в разработке сетевого драйвера.

3. Создание проекта сетевого драйвера в Visual Studio

Перед началом разработки сетевого драйвера вам необходимо создать проект в Visual Studio.

Для этого откройте Visual Studio и выберите «File» > «New» > «Project». В списке шаблонов проектов выберите «Windows Driver» и нажмите «Next». Заполните отображаемые поля, включая имя проекта и место сохранения файлов проекта. Нажмите «Finish», чтобы создать проект сетевого драйвера.

4. Написание кода драйвера

Сетевой драйвер является комплексным программным обеспечением, и код такого драйвера может быть сложным и длинным. Однако с использованием WDK вы можете легче начать работу с написанием кода и быстрее протестировать его.

В качестве одного из примеров рассмотрим создание драйвера Ethernet.

a) Интерфейс драйвера

Создайте интерфейс драйвера, который будет предоставлять таблицу методов для взаимодействия с ядром Windows. В интерфейсе должны быть определены следующие методы:

EXTERN_C_START

typedef struct _DRIVER_OBJECT DRIVER_OBJECT;
typedef struct _DEVICE_OBJECT DEVICE_OBJECT;

NTSTATUS DriverEntry(_In_ DRIVER_OBJECT* DriverObject, _In_ PUNICODE_STRING RegistryPath);

_When_(return==0, _At_(DeviceObject, __drv_allocatesMem(Mem)))
EXTERN_C NTSTATUS EthernetCreateDevice(_Inout_ DRIVER_OBJECT* DriverObject, _In_ PWCHAR DeviceName, _Out_ PDEVICE_OBJECT* DeviceObject);

EXTERN_C NTSTATUS EthernetDeleteDevice(_In_ PDEVICE_OBJECT DeviceObject);

EXTERN_C_END

b) Регистрация драйвера

Зарегистрируйте метод DriverEntry как точку входа для вашего драйвера. Эта функция вызывается при загрузке драйвера ядром Windows.

NTSTATUS DriverEntry(_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)
{
    UNREFERENCED_PARAMETER(RegistryPath);
 
    PDEVICE_OBJECT DeviceObject = NULL;
    UNICODE_STRING DeviceName;
    RtlInitUnicodeString(&DeviceName, L"\\Device\\EthDevice");

    NTSTATUS Status = EthernetCreateDevice(DriverObject, DeviceName.Buffer, &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }

    DriverObject->DriverUnload = EthernetDriverUnload;
    DriverObject->MajorFunction[IRP_MJ_CREATE] = EthernetCreate;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = EthernetClose;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = EthernetIoControl;
 
    DeviceObject->Flags |= DO_DIRECT_IO;
    DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

    return STATUS_SUCCESS;
}

c) Создание экземпляра устройства

Создайте функцию EthernetCreateDevice, которая будет вызвана при загрузке драйвера и которая создаст экземпляр устройства. Это позволит драйверу взаимодействовать с ядром Windows и управлять устройством.

NTSTATUS EthernetCreateDevice(_Inout_ PDRIVER_OBJECT DriverObject, _In_ PWCHAR DeviceName, _Out_ PDEVICE_OBJECT* DeviceObject)
{
    UNICODE_STRING DevName;
    RtlInitUnicodeString(&DevName, DeviceName);
    NTSTATUS Status = IoCreateDevice(DriverObject, 0, &DevName, FILE_DEVICE_NETWORK, 0, TRUE, DeviceObject);
 
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }

    (*DeviceObject)->StackSize = 5;
    (*DeviceObject)->Flags |= DO_BUFFERED_IO;

    return STATUS_SUCCESS;
}

5. Отладка и тестирование драйвера

После создания драйвера и написания кода его необходимо отладить и протестировать. Для этого используется Windows Debugger и Windows Hardware Lab Kit (HLK).

a) Отладка драйвера

Для отладки драйвера используйте Windows Debugger. Подключите отладочный компьютер к целевой машине и загрузите драйвер в операционную систему. Запустите Windows Debugger и подключитесь к отладочной машине.

Вы можете использовать следующие команды для отладки драйвера:

— bp

В один прекрасный день меня попросили написать Драйвер. На тот день мои познания в C/C++ ограничивались программой Hellow Word, и поэтому на вопрос: «Напишешь?» я самоуверенно ответил: «Конечно». На следующий день я узнал, что на свете существуют MSDN и DDK. Вскоре я понял, что не все Windows одинаковые, оказалось, что мой драйвер должен работать под Win2000/NT. У меня ушло больше месяца на то, чтобы скомпилировать и запустить свой первый Драйвер. По правде сказать, это был не совсем мой Драйвер, а точнее — это был genport из NTDDK. Но радовался я так, как будто минимум написал свою ОС.

Недавно мне пришлось опять вернуться к Драйверу. И вот вчера я, наконец-то, сдал работающий драйвер и решил написать эту небольшую статью, для того, чтобы как-то систематизировать то, что я узнал, и, чтобы когда мне снова придется взяться за драйвер, было от чего отталкиваться.

Люди, знающие что такое IOCTL, DEVICE_EXTENSION, MajorFunction и DriverEntry не найдут здесь ничего нового. Эта статья для тех, кто, возможно, никогда не слышал слово ДДК, и кто до сего дня никогда не заглядывал в исходники драйверов. И еще, я буду довольно-таки подробно описывать многие, даже очевидные вещи, поэтому напомню о том, что данная статья рассчитана на людей с очень малым опытом программирования, какой был у меня, когда я занялся написанием драйверов.

Первое, с чем сталкивается программист, решивший заняться драйверами, это почти полное отсутствие русскоязычной литературы по данной теме. За год поисков мне удалось найти всего три книги на русском, в которых хотя бы немного говорится о драйверах:

————————
1.   Свен Шрайбер «Недокументированные возможности Windows 2000». Издательство «Питер» 2002 год.
Здесь очень хорошо описан механизм динамической загрузки драйвера.
 ——————
2.   П. И. Рудаков, К. Г. Финогенов «Язык ассемблера: уроки программирования» Диалог МИФИ 2001 год.
Очень полезная книга для того, что бы понять, как писать драйвера без всякий Wizard-ов.
  ——————————  
3.   Светлана Сорокина, Андрей Тихонов, Андрей Щербаков «Программирование драйверов и систем безопасности». Издательство «БХВ-Петербург» 2002 год.
Здесь хорошо описывается многоуровневая модель драйверов.

Я ни в коей мере не претендую как на полноту освещения темы написания драйверов, так и на 100% правильность и достоверность того, что здесь написано (но все приведенные здесь исходники проверены и являются работоспособными). Буду благодарен всем, приславшим мне (01_artem@mail.ru) или высказавшим в форуме свои замечания.

Итак, я обращаюсь к человеку, решившему написать Драйвер уровня ядра под Win2000/NT. Надеюсь, эти заметки помогут сэкономить кучу времени и сил.

Прежде всего, я бы не рекомендовал (исходя из собственного опыта) пользоваться различными библиотеками (типа NuMega и всякими другими визардами). В основном из-за того, что даже для написания простейшего драйвера необходимо хотя бы поверхностное представление о том, как он функционирует. И самый простой способ получить представление об этом — написать драйвер самому. Мне, например, не хватило терпения разобраться с NuMega, и даже оболочки функций динамической загрузки/выгрузки драйвера, предложенные Свен Шрайбером в своей книге, я предпочел переписать.

Итак, начнем. Для начала надо установить на компьютер Visul C++ 6.0, MSDN и NTDDK установку проводить желательно именно в этом  порядке. Лично я пользуюсь редактором UltraEdit для работы с текстами драйверов, но, в принципе, исходный код драйвера можно набирать в любом текстовом редакторе, хоть в NotePad.

Создадим папку, в которой мы будем работать с драйвером (пусть это будет C:myDriver). В этой папке создадим 5 файлов:
1.   myDrv.c
2.   myDrv.h
3.   myDrv.rc
4.   MAKEFILE
5.   SOURCES

Начнем с последнего файла. В SOURCES скопируйте следующее:

  В MAKEFILE скопируйте следующее:

!INCLUDE $(NTMAKEENV)makefile.def

 В myDrv.rc скопируйте следующее:

#include <windows.h>
#include <ntverp.h>
#define VER_FILETYPE VFT_DRV
#define VER_FILESUBTYPE VFT2_DRV_SYSTEM
#define VER_FILEDESCRIPTION_STR     «Generic Port I/O»
#define VER_INTERNALNAME_STR        «myDrv.sys»
#include «common.ver»

А вот так должен выглядеть myDrv.h:

Теперь обратимся к тексту самого драйвера myDrv.c:

 Немного поясню содержимое файла myDrv.c. Итак, по порядку:

#define NT_DEVICE_NAME    L»\Device\myDrv»
#define DOS_DEVICE_NAME            L»\DosDevices\myDrv»- Эти строки служат для задания символических имен текстовыми строками с именами объекта устройства, который будет создан нашим драйвером.

Далее приведены прототипы используемых функций. Этим функциям можно дать произвольные имена, НО их сигнатура (состав параметров с типом возвращаемого значения) жестко заданы системой. [2]:Программная часть драйвера начинается с обязательной функции с именем DriverEntry(), которая автоматически вызывается системой на этапе загрузки драйвера. Эта функция должна содержать все действия по его инициализации. В качестве первого параметра наша функция получает указатель на объект драйвера типа PDRIVER_OBJECT.

При загрузке драйвера системы создается объект драйвера (driver object), олицетворяющий образ драйвера в памяти. С другой стороны, объект драйвера представляет собой структуру, содержащую необходимые для функционирования драйвера данные и адреса функций. В процессе инициализации драйвера (в DriverEntry()) создаются один или несколько объектов устройств (device object), олицетворяющие те устройства, с которыми будет работать драйвер. Этот самый  device object необходим для правильного функционирования драйвера и создается (как и в нашем случае) даже тогда, когда драйвер не имеет отношения к какому-либо реальному устройству.

Далее, в первых строках DriverEntry мы определяем используемые в ней данные, в т.ч. указатель на device object, и две символьные строки UNICODE_STRING с именами устройств. Системные программы взаимодействуют с объектом устройства, созданным драйвером, посредством указателя на него. Однако для прикладных программ объект устройства представляется одним из файловых объектов, и обращение к нему осуществляется по имени (в приложении мы будем использовать функцию CreateFile()).

Надо иметь в виду, что объект устройства должен иметь два имени, одно — в пространстве имен NT, другое — в пространстве имен Win32. Эти имена должны представлять собой структуры UNICODE_STRING. Имена объектов устройств составляются  по определенным правилам. NT-имя предваряется префиксом Device, а  Win32-имя — префиксом ?? (или DosDevice). При указании имен в Си-программе знак обратной косой черты удваивается. Для того, чтобы указанное в программе драйвера имя можно было использовать в приложении для открытия устройства, следует создать символическую связь между обоими заданными именами устройств. Для этого используем функцию IoCreateSymbolicLink(). Следующая обязательная операция — создание объекта устройства — осуществляется вызовом функции IoCreateDevice(). Первый параметр этой функции — это указатель на объект драйвера, поступающий в DriverEntry(). Второй параметр определяет размер расширения устройства — структуры, которая служит для передачи данных между функциями драйвера (состав этой структуры произволен и полностью определяется разработчиком). Третий параметр — созданное ранее NT-имя устройства. Далее идут: тип устройства (FILE_DEVICE_UNKNOWN), специальные характеристики (0), FALSE означает, что у нас однопоточное устройство. Наконец, последний параметр является выходным — через него функция возвращает указатель на созданный объект устройства.

Далее необходимо занести в объект драйвера адреса основных функций, включенных программистом в текст драйвера. Массив MajorFunction является одним из элементов структурной переменной. В этот массив мы и заносим адреса основных функций (т.е. функций, которые вызываются системой автоматически в ответ на определенные действия приложения или устройства). Завершается функция оператором return с указанием кода успешного завершения.

Функция DriverUnload() вызывается при выгрузке драйвера. Здесь мы должны выполнить действия по удалению объекта устройства, созданного в DriverEntry().

Функции DriverOpen и DriverClose в нашем случае ничего не делают и возвращают просто STATUSS_SUCCESS. Кстати, все эти функции тоже могут иметь произвольные имена, но передаваемые им параметры строго фиксированы.

[2]:Вот мы и добрались до самой содержательной, с точки зрения прикладного программирования, функции DriverDeviceControl(). Эта функция вызывается каждый раз, когда драйверу приходит IRP-пакет с каким либо IOCTL_ кодом. Грубо говоря, IRP-пакет — это структура, передавая указатель на которую, приложение может общаться с драйвером (как, впрочем, и драйвер может общаться с другим драйвером). Более подробное описание того, что такое IRP-пакет, можно найти здесь http://www.lcard.ru/~gorinov/texts/irp99.html.

IRP-пакет содержит так называемый системный буфер, служащий для обмена информацией (переменная SystemBuffer). Таким образом, нам надо получить доступ к IRP-пакету, а через него к SystemBuffer. Для этого объявляем переменную irpStack типа указателя на стековую область ввода-вывода PIO_STACK_LOCATION, и, кроме того, переменная ioBuffer, в которую будет помещен адрес системного буфера обмена. В нашем случае тип этой переменной — PULONG, в действительности тип передаваемых данных может быть каким угодно. С помощью функции IoGetCurrentIrpStackLocation() в переменную irpStack помещается адрес стековой области ввода-вывода, а в переменную ioBuffer заносится адрес системного буфера из структуры IRP. Системный буфер входит в объединение (union) с именем AssociatedIrp, поэтому мы используем конструкцию Irp->AssociatedIrp.SystemBuffer. Конструкция switch-case анализирует содержимое ячейки IoControlCode и в зависимости от значения кода выполняет те или иные действия. В нашей программе только один код действия TEST_SMTH. Засылка в буфер обмена адреса функции DriverEntry() осуществляется через указатель на этот буфер. В переменную Irp->IoStatus.Information заносим количество (4) пересылаемых байт. Для завершения IRP-пакета вызываем IoCompleteRequest().

Итак, драйвер мы написали. Теперь надо его скомпилировать. Т.к. процесс компиляции идет из командной строки, то для этой цели гораздо удобнее пользоваться bat-файлом. Создадим небольшой bat-файл с именем, допустим, Crt.bat и со следующим содержанием:

NTDDK у меня установлено в корень С:, если у Вас по-другому, то вместо C:NTDDKbin и C:NTDDK пропишите полные пути к соответствующим папкам.

Итак, теперь запустим наш Crt.bat. После окончания компиляции в папке C:myDriverobjfrei386 находим готовый драйвер myDrv.sys. Наш драйвер пока умеет только лишь загружаться/выгружаться и по специальному запросу посылает приложению адрес одной из своих процедур.

    Теперь займемся написанием приложения, работающего с нашим драйвером. Еще раз напоминаю, что мы работаем под Win2000. Эта ОС позволяет реализовать динамическую загрузку/выгрузку драйвера.

Точнее, динамическую загрузку/выгрузку служб (service), но т.к. в Win2000 в качестве службы можно рассматривать и драйвер, я буду использовать оба эти термина, подразумевая, в данной статье, наш драйвер.

Для загрузки и выгрузки драйверов используется диспетчер управления службами SC Manager (Service Control Manager). Прежде чем вы сможете работать с интерфейсом SC, вы должны получить дескриптор диспетчера служб. Для этого необходимо обратиться к функции OpenSCManager(). Дескриптор диспетчера служб необходимо использовать при обращении к функциям CreateServise() и OpenService(). Дескрипторы, возвращаемые этими функциями, необходимо использовать при обращении к вызовам, имеющим отношение к конкретной службе. К подобным вызовам относятся функции ControlService(), DeleteService() и StartService(). Для освобождения дескрипторов обоих типов используется вызов CloseServiceHandle().

Загрузка и запуск службы подразумевает выполнение следующих действий:

• Обращение к функции OpenSCManager() для получения дескриптора диспетчера
• Обращение к CreateServise() для того, чтобы добавить службу в систему. Если такой сервис уже существует, то CreateServise() выдаст ошибку с кодом 1073 (код ошибки можно прочитать GetLastError()) Данная ошибка означает, что сервис уже существует и надо вместо CreateServise() использовать OpenService().
• Обращение к StartService() для того, чтобы перевести службу в состояние функционирования.
• Если служба запустилась успешно, то можно вызвать CreateFile() для получения дескриптора, который мы будем использовать уже непосредственно при обращении к драйверу.
• И по окончании работы не забудьте дважды обратиться к CloseServiceHandle() для того, чтобы освободить дескрипторы диспетчера и службы.

Если на каком-то шаге этой последовательности возникла ошибка, нужно выполнить действия, обратные тем, которые вы успели выполнить до ошибки. Надо помнить о том, что при обращении к функциям, подобным CreateServise(), необходимо указывать полное имя исполняемого файла службы (в нашем случае полный путь и имя myDrv.sys).

Посмотрим на исходный текст простого консольного приложения, написанного на Visual C++  6.0:

И содержимое h-файла этого приложения:

Это приложение загружает драйвер, файл которого лежит в одной папке, что и exe-файл данного приложения.

Посмотрим на исходный текст:

В main() мы создаем переменную с именем драйвера (myDrv.sys) и передаем это имя в функцию динамической загрузки драйвера drvLoad(), которая выполняет все необходимые действия по работе с менеджером служб, и в конце вызывает CreateFile(), которая возвращает дескриптор, нужный для работы с драйвером как файловым объектом. Этот дескриптор, в частности, используется при вызове функции DeviceIoControl.

Если драйвер загружен успешно, то вызываем функцию TestSmth(), внутри которой мы создаем и посылаем драйверу IRP-пакет (с помощью вызова DeviceIoControl()). Приняв этот пакет, наш драйвер возвращает адрес своей процедуры DriverEntry. После этого выгружаем драйвер. Все.

Итак, мы написали простейший (дальше некуда) драйвер и приложение, работающее с ним. В этой статье я активно цитировал материалы из книги П. И. Рудаков, К. Г. Финогенов, по возможности делая ссылки на нее в виде:  [2].

Через некоторое время напишу о том, как на базе этого драйвера написать драйвер-фильтр для LPT-порта.