Winddk для windows xp

The Microsoft® Windows Server™ 2003 Service Pack 1 (SP1) Driver Development Kit (DDK) provides a driver development environment for Windows Server 2003, Windows® XP, and Windows 2000. The DDK provides additional driver-specific headers, libraries, sources, tools, and documentation that are used to develop drivers for Windows Server 2003 SP1.

42
stars

34
forks

Branches

Tags

Activity

System Requirements

Operating Systems: Windows 7, Windows Server 2003 Service Pack 1, Windows Server 2003 x64 editions, Windows Server 2008, Windows Server 2008 R2, Windows Vista, Windows XP Service Pack 3

Installation Instructions

The Microsoft Windows Software Development Kits (SDK) provide sample program code, extra libraries, and documentation to aid application developers producing Windows applications. Microsoft Windows Driver Development Kits are similar sets of samples and libraries but specific to device driver development, and much more in-depth.

The Windows Driver Kit (WDK) Version 7.1.0 is an update to the WDK 7.0.0 release and contains the tools, code samples, documentation, compilers, headers and libraries with which software developers create drivers for Windows 7, Windows Vista, Windows XP, Windows Server 2008 R2, Windows Server 2008, and Windows Server 2003. A working knowledge of C programming is necessary
to use this kit to develop Windows drivers.

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

Шаг 0 — инструментарий для написания драйвера 

1) наличие Visual Studio 2008 
2) наличие WinDDK
3) наличие виртуальной машины (типа вмварь) и установленная на ней XP
4) наличие программы для отладки DebugView
5) желательна возможность просмотра краш-дамба оперативной памяти

Шаг 1 — настройка проекта Visual Studio для написания драйвера (привязка к WinDDK)

1) создаём в студии новый проект винапи ДЛЛ (ставим галочку пустой прожект)
2) добавляем в прожект новый *.cpp файл
3) Для начала копипастим туда код пустого драйвера
#include «ntddk.h»

NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
     return STATUS_UNSUCCESSFUL;
}

4) открываем свойства проекта (правой) и правим следующее:
<сорри за язык, это копипаст из текстового файлика, куда я записывал, как настраивал проект>

+  C\C++ – General – Debug Information Format = Program Database (/Zi)
+ C\C++ – Preprocessor – Preprocessor Definitions = _X86_ [для DEBUG-версии добавить также DBG] (там было WIN32;_DEBUG;_WINDOWS;_USRDLL;MEGADRIVER_EXPORTS)
+ C\C++ – Code Generation – Enable C++ Exceptions = No
+ C\C++ – Code Generation – Basic Runtime Checks = Default
+ C\C++ – Code Generation – Buffer Security Check = No (/GS-)
+ C\C++ – Advanced – Calling Convention = __stdcall (/Gz)
+ C\C++ – Advanced – Compile As = Compile as C Code (/TC) [если драйвер пишется на чистом Си]

+ Linker – General – Output File = $(OutDir)\$(ProjectName).sys
+ Linker – General – Enable Incremental Linking = Default
+ (см ниже **) Linker – Input – Additional Dependencies = ntoskrnl.lib hal.lib $(NOINHERIT) [сюда надо также добавить все необходимые в вашем драйвере библиотеки]
+ Linker – Input – Ignore All Default Libraries = Yes (/NODEFAULTLIB)
+ Linker – Manifest File – Generate Manifest = No
+ Linker – System – SubSystem = Native (/SUBSYSTEM:NATIVE)
+ Linker – System – Driver = Driver (/DRIVER)
+ Linker – Advanced – Entry Point = DriverEntry
+ Linker – Advanced – Base Address = 0x10000
+ Linker – Advanced – Randomized Base Address = Disable (/DYNAMICBASE:NO) //!!! в 90% случаях придётся заменить на Default
+ Linker – Advanced – Data Execution Prevention (DEP) = Disable (/NXCOMPAT:NO) //!!! тоже самое, заменяем на Default

