Скрытие, открытие процесса

#include <ntddk.h>
 
#include "ioctl.h"
#define   VER_PRODUCTBUILD  2600
#include "ntifs.h"
#include <stdlib.h>
#include <stdio.h>
 
PEPROCESS Process;
LIST_ENTRY * Ob[100], *buff;
LIST_ENTRY * head;
char gbuffer[1024];
char str[100][100];
int pids[100];
int k = 0;
int count = 0;
int pid;
int f,sysMark = 0;
EPROCESS *pr,*nextproc; 
//*************************************************************
// макросы и глобальные переменные
#define GET_NEXT_ENTRY(type,field,p) ((type*)((char*)(p)->field.Flink-FIELD_OFFSET(type,field)))
 
#define GET_NEXT_PROCESS(proc) GET_NEXT_ENTRY(EPROCESS,ActiveProcessLinks,proc)
// смещение элемента двусвязного списка всех процессов в объекте процесса
#define ACTIVE_LIST_PROCESS_OFFSET  0x88
 
// возвращает указатель на элемент списка процессов объекта процесса
#define GET_ENTRY_PROCESS_LIST(process) (LIST_ENTRY*)((ULONG) process + ACTIVE_LIST_PROCESS_OFFSET)
 
#define SYM_LINK_NAME   L"\\Global??\\Driver"
#define DEVICE_NAME     L"\\Device\\DDriver"
 
 
UNICODE_STRING  DevName;
UNICODE_STRING  SymLinkName;
 
char *glWriteBuffer;
ULONG glSizeWriteBuffer;
 
 
//*************************************************************
// предварительное объявление функций
 
void HideProcess(int pid,char* nameproc);
char* ShowProcessListText();
void UnhideProcess(int pid,char* nameproc);
extern NTSTATUS PsLookupProcessByProcessId (HANDLE ProcessId, PEPROCESS *Process);
NTSTATUS DriverEntry (IN PDRIVER_OBJECT DriverObject,IN PUNICODE_STRING theRegistryPath);
VOID DriverUnload (IN PDRIVER_OBJECT DriverObject);
NTSTATUS DispatchCreate(IN PDEVICE_OBJECT DeviceObject,IN PIRP pIrp);
NTSTATUS DispatchClose(IN PDEVICE_OBJECT DeviceObject,IN PIRP pIrp);
NTSTATUS DispatchControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP pIrp);
NTSTATUS CompleteIrp( PIRP Irp, NTSTATUS status,ULONG Info);
 
 
//*************************************************************
// описание функций
 
 
// функция инициализации драйвера
NTSTATUS DriverEntry (IN PDRIVER_OBJECT DriverObject,IN PUNICODE_STRING RegistryPath){
        
PDEVICE_OBJECT  DeviceObject;               // указатель на объект устройство
NTSTATUS        status = STATUS_SUCCESS;    // статус завершения функции
 
    DriverObject->MajorFunction [IRP_MJ_CREATE        ] = DispatchCreate;
    DriverObject->MajorFunction [IRP_MJ_CLOSE         ] = DispatchClose;
    DriverObject->MajorFunction [IRP_MJ_DEVICE_CONTROL] = DispatchControl;
 
    DriverObject->DriverUnload = DriverUnload;
    
 
    pr = PsGetCurrentProcess();
    PsLookupProcessByProcessId(pr->UniqueProcessId,&Process);
    buff = GET_ENTRY_PROCESS_LIST(Process);
    head = buff->Blink;
    nextproc = GET_NEXT_PROCESS(pr);
    
#if DBG
    DbgPrint("Load driver %wZ",&DriverObject->DriverName);
#endif
 
 
    RtlInitUnicodeString(&DevName, DEVICE_NAME);
    RtlInitUnicodeString(&SymLinkName, SYM_LINK_NAME);
 
    // создание устройства
    status = IoCreateDevice(DriverObject,   // указатель на объект драйвера
                            0,              // размер области дополнительной памяти устройства
                            &DevName,       // имя устройства
                            FILE_DEVICE_UNKNOWN,    // идентификатор типа устройства
                            0,              // дополнительная информация об устройстве
                            FALSE,          // без эксклюзивного доступа
                            &DeviceObject); // адрес для сохранения указателя на объект устройства
    if(!NT_SUCCESS(status))
        return status;
 
#if DBG
    DbgPrint("Create device %ws",DEVICE_NAME);
#endif
 
    // создание символьной ссылки
    status = IoCreateSymbolicLink(&SymLinkName, &DevName);
    if (!NT_SUCCESS(status)){
        IoDeleteDevice(DeviceObject);
        return status;
        }
 
#if DBG
    DbgPrint("Create symbolic link %ws",SYM_LINK_NAME);
#endif
 
    return status;
}
 
//----------------------------------------
 
// функция выгрузки драйвера
VOID DriverUnload (IN PDRIVER_OBJECT DriverObject){
    
    for(f=0;f<count;f++){
       if(pids[f]!=0)
          UnhideProcess(pids[f],"");      
    }
    
    // удаление символьной ссылки и объекта устройства
    IoDeleteSymbolicLink(&SymLinkName);
    IoDeleteDevice( DriverObject->DeviceObject);
 
    if(glWriteBuffer)
        ExFreePool(glWriteBuffer);
#if DBG
    DbgPrint("Driver unload");
#endif
 
    return;     
}
 
//----------------------------------------
 
// функция для открытия объекта устройства
NTSTATUS DispatchCreate(IN PDEVICE_OBJECT DeviceObject,IN PIRP pIrp){
 
    return CompleteIrp(pIrp,STATUS_SUCCESS,0); // Завершение IRP
}
 
//----------------------------------------
 
// функция для закрытия объекта устройства
NTSTATUS DispatchClose(IN PDEVICE_OBJECT DeviceObject,IN PIRP pIrp){
 
    return CompleteIrp(pIrp,STATUS_SUCCESS,0);
}
 
