为了保护我们的进程不被人随便强制关闭，我们需要一种机制来实现，网上大概有几种方式：1.写一个驱动程序，在驱动程序里面hook系统的api来实现，例如ssdt方式，等等。2.就是在应用层挂钩系统api，这种方式也就远程注入，全局钩子啊等等，只是网上也有很多，不过很多在xp上是正常的到了win7 64就失效了。还有最简单的就是启动两个进程相互监视对方，(这个可能看起来不专业)。 网上方法很多，我写这个主要是学习归类整理。
       我实现的方式整一个全局的钩子  主要参考http://www.360doc.com/content/13/0911/10/13336430_313670033.shtml ，钩子部分基本是借用这里的代码，我只是在上面扩展了一下，同时可以保护多个进程，被保护的进程不需要加装hook api的dll文件。
 因为在win7 64下面挂钩任务管理器需要64位的dll和64位的安装钩子程序，这样32位的进程就很难被保护了。 编译64位程序需要vs2008有64的环境还需要设置一些64的宏，代码有注释，所以直接上代码。
       1.hook api 的主要dll文件
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include <Windows.h>
#include "Export.h"

#ifdef _WIN64
#undef _M_IX86
#endif

#include "mhook-lib\mhook.h"

//参考代码 url
//http://www.360doc.com/content/13/0911/10/13336430_313670033.shtml
//=========================================================
// struct CLIENT_ID
typedef struct _CLIENT_ID {
	DWORD_PTR UniqueProcess;
	DWORD_PTR UniqueThread;
} CLIENT_ID, *PCLIENT_ID;

//===========================================================
// NtOpenProcess
typedef ULONG (WINAPI *pfnNtOpenProcess)(
	__out PHANDLE ProcessHandle,
	__in ACCESS_MASK AccessMask ,
	__in PVOID ObjectAttributes,
	__in PCLIENT_ID ClientId);

pfnNtOpenProcess _NtOpenProcess = (pfnNtOpenProcess)GetProcAddress( GetModuleHandle(L"ntdll"),"NtOpenProcess");
//共享内存结构体，用于存储保护的PID
typedef struct SHWP_STRUCT_
{
	BOOL isWrite;
	TCHAR cProcessid[512];
} SHWP_STRUCT, *LPSHWP_STRUCT;

//==============================================================
// 变量
HINSTANCE glhInstance = NULL; 
DWORD     gProtectProcessID = 0;
HANDLE ghMapFile = NULL;
//共享内存结构体
LPSHWP_STRUCT		lpData = NULL;