потом допишем наши либы (либы для XP, т.к. драйвер для xp) 
C\C++ — General — адишонал инклуде директориес:
D:\WinDDK\6001.18002\inc\api
D:\WinDDK\6001.18002\inc\crt
D:\WinDDK\6001.18002\inc\ddk
**Linker — Input — одишонал депендиес:
D:\WinDDK\6001.18002\lib\wxp\i386\hal.lib
D:\WinDDK\6001.18002\lib\wxp\i386\ntoskrnl.lib

Шаг 2 — чтение необходимой литературы

1) Обязательно прочитать Джеффри Рихтер — Создание эффективных WIN32-приложений с учетом специфики 64-разрядной версии Windows
2) обязательно В.П. Солдатов — Программирование драйверов Windows
3) желательно Программирование драйверов для Windows Комиссарова 2007
4) для понимания Windows Internals. Fourth edition
5) Undocument NT

Шаг 3 — написание инстолятора драйвера

обычное winapi приложение(чтобы работало на голой XP), минимально — две кнопки, «текст бокс» для вывода статусов и другой отладочной информации, ну и пару «едитов» для ввода параметров, передаваемых драйверу

для XP чтобы установить драйвер в систему используем следующие функции:
1) SC_HANDLE ScManagerHandle = OpenSCManager(NULL, // local machine
NULL, // local database
SC_MANAGER_ALL_ACCESS // access required
);
2) SC_HANDLE ScServiceHandle  = CreateService ( ScManagerHandle, // handle of service control manager database
DRIVERNAME, // address of name of service to start
DRIVERNAME, // address of display name
SERVICE_ALL_ACCESS, // type of access to service
SERVICE_KERNEL_DRIVER, // type of service
SERVICE_DEMAND_START, // when to start service
SERVICE_ERROR_NORMAL, // severity if service fails to start
DRIVERBINARY, // address of name of binary file
NULL, // service does not belong to a group
NULL, // no tag requested
NULL, // no dependency names
NULL, // use LocalSystem account
NULL);// no password for service account

3)if (!StartService(ScServiceHandle,// service identifier
0, // number of arguments
NULL // pointer to arguments
  ))…

естественно проверки на нулл и обязательные CloseServiceHandle(ScServiceHandle) я опустил, суть  — читаем msdn по таким функциям
  OpenSCManager, CreateService, StartService — собственно последовательность для установки драйвера

Для того чтобы удалить из системы (XP) драйвер:

1) ScServiceHandle = OpenService(ScManagerHandle, DRIVERNAME, SERVICE_ALL_ACCESS);
2) ControlService(ScServiceHandle,  SERVICE_CONTROL_STOP, &serviceStatus)
3) DeleteService(ScServiceHandle)
ну и CloseServiceHandle(ScServiceHandle);

Для того чтобы передать что-то в драйвер/записать в драйвер:

1) HANDLE hFile = CreateFileA(«\\\\.\\MegaDriver», GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

2) DeviceIoControl(hFile, //хендл драйвера-файла… девайса вообщем
IOCTL_JUST_CHECK_STATUS,//типа запроса (задефайнен в DriverInterface.h)
NULL,
0,
&OutBuffer,
sizeof(OutBuffer),
&BytesReturned,
NULL)

+ что касается дефайнов, они не простые
#define IOCTL_SEND_DATA_STRUCT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x0800, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)
#define IOCTL_JUST_CHECK_STATUS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x0801, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)
// 0x0800 и больше — не случайная цифра, подробнее читать в литературе (список выше)

+ буффер может быть структурой, у меня это 
typedef struct TMegaDriverData{
char procToFind[255];
char procToOpen[255];
char status[255];
}MegaDriverData, PMegaDriverData;
!!! структура должна быть одинаковой и в хедере инсталятора и в хедере драйвера

Впринципе азы для написания инсталятора я перечислил, остальное за вами… приступим к главному

Шаг 4 — написание минимального драйвера

Пример задачи: Разработать драйвер (виртуального устройства), который отслеживает запуск
некоторого процесса X. При запуске этого процесса драйвер запускает другой
процесс Y. Как только процесс X завершается по какой-то причине, драйвер
выгружает процесс Y.

в хедере драйвера
наша структура с данными и дефайны