// основная функция обработки всех ioctl-запросов
NTSTATUS DispatchControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP pIrp){
 
NTSTATUS status = STATUS_SUCCESS;
PIO_STACK_LOCATION IrpStack;
ULONG   Info = 0;
ULONG   inlen;          // размер входного буфера
ULONG   outlen;         // размер выходного буфера
ULONG   len;
unsigned char *in;      // входной буфер
unsigned char *out;     // выходной буфер
ULONG   ioctl;          // ioctl-код
char*   buf;            // вспомогательный буфер
ULONG   i;              // счётчик цикла
    
    
    IrpStack = IoGetCurrentIrpStackLocation(pIrp);
 
    // получаем ioctl-код
    ioctl = IrpStack->Parameters.DeviceIoControl.IoControlCode;
 
    // размер входного буфера
    inlen = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
 
    // размер выходного буфера
    outlen = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    // проверяем тип ввода/вывода, ассоциированный с ioctl-кодом
    if( (ioctl & 0x00000003) == METHOD_BUFFERED ){
        // если буферизованный
        // то системный буфер является и входным и выходным
        out = in = pIrp->AssociatedIrp.SystemBuffer;
    }
    else{
        // иначе получаем указатели из соответствующих полей IPR
        in = IrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
        out = pIrp->UserBuffer;
    }
 
    switch(ioctl){
 
        case READ_IOCTL:
                if(glWriteBuffer)
                   ExFreePool(glWriteBuffer);
                glWriteBuffer = (char*) ExAllocatePool(PagedPool,50);
                if(glWriteBuffer){
                    EPROCESS *proc,*cur;
                    int z =0;
                    char name[17],buffer[100],pidchar[20];
                    if(sysMark==0)
                       proc = pr;
                    else
                       proc = nextproc;
                    cur = proc;
                    do{
                       PsLookupProcessByProcessId(cur->UniqueProcessId,&Process);
                       ObDereferenceObject(Process);
                       buff = GET_ENTRY_PROCESS_LIST(Process);
                       RtlCopyMemory(name,cur->ImageFileName,16);
                       pid = cur->UniqueProcessId;
                       name[16] = 0;
                       if(sysMark==0){
                           strncpy(buffer, name, 16);
                           strcat(buffer, " ");
                           sprintf(pidchar,"%d",pid);
                           strcat(buffer, pidchar);
                           strcat(buffer, "\n");
                           strcat(gbuffer, buffer);
                       } else {
                          if(pid!=4){
                             strncpy(buffer, name, 16);
                             strcat(buffer, " ");
                             sprintf(pidchar,"%d",pid);
                             strcat(buffer, pidchar);
                             strcat(buffer, "\n");
                             strcat(gbuffer, buffer);  
                          }
                       }
                       if(buff->Flink==head)
                          break;
                      cur = GET_NEXT_PROCESS(cur);
                    } while(cur != proc);
                    strcat(gbuffer,"----------------------------------------\n");
                    for(f=0;f<count;f++){
                       if(pids[f]!=0){
                           strcat(gbuffer,str[f]);
                           strcat(gbuffer, " ");
                           sprintf(pidchar,"%d",pids[f]);
                           strcat(gbuffer, pidchar);
                           strcat(gbuffer,"\n");
                        }
                    }
                    len = strlen(gbuffer);
                    RtlCopyMemory(out,gbuffer,len);
                    Info = len;
                    memset(gbuffer,0,1024);
                }
            break;
 
        case WRITE_IOCTL:
            // выделяем память
            if(glWriteBuffer)
                ExFreePool(glWriteBuffer);
            glWriteBuffer = (char*) ExAllocatePool(PagedPool,inlen);
            if(glWriteBuffer){
                RtlCopyMemory(glWriteBuffer,in,inlen);
                if(atoi(in)!=0){
                    HideProcess(atoi(in),"");
                    DbgPrint("ioctl hide number %s",in);
                } else {
                    in[inlen] = '\0';
                    HideProcess(-1,in);
                    DbgPrint("ioctl hide str %s",in);
                }
                glSizeWriteBuffer = inlen;
            }
            break;
            
        // код инвертирования переданной строки
        case TEST_IOCTL:
            if(glWriteBuffer)
                ExFreePool(glWriteBuffer);
            glWriteBuffer = (char*) ExAllocatePool(PagedPool,inlen);
            if(glWriteBuffer){
                RtlCopyMemory(glWriteBuffer,in,inlen);
                if(atoi(in)!=0){
                    DbgPrint("ioctl unhide number %s",in);
                    UnhideProcess(atoi(in),"");
                }
                else{
                    in[inlen] = '\0';
                    DbgPrint("ioctl unhide str %s",in);
                    UnhideProcess(-1,in);
                }
                glSizeWriteBuffer = inlen;
                }
            break;
            
        default:
            status = STATUS_INVALID_PARAMETER;
            break;
        
        }
 
 
    return CompleteIrp(pIrp,status,Info);
}
 
//----------------------------------------
 
// функция завершения операции с IRP-пакетом
NTSTATUS CompleteIrp(PIRP Irp, NTSTATUS status,ULONG Info){
 
    Irp->IoStatus.Status = status;      // статус завершении операции
    Irp->IoStatus.Information = Info;   // количество возращаемой информации
    IoCompleteRequest(Irp,IO_NO_INCREMENT); // завершение операции ввода-вывода
    return status;
}
 
 
//----------------------------------------
void HideProcess(int pid,char* nameproc){
 
EPROCESS *proc,*cur;
DbgPrint("Hide %s:%d",nameproc,pid);
proc=pr;    
cur=proc;
    do{
        PsLookupProcessByProcessId(cur->UniqueProcessId,&Process);
        ObDereferenceObject(Process);
        buff = GET_ENTRY_PROCESS_LIST(Process);
        DbgPrint("H do %d:%d",cur->UniqueProcessId,pid);
        if(cur->UniqueProcessId == pid || !strcmp(cur->ImageFileName, nameproc)){
            DbgPrint("%d:%d",cur->ImageFileName,nameproc);
            if(cur == nextproc) nextproc=GET_NEXT_PROCESS(nextproc);
            if(pid != -1){
                 pids[count] = pid;
                 DbgPrint("H C pid:%d",pid);
            }else{
                pids[count] = cur->UniqueProcessId;
                DbgPrint("H C upid:%d",cur->UniqueProcessId);
            }
            strcpy(str[count],&cur->ImageFileName);
            Ob[count] = buff;
            count++;
            buff->Flink->Blink = buff->Blink;
            buff->Blink->Flink = buff->Flink;
        }
           if(buff->Flink == head)
              break;
        cur = GET_NEXT_PROCESS(cur);
    } while(cur != proc);
    return;
}
//----------------------------------------
void UnhideProcess(int pid,char* nameproc){
    
   EPROCESS *proc,*cur;
   NTSTATUS status;
   int countpid,j;
    DbgPrint("Unhide %s:%d",nameproc,pid);
    if(pid==4 || !strcmp(nameproc,"System")){
        for(j=0;j<count;j++){
           if(pids[j] == 4){
               sysMark = 1;
               pids[j] = 0;
               head->Flink->Blink=Ob[j];
               Ob[j]->Flink=head->Flink;
               Ob[j]->Blink=head;
               head->Flink=Ob[j];
               break;
           }
        }
    } else {
        for(j=0;j<count;j++){
                PsLookupProcessByProcessId(pid,&Process);
                ObDereferenceObject(Process);
                buff = GET_ENTRY_PROCESS_LIST(Process);
                if(pids[j] == pid || !strcmp(str[j], nameproc)){
                    DbgPrint("Unhide2");
                    sysMark = 0;
                   pids[j]=0;
                   Ob[j]->Blink = head->Flink;
                   Ob[j]->Flink = head->Flink->Flink;
                   head->Flink->Flink->Blink = Ob[j];
                   head->Flink->Flink = Ob[j];       
                }
        }
        
    }
    return;
}
 
//----------------------------------------
 
//----------------------------------------

#include <windows.h>
#include <stdio.h>
 
 
#define READ_IOCTL  CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_BUFFERED,FILE_READ_ACCESS | FILE_WRITE_ACCESS)
 
#define WRITE_IOCTL  CTL_CODE(FILE_DEVICE_UNKNOWN,0x802,METHOD_BUFFERED,FILE_READ_ACCESS | FILE_WRITE_ACCESS)
 
#define TEST_IOCTL  CTL_CODE(FILE_DEVICE_UNKNOWN,0x803,METHOD_NEITHER,FILE_ANY_ACCESS)
 