//dll共享全局变量
#pragma data_seg("ShareSecNJ")  
HHOOK     glhHook = NULL; //把glhHook放入ShareSec段  
#pragma data_seg()  
#pragma comment(linker,"/SECTION:ShareSecNJ,RWS")//告诉编译器为ShareSec段添加共享段读写属性
void splitString(wstring& s, wstring delim,vector<wstring >& ret)
{
	size_t last = 0;
	size_t index=s.find(delim,last); //delim 为字符串的时候find_first_of可能会出错
	ret.clear();
	wstring strTmp;
	while (index!=std::wstring::npos)
	{
		strTmp = s.substr(last,index-last);
		if (strTmp.length()>1)
		{
			ret.push_back(strTmp);
		}
		last=index+delim.length();
		index=s.find(delim,last);
	}
	if (index-last>0)
	{
		strTmp = s.substr(last,index-last);
		if (strTmp.length()>1)
		{
			ret.push_back(strTmp);
		}
	}
}
BOOL isProtectPid(TCHAR *data,int upid)
{
	//OutputDebugStringA("isProtectPid          ==================          \n");
	//wstring tmpStr(lpData->cProcessid);
	wstring tmpStr(data);
	vector<wstring> vetPid;
	splitString(tmpStr,L"|",vetPid);
	for(int i=0;i<vetPid.size();++i)
	{
		//OutputDebugString(vetPid[i].c_str());
		int tmpPid = _wtoi(vetPid[i].c_str());
		if (tmpPid == upid)
		{
			return TRUE;
		}
	}
	return FALSE;
}
//定制我们自己的NtOpenProcess
ULONG WINAPI Hook_pfnNtOpenProcess(
								   __out PHANDLE ProcessHandle,
								   __in ACCESS_MASK AccessMask ,
								   __in PVOID ObjectAttributes,
								   __in PCLIENT_ID ClientId)
{
	if (lpData)
	{
		while(1)
		{
			if (FALSE == lpData->isWrite)
			{
				break;
			}
			else
			{
				::Sleep(1);
			}
		}
		//DWORD pid = GetProcessIdByHandle( ProcessHandle);
		if (isProtectPid(lpData->cProcessid,ClientId->UniqueProcess))
		{
			ProcessHandle = NULL;
		}
	}
	//简单处理，直接设置ProcessHandle，保护所有
	//ProcessHandle = NULL;
	return  _NtOpenProcess( ProcessHandle, AccessMask,ObjectAttributes,ClientId);
}
BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
					 )
{
	ghMapFile = CreateFileMapping((HANDLE)INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,0x100,L"PCMONITOR.NJ_Hook"); 
	if(ghMapFile != NULL) 
	{ //共享内存 
		lpData=(LPSHWP_STRUCT)MapViewOfFile(ghMapFile,FILE_MAP_ALL_ACCESS,0,0,0); 
	}

	glhInstance = hModule;
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
		Mhook_SetHook((PVOID*)&_NtOpenProcess, Hook_pfnNtOpenProcess);
		break;
	case DLL_PROCESS_DETACH:
		Mhook_Unhook((PVOID*)&_NtOpenProcess);
		break;
	}
	return TRUE;
}
static LRESULT WINAPI ShellHookProc(int code, WPARAM wParam, LPARAM lParam) 
{
	return ::CallNextHookEx(glhHook, code, wParam, lParam);
}
extern "C" __declspec(dllexport)  BOOL InstallHook(DWORD pid)
{	
	BOOL bResult=FALSE;
	//这里需要注意X86和X64下处理是不一样的
#ifdef _M_IX86
	glhHook = SetWindowsHookEx(WH_SHELL,ShellHookProc,glhInstance, 0);
#elif defined _M_X64
	OutputDebugStringA("_M_X64  ========================= \n");
	//glhHook = SetWindowsHookEx(WH_SHELL,ShellHookProc,0, 0);
	//我的电脑测试发现需要glhInstance 否则会出现1428的错误
	glhHook = SetWindowsHookEx(WH_SHELL,ShellHookProc,glhInstance, 0);
#endif

	if(glhHook!=NULL)
	{
		gProtectProcessID = pid;
		bResult=TRUE;
	}	

	return bResult; 
}
extern "C" __declspec(dllexport)  BOOL UninstallHook()
{	
	BOOL bResult=FALSE;
	if(glhHook)
	{
		bResult= UnhookWindowsHookEx(glhHook);
		if(bResult)
		{
			glhHook=NULL;
		}
	}
	return bResult;
}
 
2.下面是一个负责接收其他需要被保护的进程的消息，再利用共享内存把保护的进程id通知给hook api 的dll，这样就实现保护多个进程，并且被保护的进程不需要直接去加载dll文件。这是一个控制台程序 主要文件

// hookApiServe.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <Windows.h>
#include <map>
#include <string>

#include "../mhookApi64Adapt/Export.h"

using std::wstring;
using std::map;

#ifdef _WIN64
#pragma comment(lib, "../Debug/mhookApi64Adapt64.lib")
#else
#pragma comment(lib, "../Debug/mhookApi64Adapt32.lib")
#endif
//共享内存结构体，用于存储保护的PID
typedef struct SHWP_STRUCT_
{
	BOOL isWrite;
	TCHAR cProcessid[512];
} SHWP_STRUCT, *LPSHWP_STRUCT;

UINT guHookMESSAGE = 0;
HANDLE ghMapFile = NULL;
map<int,int> gProcessidMap;
void WriteMapFileData();