typedef struct TMegaDriverData{
char procToFind[255];
char procToOpen[255];
char status[255];
}MegaDriverData, PMegaDriverData;

int DataSize = sizeof(MegaDriverData);

#define IOCTL_SEND_DATA_STRUCT CTL_CODE(FILE_DEVICE_UNKNOWN, 0x0800, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)
#define IOCTL_JUST_CHECK_STATUS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x0801, METHOD_BUFFERED, FILE_READ_DATA | FILE_WRITE_DATA)

Много недокументированных структур
при получения списка процессов будут использоваться некоторые недокументированные типы и структуры, некоторые не понадобятся, но всё же я кину длинный список андокумент структур, которые выгугливались

//для поиска процессов
typedef struct _ProcessRecord
{
ULONG Visibles;
ULONG SignalState;
BOOLEAN Present;
ULONG ProcessId;
ULONG ParrentPID;
PEPROCESS pEPROCESS;
CHAR ProcessName[256];
} TProcessRecord, *PProcessRecord;

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//!!!!!!!!!!!!!!! ещё немного системных сруктур
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//это очень хитрый код,
//который заставляет работать хитрую функцию ZwQuerySystemInformation

#ifndef _ENUMPROC_
#define _ENUMPROC_

typedef enum _SYSTEM_INFORMATION_CLASS {
SystemBasicInformation, // 0
SystemProcessorInformation, // 1
SystemPerformanceInformation, // 2
SystemTimeOfDayInformation, // 3
SystemNotImplemented1, // 4
SystemProcessesAndThreadsInformation, // 5
SystemCallCounts, // 6
SystemConfigurationInformation, // 7
SystemProcessorTimes, // 8
SystemGlobalFlag, // 9
SystemNotImplemented2, // 10
SystemModuleInformation, // 11
SystemLockInformation, // 12
SystemNotImplemented3, // 13
SystemNotImplemented4, // 14
SystemNotImplemented5, // 15
SystemHandleInformation, // 16
SystemObjectInformation, // 17
SystemPagefileInformation, // 18
SystemInstructionEmulationCounts, // 19
SystemInvalidInfoClass1, // 20
SystemCacheInformation, // 21
SystemPoolTagInformation, // 22
SystemProcessorStatistics, // 23
SystemDpcInformation, // 24
SystemNotImplemented6, // 25
SystemLoadImage, // 26
SystemUnloadImage, // 27
SystemTimeAdjustment, // 28
SystemNotImplemented7, // 29
SystemNotImplemented8, // 30
SystemNotImplemented9, // 31
SystemCrashDumpInformation, // 32
SystemExceptionInformation, // 33
SystemCrashDumpStateInformation, // 34
SystemKernelDebuggerInformation, // 35
SystemContextSwitchInformation, // 36
SystemRegistryQuotaInformation, // 37
SystemLoadAndCallImage, // 38
SystemPrioritySeparation, // 39
SystemNotImplemented10, // 40
SystemNotImplemented11, // 41
SystemInvalidInfoClass2, // 42
SystemInvalidInfoClass3, // 43
SystemTimeZoneInformation, // 44
SystemLookasideInformation, // 45
SystemSetTimeSlipEvent, // 46
SystemCreateSession, // 47
SystemDeleteSession, // 48
SystemInvalidInfoClass4, // 49
SystemRangeStartInformation, // 50
SystemVerifierInformation, // 51
SystemAddVerifier, // 52
SystemSessionProcessesInformation // 53
} SYSTEM_INFORMATION_CLASS;

typedef struct _SYSTEM_THREAD_INFORMATION {
LARGE_INTEGER KernelTime;
LARGE_INTEGER UserTime;
LARGE_INTEGER CreateTime;
ULONG WaitTime;
PVOID StartAddress;
CLIENT_ID ClientId;
KPRIORITY Priority;
KPRIORITY BasePriority;
ULONG ContextSwitchCount;
LONG State;
LONG WaitReason;
} SYSTEM_THREAD_INFORMATION, * PSYSTEM_THREAD_INFORMATION;