// имя драйвера
#define DRIVER_NAME     "Driver"
 
// файл драйвера
#define DRIVER_FILE     "Driver.sys"
 
 
typedef struct _UNICODE_STRING {
    USHORT  Length;
    USHORT  MaximumLength;
    PWSTR  Buffer;
} UNICODE_STRING, *PUNICODE_STRING;
 
typedef long NTSTATUS;
 
typedef NTSTATUS (*NT_LOAD_DRIVER)(
    IN PUNICODE_STRING DriverServiceName
    );
 
 
typedef NTSTATUS (*NT_UNLOAD_DRIVER)(
    IN PUNICODE_STRING DriverServiceName
    );
 
 
bool LoadDriver(char *driver_name,WCHAR *driver_path);
 
bool UnloadDriver(char *driver_name);
 
BOOLEAN StopDriver(char* DriverName);
 
BOOLEAN StartDriver(char* DriverName);
 
BOOLEAN RemoveDriver(char* DriverName);
 
bool UnloadDriver(char *driver_name);
 
BOOLEAN InstallDriver(char* DriverName, char* LoadPath);
 
 
int main(){
 
    char str[1000];
    char buf[1000];
    char in [2048];          // входной буфер
    char out [2048];         // выходной буфер
    int act;
    DWORD BytesReturned;
 
 
    GetFullPathNameA(DRIVER_FILE,1000,buf,NULL);
 
    if(!InstallDriver(DRIVER_NAME,buf))
        return 0;
    if(!StartDriver(DRIVER_NAME))
        return 0;
 
    HANDLE file = CreateFileA("\\\\.\\Driver",
        GENERIC_READ | GENERIC_WRITE, 
        FILE_SHARE_READ | FILE_SHARE_WRITE, 
        NULL, 
        OPEN_EXISTING, 
        FILE_ATTRIBUTE_NORMAL, 
        (HANDLE) NULL);
    printf("1 - print process list\n2 - hide process\n3 - open process\n");
    while(1){
        scanf("%d",&act);
        switch (act){
 
        case 1:
            if( !DeviceIoControl(file,
                READ_IOCTL,
                NULL,
                0,
                out,
                2048,
                &BytesReturned,
                NULL) )
                printf("Error read\n");
            out[BytesReturned] = 0;
            printf("%s\n",out);
            break;
 
        case 2:
            printf("Enter pid or name for hide\n");
            scanf("%s",str);
            //if(atoi(str)!=0){
                strcpy(in,str);
                if( !DeviceIoControl(file,          // описатель открытого устройства драйвера
                    WRITE_IOCTL,    // ioctl-код
                    in,             // входной буфер
                    strlen(in),     // размер входного буфера
                    NULL,           // выходной буфер
                    0,              // размер выходного буфера
                    &BytesReturned, // количество возвращённых байт
                    NULL) )
                    printf("Error write\n");
            //}
            break;
        
        case 3:
            printf("Enter pid or name for open\n");
            scanf("%s",str);
            //if(atoi(str)!=0){
                strcpy(in,str);
                if( !DeviceIoControl(file,          // описатель открытого устройства драйвера
                    TEST_IOCTL,    // ioctl-код
                    in,             // входной буфер
                    strlen(in),     // размер входного буфера
                    NULL,           // выходной буфер
                    0,              // размер выходного буфера
                    &BytesReturned, // количество возвращённых байт
                    NULL) )
                    printf("Error write\n");
            //}
            break;
 
            default:
               CloseHandle(file);
 
               if(!StopDriver(DRIVER_NAME))
                  return 0;
               if(!RemoveDriver(DRIVER_NAME))
                  return 0;
               
            return 1;
        }
    }
    return 0;
}
 
//----------------------------------------
 
bool LoadDriver(char *driver_name, WCHAR *driver_path){
 
    HKEY service_key;
    HKEY driver_key;
    DWORD Type = 1;
    DWORD Start = 2;
    DWORD ErrorControl = 1;
    UNICODE_STRING unistr;
    NT_LOAD_DRIVER nld;
    WCHAR un_driver_name[MAX_PATH];
    WCHAR *un_path = L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\";
 
    if(RegOpenKeyExA(HKEY_LOCAL_MACHINE,
        "SYSTEM\\CurrentControlSet\\Services",
        0,
        KEY_CREATE_SUB_KEY,
        &service_key) 
        != ERROR_SUCCESS)
        return false;
 
    if(RegCreateKeyExA(service_key,
        driver_name,
        0,
        NULL,
        0,
        KEY_SET_VALUE,
        NULL,
        &driver_key,
        NULL) 
        != ERROR_SUCCESS){
            RegCloseKey(service_key);
            return false;
    }
 
    // устанавливаем значения
    RegSetValueExA(driver_key,"Type",0,REG_DWORD,(BYTE*)&Type,4);
    RegSetValueExA(driver_key,"Start",0,REG_DWORD,(BYTE*)&Start,4);
    RegSetValueExA(driver_key,"ErrorControl",0,REG_DWORD,(BYTE*)&ErrorControl,4);
    RegSetValueExW(driver_key,L"ImagePath",0,REG_EXPAND_SZ,(BYTE*)driver_path,2*wcslen(driver_path)+2);
    RegSetValueExA(driver_key,"DisplayName",0,REG_SZ,(BYTE*)driver_name,strlen(driver_name));
 
    // копируем строку "\\Registry\\Machine\\System\\CurrentControlSet\\Services\\"
    RtlCopyMemory(un_driver_name,un_path,2*wcslen(un_path));
 
    // добавляем имя драйвера
    MultiByteToWideChar(CP_ACP,0,driver_name,strlen(driver_name) + 1,un_driver_name + wcslen(un_path),MAX_PATH);
 
    // инициализируем структуру UNICODE_STRING
    unistr.Buffer = un_driver_name;
    unistr.Length = 2*wcslen(un_driver_name);
    unistr.MaximumLength = 2*wcslen(un_driver_name) + 2;
 
    printf("Load registry path %S\n",un_driver_name);
 
    // системный вызов загрузки драйвера
    nld = (NT_LOAD_DRIVER)GetProcAddress(LoadLibraryA("ntdll.dll"),"NtLoadDriver");
    printf("status = %p\n\n",nld(&unistr));
    //NtLoadDriver(&unistr);
 
    RegCloseKey(driver_key);
    RegCloseKey(service_key);
 
    return true;
}
 
//----------------------------------------
 
 
bool UnloadDriver(char *driver_name){
 
    UNICODE_STRING unistr;
    NT_UNLOAD_DRIVER unld;
    WCHAR un_driver_name[MAX_PATH];
    static WCHAR *un_path = L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\";
 
 
    // копируем строку "\\Registry\\Machine\\System\\CurrentControlSet\\Services\\"
    RtlCopyMemory(un_driver_name,un_path,2*wcslen(un_path));
 
    // добавляем имя драйвера
    MultiByteToWideChar(CP_ACP,0,driver_name,strlen(driver_name) + 1,un_driver_name + wcslen(un_path),MAX_PATH);
 
    // инициализируем структуру UNICODE_STRING
    unistr.Buffer = un_driver_name;
    unistr.Length = 2*wcslen(un_driver_name);
    unistr.MaximumLength = 2*wcslen(un_driver_name) + 2;
 
    printf("Unload registry path %S\n",un_driver_name);
 
    // системный вызов загрузки драйвера
    unld = (NT_LOAD_DRIVER)GetProcAddress(LoadLibraryA("ntdll.dll"),"NtUnloadDriver");
    printf("status = %p\n\n",unld(&unistr));
    //NtUnloadDriver(&unistr);
 
    return true;
}
 