LRESULT CALLBACK HookApiServeWndProc(HWND h, UINT msg, WPARAM wp, LPARAM lp)
{
	if (guHookMESSAGE == msg)
	{
		printf("HookApiServeWndProc guHookMESSAGE \r\n");
		int npid = lp;
		if (wp == 0)
		{
			gProcessidMap[npid] = 0;
		}
		else
		{
			map<int,int>::iterator it = gProcessidMap.find(npid);
			if (it!=gProcessidMap.end())
			{
				gProcessidMap.erase(it);
			}
		}
		WriteMapFileData();
	}
switch (msg)
	{
	case WM_CREATE://窗口创建?
		//printf("WM_CREATE finish \r\n");
		break;
	case WM_DEVICECHANGE:
		break;
	case WM_CLOSE:
	case WM_DESTROY:
		UninstallHook();
		//printf("WM_DESTROY will come \r\n");
		break;
	default:
		return DefWindowProc(h, msg, wp, lp);
	}
	return 0;
}
void WriteMapFileData()
{
	if (ghMapFile)
	{
		wstring pidList;
		pidList.clear();
		map<int,int>::iterator it;
		for(it=gProcessidMap.begin();it!=gProcessidMap.end();++it)
		{
			TCHAR tmpChar[16] = {0};
			int upid = it->first;
			_itow(upid,tmpChar,10);
			pidList.append(tmpChar);
			pidList+=L"|";
		}//拷贝数据到共享文件里。
		LPSHWP_STRUCT lpData=(LPSHWP_STRUCT)MapViewOfFile(ghMapFile,FILE_MAP_ALL_ACCESS,
			0,0,0);
		//这里事实上需要判断长度问题
		int len = pidList.length();
		if (len>512)
		{
			len = 511;
		}
		lpData->isWrite = TRUE;
		memcpy(lpData->cProcessid,pidList.c_str(),len*2);
		lpData->isWrite = FALSE;

		FlushViewOfFile(lpData,sizeof(SHWP_STRUCT));
	}
}
int _tmain(int argc, _TCHAR* argv[])
{
	//程序单例模式
	HANDLE mutex = CreateMutex(NULL,true,TEXT("<Guid(\"44305E56-3E7D-41C5-9D42-0C6C7822A228\")>"));
	DWORD err = GetLastError();
	if(err == ERROR_ALREADY_EXISTS)
	{
		//打开原来的程序
		//此程序实例退出
		exit(0);
	}
//共享内存结构体
	LPSHWP_STRUCT		lpData = NULL;
	//打开共享的文件对象。
	ghMapFile = OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,L"PCMONITOR.NJ_Hook");
	if(NULL == ghMapFile)
	{
		ghMapFile = CreateFileMapping((HANDLE)INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,0x100,L"PCMONITOR.NJ_Hook"); 
	}

	guHookMESSAGE = RegisterWindowMessage(L"NJ_Hook_Api_MESSAGE");
	
	gProcessidMap.clear();
	gProcessidMap[GetCurrentProcessId()] = 0;

	WriteMapFileData();
加载钩子
	InstallHook(GetCurrentProcessId());
	//system("pause");

	WNDCLASS wc;
	ZeroMemory(&wc, sizeof(wc));
	wc.lpszClassName = TEXT("HookApiServe");
	wc.lpfnWndProc = HookApiServeWndProc;
	RegisterClass(&wc);
	HWND h = CreateWindow(TEXT("HookApiServe"), TEXT(""), 0, 0, 0, 0, 0,
		0, 0, GetModuleHandle(0), 0);
	MSG msg;
	while(GetMessage(&msg,0,0,0) >0) 
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return 0;
}


3.下面是被保护程序的需要添加的代码  这只是个测试程序
// testMhookApi.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <Windows.h>
#include <string>
using std::string;