typedef struct _SYSTEM_PROCESS_INFORMATION {
ULONG NextEntryDelta;
ULONG ThreadCount;
ULONG Reserved1[6];
LARGE_INTEGER CreateTime;
LARGE_INTEGER UserTime;
LARGE_INTEGER KernelTime;
UNICODE_STRING ProcessName;
KPRIORITY BasePriority;
ULONG ProcessId;
ULONG InheritedFromProcessId;
ULONG HandleCount;
ULONG Reserved2[2];
VM_COUNTERS VmCounters;
IO_COUNTERS IoCounters;
SYSTEM_THREAD_INFORMATION Threads[1];
} SYSTEM_PROCESS_INFORMATION, * PSYSTEM_PROCESS_INFORMATION;
//самый хитрый код, собстно ZwQuerySystemInformation
NTSYSAPI
NTSTATUS
NTAPI
ZwQuerySystemInformation(
IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
OUT PVOID SystemInformation,
IN ULONG SystemInformationLength,
OUT PULONG ReturnLength OPTIONAL
);

#endif

конец хедера

Функции которые мы будем писать:
//Entry Point — точка входа
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath);

//обработчики IO обращений к драйверу
NTSTATUS CreateMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS ReadMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS WriteMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS CloseMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
//System
NTSTATUS ShutDownMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS CleanUpMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS IoCtlMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);

//Exit Point
NTSTATUS MyDriverUnload(IN PDRIVER_OBJECT DriverObject);

//Labz Fints
NTSTATUS WriteToFile(IN char myString[]);//своеобразный запись в логфайл на винте
BOOLEAN FindProcess(IN char ProcessName[]);//суть задания
void NotifyRoutine(IN HANDLE ParentId, IN HANDLE ProcessId, IN BOOLEAN Create);//чтобы в таймере вечно не проверять список процессов, а проверять только при запуске нового процесса в системе

Может понадобиться
#include «ntddk.h»
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
…