//----------------------------------------
 
//----------------------------------------
void PrintErrorMessage(DWORD err){
    char *msg;
    char *conmsg;
    DWORD res= FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_ALLOCATE_BUFFER,
        NULL,
        err,    // код ошибки
        0,      // идентификатор языка по-умолчанию
        (LPTSTR) &msg, 0, NULL);
    if(res) {
        conmsg=new char[strlen(msg)+1];
        CharToOemA(msg,conmsg);
        printf("%s",conmsg);    // вывод сообщения на экран
        LocalFree(msg);     // освобождение буфера с текстом сообщения
        delete [] conmsg;
    }
 
    return;
}
 
BOOLEAN InstallDriver(char* DriverName, char* LoadPath){
 
    SC_HANDLE   SCManager;
    SC_HANDLE   service;
    DWORD       err;
 
    // открываю менеджер служб
    SCManager=OpenSCManager(0,          // локальный компьютер
        0,          // текущая база данных сервисов
        SC_MANAGER_ALL_ACCESS   // права доступа
        );
 
    if(!SCManager){
        PrintErrorMessage(GetLastError());
        return FALSE;
    }
 
 
    service = CreateServiceA(SCManager,              // описатель диспетчера сервисов
        DriverName,              // имя устанавливаемого сервиса
        DriverName,              // отображаемое имя устанавливаемого сервиса
        SERVICE_ALL_ACCESS,      // тип доступа к сервису
        SERVICE_KERNEL_DRIVER,   // тип сервиса
        SERVICE_DEMAND_START,    // параметр запуска:
        SERVICE_ERROR_NORMAL,    // реакция на ошибки при старте сервиса
        LoadPath,                // путь к исполняемому файлу
        NULL,
        NULL,
        NULL,
        NULL,
        NULL
        );
 
    if(service == NULL){
        err = GetLastError();
        if (err == ERROR_SERVICE_EXISTS)
            return TRUE;
        else{
            PrintErrorMessage(err);
            return FALSE;
        }
    }
 
    CloseServiceHandle(service);
 
    CloseServiceHandle(SCManager);
 
    return TRUE;
}
 
//----------------------------------------
 
BOOLEAN RemoveDriver(char* DriverName){
 
    SC_HANDLE   service;
    SC_HANDLE   SCManager;
 
    SCManager=OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS);
    if(!SCManager){
        PrintErrorMessage(GetLastError());
        return FALSE;
    }
 
    service = OpenServiceA(SCManager,
        DriverName,
        SERVICE_ALL_ACCESS
        );
 
    if (service == NULL) {
        PrintErrorMessage(GetLastError());
        return FALSE;
    }
 
    if(!DeleteService(service)) {
        PrintErrorMessage(GetLastError());
        CloseServiceHandle(service);
        CloseServiceHandle(SCManager);
        return FALSE;
    }
 
    CloseServiceHandle(service);
 
    CloseServiceHandle(SCManager);
 
    return TRUE;
}
 
//----------------------------------------
 
BOOLEAN StartDriver(char* DriverName){
 
    SC_HANDLE   service;
    SC_HANDLE   SCManager;
    DWORD err;
 
    SCManager=OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS);
    if(!SCManager){
        PrintErrorMessage(GetLastError());
        return FALSE;
    }
 
    service = OpenServiceA(SCManager, DriverName, SERVICE_ALL_ACCESS);
 
    if (service == NULL) {
        PrintErrorMessage(GetLastError());
        return FALSE;
    }
 
    if (!StartService(service, 0, NULL)) {
 
        err = GetLastError();
 
        if(err == ERROR_SERVICE_ALREADY_RUNNING)
            return TRUE;
        else{
            PrintErrorMessage(GetLastError());
            return FALSE;
        }
    }
 
    CloseServiceHandle(service);
 
    CloseServiceHandle(SCManager);
 
    return TRUE;
}
 
//----------------------------------------
 
BOOLEAN StopDriver(char* DriverName){
 
    SC_HANDLE   service;
    SC_HANDLE   SCManager;
    SERVICE_STATUS serstatus;
 
    SCManager=OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS);
    if(!SCManager){
        PrintErrorMessage(GetLastError());
        return FALSE;
    }
 
    service = OpenServiceA(SCManager, DriverName, SERVICE_ALL_ACCESS);
 
    if (service == NULL) {
        PrintErrorMessage(GetLastError());
        return FALSE;
    }
 
    if (!ControlService(service, SERVICE_CONTROL_STOP, &serstatus)){
        PrintErrorMessage(GetLastError());
        CloseServiceHandle(service);
        CloseServiceHandle(SCManager);
        return FALSE;
    }
 
    CloseServiceHandle(service);
 
    CloseServiceHandle(SCManager);
 
    return TRUE;
 
}

*** ERROR: Symbol file could not be found.  Defaulted to export symbols for ntkrnlpa.exe - 
nt!MmGetSystemRoutineAddress+0x1dea:
805a3f1a f6472702        test    byte ptr [edi+27h],2
kd> g
 
*** Fatal System Error: 0x0000007f
                       (0x0000000D,0x00000000,0x00000000,0x00000000)
 
 
*** Fatal System Error: 0x0000007f
                       (0x0000000D,0x00000000,0x00000000,0x00000000)
 
 
*** Fatal System Error: 0x0000007f
                       (0x0000000D,0x00000000,0x00000000,0x00000000)
 
 
*** Fatal System Error: 0x0000007f
                       (0x0000000D,0x00000000,0x00000000,0x00000000)
 
 
*** Fatal System Error: 0x0000007f
                       (0x00000008,0x80042000,0x00000000,0x00000000)
 
Break instruction exception - code 80000003 (first chance)
 
A fatal system error has occurred.
Debugger entered on first try; Bugcheck callbacks have not been invoked.
 
A fatal system error has occurred.
 
*********************************************************************
* Symbols can not be loaded because symbol path is not initialized. *
*                                                                   *
* The Symbol Path can be set by:                                    *
*   using the _NT_SYMBOL_PATH environment variable.                 *
*   using the -y <symbol_path> argument when starting the debugger. *
*   using .sympath and .sympath+                                    *
*********************************************************************
*******************************************************************************
*                                                                             *
*                        Bugcheck Analysis                                    *
*                                                                             *
*******************************************************************************
 
Use !analyze -v to get detailed debugging information.
 
BugCheck 7F, {8, 80042000, 0, 0}
 
WARNING: Process directory table base 06B40220 doesn't match CR3 00B01000
WARNING: Process directory table base 06B40220 doesn't match CR3 00B01000
***** Kernel symbols are WRONG. Please fix symbols to do analysis.
 
