c# 防止任务管理器强行结束进程 (关注给分) 百分贴

Question

 c#    防止任务管理器强行结束进程  有一篇文章 用VC++实现是这样写的
附件[SafeProcess.rar]：
http://blog.blogchina.com/upload/2004-12-20/20041220143803647829.rar1. 通过Timer过程或其他方式查找Windows任务管理器窗口是否存在。
    ::FindWindow(NULL,  "Windows 任务管理器")
    如果存在，则进入第二步。2. 设置一个WH_CBT类型的HOOK
    g_cbtHook = SetWindowsHookEx(WH_CBT, (HOOKPROC)CBTProc, g_hInstance, NULL);
   在 (HOOKPROC)CBTProc中处理HCBT_ACTIVATE和HCBT_DESTROYWND两类消息。// The CBT hook Proc(Computer Based Training Hook)
LRESULT CALLBACK CBTProc(int nCode, WPARAM wParam, LPARAM lParam)
{
      CHAR szText[256];
      CHAR szWindowText[32];
      HWND hWnd;      memset(szWindowText, NULL, sizeof(szWindowText));
      strcpy(szWindowText, "任务管理器警告");      switch(nCode)
     {
            case HCBT_ACTIVATE:
                    hWnd = (HWND)wParam;
                    GetWindowText(hWnd,szText,256);
                    if(strcmp(szText, szWindowText) == 0)
                    {
                          if(!bSetWindowLong)
                          {
                                g_hWnd = Wnd;
                                g_orgProc=(WNDPROC)SetWindowLong(hWnd,GWL_WNDPROC,(LONG)NewWndProc);
                                bSetWindowLong = TRUE;
                          }
                    }
                    break;
            case HCBT_DESTROYWND: 
                    hWnd = (HWND)wParam;
                    GetWindowText(hWnd,szText,256);
                    if(strcmp(szText, szWindowText) == 0)
                    {
                         SetWindowLong(g_hWnd,GWL_WNDPROC,(LONG)g_orgProc);
                         g_hWnd = NULL;
                         bSetWindowLong = false;
                    }
                    break;
     }
     return CallNextHookEx(NULL, nCode, wParam, lParam);
}//End of the hook procedure3. NewWndProc中如果用户点击OK按钮，则可以加入自己的处理过程，使其无效。LRESULT CALLBACK NewWndProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
      switch(uMsg)
      {
      case WM_COMMAND:
             if ((wParam == 0x06) && (HIWORD(wParam) == BN_CLICKED) )
             { 
                  /*Add your own procedure*/
                   return 0;
             } 
             break; 
      default:
             break;
      }
      return CallWindowProc(g_orgProc, hWnd, uMsg, wParam, lParam);
}-----------------------------------------------------------------------------------------
<h2><b>最好是能直接改成C# 然后把完全代码发出来，
那样就不用看我写的程序了  我写的程序中有很多错误
</b><h2>
我写的程序: [DllImport("user32.dll", EntryPoint="GetWindowText")] 
public static extern int GetWindowText ( 
int hwnd, 
string lpString, 
int cch
);
[DllImport("Kernel32.dll")]
        static extern long SetWindowLong(
int hWnd,
int nIndex,
int dwNewLong); 
        [DllImport("Kernel32.dll")]
        static extern IntPtr FindWindow(string str, string strname );//"Windows 任务管理器"        [DllImport("Kernel32.dll")]
        static extern int GetCurrentThreadId(); //取得当前线程编号的API        [DllImport("User32.dll")]
        internal extern static void UnhookWindowsHookEx(IntPtr handle); //取消Hook的API        [DllImport("user32.dll", CharSet = CharSet.Auto,
                          CallingConvention = CallingConvention.StdCall, SetLastError = true)]
        private static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hMod, int dwThreadId);   
        [DllImport("User32.dll")]
        internal extern static IntPtr CallNextHookEx(IntPtr handle, int code, IntPtr wparam, IntPtr lparam); //取得下一个Hook的API
        [DllImport("user32.dll")]
        protected static extern IntPtr CallWindowProc(IntPtr lpPrevWndFunc, IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
        protected delegate IntPtr WndProcDelegate(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);
        internal delegate IntPtr HookProc(int code, IntPtr wparam, IntPtr lparam);        private HookProc g_cbtHook =null;
        private IntPtr g_hwnd = (IntPtr)0;
        private void button1_Click()
        {
            g_hwnd = FindWindow(null, "Windows 任务管理器");
            g_cbtHook = SetWindowsHookEx((int)HookType.CBT, (HookProc)CBTProc, (HookProc)g_hwnd, 0);        }
        public static int HIWORD(int i)
        {
            return i >> 16;
        }         public  void memset(char[] buf1, char val, int size)
        {
            int i;
            for (i = 0; i < size; i++)
                buf1[i] = val;
        }
        public string szWindowText = "任务管理器警告";
       public int g_orgProc = 0;
        public bool bSetWindowLong = false;
        private IntPtr CBTProc(int nCode, IntPtr wParam, IntPtr lParam)
        {
              char [] szText=new char[256];
              
              int hWnd=0;
              char[] bufzz = new char[szWindowText.Length];
              for (int i = 0; i < szWindowText.Length; i++)
              {
                  bufzz[i] = szWindowText[i];
              }
              memset(bufzz, ' ', 32);
      szWindowText= "任务管理器警告";
      switch(nCode)
     {
            case (int)HookType.HCBT_ACTIVATE:
                    hWnd = (int)wParam;
                    GetWindowText(hWnd,szText.ToString(),256);
                    if(szText.ToString()!= szWindowText)
                    {
                        if (!bSetWindowLong)
                          {
                                g_hwnd = (IntPtr)hWnd;
                                g_orgProc = (IntPtr)SetWindowLong(hWnd, (int)HookType.GWL_WNDPROC, (int)NewWndProc);
                                bSetWindowLong =true;
                          }
                    }
                    break;
                case (int)HookType.HCBT_DESTROYWND: 
                    hWnd = (int)wParam;
                    GetWindowText(hWnd,szText.ToString(),256);
                    if(szText.ToString()!=szWindowText)
                    {
                         SetWindowLong((int)g_hwnd,(int)HookType. GWL_WNDPROC,(int)g_orgProc);
                         g_hwnd = (IntPtr)0;
                         bSetWindowLong = false;
                    }
                    break;
     }
     return CallNextHookEx((IntPtr)0, nCode, wParam, lParam);
        }
        private IntPtr NewWndProc(int hWnd, int uMsg, IntPtr wParam, IntPtr lParam)
{
      switch(uMsg)
      {
      case (int)HookType. WM_COMMAND:
          if ((wParam == (IntPtr)0x06) && (HIWORD((int)wParam) == 0))//BN_CLICKED 0
             { 
                  /*Add your own procedure*/
                   return (IntPtr)0;
             } 
             break; 
      default:
             break;
      }
      return CallWindowProc(g_orgProc, hWnd, uMsg, wParam, lParam);
}        internal enum HookType //枚举，钩子类型
        {            //MsgFilter=-1;
            //JournalRecord=0;
            //JournalPlayback=1;
            //Keyboard = 2
            //GetMessage=3;
            //CallWndProc=4;
             CBT=12,
            //KeyboardLL=13;
            //MouseLL=14;
            
 // HCBT_MOVESIZE       0
 //HCBT_MINMAX     =    1
 //HCBT_QS           =  2
 //HCBT_CREATEWND    =  3
 HCBT_DESTROYWND    = 4,
 HCBT_ACTIVATE      = 5,
 //HCBT_CLICKSKIPPED  = 6
 //HCBT_KEYSKIPPED    = 7
 //HCBT_SYSCOMMAND    = 8
 //HCBT_SETFOCUS      = 9
GWL_WNDPROC        = -4,
// GWL_HINSTANCE       =-6
// GWL_HWNDPARENT      =-8
// GWL_STYLE           =-16
// GWL_EXSTYLE         =-20
// GWL_USERDATA        =-21
// GWL_ID              =-12
            WM_COMMAND     =                 0x0111
        };
    }---------------------------------------------------------------