Код Драйвера:
<не самый оптимальный код, всётаки писал очень давно, да и это первый драйвер в моей жизни)) ботинками не кидать!>
<комментарии писал во время написания драйвера, буду стараться их отцензурить и дописать по понятнее>
<на название драйвера (Мега) закройте глаза>
<к сожалению сбились все студийные отступы((>

//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//!!!!! Some Global Vars
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
MegaDriverData gData; //структурка в которой хранятся параметры, переданные из Юзерской проги (2-3 строки)
BOOLEAN gInited; //флаг, который показывает пришла ли структура с параметрами (тру если да)
HANDLE gThreadHandle; //хендл потока, который будем создавать, для поиска процессов
PKEVENT gEvent;//id именованного евента
HANDLE ghProcessHandle;//хендл этого евента
//———————
char FindBuffer[256];
typedef ULONG DWORD;
typedef VOID* LPVOID;
#define STATUS_INFO_LENGTH_MISMATCH ((NTSTATUS)0xC0000004L) //код ошибки, которую возвращает ZwQuerySystemInformation
//если вдруг ей нехватает выделенного буффера
//в таком случае надо выделить бефер побольше
#define SystemProcessesAndThreadsInformation 5 // тупо тип вывода(отображения) инфы

//==================================================================================
//===== Процедура Входа в драйвер
//==================================================================================
NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
UNICODE_STRING NameString, LinkString, ProcessEventName;
PDEVICE_OBJECT DeviceObject;//переменная объекта устройства
NTSTATUS Status;//код статуса
PEXAMPLE_DEVICE_EXTENSION dx;
PVOID pvWaitEvents[1];
OBJECT_ATTRIBUTES oaUserEvent;
gInited = FALSE;
 DbgPrint(» >MegaDriver: we are inda DriverEntry»); //открываем DbgView — он отлавливает DbgPrint — будем видеть что происходит

 //================================================================================================
//===== Инитим указатели на функции
 //================================================================================================
DriverObject->DriverUnload = MyDriverUnload;
DriverObject->MajorFunction[IRP_MJ_CREATE] = CreateMyDriver;//CreateFile
DriverObject->MajorFunction[IRP_MJ_READ] = ReadMyDriver; //readfile
DriverObject->MajorFunction[IRP_MJ_WRITE] = WriteMyDriver; //write…
DriverObject->MajorFunction[IRP_MJ_CLOSE] = CloseMyDriver; //CloseFile
//DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = ShutDownMyDriver;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = IoCtlMyDriver;

 //=================================================================================================
//===== Создаём девайс
 //=================================================================================================
//юникодим имя нашего драйвера
RtlInitUnicodeString(&NameString, L»\\Device\\MegaDriver»);
//создаём девайс
Status = IoCreateDevice(DriverObject, sizeof(65533), &NameString, 0, 0, FALSE, &DeviceObject);
if(!NT_SUCCESS(Status))
{
DbgPrint(» >MegaDriver: DriverEntry-> IoCreateDevice — [failed]»);
return Status;
}
else DbgPrint(» >MegaDriver: DriverEntry-> IoCreateDevice — [ok]»);

//если всё гуд, то ставим флаги
DeviceObject->Flags |= DO_DIRECT_IO;
DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;

// Получаем указатель на область, предназначенную под
// структуру расширение устройства
dx = (PEXAMPLE_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
dx->fdo = DeviceObject; // Сохраняем обратный указатель

 //==========================================================================================
//===== Создаём симболик линк
 //==========================================================================================
//Юникодим имя линку
RtlInitUnicodeString(&LinkString, L»\\DosDevices\\MegaDriver»);
//создаём символьную ссылку
Status = IoCreateSymbolicLink(&LinkString, &NameString);

//если краш, то удаляем девайс и выходим
if(!NT_SUCCESS(Status))
{
   DbgPrint(» >MegaDriver: DriverEntry-> IoCreateSymbolikLink — [failed]»);
   IoDeleteDevice(DriverObject->DeviceObject);//сносим девайс
return Status;
} else DbgPrint(» >MegaDriver: DriverEntry-> IoCreateSymbolikLink — [ok]»);

 //==================================================================================================
//===== Создаём евент
 //==================================================================================================
//RtlInitUnicodeString(&ProcessEventName, L»\\\\BaseNamedObjects\\Global\\EVENT_NAME»);
//gEvent = IoCreateNotificationEvent(&ProcessEventName, &ghProcessHandle);
//if(ghProcessHandle!=NULL)
//{
// KeClearEvent(gEvent);
// DbgPrint(» >MegaDriver: DriverEntry-> EventCreated — [ok]»);
 //}//хоть код и закоменчен, может пригодиться =) 
RtlInitUnicodeString(&ProcessEventName,L»\\BaseNamedObjects\\DriverProcessEvent»);//v draivere
gEvent = IoCreateNotificationEvent(&ProcessEventName,&ghProcessHandle);
if(ghProcessHandle!=NULL)
{
KeClearEvent(gEvent);
DbgPrint(» >MegaDriver: DriverEntry-> EventCreated — [ok]»);
}

//BSOD
//KeBugCheck(1);
if(NT_SUCCESS(Status))
DbgPrint(» >MegaDriver: DriverEntry-> all done — [ok]»);

return STATUS_SUCCESS;
}

//================================================================================================
//===== Функция создания
//================================================================================================
NTSTATUS CreateMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
DbgPrint(» >MegaDriver: CreateDriver-> we are inda \»file\» — [ok]»);
IoCompleteRequest(Irp, IO_NO_INCREMENT);//завершаем обработку запроса

return STATUS_SUCCESS;
}

//=================================================================================================
//===== Функция Чтения  // обработка IO будет в IOctl
/================================================================================================
NTSTATUS ReadMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
IoCompleteRequest(Irp, IO_NO_INCREMENT);//завершаем обработку запроса
DbgPrint(» >MegaDriver: ReadDriver»);

return STATUS_SUCCESS;
}

//==================================================================================================
//===== Функция Записи
//=================================================================================================
NTSTATUS WriteMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
IoCompleteRequest(Irp, IO_NO_INCREMENT);//завершаем обработку запроса
DbgPrint(» >MegaDriver: WriteDriver»);

return STATUS_SUCCESS;
}

