监控进程创建结束非HOOK方式
easyhook 例子-概述说明以及解释
easyhook 例子-概述说明以及解释1.引言1.1 概述EasyHook是一个开源的Windows API Hooking 框架，它的设计目标是为了允许开发者在不修改原始代码的情况下，对已编译的应用程序或系统功能进行拦截和修改。
通过使用EasyHook，开发者可以实现对目标应用程序中指定函数的替换、监视和自定义功能的注入。
API Hooking是一种常见的技术，它通过拦截目标应用程序与操作系统之间的函数调用，使得我们可以截获这些函数的输入参数和返回值，并且可以在这些函数被调用前后做一些自定义的操作。
而EasyHook作为一个底层Hooking框架，提供了一套简单易用的API，帮助我们快速、方便地实现Hook功能。
与其他Hooking解决方案相比，EasyHook具有以下几个优点。
首先，它采用用户模式Hook的方式，不需要特权访问，因此可以安全地运行在普通用户账户下。
其次，EasyHook提供了友好的编程接口和详细的文档，降低了学习和使用的门槛。
再次，EasyHook支持跨平台，可以用于Windows XP到Windows 10的各个版本，并且还支持32位和64位应用程序。
此外，EasyHook还支持在不同的.NET Framework版本中使用，提供了强大而灵活的功能，使得开发人员能够快速解决各种Hooking问题。
EasyHook的使用场景非常广泛，例如：调试和逆向工程、性能分析、安全审计、游戏模块注入等。
它可以帮助我们监视和改变目标应用程序的行为，甚至可以在运行时动态修改应用程序的行为，从而满足我们的个性化需求。
在本文中，我们将介绍EasyHook框架的基本原理和使用方法，并分析其在实际应用中的优势和特点。
最后，我们将总结EasyHook的应用价值，展望和探讨其未来的发展方向。
通过对EasyHook的深入学习和实践，相信读者能够更好地掌握Hooking技术，并在实际项目中灵活运用。
1.2文章结构1.2 文章结构本文将按照以下结构来叙述和探讨easyhook的例子和使用方法：1. 引言：对easyhook进行简要介绍，并解释文章涉及的目的和意义。
进程的控制方法
进程的控制方法
1、进程创建：创建一个新的进程，可以使用系统调用如fork（）、
exec（）、CREATE等函数来实现。
2、进程终止：进程完成其任务后，主动调用exit（）或_exit（）
函数来终止自己。
3、进程阻塞：进程主动调用阻塞原语，如semwait（）、msgrcv
（）等，将自己的状态由运行变为等待状态。
4、进程唤醒：进程被阻塞后，等待某个事件的发生，如消息的到
来或信号量的增加，然后被唤醒。
5、进程同步：进程在并发执行过程中，由于共享资源而产生竞争，
需要采取措施进行协调，如信号量、消息队列、管程等。
6、进程通信：进程之间需要传递消息和共享数据，可以使用管道、
共享内存、消息队列、信号等机制进行通信。
7、进程调度：操作系统根据一定的调度算法，将CPU的时间片分
配给各个进程，控制它们的执行顺序和时间。
8、进程撤销：进程在执行过程中出现错误或异常情况，需要调用
撤销原语，如kill（）、exit（）等，终止该进程的执行。
9、进程死锁：进程在等待对方释放资源时出现相互等待的情况，
导致两个或多个进程都无法继续执行，需要采取措施避免死锁的发生。
过程控制的方法有哪些
过程控制的方法有哪些过程控制是指在计算机操作系统中对运行的进程进行管理和调度的一种机制。
它涉及到进程的创建、终止、调度、同步和通信等方面，是操作系统中非常重要的一部分。
在过程控制中，有许多不同的管理方法和策略，我将在以下几个方面逐一介绍。
1. 进程创建：进程的创建通常有三种方式：用户请求创建、系统初始化创建和进程自我复制。
用户请求创建是指用户通过运行特定的系统调用，在操作系统中创建新的进程。
系统初始化创建是指操作系统在系统启动时预先创建一些必要的进程，例如init 进程。
进程自我复制是指一个正在运行的进程创建一个与自己相同的新进程。
2. 进程终止：进程的终止可以通过三种方式实现：正常终止、异常终止和外界干预终止。
正常终止是指进程完成了它的任务，然后自愿退出。
异常终止是指进程由于发生了一些错误或异常情况而被迫退出。
外界干预终止是指操作系统或其他进程通过发送特定的信号来终止一个进程。
3. 进程调度：进程调度是指操作系统在多个进程之间进行切换和调度，以实现对系统资源的合理利用。
常见的调度算法有先来先服务（FCFS）、最短作业优先（SJF）、最短剩余时间优先（SRTF）、轮转调度、优先级调度等。
4. 进程同步：进程同步是指多个进程之间的相互协作，以保证它们之间的临界资源的安全访问。
常见的进程同步方法有互斥锁、信号量、条件变量等。
5. 进程通信：进程通信是指进程之间传递信息和数据的过程。
常见的进程通信方法有管道、消息队列、共享内存、信号和套接字等。
6. 进程间通信（IPC）：进程间通信是指两个或多个进程之间进行信息和数据交流的过程。
IPC可以通过共享内存、消息传递、管道、信号和套接字等方式来实现。
7. 进程死锁避免：死锁是指多个进程之间由于彼此之间的循环等待而无法继续执行的一种情况。
为了避免死锁的发生，可以采用资源分配的策略、资源有序分配策略和银行家算法等方法。
8. 多线程：多线程是指在同一个进程内同时执行多个线程，每个线程都拥有独立的程序计数器、栈和寄存器。
新的结束进程方法、结束伪装的系统进程“svchost.exe”
一、有的网吧系统存在伪装的系统进程“svchost.exe”，一般都是后台广告或着木马进程，这样的进程很难发现和结束，下面利用WMIC的CMD命令来结束：
wmic process where "name='svchost.exe' and
ExecutablePath<>'C:\\WINDOWS\\system32\\svchost.exe'" call Terminate
请在CMD里面输入粘贴以上命令回车试试效果，或者把它放到批处理里面也行，这段命令的意思是：结束目录不在system32下的所有“svchost.exe”进程另外看到楼下有同学说用“taskkill /f /im svchost.exe” , taskkill不能这样用来结束系统进程，因为这样会把所有的“svchost.exe”全部结束掉，可能会蓝屏或自动关机
二、单纯的wmic命令行下结束进程的方法（类似taskkill）：
wmic process where "name='qq2018.exe'" call Terminate
请在CMD里面输入粘贴以上命令回车试试效果，或者把它放到批处理里面也行，这段命令的意思是：结束所有的“qq2018.exe”进程，可以替代用于“taskkill”不能结束的广告进程。
hook实现原理
hook实现原理Hook，即钩子，是一种在特定事件发生之前、之中或之后执行的代码。
在编程中，钩子技术被广泛应用于各种场景，如进程间通信、事件处理、性能监控等。
本文将介绍钩子的基本原理，以及在C++编程语言中使用钩子进行事件处理的实现方法。
一、钩子的基本原理钩子是一种特殊的函数，通常在特定事件发生时被系统调用。
钩子的实现原理通常是在系统调用事件发生之前，通过某种方式拦截事件的执行流程，并添加自定义的代码。
这种实现方式依赖于编程语言的底层机制，通常涉及到操作系统的内存管理、进程控制、中断处理等方面。
在C++中，钩子的实现通常需要借助操作系统提供的API函数或内核对象来实现。
钩子的注册和注销通常需要调用相应的API函数，以便在特定事件发生时触发钩子函数。
同时，钩子函数需要具备可移植性，以便在不同的操作系统和平台上使用。
1. 钩子注册和注销在C++中，钩子的注册和注销通常需要使用操作系统提供的API函数。
例如，在Windows操作系统中，可以使用SetWindowsHookEx()函数注册钩子，使用UnhookWindowsHookEx()函数注销钩子。
这些函数需要传递钩子函数的地址作为参数，以便在特定事件发生时执行钩子函数。
2. 钩子函数的执行当事件发生时，操作系统会根据注册的钩子函数列表，依次调用相应的钩子函数。
每个钩子函数会在事件发生的过程中添加自定义的代码，从而实现钩子的功能。
钩子函数的执行顺序和执行时机取决于注册时的顺序和条件。
3. 钩子的类型和用途钩子根据实现方式可以分为不同的类型，如键盘钩子、鼠标钩子、定时器钩子等。
不同类型的钩子适用于不同的场景，如键盘钩子可用于实现键盘快捷键功能，鼠标钩子可用于实现鼠标事件处理等。
根据用途不同，钩子可以应用于各种编程场景，如游戏开发、网络通信、应用性能监控等。
三、案例分析：C++游戏开发中的钩子实现在C++游戏开发中，钩子技术常用于事件处理和性能监控。
以下是一个简单的示例程序，展示了如何在游戏开发中使用钩子技术：1. 程序初始化时注册鼠标移动钩子在程序初始化时，使用系统API函数注册鼠标移动钩子。
HOOK教程一_使用SetWindowsHookEx进行Windows消息HOOK
关于 Hook·使用 SetWindowsHookEx 进行消息 HOOK 一、基本概念：
钩子(Hook)， 是 Windows 消息处理机制的一个平台,应用程序可以在上面设置子程以监视指定窗 口的某种消息，而且所监视的窗口可以是其他进程所创建的。当消息到达后，在目标窗口处理函 数之前处理它。钩子机制允许应用程序截获处理 window 消息或特定事件。 钩子实际上是一个处理消息的程序段，通过系统调用，把它挂入系统。每当特定的消息发出， 在没有到达目的窗口前，钩子程序就先捕获该消息，亦即钩子函数先得到控制权。这时钩子函数 即可以加工处理（改变）该消息，也可以不作处理而继续传递该消息，还可以强制结束消息的传 递。
4、系统钩子与线程钩子：
SetWindowsHookEx()函数的最后一个参数决定了此钩子是系统钩子还是线程钩子。 线程勾子用于监视指定线程的事件消息。 线程勾子一般在当前线程或者当前线程派生的线程内。 系统勾子监视系统中的所有线程的事件消息。因为系统勾子会影响系统中所有的应用程序，所 以勾子函数必须放在独立的动态链接库 (DLL) 中。系统自动将包含 "钩子回调函数"的 DLL 映射到 受钩子函数影响的所有进程的地址空间中，即将这个 DLL 注入了那些进程。 几点说明： （1）如果对于同一事件（如鼠标消息）既安装了线程勾子又安装了系统勾子，那么系统会自动先 调用线程勾子，然后调用系统勾子。 （2）对同一事件消息可安装多个勾子处理过程，这些勾子处理过程形成了勾子链。当前勾子处理 结束后应把勾子信息传递给下一个勾子函数。 （3）勾子特别是系统勾子会消耗消息处理时间，降低系统性能。只有在必要的时候才安装勾子， 在使用完毕后要及时卸载。
HOOK监控任务管理器
HOOK监控任务管理器思路：其实比较简单，还是利用DLL，首写跟据API函数OpenProcess与TerminateProcess的结构自已编写两个与这两个API一样的函数，再利用GetProcAddress获取系统的那两个API函数入口地址，最后用WriteProcessMemory将你写的函数的地址替换掉原来系统的函数地址。
这样所有调用这两系统API都将先执行你的函数。
如果只Hook其中一个函数比如只hook OpenProcess的话那么任务管理器将不能获取到你的进程信息那么会出错。
如果只hook TerminateProcess那样也不行，因为一个进程的句柄在本进程与别的进程中是不一样的，所以如果你不知道自已进程在别人进程中的句柄那么是没办法hook TerminateProcess的。
本例中首先利用OpenProcess获取自已在别的进程中的句柄，然后hook TerminateProcess进程监控，如果发现有程序调用TerminateProcess并且所结束的对象正是自已，那么就给出提示窗口。
貌似讲了一大堆废话。
还是看代码直接------------------------------------------------调用部分unit Unit1;interfaceusesWindows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,Dialogs, StdCtrls;typeTForm1 = class(TForm)Button1: TButton;Button2: TButton;procedure Button1Click(Sender: TObject);procedure Button2Click(Sender: TObject);private{ Private declarations }public{ Public declarations }end;varForm1: TForm1;procedure StartHook(pid: DWORD); stdcall; external 'hookdll.dll';procedure EndHook; stdcall; external 'hookdll.dll';implementation{$R *.dfm}procedure TForm1.Button1Click(Sender: TObject);beginStartHook(GetCurrentProcessId);end;procedure TForm1.Button2Click(Sender: TObject);beginEndHook;end;end.-----------------------------------------------------------------------------------------DLL文件，全部实现都在这里--------------------- Hookdll.dprlibrary Hookdll;usesSysUtils,Classes,Windows,Dialogs,unitHook in 'unitHook.pas';constHOOK_MEM_FILENAME = 'tmp.hkt';varhhk: HHOOK;Hook: array[0..2] of TNtHookClass;//内存映射MemFile: THandle;startPid: PDWORD; //保存PIDfhProcess: THandle; //保存本进程在远程进程中的句柄//拦截 OpenProcessfunction NewOpenProcess(dwDesiredAccess: DWORD; bInheritHandle: BOOL; dwProcessId: DWORD): THand le; stdcall;typeTNewOpenProcess = function (dwDesiredAccess: DWORD; bInheritHandle: BOOL; dwProcessId: DWORD): T Handle; stdcall;beginif startPid^ = dwProcessId then beginHook[1].UnHook;Result := TNewOpenProcess(Hook[1].BaseAddr)(dwDesiredAccess, bInheritHandle, dwProcessId);fhProcess:=Result;Hook[1].Hook;exit;end;Hook[1].UnHook;Result := TNewOpenProcess(Hook[1].BaseAddr)(dwDesiredAccess, bInheritHandle, dwProcessId);Hook[1].Hook;end;function NewTerminateProcess(hProcess: THandle;uExitCode: UINT): BOOL; Stdcall;typeTNewTerminateProcess = function (hProcess: THandle;uExitCode: UINT): BOOL; Stdcall;beginif fhProcess = hProcess then beginshowmessage('不准关闭我！');result := true;exit;end;Hook[2].UnHook;Result := TNewTerminateProcess(Hook[2].BaseAddr)(hProcess, uExitCode );Hook[2].Hook;end;procedure InitHook; //安装 HookbeginHook[1] := TNtHookClass.Create('kernel32.dll', 'OpenProcess', @NewOpenProcess);hook[2] := TNtHookClass.Create('kernel32.dll', 'TerminateProcess', @NewTerminateProcess);end;procedure UninitHook; //删除 HookvarI: Integer;beginfor I := 0 to High(Hook) dobeginFreeAndNil(Hook[I]);end;end;procedure MemShared();beginMemFile:=OpenFileMapping(FILE_MAP_ALL_ACCESS,False, HOOK_MEM_FILENAME); //打开内存映射文件if MemFile = 0 then beginMemFile := CreateFileMapping($FFFFFFFF, nil, PAGE_READWRITE, 0, 4, HOOK_MEM_FILENAME);end;if MemFile <> 0 then//映射文件到变量startPid := MapViewOfFile(MemFile,FILE_MAP_ALL_ACCESS,0,0,0); end;//传递消息function HookProc(nCode, wParam, lParam: Integer): Integer; stdcall;beginResult := CallNextHookEx(hhk, nCode, wParam, lParam);end;//开始HOOKprocedure StartHook(pid: DWORD); stdcall;beginstartPid^ := pid;hhk := SetWindowsHookEx(WH_CALLWNDPROC, HookProc, hInstance, 0); end;//结束HOOKprocedure EndHook; stdcall;beginif hhk <> 0 thenUnhookWindowsHookEx(hhk);end;//环境处理procedure DllEntry(dwResaon: DWORD);begincase dwResaon ofDLL_PROCESS_A TTACH: InitHook; //DLL载入DLL_PROCESS_DETACH: UninitHook; //DLL删除end;end;exportsStartHook, EndHook;beginMemShared;{ 分配DLL程序到 DllProc 变量 }DllProc := @DllEntry;{ 调用DLL加载处理 }DllEntry(DLL_PROCESS_A TTACH);end.--------------------------- 单元unitHook.pasunit unitHook;interfaceusesWindows, Messages, Classes, SysUtils;type//NtHook类相关类型TNtJmpCode=packed record //8字节MovEax:Byte;Addr:DWORD;JmpCode:Word;dwReserved:Byte;end;TNtHookClass=class(TObject)privatehProcess:THandle;NewAddr:TNtJmpCode;OldAddr:array[0..7] of Byte;ReadOK:Boolean;publicBaseAddr:Pointer;constructor Create(DllName,FuncName:string;NewFunc:Pointer);destructor Destroy; override;procedure Hook;procedure UnHook;end;implementation//==================================================//NtHOOK 类开始//==================================================constructor TNtHookClass.Create(DllName: string; FuncName: string;NewFunc:Pointer);varDllModule:HMODULE;dwReserved:DWORD;begin//获取模块句柄DllModule:=GetModuleHandle(PChar(DllName));//如果得不到说明未被加载if DllModule=0 then DllModule:=LoadLibrary(PChar(DllName));//得到模块入口地址（基址）BaseAddr:=Pointer(GetProcAddress(DllModule,PChar(FuncName)));//获取当前进程句柄hProcess:=GetCurrentProcess;//指向新地址的指针NewAddr.MovEax:=$B8;NewAddr.Addr:=DWORD(NewFunc);NewAddr.JmpCode:=$E0FF;//保存原始地址ReadOK:=ReadProcessMemory(hProcess,BaseAddr,@OldAddr,8,dwReserved); //开始拦截Hook;end;//释放对象destructor TNtHookClass.Destroy;beginUnHook;CloseHandle(hProcess);inherited;end;//开始拦截procedure TNtHookClass.Hook;vardwReserved:DWORD;beginif (ReadOK=False) then Exit;//写入新的地址WriteProcessMemory(hProcess,BaseAddr,@NewAddr,8,dwReserved);end;//恢复拦截procedure TNtHookClass.UnHook;vardwReserved:DWORD;beginif (ReadOK=False) then Exit;//恢复地址WriteProcessMemory(hProcess,BaseAddr,@OldAddr,8,dwReserved); end;end.。
进程的控制方法
进程的控制方法进程是计算机中最基本的资源单位，它是程序在执行过程中分配和管理资源的基本单位。
为了合理有效地控制进程，提高计算机系统的性能和可靠性，我们常常需要采取一些控制方法。
本文将介绍几种常见的进程控制方法。
一、进程的创建和终止控制1. 进程的创建进程的创建是指在系统中生成一个新的进程。
常见的进程创建方法有：（1）父进程创建子进程：父进程通过调用系统调用（如fork()）创建一个新的子进程，子进程会继承父进程的资源和状态，然后可以执行不同的程序段。
（2）系统初始化创建进程：系统启动时，会自动创建一些特殊的进程，如init进程（在Linux系统中）。
2. 进程的终止进程的终止是指进程执行完毕或被强制终止。
常见的进程终止方法有：（1）正常终止：进程执行完毕后，会自动终止，并释放占用的资源。
（2）异常终止：进程在执行过程中遇到错误或异常情况，导致无法继续执行，会被强制终止。
二、进程的切换控制进程的切换是指在多道程序环境下，由于资源有限，系统需要在多个进程之间进行切换，以实现并发执行。
常见的进程切换方法有：1. 抢占式调度抢占式调度是指操作系统通过时钟中断等方式，强制挂起正在执行的进程，并将CPU分配给其他可执行的进程。
这种调度方式可以实现公平性和高效性，但需要考虑进程切换的开销。
2. 非抢占式调度非抢占式调度是指进程只有在主动放弃CPU时，才会被操作系统挂起。
这种调度方式可以减少进程切换的开销，但可能导致某些进程长时间占用CPU，影响其他进程的执行。
三、进程的同步和通信控制进程的同步和通信是指多个进程之间通过共享资源或消息传递等方式进行合作和协调。
常见的进程同步和通信方法有：1. 互斥锁互斥锁是一种用于实现进程互斥访问共享资源的机制。
当一个进程需要访问共享资源时，它必须先获得互斥锁，其他进程则需要等待锁的释放。
2. 信号量信号量是一种用于实现进程同步和互斥的机制。
通过对信号量的P 操作和V操作，进程可以实现对临界资源的互斥访问和同步执行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
监控进程创建结束非HOOK方式学习各种高级外挂制作技术，马上去百度搜索"魔鬼作坊"，点击第一个站进入，快速成为做挂达人。
主要思想用到内核中设置事件和一个进程回调函数实现内核代码如下：////////////////////////////////////////////////////ProcDrv.cpp文件extern"C"{#include<ntddk.h>#include<ntdef.h>#include<ntstrsafe.h>}#include"ProcDrv.h"//自定义函数的声明NTSTA TUS DispatchCreateClose(PDEVICE_OBJECT pDevObj,PIRP pIrp);void DriverUnload(PDRIVER_OBJECT pDriverObj);NTSTA TUS DispatchIoctl(PDEVICE_OBJECT pDevObj,PIRP pIrp);VOID ProcessCallback(IN HANDLE hParentId,IN HANDLE hProcessId,IN BOOLEAN bCreate);//驱动内部名称、符号连接名称、事件对象名称#define DEVICE_NAME L"\\Device\\devNTProcDrv"#define LINK_NAME L"\\DosDevices\\slNTProcDrv"#define EVENT_NAME L"\\BaseNamedObjects\\NTProcDrvProcessEvent"typedef struct_DEVICE_EXTENSION//设备对象的私有存储{HANDLE hProcessHandle;//事件对象句柄PKEVENT ProcessEvent;//用户和内核通信的事件对象指针HANDLE hPParentId;//在回调函数中保存进程信息，当用户程序请求时，传递过去HANDLE hPProcessId;BOOLEAN bPCreate;}DEVICE_EXTENSION,*PDEVICE_EXTENSION;PDEVICE_OBJECT g_pDeviceObject;//驱动程序加载时调用DriverEntry例程extern"C"NTSTA TUS DriverEntry(PDRIVER_OBJECT pDriverObj,PUNICODE_STRING pRegistryString){NTSTA TUS status=STA TUS_SUCCESS;//初始化各个派遣例程pDriverObj->MajorFunction[IRP_MJ_CREATE]=DispatchCreateClose;pDriverObj->MajorFunction[IRP_MJ_CLOSE]=DispatchCreateClose;pDriverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL]=DispatchIoctl;pDriverObj->DriverUnload=DriverUnload;//创建、初始化设备对象//设备名称UNICODE_STRING ustrDevName;RtlInitUnicodeString(&ustrDevName,DEVICE_NAME);//创建设备对象PDEVICE_OBJECT pDevObj;status=IoCreateDevice(pDriverObj,sizeof(DEVICE_EXTENSION),//为设备扩展结构申请空间&ustrDevName,FILE_DEVICE_UNKNOWN,0,FALSE,&pDevObj);if(!NT_SUCCESS(status)){return status;}PDEVICE_EXTENSION pDevExt=(PDEVICE_EXTENSION)pDevObj->DeviceExtension;//创建符号连接名称//符号连接名称UNICODE_STRING ustrLinkName;RtlInitUnicodeString(&ustrLinkName,LINK_NAME);//创建关联status=IoCreateSymbolicLink(&ustrLinkName,&ustrDevName);if(!NT_SUCCESS(status)){IoDeleteDevice(pDevObj);return status;//保存到设备对象的指针，下面在进程回调函数中还要使用g_pDeviceObject=pDevObj;//为了用户模式进程能够监视，创建事件对象UNICODE_STRING uszProcessEventString;RtlInitUnicodeString(&uszProcessEventString,EVENT_NAME);pDevExt->ProcessEvent=IoCreateNotificationEvent(&uszProcessEventString, &pDevExt->hProcessHandle);//设置它为非受信状态KeClearEvent(pDevExt->ProcessEvent);//设置回调例程status=PsSetCreateProcessNotifyRoutine(ProcessCallback,FALSE);return status;}void DriverUnload(PDRIVER_OBJECT pDriverObj){DbgPrint("Driver Unload\n");//移除进程回调例程PsSetCreateProcessNotifyRoutine(ProcessCallback,TRUE);//删除符号连接名称UNICODE_STRING strLink;RtlInitUnicodeString(&strLink,LINK_NAME);IoDeleteSymbolicLink(&strLink);//删除设备对象IoDeleteDevice(pDriverObj->DeviceObject);}//处理IRP_MJ_CREATE、IRP_MJ_CLOSE功能代码NTSTA TUS DispatchCreateClose(PDEVICE_OBJECT pDevObj,PIRP pIrp){pIrp->IoStatus.Status=STA TUS_SUCCESS;//完成此请求IoCompleteRequest(pIrp,IO_NO_INCREMENT);return STA TUS_SUCCESS;//I/O控制派遣例程NTSTA TUS DispatchIoctl(PDEVICE_OBJECT pDevObj,PIRP pIrp){DbgPrint("ProcDrv:DispatchIoctl()...\n");//假设失败NTSTA TUS status=STA TUS_INVALID_DEVICE_REQUEST;//取得此IRP（pIrp）的I/O堆栈指针PIO_STACK_LOCATION pIrpStack=IoGetCurrentIrpStackLocation(pIrp);//取得设备扩展结构指针PDEVICE_EXTENSION pDevExt=(PDEVICE_EXTENSION)pDevObj->DeviceExtension;//取得I/O控制代码ULONG uIoControlCode=pIrpStack->Parameters.DeviceIoControl.IoControlCode;//取得I/O缓冲区指针和它的长度PCALLBACK_INFO pCallbackInfo= (PCALLBACK_INFO)pIrp->AssociatedIrp.SystemBuffer;ULONG uInSize=pIrpStack->Parameters.DeviceIoControl.InputBufferLength;ULONG uOutSize=pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;switch(uIoControlCode){case IOCTL_NTPROCDRV_GET_PROCINFO://向用户程序返回有事件发生的进程的信息{if(uOutSize>=sizeof(CALLBACK_INFO)){pCallbackInfo->hParentId=pDevExt->hPParentId;pCallbackInfo->hProcessId=pDevExt->hPProcessId;pCallbackInfo->bCreate=pDevExt->bPCreate;status=STA TUS_SUCCESS;}}break;}if(status==STA TUS_SUCCESS){pIrp->rmation=uOutSize;else{pIrp->rmation=0;}//完成请求pIrp->IoStatus.Status=status;IoCompleteRequest(pIrp,IO_NO_INCREMENT);return status;}//进程回调函数VOID ProcessCallback(IN HANDLE hParentId,IN HANDLE hProcessId,IN BOOLEAN bCreate){DbgPrint("Call ProcessCallback()\n");//得到设备扩展结构的指针PDEVICE_EXTENSION pDevExt= (PDEVICE_EXTENSION)g_pDeviceObject->DeviceExtension;//安排当前值到设备扩展结构//用户模式应用程序将使用DeviceIoControl调用把它取出pDevExt->hPParentId=hParentId;pDevExt->hPProcessId=hProcessId;pDevExt->bPCreate=bCreate;if(pDevExt->bPCreate){DbgPrint("create:%d\n",pDevExt->hPProcessId);}else{DbgPrint("Kill:%d\n",pDevExt->hPProcessId);}//触发这个事件，以便任何正在监听的用户程序知道有事情发生了。