一、逻辑分析

1、windows没有fork函数,无法创建僵尸进程，使用打开非子进程的方式打开外部进程---打开外部进程

2、守护进程应该是单例的进程---》单例进程

3、守护进程应该是存在一个子线程不断的判断是否存在守护目标，若不存在(异常退出)则启动守护目标

4、当守护目标正常退出时,需要关闭守护进程

(1)、直接kill掉守护进程(守护进程没有做成病毒进程(系统进程)---记录下这里没找到方法)

(2)、进程间通讯实现关闭守护进程---有很多的方法博主使用的是命名管道

二、守护线程

#pragma once

#include <QThread>

class HiDaemon : public QThread
{
	Q_OBJECT
public:
	HiDaemon(QObject *parent = nullptr);
	~HiDaemon();

public slots:
	void start();
	void stop();

private:
	void run();

private:
	volatile bool			m_bRunning;

	QString					m_strFilePath;
	QString					m_strProducerName;
};

#include "HiDaemon.h"
#include <windows.h>
#include "tlhelp32.h"
#include "tchar.h"
#include "HiDaemonDef.h"
#include "HiUtils.h"
#include <QMessageBox>

HiDaemon::HiDaemon(QObject *parent)
	: QThread(parent)
	, m_bRunning(false)
	, m_strProducerName("")  // 这里自定义默认值
{
	m_strFilePath = QApplication::applicationDirPath();

	QStringList strList = QApplication::arguments();
	if (strList.size() > 1)
	{
		m_strProducerName = strList.at(1);
	}
}

HiDaemon::~HiDaemon()
{
}

void HiDaemon::start()
{
	if (m_bRunning)
	{
		return;
	}
	m_bRunning = true;

	QThread::start();
}

void HiDaemon::stop()
{
	m_bRunning = false;
	wait(1000);
}