//===============================================================================================
//===== Функция закрытия
//==============================================================================================
NTSTATUS CloseMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
DbgPrint(» >MegaDriver: CloseMyDriver-> trying to close \»file\» «);
IoCompleteRequest(Irp, IO_NO_INCREMENT);//завершаем обработку запроса
DbgPrint(» >MegaDriver: CloseMyDriver-> closed — [ok] «);

return STATUS_SUCCESS;
}

//=====================================================================================
//===== Функция Остановки Драйвера
//=====================================================================================
NTSTATUS ShutDownMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
DbgPrint(» >MegaDriver: StopDriver»);
IoCompleteRequest(Irp, IO_NO_INCREMENT);//завершаем обработку запроса

return STATUS_SUCCESS;
}

!!!важная функция

//===============================================================================================
//===== Функция IO Control
//===============================================================================================
NTSTATUS IoCtlMyDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
MegaDriverData *pdata;
NTSTATUS status = STATUS_SUCCESS;
ULONG BytesCount =0; // Число переданных/полученных байт (пока 0)
PIO_STACK_LOCATION IrpStack=IoGetCurrentIrpStackLocation(Irp);
UCHAR *buff;//for byte

// Получаем указатель на расширение устройства
PEXAMPLE_DEVICE_EXTENSION dx = (PEXAMPLE_DEVICE_EXTENSION)DeviceObject->DeviceExtension;

// Выделяем из IRP значение IOCTL кода (причина вызова)
ULONG ControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
//лог
DbgPrint(» >MegaDriver: IoCtlDriver — we are in»);

//——————————————————————————-———————————
switch(ControlCode)
{
//тут нам прислали структурку с двумя строкаме
case IOCTL_SEND_DATA_STRUCT:
BytesCount = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
if(DataSize == BytesCount)
{
//===================================================================================================
//===== Получаем параметры
//===================================================================================================
DbgPrint(» >MegaDriver: IoCtlDriver -> Check BufferIn Size — [ok]»);

//проверяем параметр
if(((MegaDriverData*)Irp->AssociatedIrp.SystemBuffer)->procToFind == NULL)
{
DbgPrint(» >MegaDriver: IoCtlDriver -> Input Params == NULL»);
break;//сваливаем нахер, ибо иначе может быть бсод…
}
//copy data
strcpy(gData.procToFind, ((MegaDriverData*)Irp->AssociatedIrp.SystemBuffer)->procToFind);
strcpy(gData.procToOpen, ((MegaDriverData*)Irp->AssociatedIrp.SystemBuffer)->procToOpen);
//show what we have
DbgPrint(» >MegaDriver: IoCtlDriver -> Input Params:»);
DbgPrint(» >MegaDriver: IoCtlDriver -> procToFind %s», gData.procToFind);
DbgPrint(» >MegaDriver: IoCtlDriver -> procToOpen %s», gData.procToOpen);
//if not BSOD =)
gInited = TRUE;
  //Шикарно… тут мы приняли параметрЫ !!!

//создаем нотифаер на создание нового процесса в системе
PsSetCreateProcessNotifyRoutine(NotifyRoutine, FALSE);

//===================================================================================================
//===== Чонить отсылаем обратно
//===================================================================================================
pdata = (MegaDriverData*)Irp->AssociatedIrp.SystemBuffer;
strcpy(gData.status, «all data accepted»);//нипашет пока
strcpy(pdata->procToFind, «11111111111»);
strcpy(pdata->procToOpen, «22222222222»);
if(FindProcess(FindBuffer))
{
DbgPrint(» >MegaDriver: +++ PROCESS FOUND +++»);
strcpy(pdata->status, «found»);
}
else
{
strcpy(pdata->status, «not found»);
}
Irp->IoStatus.Information = sizeof(gData);

DbgPrint(» >MegaDriver: IoCtlDriver -> Status: %s», pdata->status);

//осталось всеголишь найти нужный процесс)))

//IoRequestDpc( //create DPC
//IoInitializeDpcRequest
//KeInsertQueueDpc
//PsCreateSystemThread//IRQL_PASSIVE_LEVEL
//WriteToFile(«First test string from IoCtl \r\n»);
//———

}
else DbgPrint(» >MegaDriver: IoCtlDriver -> Check BufferIn Size — [failed]»);
break;
case IOCTL_JUST_CHECK_STATUS:
pdata = (MegaDriverData*)Irp->AssociatedIrp.SystemBuffer;
strcpy(gData.status, «all data accepted»);//нипашет пока
strcpy(pdata->procToFind, «11111111111»);
strcpy(pdata->procToOpen, «22222222222»);
if(FindProcess(FindBuffer))
{
DbgPrint(» >MegaDriver: +++ PROCESS FOUND +++»);
strcpy(pdata->status, «found»);
}
else
{
strcpy(pdata->status, «not found»);
}
Irp->IoStatus.Information = sizeof(gData);

DbgPrint(» >MegaDriver: IoCtlDriver -> Status: %s», pdata->status);
break;
default:
DbgPrint(» >MegaDriver: IoCtlDriver -> UnKnown ControlCode»);
}
//——————————————————————————-———————————