BOOL ExecuteShell(string exe,string arg,BOOL wait,DWORD* exitCode /* = NULL */)
{SHELLEXECUTEINFOA ShExecInfo = {0};
	ShExecInfo.cbSize = sizeof(SHELLEXECUTEINFOA);
	ShExecInfo.fMask  = SEE_MASK_NOCLOSEPROCESS;
	ShExecInfo.hwnd   = NULL;


	ShExecInfo.lpVerb = "runas";
	if (!arg.empty())
	{
		ShExecInfo.lpParameters		= (LPCSTR)arg.c_str();//(LPCWSTR)lpParameters;
	}
	if (!exe.empty())
	{
		ShExecInfo.lpFile			= (LPCSTR)exe.c_str();
	}

	ShExecInfo.lpDirectory		= NULL;
	ShExecInfo.nShow			= SW_HIDE;//(nShowCmd != SW_HIDE)?(SW_SHOW):(SW_HIDE);
	ShExecInfo.hInstApp			= NULL;
	if(!ShellExecuteExA(&ShExecInfo))
	{
		return FALSE;
	}if (wait)
	{
		WaitForSingleObject(ShExecInfo.hProcess,INFINITE);

		if (NULL != exitCode)
		{
			GetExitCodeProcess(ShExecInfo.hProcess,exitCode);
		}
	}
	return TRUE;
}
BOOL IsWow64() 
{ 
	typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL); 
	LPFN_ISWOW64PROCESS fnIsWow64Process; 
	BOOL bIsWow64 = FALSE; 
	fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress( GetModuleHandle(L"kernel32"),"IsWow64Process"); 
	if (NULL != fnIsWow64Process) 
	{ 
		fnIsWow64Process(GetCurrentProcess(),&bIsWow64);
	} 
	return bIsWow64; 
}
int _tmain(int argc, _TCHAR* argv[])
{

	if (IsWow64())
	{
		ExecuteShell("E:/test/hook/mhookApi64Adapt/Debug/hookApiServe64.exe","",FALSE,NULL);
	}
	else
	{
		ExecuteShell("E:/test/hook/mhookApi64Adapt/Debug/hookApiServe32.exe","",FALSE,NULL);
	}

	//system("pause");
	UINT HookMESSAGE = RegisterWindowMessage(L"NJ_Hook_Api_MESSAGE");
往 所有的 窗口 广播一个消息
	::PostMessage(HWND_BROADCAST,HookMESSAGE,0,GetCurrentProcessId());

	//InstallHook(GetCurrentProcessId());
	system("pause");
	//UninstallHook();
	return 0;
}
 
编译64的hook程序的时候
#ifdef _WIN64

#undef _M_IX86

#endif  
这个主要是我的不管怎么设置都是有_M_IX86这个宏的  但是又需要mhook-lib 编译64的，所以我强制把宏去掉了，在工程设置里面添加 _WIN64;_M_X64;  还有mhook.h里面也添加了去掉64的时候去掉_M_IX86宏， 如果你的工程64环境可以不显示_M_IX86宏，就没必要添加这个去掉宏的操作。工程主要是挂钩SetWindowsHookEx(WH_SHELL,ShellHookProc,glhInstance, 0); 的WH_SHELL消息。同样也可以采用远程注入的方式让其他进程加载我们的hook
 dll。下面给出一段 注入的代码