*** ERROR: Module load completed but symbols could not be loaded for mssmbios.sys
*************************************************************************
***                                                                   ***
***                                                                   ***
***    Your debugger is not using the correct symbols                 ***
***                                                                   ***
***    In order for this command to work properly, your symbol path   ***
***    must point to .pdb files that have full type information.      ***
***                                                                   ***
***    Certain .pdb files (such as the public OS symbols) do not      ***
***    contain the required information.  Contact the group that      ***
***    provided you with these symbols if you need this command to    ***
***    work.                                                          ***
***                                                                   ***
***    Type referenced: nt!_KPRCB                                     ***
***                                                                   ***
*************************************************************************
*************************************************************************
***                                                                   ***
***                                                                   ***
***    Your debugger is not using the correct symbols                 ***
***                                                                   ***
***    In order for this command to work properly, your symbol path   ***
***    must point to .pdb files that have full type information.      ***
***                                                                   ***
***    Certain .pdb files (such as the public OS symbols) do not      ***
***    contain the required information.  Contact the group that      ***
***    provided you with these symbols if you need this command to    ***
***    work.                                                          ***
***                                                                   ***
***    Type referenced: nt!_KPRCB                                     ***
***                                                                   ***
*************************************************************************
Probably caused by : ntkrnlpa.exe ( nt!KeRegisterBugCheckReasonCallback+77c )
 
Followup: MachineOwner
---------
 
nt!DbgBreakPointWithStatus+0x4:
80526da8 cc              int     3
kd> !analyze -v
*******************************************************************************
*                                                                             *
*                        Bugcheck Analysis                                    *
*                                                                             *
*******************************************************************************
 
UNEXPECTED_KERNEL_MODE_TRAP (7f)
This means a trap occurred in kernel mode, and it's a trap of a kind
that the kernel isn't allowed to have/catch (bound trap) or that
is always instant death (double fault).  The first number in the
bugcheck params is the number of the trap (8 = double fault, etc)
Consult an Intel x86 family manual to learn more about what these
traps are. Here is a *portion* of those codes:
If kv shows a taskGate
        use .tss on the part before the colon, then kv.
Else if kv shows a trapframe
        use .trap on that value
Else
        .trap on the appropriate frame will show where the trap was taken
        (on x86, this will be the ebp that goes with the procedure KiTrap)
Endif
kb will then show the corrected stack.
Arguments:
Arg1: 00000008, EXCEPTION_DOUBLE_FAULT
Arg2: 80042000
Arg3: 00000000
Arg4: 00000000
 
Debugging Details:
------------------
 
***** Kernel symbols are WRONG. Please fix symbols to do analysis.
 
*************************************************************************
***                                                                   ***
***                                                                   ***
***    Your debugger is not using the correct symbols                 ***
***                                                                   ***
***    In order for this command to work properly, your symbol path   ***
***    must point to .pdb files that have full type information.      ***
***                                                                   ***
***    Certain .pdb files (such as the public OS symbols) do not      ***
***    contain the required information.  Contact the group that      ***
***    provided you with these symbols if you need this command to    ***
***    work.                                                          ***
***                                                                   ***
***    Type referenced: nt!_KPRCB                                     ***
***                                                                   ***
*************************************************************************
*************************************************************************
***                                                                   ***
***                                                                   ***
***    Your debugger is not using the correct symbols                 ***
***                                                                   ***
***    In order for this command to work properly, your symbol path   ***
***    must point to .pdb files that have full type information.      ***
***                                                                   ***
***    Certain .pdb files (such as the public OS symbols) do not      ***
***    contain the required information.  Contact the group that      ***
***    provided you with these symbols if you need this command to    ***
***    work.                                                          ***
***                                                                   ***
***    Type referenced: nt!_KPRCB                                     ***
***                                                                   ***
*************************************************************************
 
ADDITIONAL_DEBUG_TEXT:  
Use '!findthebuild' command to search for the target build information.
If the build information is available, run '!findthebuild -s ; .reload' to set symbol path and load symbols.
 
MODULE_NAME: nt
 
FAULTING_MODULE: 804d7000 nt
 
DEBUG_FLR_IMAGE_TIMESTAMP:  41107b0c
 
BUGCHECK_STR:  0x7f_8
 
DEFAULT_BUCKET_ID:  DRIVER_FAULT
 
LAST_CONTROL_TRANSFER:  from 804f83fa to 80526da8
 
STACK_TEXT:  
WARNING: Stack unwind information not available. Following frames may be wrong.
80545cfc 804f83fa 00000003 00000000 00000000 nt!DbgBreakPointWithStatus+0x4
805460dc 8053e6e2 0000007f 00000008 80042000 nt!KeRegisterBugCheckReasonCallback+0x77c
00000000 00000000 00000000 00000000 00000000 nt!Kei386EoiHelper+0x166a
 
 
STACK_COMMAND:  kb
 
FOLLOWUP_IP: 
nt!KeRegisterBugCheckReasonCallback+77c
804f83fa e85d6a0000      call    nt!ZwYieldExecution+0x630 (804fee5c)
 
SYMBOL_STACK_INDEX:  1
 
SYMBOL_NAME:  nt!KeRegisterBugCheckReasonCallback+77c
 
FOLLOWUP_NAME:  MachineOwner
 
IMAGE_NAME:  ntkrnlpa.exe
 
BUCKET_ID:  WRONG_SYMBOLS
 
Followup: MachineOwner
---------

ODULE_NAME: Driver
 
FAULTING_MODULE: 804d7000 nt
 
DEBUG_FLR_IMAGE_TIMESTAMP:  530a027a
 
FAULTING_IP: 
Driver!DriverUnload+6f [c:\users\nit.c @ 119]
f0e825af ebce            jmp     Driver!DriverUnload+0x3f (f0e8257f)
 
BUGCHECK_STR:  0xc2_40
 
DEFAULT_BUCKET_ID:  DRIVER_FAULT
 
LAST_CONTROL_TRANSFER:  from 804f83fa to 80526da8
 
STACK_TEXT:  
WARNING: Stack unwind information not available. Following frames may be wrong.
f9dfb8c4 804f83fa 00000003 f0978b00 8055a6c0 nt!DbgBreakPointWithStatus+0x4
f9dfbca4 804f8925 000000c2 00000040 00000000 nt!KeRegisterBugCheckReasonCallback+0x77c
f9dfbcc4 805429ed 000000c2 00000040 00000000 nt!KeBugCheckEx+0x1b
f9dfbd04 80543b9d 00000000 f0978b00 f0978b00 nt!ExRaiseStatus+0xced
f9dfbd44 f0e825af 00000000 00000000 00000001 nt!ExFreePoolWithTag+0x1b7
f9dfbd58 80575633 816bf040 f0978b00 8055a1fc Driver!DriverUnload+0x6f [c:\users\nit.c @ 119]
f9dfbd74 80533dd0 f0978b00 00000000 81bca388 nt!NtWriteFile+0x457d
f9dfbdac 805c4a28 f0978b00 00000000 00000000 nt!ExQueueWorkItem+0x1b2
f9dfbddc 80540fa2 80533cd0 00000001 00000000 nt!PsRemoveCreateThreadNotifyRoutine+0x21e
00000000 00000000 00000000 00000000 00000000 nt!KiDispatchInterrupt+0x5a2
 
 
STACK_COMMAND:  kb
 