IoCompleteRequest(Irp, IO_NO_INCREMENT);//завершаем обработку запроса

return STATUS_SUCCESS;
}

//=======================================================================================
//===== Функция Выгрузки Драйвера
//=======================================================================================
NTSTATUS MyDriverUnload(IN PDRIVER_OBJECT DriverObject)
{
UNICODE_STRING LinkString;

//PsTerminateSystemThread(STATUS_SUCCESS);

//сносим евент
//eve//ZwClose(ghProcessHandle);
ZwClose(ghProcessHandle);

//снимает нотифаер на создание процесса в системе (если же он конечно создан)
if(gInited)PsSetCreateProcessNotifyRoutine(NotifyRoutine, TRUE);

DbgPrint(» >MegaDriver: UnloadDriver»);
//Юникодим имя симлики
RtlInitUnicodeString(&LinkString, L»\\DosDevices\\MegaDriver»);
//удаляем симлинк
IoDeleteSymbolicLink(&LinkString);
//удаляем девайс
IoDeleteDevice(DriverObject->DeviceObject);

return STATUS_SUCCESS;
}

//File name — HardCoded
//open file, write myString to file, close file
//IRQL: PASSiVE_LEVEL
//
NTSTATUS WriteToFile(IN char myString[])
{
NTSTATUS status;
UNICODE_STRING fullFileName;
HANDLE fileHandle;
IO_STATUS_BLOCK iostatus;
OBJECT_ATTRIBUTES oa;
ULONG len;

//юникодим имя файла
RtlInitUnicodeString( &fullFileName,
L»\\??\\C:\\MegaDriverLog.txt»);

InitializeObjectAttributes( &oa,
&fullFileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
NULL,
NULL );
//открываем/создаем файл
status = ZwCreateFile ( &fileHandle,
GENERIC_WRITE | SYNCHRONIZE,//IN ACCESS_MASK
&oa,// IN POBJECT_ATTRIBUTES
&iostatus,//OUT PIO_STATUS_BLOCK
0, // alloc size = none//IN PLARGE_INTEGER
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_WRITE,
FILE_OPEN_IF,//если есть — дописать
FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0);
// Здесь:
// GENERIC_WRITE равно STANDARD(0x40000000L)
//
// FILE_GENERIC_WRITE равно STANDARD_RIGHTS_WRITE|FILE_WRITE_DATA |
// FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_APPEND_DATA |
// SYNCHRONIZE, что можно увидеть в заголовочном файле winnt.h

if( NT_SUCCESS(status))
{
// Структура, которая поможет определить длину файла:
FILE_STANDARD_INFORMATION fileInfo;

status = // Получаем информацию о файле
ZwQueryInformationFile( fileHandle,
&iostatus,
&fileInfo,
sizeof(FILE_STANDARD_INFORMATION),
FileStandardInformation
);
len = strlen(myString);
if( NT_SUCCESS(status) )
{
LARGE_INTEGER ByteOffset = fileInfo.EndOfFile;
status = ZwWriteFile(fileHandle,
NULL,
NULL,
NULL,
&iostatus,
myString, len, // Записываемая строка
&ByteOffset, // a если NULL? см. ниже
NULL);
if( !NT_SUCCESS(status) || iostatus.Information != len )
{
DbgPrint(«WriteToFile: Error on writing. Status = %x.», status);
}
}
ZwClose(fileHandle);
}

return STATUS_SUCCESS;
}