错误好多 再编译器里看吧 帖子太长
--------------------------------------------------------------------------<h1><b>最好是不看我写的程序  直接写出完全的代码  先谢谢各位了</b></h1>
关注借有分

Answer 1

C#应该是实现不了的，因为.net不支持

Answer 2

用C++封装成dll,然后C#调用dll也许可以

Answer 3

.net可以实现的吧   他引用的dll和我做过的一样的多，还有自己定义的结构体什么的   很多，api的也有

Answer 4

C++能实现  C#一般还是可以实现的
最多用unsafe 代码  
还有注意C++和C#参数的转换问题  这个是最麻烦的。

Answer 5

反编译过后再看unsafe简直就是个垃圾……

Answer 6

嗯,
提一个比较偏的方法;理论上应该可行.
前提是你的C#进程必须能获得操作Windows任务管理器进程内存的权限.因为进程管理器用一个ListView32控件显示进程列表.
接下来的事就好办了.先找到taskmgr的主窗体,遍历子窗体到对应的ListView控件.
这时候就能通过发消息来获取ListView的内容了.不过由于ListView与自己的程序不
处于同一个进程,而消息发送的缓冲区指针只能于同一进程空间.所以需要用到大量的跨
进程内存操作.获得ListView内容后的事就好办了.找到包含自己进程名的LVITEM,发条
LVM_DELETEITEM消息让它删掉就行了.设置个timer随时监视taskmgr应该就能让你的
进程在windows任务管理器里"消失".关于跨进程操作ListView32控件,可以参考拙作 らぶデス海茶３去码补丁.