void HiDaemon::run()
{
	STARTUPINFOA si;
	//进程对象
	PROCESS_INFORMATION pi;
	//初始化 
	ZeroMemory(&si, sizeof(si));
	si.cb = sizeof(si);
	ZeroMemory(&pi, sizeof(pi));

	//构造cmd执行守护进程的字符串
	char pCmd[MAX_PATH_NUM] = { 0 };

	{
		QFileInfo file(m_strFilePath + QDir::separator() + m_strProducerName);

		QString strFilePath = file.filePath();
		strcat_s(pCmd, strFilePath.toStdString().c_str());
	}
	
	while (m_bRunning)
	{
		//检查守护程序是否存在
		pi.hProcess = GetProcessHandleByName(m_strProducerName);

		if (pi.hProcess == nullptr)
		{
			// 创建子进程，判断是否执行成功
			if (CreateProcessA(NULL, pCmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
			{
				// 创建失败
			}
		}

		if (pi.hProcess != nullptr)
		{
			//无限等待子进程退出
			WaitForSingleObject(pi.hProcess, INFINITE);
			CloseHandle(pi.hProcess);
			CloseHandle(pi.hThread);
		}
		

		Sleep(100);
	}
}

二、命名管道实时通讯

#pragma once
#include <windows.h>
#include <QThread>

//
//HANDLE CreateNamedPipe(
//	LPCTSTR lpName,								// pipe name
//	DWORD dwOpenMode,							// pipe open mode
//	DWORD dwPipeMode,							// pipe-specific modes
//	DWORD nMaxInstances,						// maximum number of instances
//	DWORD nOutBufferSize,						// output buffer size
//	DWORD nInBufferSize,						// input buffer size
//	DWORD nDefaultTimeOut,						// time-out interval
//	LPSECURITY_ATTRIBUTES lpSecurityAttributes  // SD
//  );
//

class HiNamePipeServer : public QThread
{
	Q_OBJECT
public:
	HiNamePipeServer(QObject *parent = nullptr);
	~HiNamePipeServer();

	void start();
	void stop();

private slots:
	void onParse();

private:
	void creatPipe();
	void run();

signals:
	void parse();
	void stopDaemon();

private:
	HANDLE						 m_pHandle;
	HANDLE						 m_pEvent;
	volatile bool				 m_bRunning;
	char						 m_readbuffer[100];
	DWORD						 m_readLenth;
	bool						 m_resetStarted;
	QString						 m_strFilePath;
	QString						 m_strProducerName;
};

#include "HiNamePipeServer.h"
#include <windows.h>
#include <QDebug>
#include "HiDaemonDef.h"
#include "HiUtils.h"
HiNamePipeServer::HiNamePipeServer(QObject *parent)
	: QThread(parent)
	, m_bRunning(false)
	, m_pHandle(nullptr)
	, m_resetStarted(false)
{
	creatPipe();
	connect(this, &HiNamePipeServer::parse, this, &HiNamePipeServer::onParse, Qt::DirectConnection);
	m_strFilePath = QApplication::applicationDirPath();

	QStringList strList = QApplication::arguments();
	if (strList.size() > 1)
	{
		m_strProducerName = strList.at(1);
	}
}

HiNamePipeServer::~HiNamePipeServer()
{
	if (m_pHandle)
	{
		CloseHandle(m_pHandle);
	}
	CloseHandle(m_pEvent);
}

void HiNamePipeServer::start()
{
	if (m_bRunning)
	{
		return;
	}
	m_bRunning = true;
	QThread::start();
}

void HiNamePipeServer::stop()
{
	m_bRunning = false;
}

void HiNamePipeServer::onParse()
{
	QString strMsg = m_readbuffer;

	QStringList paramList = strMsg.split(WRITE_SPACER);
	if (paramList.size() != 2)
	{
		return;
	}
	
	PipeWriteType writeType = PipeWriteType(paramList.at(0).toInt());

	switch (writeType)
	{
	case PipeWriteType_ClientExit:
	{
		emit stopDaemon();
		qApp->quit();
		break;
	}
	case PipeWriteType_ClinetRestart:
	{
		if (m_resetStarted == false)
		{
			m_resetStarted = true;
			KillProcess(m_strProducerName);
		}
		break;
	}
	default:
		break;
	}

}

void HiNamePipeServer::creatPipe()
{
	m_pHandle = CreateNamedPipe(PIPE_NAME, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE, PIPE_MAXINSTANCES, 0, 0, 1000, NULL);
	if (INVALID_HANDLE_VALUE == m_pHandle)
	{
		CloseHandle(m_pHandle);
		// 创建管道失败
		m_pHandle = nullptr;
	}
}

void HiNamePipeServer::run()
{
	// 这里暂时同步调用，可以考虑使用异步设置超时事件
	while (m_bRunning)
	{
		OVERLAPPED  ovlap;
		ZeroMemory(&ovlap, sizeof(OVERLAPPED));
		//2. 创建管道连接
		if (!ConnectNamedPipe(m_pHandle, &ovlap))
		{
			if (ERROR_IO_PENDING != GetLastError())
			{
				Sleep(100);
				continue;
			}
		}

		// 这个等待可能非常的久
		if (ReadFile(m_pHandle, m_readbuffer, 100, &m_readLenth, NULL) == TRUE)
		{
			emit parse();
		}
		DisconnectNamedPipe(m_pHandle);
	}
}

管道读取线程是阻塞的

三、主函数

#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <iostream>
#include <string>
#include <QString>
#include <QApplication>
#include "HiNamePipeServer.h"
#include "HiDaemon.h"
#include <QObject>
#include "HiSingleApplication.h"

LPCTSTR szAppClassName = TEXT("HiDaemon");
LPCTSTR szAppWindowName = TEXT("HiDaemon");


// HANDLE hProcess = ::OpenProcess(PROCESS_TERMINATE, FALSE, dwProcessID);
// ::TerminateProcess(hProcess, 0);
// CloseHandle(hProcess);

using namespace std;

// 隐藏DOS黑窗口
#ifdef _MSC_VER
#pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )
#endif

int main(int argc, char* argv[])
{
	HiSingleApplication a(argc, argv);
	// 这里应该传入的产品类型，不同的产品，启动后可能动作不一致
	QCoreApplication::setOrganizationName("EnlightV");
	QCoreApplication::setApplicationName("HiDaemon");
	if (a.isRunning())
	{
		return 0;
	}

	HiDaemon *daemon = new HiDaemon;
	HiNamePipeServer *server = new HiNamePipeServer;

	QObject::connect(server, &HiNamePipeServer::stopDaemon, daemon, &HiDaemon::stop, Qt::DirectConnection);

	daemon->start();
	server->start();

	a.exec();

	return 0;
}

四、应用程序启动守护进程

// 获取守护进程句柄
HANDLE GetProcessHandleByName(const QString &name)
{
	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if (INVALID_HANDLE_VALUE == hSnapshot)
	{
		return NULL;
	}
	PROCESSENTRY32 pe = { sizeof(pe) };
	BOOL fOk;
	for (fOk = Process32First(hSnapshot, &pe); fOk; fOk = Process32Next(hSnapshot, &pe))
	{
		if (QString::fromWCharArray(pe.szExeFile) == name)
		{
			CloseHandle(hSnapshot);
			return GetProcessHandle(pe.th32ProcessID);
		}
	}
	return NULL;
}

//tempPath 是自定义的一个可写目录
void StartDaemon(const QString &tempPath)
{
	// 1、检测守护进程是否已经启动了
	if (GetProcessHandleByName(DAEMON_NAME) != nullptr)
	{
		return;
	}

	QString batFile = tempPath + QDir::separator() + "StartDaemon.bat";
	if (QFile(batFile).exists())
	{
		QFile(batFile).remove();
	}

	QFile file(batFile);
	if (file.open(QFile::ReadWrite))
	{
		QString strParam = QString("@echo off \n start /d  \"%1\" HiDaemond.exe  \"%2\" \n exit").arg(QCoreApplication::applicationDirPath()).arg(QFileInfo(QCoreApplication::applicationFilePath()).fileName());
		file.write(strParam.toLocal8Bit());
		file.close();

		QProcess p;
		p.start("cmd.exe", QStringList() << "/c" << batFile);
		if (p.waitForStarted())
		{
			p.waitForFinished(2000);
			return;
		}
	}
	else
	{
		QString strAppPath = QApplication::applicationDirPath();
		QStringList arguments;
		{
			QFileInfo file(QApplication::applicationFilePath());
			arguments.append(file.fileName());
		}
		QFileInfo deamonFile(strAppPath + QDir::separator() + DAEMON_NAME);
		if (deamonFile.exists())
		{
			std::wstring operate = QString("runas").toStdWString();//临时提升管理员权限
			std::wstring path = QCoreApplication::applicationDirPath().toStdWString();
			std::wstring appName = QFileInfo(QCoreApplication::applicationFilePath()).fileName().toStdWString();;
			std::wstring file = deamonFile.filePath().toStdWString();
			int ret = (int)ShellExecute(NULL, operate.c_str(), file.c_str(), appName.c_str(), path.c_str(), SW_SHOWNORMAL);
		}

	}
}

五、主端关闭时候，通讯给守护进程自行关闭

#pragma once

#include <windows.h>

class HiNamePipeClient
{
public:
	static HiNamePipeClient* getInstance();
	void writeFile(PipeWriteType type,  const QString & param = QString());

protected:
	HiNamePipeClient();
	~HiNamePipeClient();

private:
	bool openPipe();

private:
	HANDLE  m_pHandle;
};

inline HiNamePipeClient *pipeClient()
{
	return HiNamePipeClient::getInstance();
}

#include "HiNamePipeClient.h"
#include "guard.h"

enum PipeWriteType
{
	PipeWriteType_ClientExit = 0,							// 客户端正常退出
	PipeWriteType_ClinetRestart,							// 客户端重启
};

HiNamePipeClient* HiNamePipeClient::getInstance()
{
	static HiNamePipeClient instance;
	return &instance;
}

void HiNamePipeClient::writeFile(PipeWriteType type, const QString & param)
{
#if HIRENDER_C_SERIES
	if (openPipe())
	{
		DWORD dwWriteLen = 0;
		QString strParam = QString("%1#%2").arg((int)type).arg(param);
		if (WriteFile(m_pHandle, strParam.toStdString().c_str(), strParam.length(), &dwWriteLen, NULL))
		{
			// 写入成功
		}
		CloseHandle(m_pHandle);
		m_pHandle = nullptr;	
	}
	Sleep(200);
#endif
}

HiNamePipeClient::HiNamePipeClient()
	: m_pHandle(nullptr)
{

}

HiNamePipeClient::~HiNamePipeClient()
{

}

bool HiNamePipeClient::openPipe()
{
	if (m_pHandle)
	{
		CloseHandle(m_pHandle);
	}
	if (!WaitNamedPipe(PIPE_NAME, PIPE_TIMEOUT))
	{
		// 当前没有可利用的命名管道实例！
		return false;
	}

	m_pHandle = CreateFile(PIPE_NAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (INVALID_HANDLE_VALUE == m_pHandle)
	{
		// "打开命名管道失败！
		m_pHandle = NULL;
		return false;
	}
	return true;
}

六、强制关闭守护进程（提供方法、博主程序中未使用）

bool KillProcess(QString ProcessName)
{
	QProcess p;
	QString c = "taskkill /im " + ProcessName + " /f";    //exeFileName为要杀死的进程名
	p.execute(c);
	p.close();
	return true;
}

前面我学习过 32位系统里进行驱动隐藏进程，http://bbs.dult.cn/thread-10701-1-1.html
来防止破解或被游戏检测到辅助
本节例子教程讲述的是在64位 win7系统进行驱动隐藏进程，
毕竟现在网络上能在64位win7系统里进行驱动隐藏进程的非常少
所以独立团有必要在驱动模块里加入强大的64位系统驱动隐藏进程功能
隐藏后的效果如下：

可以看见64位win7系统里的任务管理器里已经找不到我们的程序（驱动保护例子.exe）进程名了
成功的隐藏了，驱动隐藏了后，就连OD和CE都无法找到我们的程序进程名，也就无法附加我们辅助程序的进程了，
无法进行破坏我们程序了！
源码下载：http://bbs.dult.cn/forum.php?mod=viewthread&tid=11723

隐藏进程之内核版实现

隐藏进程通常出现在恶意程序中，隐藏的进程能让任务管理器、procexp等3环的程序无法找到它，那么如何实现隐藏进程呢？

由于对这方面还是很感兴趣，今天就来研究一下内核层的隐藏进程，首先在用户层3环，如任务管理器、procexp遍历进程都是使用CreateToolhelp32Snapshot()API创建快照遍历查找的，使用快照的API在内核中就是通过访问一个双向链表的数据结构来得到每一个进程的信息的，那么我们只要把需要隐藏的进程信息从这个链表中干掉，就能完成隐藏的目的。

每个进程在内核中都有一个内核对象，内核对象的信息被保存在一个名为_EPROCESS的结构体中，首先进行双机调试，在这我调试的是WIN7虚拟机，在windbg调试器中输入dt _eprocess指令即可查看_EPROCESS结构体

在这里要注意的是偏移0xb8的一个字段：
+0x0b8 ActiveProcessLinks : _LIST_ENTRY
这个字段记录的就是当前系统上的活动进程链表, 通过遍历这条链表就能得到当前系统上的所有进程。
在隐藏进程时还需要关注的一个字段是在偏移为0x16c处的一个字段：
+0x16c ImageFileName : [15] UChar
这个字段记录的当前进程的名称字符串的地址。
当然上面这两个的字段的偏移并不是固定的，在不同版本的系统中偏移有可能不同，所以使用时要查看该系统的字段偏移。

_LIST_ENTRY是一个双向链表,分别指向下一节点和上一节点

系统通过这个链表把每个进程都链接在了一起，假设现在系统中只有3个进程，那么链接关系大体如下图

那么从上图中可以看出只要操作_LIST_ENTRY这个双向链表，我们就可以遍历系统上的全部进程。在隐藏进程中，我们只要通过链表操作，对比进程名称，找到我们想隐藏的程序，把它从这个链表中删除。
在这通过一个宏：
PsGetCurrentProcess()
作用是可获取当前进程的内核对象，可得到当前第一个节点。主要代码如下

        //进程名称
		char* ProcName = NULL;
		ProcName = (char*)pInputBuff;		
		//获取当前进程对象
		PEPROCESS NowProc = PsGetCurrentProcess();
		//获取进程对象内的当前活动进程链表
		LIST_ENTRY* pNowList = (LIST_ENTRY*)((ULONG)NowProc + 0xb8);
		//临时链表
		LIST_ENTRY* pTempList = pNowList;
		//遍历链表
		while (pNowList != pTempList->Flink)
		{
			//相对进程对象偏移0x16c保存的是ImageFileName,
			//当前相对进程对象偏移是0xb8，需要减去
			//对比是否为目标进程			
			if (!strcmp(ProcName, (char*)
				((ULONG)pTempList - 0xb8 + 0x16c)))
			{
				//把找到的进程从链表中删除
				(pTempList->Blink)->Flink = pTempList->Flink;
				(pTempList->Flink)->Blink = pTempList->Blink;
				
				pTempList->Flink = pTempList->Blink = NULL;
				KdPrint(("成功删除程序链表节点\n"));

				break;
			}
			pTempList = pTempList->Flink;
		}

亲测有效，我隐藏的是记事本notepad.exe，在任务管理器中确实找不到这个进程，在procexp也没有,见图

使用内核级工具PCHunter查看进程

上图PCHunter中notepad.exe确实存在，还把该程序标称红色，说明是危险程序，因为PCHunter检测出他是隐藏的程序所以标红，这也说明PCHunter功能非常强大！
到此内核版隐藏进程就成功了，但它并不就是无敌了，PCHunter能找到隐藏的进程的因为它遍历进程方法与任务管理器的方式不同，它是通过内核级API进行暴力枚举，通过PsLookupProcessByProcessId这个API，其原理是输入一个PID返回该进程的EPROCESS结构的引用指针，那么for循环假设给定PID是遍历0~10万，那么PID只要在这个范围的的进程就无所遁形都会被找出来，这就是传说中的暴力枚举进程！

具体源码：

内核层：

#include <ntifs.h>
#define IOCTL_BASE 0x800
#define MY_CTL_CODE(code)       \
		CTL_CODE( \
		FILE_DEVICE_UNKNOWN, \
		IOCTL_BASE+(code), \
		METHOD_OUT_DIRECT, \
		0 \
		）
#define DF_GET_PROC_HIDE MY_CTL_CODE(7)

//卸载驱动
void UnLoad(DRIVER_OBJECT* obj)
{
	KdPrint(("驱动已卸载\n"));
	UNICODE_STRING userName;
	RtlInitUnicodeString(&userName,
		L"\\DosDevices\\MyFristDriver_User");
	//删除符号链接
	IoDeleteSymbolicLink(&userName);
	//删除设备对象
	IoDeleteDevice(obj->DeviceObject);
}

NTSTATUS InCreate(DEVICE_OBJECT *Device, IRP *irp);
NTSTATUS InClose(DEVICE_OBJECT *Device, IRP *irp);
NTSTATUS DeviceCtrl(DEVICE_OBJECT* device, IRP* irp);

//驱动入口
NTSTATUS DriverEntry(DRIVER_OBJECT* driver, UNICODE_STRING* path)
{
	path;
	KdPrint(("驱动已加载\n"));
	DbgBreakPoint();
	
	//1.创建一个设备对象
	DEVICE_OBJECT* DeviceObj = NULL;
	UNICODE_STRING deviceName;
	RtlInitUnicodeString(&deviceName,
		L"\\Device\\MyFristDriver");
	NTSTATUS status = IoCreateDevice(
		driver,
		0,
		&deviceName,
		FILE_DEVICE_UNKNOWN,
		0, 0,
		&DeviceObj);
	if (status != STATUS_SUCCESS)
		return status;
	driver->Flags |= DO_DIRECT_IO;//直接IO

	//2.绑定一个符号链接
	UNICODE_STRING userName;
	RtlInitUnicodeString(&userName,
		L"\\DosDevices\\MyFristDriver_User");
	IoCreateSymbolicLink(&userName, &deviceName);


	//调用派遣函数
	driver->MajorFunction[IRP_MJ_CREATE] = InCreate;
	driver->MajorFunction[IRP_MJ_CLOSE] = InClose;
	driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DeviceCtrl;

	driver->DriverUnload = UnLoad;
	return STATUS_SUCCESS;
}

NTSTATUS InCreate(DEVICE_OBJECT *Device, IRP *irp)
{
	Device;
	KdPrint(("调用了创建派遣函数\n"));
	irp->IoStatus.Status = STATUS_SUCCESS;
	irp->IoStatus.Information = 0;
	IoCompleteRequest(irp, IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}
NTSTATUS InClose(DEVICE_OBJECT *Device, IRP *irp)
{
	Device;
	KdPrint(("调用了关闭派遣函数\n"));
	irp->IoStatus.Status = STATUS_SUCCESS;
	irp->IoStatus.Information = 0;
	IoCompleteRequest(irp, IO_NO_INCREMENT);
	return STATUS_SUCCESS;
}



//通过控制码方式通讯
NTSTATUS DeviceCtrl(DEVICE_OBJECT* device, IRP* irp)
{
	KdPrint(("已进入控制码通讯\n"));	
	device;
	NTSTATUS status = STATUS_SUCCESS;
	ULONG complateSize = 0;
	HANDLE hFile = NULL;
	irp->IoStatus.Status = STATUS_SUCCESS;

	//1.获取IO栈位置
	IO_STACK_LOCATION* pIoStack = 
		IoGetCurrentIrpStackLocation(irp);

	//2.获取传入的参数
	//2.1 IO设备控制码
	ULONG ctrlCode = 
		pIoStack->Parameters.DeviceIoControl.IoControlCode;

	//2.2 输入缓冲区的字节数
	ULONG inputSize = pIoStack->
			Parameters.DeviceIoControl.InputBufferLength;

	//2.3获取输入缓冲区
	PVOID pInputBuff = irp->AssociatedIrp.SystemBuffer;

	//选择控制码
    switch (ctrlCode)
	{
	//HideProcess
	case DF_GET_PROC_HIDE:
	{		
		//进程名称
		char* ProcName = NULL;
		ProcName = (char*)pInputBuff;		
		//获取当前进程对象
		PEPROCESS NowProc = PsGetCurrentProcess();
		//获取进程对象内的当前活动进程链表
		LIST_ENTRY* pNowList = (LIST_ENTRY*)((ULONG)NowProc + 0xb8);
		//临时链表
		LIST_ENTRY* pTempList = pNowList;
		//遍历链表
		while (pNowList != pTempList->Flink)
		{
			//相对进程对象偏移0x16c保存的是ImageFileName,
			//当前相对进程对象偏移是0xb8，需要减去			
			if (!strcmp(ProcName, (char*)
				((ULONG)pTempList - 0xb8 + 0x16c)))
			{
				//把找到的进程从链表中删除
				(pTempList->Blink)->Flink = pTempList->Flink;
				(pTempList->Flink)->Blink = pTempList->Blink;
				
				pTempList->Flink = pTempList->Blink = NULL;
				KdPrint(("成功删除程序链表节点\n"));				
				break；
			}
			pTempList = pTempList->Flink;
		}
	}
	break;
	
	irp->IoStatus.Status = STATUS_SUCCESS;
	irp->IoStatus.Information = inputSize;
	IoCompleteRequest(irp, IO_NO_INCREMENT);
	return status;
	}
	

用户层：

#include <windows.h>
#define IOCTL_BASE 0x800
#define MY_CTL_CODE(code)       \
		CTL_CODE( \
		FILE_DEVICE_UNKNOWN, \
		IOCTL_BASE+(code), \
		METHOD_OUT_DIRECT, \
		0 \
		)
#define DF_GET_PROC_HIDE MY_CTL_CODE(7)

	
//隐藏进程
void HideProc(HANDLE hSys, DWORD size)
{
	//要隐藏进程的字符
	char pBuff[128] = { 0 };
	int inputSize = strlen("notepad.exe") + 1;	
	memcpy(pBuff, "notepad.exe", inputSize);
	
	//调用设备控制码函数
	BOOL nRet = DeviceIoControl(
		hSys,
		DF_GET_PROC_HIDE,
		(LPVOID)pBuff,
		inputSize,
		NULL,
		0,
		&size,
		NULL);
	if (!nRet)
	{
		printf("调用隐藏程序控制码失败%d\n", GetLastError());
		return;
	}
	printf("隐藏程序成功！\n");
}
	
	
int main()
{
	//打开该驱动
	HANDLE hSys = CreateFile(
		L"\\??\\MyFristDriver_User",
		GENERIC_ALL,
		FILE_SHARE_READ,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL);
	if (hSys==INVALID_HANDLE_VALUE)
	{
		printf("打开驱动失败 %d\n", GetLastError());
		getchar();
		return 0;
	}
	else printf("打开驱动成功\n");
	DWORD size = 0;

	//调用隐藏进程函数
	HideProc(hSys, size);

	getchar();
	CloseHandle(hSys);
}