//IRQL: PASSIVE_LEVEL
//примечание тем, кто будет это читать:
//все орфографические очепятки допущены автором намеренно.
// (с) DjComandos
BOOLEAN FindProcess(IN char ProcessName[])
{
ULONG BufferSize = 64000; // начальный размер буфера ~ 64kb
LPVOID pBuffer = NULL; // указатель на буфер
NTSTATUS Status;
PSYSTEM_PROCESS_INFORMATION pInfo;
LPWSTR tempProcessName;//

WriteToFile(«\r\n\r\n>New Log: \r\n»);

//цикл: пока не выделим буфер нужного размера
do
{
//создаем буфер в памяти размером BufferSize
pBuffer = ExAllocatePool (NonPagedPool, BufferSize);
// тестим — выделили ли память?
if (pBuffer == NULL)
{
//всё совсем херово
return FALSE;
}
// юзаем хитрую функцию
Status = ZwQuerySystemInformation(
SystemProcessesAndThreadsInformation,//тип вывода инфы = 5
pBuffer, //указатель на буфер
BufferSize,//размер буфера(длина)
NULL);//длинна того чего вернули (а посрать сколько)
//если нам вернули больше чем размер буффера
if (Status == STATUS_INFO_LENGTH_MISMATCH)
{
// овобождаем буфера
ExFreePool(pBuffer);
// увеличиваем размер буфера (с маленьким запасов в два раза)
BufferSize *= 2;
}
// другая ошибко
else if (!NT_SUCCESS(Status))
{
//освобожаем память
ExFreePool(pBuffer);
//и валим нахер
return FALSE;
}
}
while (Status == STATUS_INFO_LENGTH_MISMATCH);
//——————————————————————————-——————————
//— если дошли доседова, то:
//— у нас есть указатель на список структур,
//— которые описывают все запущенные в системе процессы
//— КРОМЕ тех, которые всякими хитрыми методами
//— скрывались (т.е. отображаются только легальные, нескрытые процессы типа Notepad)
//——————————————————————————-——————————

pInfo = (PSYSTEM_PROCESS_INFORMATION)pBuffer;//вот он родимый

while(UNTIL_THE_END_OF_TIMES)
{
tempProcessName = pInfo->ProcessName.Buffer; //получаем имя процесса
if (tempProcessName == NULL) //если не получили
tempProcessName = L»NULL»; //то как-то так
//декодем в ОСКИ
wcstombs(ProcessName,tempProcessName,256);

//==============================================================
//===== А собственно это наш процесс?
//==============================================================

if(strcmp(ProcessName,gData.procToFind)==0)
{
//наш клиент
//задокументируем
WriteToFile(«\r\n\r\n>FOUND: «);
WriteToFile(ProcessName);
return TRUE;
}

//пишем в лог перевод каретке
WriteToFile(«\r\n»);
//пишем в лог имя процесса
WriteToFile(ProcessName);

// если в pInfo больше нихера нет
if (pInfo->NextEntryDelta == 0)
break; //то валим

// Like a i++ inda Array
pInfo = (PSYSTEM_PROCESS_INFORMATION)(((PUCHAR)pInfo)+ pInfo->NextEntryDelta);//ну GetNext
}
//убрали за собой
ExFreePool(pBuffer);

//если дошли доседава — нихера не нашли
return FALSE;//печально
}

//========================================================================================================
//====== NotifyRoutine
//========================================================================================================
void NotifyRoutine(IN HANDLE ParentId,
IN HANDLE ProcessId,
IN BOOLEAN Create)
{
DbgPrint(«MegaDriver: NotifyRoutine: a new process was created»);
KeSetEvent(gEvent, 0, FALSE);
//магия
KeClearEvent(gEvent);
}