//提升进程权限
BOOL SetPrivilege(LPCTSTR lpszPrivilege, BOOL bEnablePrivilege)   
{  
	TOKEN_PRIVILEGES tp;  
	HANDLE hToken;  
	LUID luid;  
	if( !OpenProcessToken(GetCurrentProcess(),  
		TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,   
		&hToken) )  
	{  
		_tprintf(L"OpenProcessToken error: %u/n", GetLastError());  
		return FALSE;  
	}  
	if( !LookupPrivilegeValue(NULL,  
		lpszPrivilege,  
		&luid) )  
	{  
		_tprintf(L"LookupPrivilegeValue error: %u/n", GetLastError() );   
		return FALSE;   
	} 
tp.PrivilegeCount = 1;  
	tp.Privileges[0].Luid = luid;  
	if( bEnablePrivilege )  
		tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;  
	else  
		tp.Privileges[0].Attributes = 0;  
	if( !AdjustTokenPrivileges(hToken,   
		FALSE,   
		&tp,   
		sizeof(TOKEN_PRIVILEGES),   
		(PTOKEN_PRIVILEGES) NULL,   
		(PDWORD) NULL) )  
	{   
		_tprintf(L"AdjustTokenPrivileges error: %u/n", GetLastError() );   
		return FALSE;   
	}  if( GetLastError() == ERROR_NOT_ALL_ASSIGNED )  
	{  
		_tprintf(L"The token does not have the specified privilege. /n");  
		return FALSE;  
	}   
	return TRUE;  
} 
BOOL injectDll(DWORD pid,const char* dllpath)
{
	HANDLE hInjectProcess = OpenProcess(PROCESS_CREATE_THREAD|PROCESS_VM_OPERATION|PROCESS_VM_WRITE|PROCESS_ALL_ACCESS,FALSE,pid);
	
	if(hInjectProcess)
	{
		// 向目标进程地址空间写入DLL地址。 
		DWORD dllLength = lstrlenA(dllpath) + 1; 
		SIZE_T writeLength = 0; 
		LPVOID pRmtdllPathSpace = VirtualAllocEx(hInjectProcess, NULL, dllLength, MEM_COMMIT, PAGE_READWRITE); 
		if (NULL == pRmtdllPathSpace)  
		{ 
			printf("VirtualAllocEx failed! %d \n",GetLastError());
			CloseHandle(hInjectProcess);  
			return FALSE; 
		} 
if (WriteProcessMemory(hInjectProcess, pRmtdllPathSpace, (LPVOID) dllpath, dllLength, &writeLength))  
		{ 
			// 需写入字节数与实际写入字节数不同，数据异常导致失败。 
			if (dllLength != writeLength)  
			{  
				printf("WriteProcessMemory length is err %d \n",GetLastError());
				VirtualFreeEx(hInjectProcess, pRmtdllPathSpace, writeLength, MEM_DECOMMIT); 
				CloseHandle(hInjectProcess); 
				return FALSE; 
			}  
		}  
		else 
		{ 
			printf("WriteProcessMemory failed! %d \n",GetLastError());
			CloseHandle(hInjectProcess);  
			return FALSE; 
		} 
// CreateRemoteThread 64的进程需要64的dll和64的注入进程
		HANDLE hRmtThread = CreateRemoteThread(hInjectProcess,NULL,0,(LPTHREAD_START_ROUTINE)LoadLibraryA,pRmtdllPathSpace,NULL,0);
		if (NULL == hRmtThread)  
		{  
			printf("create remote thread failed! %d \n",GetLastError());
			return FALSE;  
		}  

		VirtualFreeEx(hInjectProcess, pRmtdllPathSpace, dllLength, MEM_RELEASE);   
		CloseHandle(hInjectProcess);  
		hInjectProcess = NULL;  
		
		return TRUE;
	}
else
	{
		printf("OpenProcess failed! %d \n",GetLastError());
		return FALSE; 
	}
}


函数功能是往指定pid的进程注入指定的dll文件，注意 ：注入64的进程需要 64的dll和 64的执行注入程序。
 