FOLLOWUP_IP: 
Driver!DriverUnload+6f [c:\users\nit.c @ 119]
f0e825af ebce            jmp     Driver!DriverUnload+0x3f (f0e8257f)
 
FAULTING_SOURCE_CODE:  
   115:         ExFreePool(glWriteBuffer);
   116:     for(i=0; i<=count; i++){
   117:         if(glWriteBuffer)
   118:             ExFreePool(glName[i]);
>  119:     }
   120:     OpenAll();
   121: #if DBG
   122:     DbgPrint ("Driver unload\n");
   123: #endif
   124:

#include <ntddk.h>
#include <stdlib.h>
#include <stdio.h>
#define HIDE  CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_NEITHER,FILE_ANY_ACCESS)
#define OPEN  CTL_CODE(FILE_DEVICE_UNKNOWN,0x802,METHOD_NEITHER,FILE_ANY_ACCESS)
#define LIST  CTL_CODE(FILE_DEVICE_UNKNOWN,0x803,METHOD_NEITHER,FILE_ANY_ACCESS)
#define HIDEALL  CTL_CODE(FILE_DEVICE_UNKNOWN,0x804,METHOD_NEITHER,FILE_ANY_ACCESS)
#define OPENALL  CTL_CODE(FILE_DEVICE_UNKNOWN,0x805,METHOD_NEITHER,FILE_ANY_ACCESS)
#define INFO  CTL_CODE(FILE_DEVICE_UNKNOWN,0x806,METHOD_NEITHER,FILE_ANY_ACCESS)
#define SYM_LINK_NAME   L"\\Global??\\Driver"
#define DEVICE_NAME     L"\\Device\\DDriver"
#define ACTIVE_LIST_PROCESS_OFFSET  0x88
#define PID_PROCESS_OFFSET          0x84
#define IMAGE_NAME_PROCESS_OFFSET   0x174
#define GET_ENTRY_PROCESS_LIST(process) (LIST_ENTRY*)((ULONG) process + ACTIVE_LIST_PROCESS_OFFSET)
#define GET_NAME_PROCESS(process) ((char*)process+IMAGE_NAME_PROCESS_OFFSET)
#define GET_NEXT_PROCESS(process) ( ( (ULONG) ((LIST_ENTRY*)((ULONG)process + ACTIVE_LIST_PROCESS_OFFSET))->Flink ) - ACTIVE_LIST_PROCESS_OFFSET )
#define HANDLE_TABLE_PROCESS_OFFSET 0xc4
#define LIST_HANDLE_TABLE_OFFSET    0x1c
UNICODE_STRING  DevName;
UNICODE_STRING  SymLinkName;
char *glWriteBuffer;
ULONG glSizeWriteBuffer;
PEPROCESS proc;
ULONG start;
int count=0;
int AllorNot=0;
ULONG glPid[100];
char* glName[100];
char globBuf[2048];
LIST_ENTRY  *HandleTableListHead;
 
 
//*************************************************************
// предварительное объявление функций
 
NTSTATUS DriverEntry (IN PDRIVER_OBJECT DriverObject,IN PUNICODE_STRING RegistryPath);
VOID DriverUnload (IN PDRIVER_OBJECT DriverObject);
NTSTATUS DispatchCreate(IN PDEVICE_OBJECT DeviceObject,IN PIRP pIrp);
NTSTATUS DispatchClose(IN PDEVICE_OBJECT DeviceObject,IN PIRP pIrp);
NTSTATUS DispatchControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP pIrp);
NTSTATUS CompleteIrp( PIRP Irp, NTSTATUS status,ULONG Info);
void HideProcess(ULONG process);
void UnhideProcess(HANDLE process);
void InfoProcess(ULONG process);
void ShowAllProcess(ULONG start_process);
void OpenAll();
void HideAll(ULONG start_process);
extern NTSTATUS PsLookupProcessByProcessId (HANDLE ProcessId, PEPROCESS *Process);
//*************************************************************
// описание функций
 
// функция инициализации драйвера
NTSTATUS DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath) {
    PDEVICE_OBJECT  DeviceObject;               // указатель на объект устройство
    NTSTATUS        status = STATUS_SUCCESS;
#if DBG
    DbgPrint ("Load driver %wZ\n", &DriverObject->DriverName);
    DbgPrint ("Registry path %wZ\n", RegistryPath);
#endif
    DriverObject->MajorFunction [IRP_MJ_CREATE        ] = DispatchCreate;
    DriverObject->MajorFunction [IRP_MJ_CLOSE         ] = DispatchClose;
    DriverObject->MajorFunction [IRP_MJ_DEVICE_CONTROL] = DispatchControl;
    
    DriverObject->DriverUnload = DriverUnload;
 
    RtlInitUnicodeString(&DevName, DEVICE_NAME);
    RtlInitUnicodeString(&SymLinkName, SYM_LINK_NAME);
    
    status = IoCreateDevice(DriverObject,   // указатель на объект драйвера
                            0,              // размер области дополнительной памяти устройства
                            &DevName,       // имя устройства
                            FILE_DEVICE_UNKNOWN,    // идентификатор типа устройства
                            0,              // дополнительная информация об устройстве
                            FALSE,          // без эксклюзивного доступа
                            &DeviceObject); // адрес для сохранения указателя на объект устройства
    if(!NT_SUCCESS(status))
        return status;
#if DBG 
    DbgPrint("Create device %ws",DEVICE_NAME);
#endif  
    status = IoCreateSymbolicLink(&SymLinkName, &DevName);
    if (!NT_SUCCESS(status)){
        IoDeleteDevice(DeviceObject);
        return status;
        }
 
#if DBG
    DbgPrint("Create symbolic link %ws",SYM_LINK_NAME);
#endif
    HandleTableListHead = (GET_ENTRY_PROCESS_LIST((ULONG)PsGetCurrentProcess()))->Blink;
    start=(ULONG)HandleTableListHead-ACTIVE_LIST_PROCESS_OFFSET;
    return STATUS_SUCCESS;
}
 
//--------------------
 
// функция выгрузки драйвера
VOID DriverUnload (IN PDRIVER_OBJECT DriverObject) {
    int i;
    IoDeleteSymbolicLink(&SymLinkName);
    IoDeleteDevice( DriverObject->DeviceObject);
 
    if(glWriteBuffer)
        ExFreePool(glWriteBuffer);
    for(i=0; i<=count; i++){
        if(glWriteBuffer)
            ExFreePool(glName[i]);
    }
    OpenAll();
#if DBG
    DbgPrint ("Driver unload\n");
#endif
 
    return;     
}
 