Answer 7

楼主你那个方法治标不治本，的确是在防止“ 任务管理器”去结束，但是你放不了我来结束你的进程，我写个程序可以绕过你的检测，结束你的进程，因为你只判断了一个叫“Windows 任务管理器”的进程并捕获它的消息。
说的简单些吧，假如我的操作系统是因为的，那么我的任务管理器的标题就不叫“Windows 任务管理器”了——全部是英文名。

Answer 8

楼主你那个方法治标不治本，的确是在防止“ 任务管理器”去结束，但是你防不了我来结束你的进程，我写个程序可以绕过你的检测，结束你的进程，因为你只判断了一个叫“Windows 任务管理器”的进程并捕获它的消息。 
说的简单些吧，假如我的操作系统是英文的，那么我的任务管理器的标题就不叫“Windows 任务管理器”了——全部是英文名。

Answer 9

任务管理器在各版windows操作系统下的进程名都是"taskmgr.exe".我当然不会傻到用"Windows 任务管理器"去做FindWindow.另外LZ只要求无法用任务管理器结束进程嘛...我当然就只处理任务管理器咯.当然你写的任务管理器我没办法,
另外要结束程序的话直接用taskkill就可以了.

Answer 10

建个窗口,挡住整个屏幕,用钩子勾掉 ctrl alt 或 del键.

Answer 11

这样不行啊  我写个bat 一样可以结束的

Answer 12

用C#很难实现啊，我以前也研究过这个问题，用C#没有实现，还是用C++吧

Answer 13

c#    防止任务管理器强行结束进程 有一篇文章 用VC++实现是这样写的 
附件[SafeProcess.rar]： 
http://blog.blogchina.com/upload/2004-12-20/20041220143803647829.rar 1. 通过Timer过程或其他方式查找Windows任务管理器窗口是否存在。 
    ::FindWindow(NULL,  "Windows 任务管理器") 
    如果存在，则进入第二步。 2. 设置一个WH_CBT类型的HOOK 
    g_cbtHook = SetWindowsHookEx(WH_CBT, (HOOKPROC)CBTProc, g_hInstance, NULL); 
  在 (HOOKPROC)CBTProc中处理HCBT_ACTIVATE和HCBT_DESTROYWND两类消息。 // The CBT hook Proc(Computer Based Training Hook) 