转载的，mark一下
禁止别人用任务管理器，结束自己的程序进程(.NET程序）。带着这个问题，我开始Google,开始baidu，又开始编程了。和原来的搜索结果一样，什么东西都是一筹莫展，得到的答案永远是：C#没有办法自己去禁止别人用任务管理器结束自己进程。不过功夫不负有心人。我还是找到一大堆的替代方法，可以让别人不结束自己进程的方法。

总结方法有：

1． 把任务管理器程序给别人删除了，不让别人打开（妈呀，这个我觉得最不可取了，有点杀鸡取卵的味道，没有任务管理器，我是无法忍受的。毕竟人家用户，购买了你产品，你总不可能把别人任务管理器给洗白了吧？）否决！

2． 接下来这个比较温柔，通过C#内置的Process类，对任务管理器的进程进行扫描，如果检查到有taskmgr.exe的进程（任务管理器进程），就把这个进程结束了。（虽然没有第一个来的恶劣，但是，用户还是不能使用任务管理器）否决！

3． 写两个程序进行双保护。这个想法是网上提的最多的思路，如果一个程序被结束了，另一个程序检测到这个程序不在了，就立即重新启动该程序，双双保护，互助互利（结果我尝试了一下，不可取，因为1,CPU使用率太高，一直在循环检测，计算机速度立即就下了。我妈妈这个机子，P4的配置，1G内存，也来不起了。网页也卡起了。2，我写了一个第三方程序，以最快速率去结束这个两个进程，如果这两个进程为了节约CPU的使用率，而把扫描间隔时间隔的太开的话，立刻被我的程序洗白。所以，理论上这种方法，肯定是会被洗白的）否决

4． 技术含量比较高了，通过Windows的驱动机制，把自己给隐藏了（把自己变成驱动），然后隐藏到系统中运行，在任务管理器完全找不到，其实我多喜欢这种方式的，但是，这个程序一弄出来，瑞星，Google,Hotmail,360卫士，全部当成病毒查出来了，我当时眼流花都要流出来了。他们都太不给面子，Google,Hotmail直接把我的附件删除了。随便我压缩，分包压缩，都逃不过他们的法眼。所以，我清楚的意识到，这种程序弄出来，在客户机器上，肯定是无法长久生存的。毕竟一个堂堂正正的程序，干嘛要去隐藏呢？所以。该条方案否决！

5． 用第三方的VC++程序，辅助C#程序达到不让别人禁止C#进程的方法。哎，弄了半天，这种方法，我认为最行之有效。毕竟不得不承认，要搞Windows系统级的程序设计，C++是当之无愧的龙头老大，C#只是一个做网站级应用的能手。不过，你发布一个程序给用户，用户看到那个任务管理器里面还有个其他程序在运作或者是看到你的安装包里面怎么还有其他程序名字，确实感觉太不专业，太不地道了。话又说回来，这种辅助程序一般都要收费。我下载的那个就要收费。所以，最后，这个方案也否决了！

难道，C#真的就不能自己弄个什么名堂的东西出来，不被任务管理器结束吗？实际，我认为，C#是可以做到这一点的。原因有2个。1,C#是支持带*号这种指针的方式的。也就是说，C#可以使用指针。2，C#可以完全无障碍的调用Windows自己的API函数（虽然性能没有VC++开发的好），调用第三方开发的COM组件，甚至调用USB插口接口相关信息（曾今做U盘杀毒的时候，用到过，不过主要还是结合API完成的，一个未公开的API函数R开头的忘记了）。所以，为此，我抱着信心开始准备找第三方提供的动态链接库之类的东西，毕竟要自己写，C#还是有许多性能和调用方面的麻烦问题要考虑，毕竟不是毕业设计，所以，能简单就简单，只要克服以上提到的5种方法的不足。

最后，功夫不负有心人，找了大半天，找到了一个叫Peter的牛人，写了一个通过VC++程序调用VC++动态链接库，实现的VC++程序不被任务管理器结束的源代码。幸亏源代码相当详尽（VC++动态链接库的源码，VC++应用程序源码），要不然，后面的活路，就没有办法做了。于是我开始，慢慢，慢慢走上辛苦的VC++代码分析上。你们可能要问我干什么？我可以很坦然的告诉你，虽然我VC++能力确实不强，但是我要把VC++的代码，移植到C#上。听起来，很不可思意，但是，我真的成功了。最后，为了报答我的学校——成都电子机械高等专科学校和成都信息工程学院。我把VC++应用程序调用代码，移植到.NET上，并且，为了调用方便，我做成了.NET可以识别的dll运行库。只要按以下方式调用运行即可。这个dll运行库可以保护自己进程，也可以通过设置保护其他进程，作为第三方动态链接库存在。（很幸运，虽然这个第三方动态链接库我还是很花了些时间，但是绝对不收费，免费放送，提供C#工程源码下载！如果大家有兴趣也可以一起讨论一下，我的邮件是Email:k.liuxu@gmail.com），至于那个牛人的设计思路，其实，就是用系统函数挂钩，挂接了所有的系统函数消息。没有直接分析任务管理器这些东西。不过，在CMD命令控制台中，无法接受消息，所以，用命令控制台，是可以结束进程的。不过，命令控制台，一般用户不会使用，可以直接把命令控制台删除，或者移植到程序内部调用，不准用户外部调用，就行了。至于其他更麻烦的东西，就有兴趣大家在慢慢聊吧。

前面分析VC++代码是一个艰苦的历程，简直是挥泪分析啊，眼睛都看肿了，才把VC++应用程序部分移植出来。其实总结了一下，实际上还是因为自己学习不扎实，所以才看的恼火，对不起电子高专培养我的刘光会和杨勇老师，对不起信息工程学院的安俊秀和陈晓红老师。不过最后弄出来了，还是一件好事情吧，也充分说明了C#还是可以搞一些基于系统级的调用和编程的。也许在大鸟眼睛中，移植这种工作并不算什么，这种程序也许是小儿科，不过，对于，刚刚毕业的我来说，还是一种不小的挑战。

由于时间有限，我只把前半部分的VC++应用程序端移植完成，在以后的时间中，等我把Dll部分抽象出来，我会做成.NET可以识别的dll发布出来。如果还有时间，我就再来说说，我怎么分析的吧。不过这个可能要说很久很久了，毕竟涵盖了5年我大学学习的所有基础知识，大到系统，小到函数指针，代理，枚举这些结构，内存存储空间等等。好了废话不多说了。现在主要看看怎么使用。
首先，我们必须具备两个DLL文件，一个是我用.NET程序生成的KProtectProcess.dll文件,这个文件可以直接放到VS.NET开发环境中进行使用。还有一个是我还没有编译出来的NKCore.dll文件（其实我移植了一半，但是里面设计很多系统关键字，我在C#中还没有找到很好的解决方案，所以正在研究），这个文件是C++的运行库，实际上核心也是这个文件。




1首先我们新建立一个工程。如下：

2．按照如图，放置这些控件，以便我们操作

3．添加引用.NET可以识别的KProtectProcess.dll动态链接库（VB.NET,J#.NET,VC++.NET都可以调用）右键项目，选择添加引用：

4．找到KProtectProcess.dll这个文件并添加（注意保持，KProtectProcess.dll文件和NKCore.dll文件在同一目录中）

5.点确定以后，你会看到工程中，多了一个程序集KProtectProcess.dll

6.双击，按钮进入代码的编写，（其中保护自己，停止保护自己，保护其他进程，停止保护其他进程按钮的名字分别是：button1,button2,button3,button4）,具体调用代码编写如下（代码调用，已经简化的相当简单了）:自身保护调用SelfProtection(),自身释放调用UnLoadProtection(),其他进程保护，首先调用ProtectProcessID赋值，然后调用ProtectProcess进行保护，如果不赋值，我会抛出一个异常。

7. 所有工作都准备完毕就可以调试了。其中以下演示怎么保护其他进程。比如我们现在打开Windows计算器这个程序，计算器这个程序的进程名是calc.exe,所以，我们就找他的进程号PID.1764






现在只需要在程序的进程号中输入，1764,然后点保护，最后，你看用任务管理器是不是不能结束calc这个程序了？很简单吧？

1、用任务管理器里的应用程序里的结束任务的话是会发一个WM_CLOSE命令给应用程序。
2、用任务管理器的进程里的结束进程的话是不发送任何命令的，直接把其杀掉。

遇到一个问题，本地运行一个名字为 TesJar-1.0.1.jar，使用“Ctrl  C”关闭该jar进程，该进程使用的是“8080”端口，此时，启动另外一个TestJarCopy.jar时，提示端口被占用。

1，可以通过查询8080端口的PID，在任务管理器中，结束该线程。

查找pid

2，但是，这样做可能会有些麻烦。其实既然这个jar是自己跑起来的，你也知道它的名字，何不直接在任务管理器中关闭它。

如图所示：

1）在这个地方点击右键



2）选中命令行



3）在“命令行”列找到熟悉的jar名，结束任务即可。

 

3，之前在任务管理器，一直找不到“命令行”这个列，点击“查看”，只有“立即刷新”和“更新速度”，没有“选择列”。右击“详细信息”这个选项卡，也不行。应当如 2.1）图所示的位置右击。

 

 

当不小心双击了 jar来启动程序的时候，此时，在任务管理器出现的是 javaw.exe 进程，此时，关闭这个进程，最简单的办法就是，根据该进程的命令行来关闭