//--------------------
NTSTATUS DispatchCreate(IN PDEVICE_OBJECT DeviceObject,IN PIRP pIrp){
 
    return CompleteIrp(pIrp,STATUS_SUCCESS,0); // Завершение IRP
}
NTSTATUS DispatchClose(IN PDEVICE_OBJECT DeviceObject,IN PIRP pIrp){
 
    return CompleteIrp(pIrp,STATUS_SUCCESS,0);
}
//--------------------
NTSTATUS DispatchControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP pIrp){
 
NTSTATUS status = STATUS_SUCCESS;
PIO_STACK_LOCATION IrpStack;
ULONG   Info = 0;
ULONG   ioctl;
ULONG   inlen; 
ULONG   outlen;         // размер выходного буфера
ULONG   len;
char pidchar[10];
unsigned char *in;  
unsigned char *out;
int i;
    IrpStack = IoGetCurrentIrpStackLocation(pIrp);
    ioctl = IrpStack->Parameters.DeviceIoControl.IoControlCode;
    // размер входного буфера
    inlen = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
 
    // размер выходного буфера
    outlen = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    // проверяем тип ввода/вывода, ассоциированный с ioctl-кодом
    if( (ioctl & 0x00000003) == METHOD_BUFFERED ){
        // если буферизованный
        // то системный буфер является и входным и выходным
        out = in = pIrp->AssociatedIrp.SystemBuffer;
        }
    else{
        // иначе получаем указатели из соответствующих полей IPR
        in = IrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
        out = pIrp->UserBuffer;
        }
    switch(ioctl){
        // код чтения с устройства
        case HIDE:
            if(glWriteBuffer)
                ExFreePool(glWriteBuffer);
            glWriteBuffer = (char*) ExAllocatePool(PagedPool,inlen);
            if(glWriteBuffer){
                // копируем записываемые данные в глобальный буфер
                RtlCopyMemory(glWriteBuffer,in,inlen);
                glSizeWriteBuffer = inlen;
            }
            //DbgPrint("%d", in);
            
            status = PsLookupProcessByProcessId((HANDLE)atoi(glWriteBuffer),&proc);
            if(NT_SUCCESS(status)){
                // скрываем процесс
                HideProcess((ULONG)proc);
                ObDereferenceObject(proc);
                }
            break;
        case LIST:
            if(glWriteBuffer)
                ExFreePool(glWriteBuffer);
            glWriteBuffer = (char*) ExAllocatePool(PagedPool,50);
            if(glWriteBuffer){
                //len = outlen > glSizeWriteBuffer ? glSizeWriteBuffer : outlen;
                strcpy(globBuf, "");
                memset(globBuf, 0,2048);
                ShowAllProcess(start);
                strcat(globBuf, "---Hiden Process---\n");
                for(i=0; i<count; i++){
                    sprintf(pidchar,"%d",glPid[i]);
                    strcat(globBuf,glName[i]);
                    strcat(globBuf," ");
                    strcat(globBuf,pidchar);
                    strcat(globBuf,"\n");
                }
                len=strlen(globBuf);
                glSizeWriteBuffer = len;
                Info = len;
                RtlCopyMemory(out,globBuf,len);
            }
                
            break;
        case OPEN: 
        if(glWriteBuffer)
                ExFreePool(glWriteBuffer);
            glWriteBuffer = (char*) ExAllocatePool(PagedPool,inlen);
            if(glWriteBuffer){
                // копируем записываемые данные в глобальный буфер
                RtlCopyMemory(glWriteBuffer,in,inlen);
                glSizeWriteBuffer = inlen;
            }
                // если процесс ещё существует, то отменяем скрытие процесса
                UnhideProcess((HANDLE)atoi(glWriteBuffer));
            break;
        case OPENALL:
            if(glWriteBuffer)
                ExFreePool(glWriteBuffer);
            glWriteBuffer = (char*) ExAllocatePool(PagedPool,50);
            if(glWriteBuffer){
                OpenAll();
                strcpy(glWriteBuffer,"All process unhide\n");
                len=strlen(glWriteBuffer);
                glSizeWriteBuffer = len;
                Info = len;
                RtlCopyMemory(out,glWriteBuffer,len);
            }
        break;
        case HIDEALL:
            if(glWriteBuffer)
                ExFreePool(glWriteBuffer);
            glWriteBuffer = (char*) ExAllocatePool(PagedPool,50);
            if(glWriteBuffer){
                HideAll(start);
                strcpy(glWriteBuffer,"All process hide\n");
                len=strlen(glWriteBuffer);
                glSizeWriteBuffer = len;
                Info = len;
                RtlCopyMemory(out,glWriteBuffer,len);
            }
        default:
            status = STATUS_INVALID_PARAMETER;
            break;
    }
    return CompleteIrp(pIrp,status,Info);
}
//--------------------
NTSTATUS CompleteIrp(PIRP Irp, NTSTATUS status,ULONG Info){
 
    Irp->IoStatus.Status = status;      // статус завершении операции
    Irp->IoStatus.Information = Info;   // количество возращаемой информации
    IoCompleteRequest(Irp,IO_NO_INCREMENT); // завершение операции ввода-вывода
    return status;
}
void HideProcess(ULONG process){
ULONG pid;
LIST_ENTRY *entry;
char name[20];
char* buffer="";
char pidchar[10];
int i;
    DbgPrint("%d", process);
    DbgPrint("%s", process);
    strncpy(name,GET_NAME_PROCESS(process),16);
    name[16]=0;
    glName[count] = (char*)ExAllocatePool(PagedPool, 17);
    strncpy(buffer, name, 17);
    strcpy(glName[count], buffer);
    DbgPrint("%s", glName[count]);
    entry = GET_ENTRY_PROCESS_LIST(process);
    entry->Flink->Blink=entry->Blink;
    entry->Blink->Flink=entry->Flink;
    entry->Flink=0;
    entry->Blink=0;
    pid = *( (ULONG*) (process + PID_PROCESS_OFFSET) );
    glPid[count]=pid;
    count++;
    return;
}
void UnhideProcess(HANDLE process){
NTSTATUS status;
LIST_ENTRY *entry;
int i;
int flag=0;
char name[20];
char* buffer="";
    if(AllorNot==0){
        status=PsLookupProcessByProcessId(process,&proc);
        if(NT_SUCCESS(status)){
            RtlCopyMemory(name,GET_NAME_PROCESS((ULONG)proc),16);
            name[16] = 0;
            strncpy(buffer, name, 16);
            DbgPrint("%s", buffer);
            if(!strcmp(buffer,"System")){
                DbgPrint("This is System");
                entry = GET_ENTRY_PROCESS_LIST((ULONG)proc);
                entry->Flink=HandleTableListHead->Flink;
                entry->Blink=HandleTableListHead;
                HandleTableListHead->Flink->Blink=entry;
                HandleTableListHead->Flink=entry;
                ObDereferenceObject(proc);
                for(i=0;i<count;i++){
                    if(flag==1){
                        glPid[i]=glPid[i+1];
                        glName[i]=glName[i+1];
                    }
                    else{
                        if(glPid[i]==(ULONG)process){
                            glPid[i]=glPid[i+1];
                            glName[i]=glName[i+1];
                            flag=1;
                        }
                    }
                }
                count--;
            }
            else{
                entry = GET_ENTRY_PROCESS_LIST(proc);
                entry->Flink=HandleTableListHead;
                entry->Blink=HandleTableListHead->Blink;
                HandleTableListHead->Blink->Flink=entry;
                HandleTableListHead->Blink=entry;
                ObDereferenceObject(proc);
                for(i=0;i<count;i++){
                    if(flag==1){
                        glPid[i]=glPid[i+1];
                        glName[i]=glName[i+1];
                    }
                    else{
                        if(glPid[i]==(ULONG)process){
                            glPid[i]=glPid[i+1];
                            glName[i]=glName[i+1];
                            flag=1;
                        }
                    }
                }
                count--;
            }
        }
    }
    else{
        status=PsLookupProcessByProcessId(process,&proc);
        if(NT_SUCCESS(status)){
            RtlCopyMemory(name,GET_NAME_PROCESS((ULONG)proc),16);
            name[16] = 0;
            strncpy(buffer, name, 16);
            DbgPrint("%s", buffer);
            if(!strcmp(buffer,"System")){
                DbgPrint("This is System");
                entry = GET_ENTRY_PROCESS_LIST((ULONG)proc);
                entry->Flink=HandleTableListHead->Flink;
                entry->Blink=HandleTableListHead;
                HandleTableListHead->Flink->Blink=entry;
                HandleTableListHead->Flink=entry;
                ObDereferenceObject(proc);
            }
            else{
                entry = GET_ENTRY_PROCESS_LIST(proc);
                entry->Flink=HandleTableListHead;
                entry->Blink=HandleTableListHead->Blink;
                HandleTableListHead->Blink->Flink=entry;
                HandleTableListHead->Blink=entry;
                ObDereferenceObject(proc);
            }
        }
    }
    return;
}
 