LRESULT CALLBACK CBTProc(int nCode, WPARAM wParam, LPARAM lParam) 
{ 
      CHAR szText[256]; 
      CHAR szWindowText[32]; 
      HWND hWnd;       memset(szWindowText, NULL, sizeof(szWindowText)); 
      strcpy(szWindowText, "任务管理器警告");       switch(nCode) 
    { 
            case HCBT_ACTIVATE: 
                    hWnd = (HWND)wParam; 
                    GetWindowText(hWnd,szText,256); 
                    if(strcmp(szText, szWindowText) == 0) 
                    { 
                          if(!bSetWindowLong) 
                          { 
                                g_hWnd = Wnd; 
                                g_orgProc=(WNDPROC)SetWindowLong(hWnd,GWL_WNDPROC,(LONG)NewWndProc); 
                                bSetWindowLong = TRUE; 
                          } 
                    } 
                    break; 
            case HCBT_DESTROYWND: 
                    hWnd = (HWND)wParam; 
                    GetWindowText(hWnd,szText,256); 
                    if(strcmp(szText, szWindowText) == 0) 
                    { 
                        SetWindowLong(g_hWnd,GWL_WNDPROC,(LONG)g_orgProc); 
                        g_hWnd = NULL; 
                        bSetWindowLong = false; 
                    } 
                    break; 
    } 
    return CallNextHookEx(NULL, nCode, wParam, lParam); 
}//End of the hook procedure 3. NewWndProc中如果用户点击OK按钮，则可以加入自己的处理过程，使其无效。 LRESULT CALLBACK NewWndProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam) 
{ 
      switch(uMsg) 
      { 
      case WM_COMMAND: 
            if ((wParam == 0x06) && (HIWORD(wParam) == BN_CLICKED) ) 
            { 
                  /*Add your own procedure*/ 
                  return 0; 
            } 
            break; 
      default: 
            break; 
      } 
      return CallWindowProc(g_orgProc, hWnd, uMsg, wParam, lParam); 
} 
----------------------------------------------------------------------------------------- 
<h2> <b>最好是能直接改成C# 然后把完全代码发出来， 
那样就不用看我写的程序了  我写的程序中有很多错误 
</b> <h2> 

Answer 14

不懂得vc和c#可能翻译不出来哟！
关注高手直接写一个。

Answer 15

屏蔽系统管理器热键，自动开关public Form1()
{
InitializeComponent();
}
[DllImport(@"native.dll", EntryPoint = "FuckSysKey")]
private extern static bool FuckSysKey(bool enAble);private void button1_Click(object sender, EventArgs e)
{
FuckSysKey(false);
}
private void button2_Click(object sender, EventArgs e)
{
FuckSysKey(true);
} 具体的动态库的dll的下载地址: 
http://download.csdn.net/source/1311907

Answer 16

有时一些流氓软件，在你强行关闭进程的时候，会提示“不能关闭”，或者像Sqlserver这样的进程，
当你关闭的时候，会重新启动一个新的进程。我认为想控制不让关闭是很困难的，而且我可以用像360等软件来关闭，那你又怎么控制？
还是用第二种，即关可以，但之后我又重启一个，不也可以嘛，干嘛非得让它不能被关掉呢，你想让人家骂你流氓吗？

Answer 17

狂顶啊！！！各位，我现在还只是一个学生。
近来我写了一个软件，名称是“梦中女孩”。
用途就是管理电脑上的所有的软件的运行。比如，我在数据库中设计了一个任务： 7：00-11：00  不允许执行 QQGame 进程，那么，时钟控件就会循环监测....但问题来了，如果我实在是想玩  QQGame 了， 我心痒的受不了了，——于是，就毫不犹豫的  打开任务管理器。“梦中女孩2.0” 右键， “结束进程”。
于是，我又可以玩 QQGame 了。——关注该帖， 我就想如何让自己没那么容易将 “梦中女孩”结束啊......之前，“梦中女孩1.0  1.1 ” 版本，我是启动了一个 “护花使者”进程。 “梦中女孩”无限的保护并启动 “护花使者”。
“护花使者”如果监测到“梦中女孩”进程结束了， 
就会做出三件事：无限关闭任务管理器；提示：梦中女孩被非法结束，将关机；然后倒计时20秒后关机。但，C# 本来 内存使用比较大， 能少一个“护花使者”就相当于减少了 30 M内存，我才 512 内存啊......

Answer 18

>>>>>>>>>>------------------------------------------------------------------------------------------<<<<<<<<<<

Answer 19

这个地方有一个C#可以调用的DLL,直接用就OK了，还有工程文件源代码。
主要思路是截获发送的关闭进程，进程号的消息。
http://blog.csdn.net/kangkanglx/archive/2010/06/25/5692984.aspx