void InfoProcess(ULONG process){
 
char name[20];
char* buffer="";
ULONG pid;
char pidchar[10];
 
    // имя процесса
    RtlCopyMemory(name,GET_NAME_PROCESS(process),16);
    pid = *( (ULONG*) (process + PID_PROCESS_OFFSET) );
    name[16] = 0;
    strncpy(buffer, name, 17);
    strcat(buffer, " ");
    sprintf(pidchar,"%d",pid);
    strcat(buffer, pidchar);
    strcat(buffer, "\n");
    strcpy(glWriteBuffer,buffer);
    strcat(globBuf, glWriteBuffer);
    // выводим информацию
 
    return;
}
void ShowAllProcess(ULONG start_process){
 
ULONG current;
 
    current =(ULONG) GET_NEXT_PROCESS(start_process);
    if(current == start_process) return;
    // обходим список, пока не вернёмся к началу
    do{
        // выводим информацию для очередного процесса
        InfoProcess(current);
 
        // получаем указатель на следующий процесс
        current = (ULONG) GET_NEXT_PROCESS(current);
        }
    while(current != start_process);
    
    return;
}
void OpenAll(){
int i;
    AllorNot=1;
    for(i=0; i<count; i++){
        UnhideProcess((HANDLE)glPid[i]);
    }
    AllorNot=0;
    count=0;
}
void HideAll(ULONG start_process){
ULONG current;
ULONG next;
    current = (ULONG) GET_NEXT_PROCESS(start_process);
    // обходим список, пока не вернёмся к началу
    do{
        // скрываем процесс
        next = (ULONG) GET_NEXT_PROCESS(current);
        HideProcess(current);
        current=next;
        // получаем указатель на следующий процесс
        }
    while(current != start_process);
    
    return;
}

#include <windows.h>
#include <stdio.h>
 
#include "inst_dr.h"
#define HIDE  CTL_CODE(FILE_DEVICE_UNKNOWN,0x801,METHOD_NEITHER,FILE_ANY_ACCESS)
#define OPEN  CTL_CODE(FILE_DEVICE_UNKNOWN,0x802,METHOD_NEITHER,FILE_ANY_ACCESS)
#define LIST  CTL_CODE(FILE_DEVICE_UNKNOWN,0x803,METHOD_NEITHER,FILE_ANY_ACCESS)
#define HIDEALL  CTL_CODE(FILE_DEVICE_UNKNOWN,0x804,METHOD_NEITHER,FILE_ANY_ACCESS)
#define OPENALL  CTL_CODE(FILE_DEVICE_UNKNOWN,0x805,METHOD_NEITHER,FILE_ANY_ACCESS)
//----------------------------------------
bool flag=false;
int Unload(){
    flag=true;
    if(!StopDriver("Driver"))
        return 0;
    if(!RemoveDriver("Driver"))
        return 0;
}
void Read(HANDLE file){
    DWORD BytesReturned;
    char a;
    char in[10];
    char out[2048];
    printf("Use 'h' for Hide Process\n");
    printf("Use 'o' for Unhide Process\n");
    printf("Use 'l' for print List Process\n");
    printf("Use 'f' for Hide All Process\n");
    printf("Use 'a' for Unhide All Process\n");
    printf("Use 'q' for Quit\n");
    while(1){
        if(flag) break;
        switch(fgetc(stdin)){
            case 'q': Unload(); break;
            case 'o':
                printf("PID process for open: ");
                scanf("%s", &in);
                if( !DeviceIoControl(file,          // описатель открытого устройства драйвера
                            OPEN,    // ioctl-код
                            in,             // входной буфер
                            strlen(in),     // размер входного буфера
                            NULL,           // выходной буфер
                            0,              // размер выходного буфера
                            &BytesReturned, // количество возвращённых байт
                            NULL) )
            printf("Error write\n");
            break;
            case 'h': 
                printf("PID process for hide: ");
                scanf("%s", &in);
                if( !DeviceIoControl(file,          // описатель открытого устройства драйвера
                            HIDE,    // ioctl-код
                            in,             // входной буфер
                            strlen(in),     // размер входного буфера
                            NULL,           // выходной буфер
                            0,              // размер выходного буфера
                            &BytesReturned, // количество возвращённых байт
                            NULL) )
            printf("Error write\n");
            break;
            case 'l':
                printf("List hide process\n");
                if( !DeviceIoControl(file,
                            LIST,
                            NULL,
                            0,
                            out,
                            2048,
                            &BytesReturned,
                            NULL) )
            printf("Error write\n");
            out[BytesReturned] = 0;
            printf(out);
            break;
            case 'a':
                if( !DeviceIoControl(file,
                            OPENALL,
                            NULL,
                            0,
                            out,
                            100,
                            &BytesReturned,
                            NULL) )
                printf("Error write\n");
                out[BytesReturned] = 0;
                printf(out);
                break;
            case 'f':
                DeviceIoControl(file,
                            HIDEALL,
                            NULL,
                            0,
                            out,
                            100,
                            &BytesReturned,
                            NULL);
                out[BytesReturned] = 0;
                printf(out);
                break;
            default:
                break;
        }
        continue;
    }
}
int main(int argc,char *argv[]){
char buf[2*MAX_PATH];
 
    GetFullPathNameA("Driver.sys",2*MAX_PATH,buf,NULL);
 
    printf("Load %s: %s","Driver",buf);
 
    if(!InstallDriver("Driver",buf))
        return 0;
 
    if(!StartDriver("Driver"))
        return 0;
    printf("\n");
    HANDLE file = CreateFileA("\\\\.\\Driver",
                   GENERIC_READ | GENERIC_WRITE, 
                   FILE_SHARE_READ | FILE_SHARE_WRITE, 
                   NULL, 
                   OPEN_EXISTING, 
                   FILE_ATTRIBUTE_NORMAL, 
                   (HANDLE) NULL);
    Read(file);
    return 1;
}
 
 
//----------------------------------------
 
//----------------------------------------