100分求 WINFORM程序如何屏蔽系统热键

[yaoqiuchen]

本人现要开发一WINFORM应用程序，有点类似于网吧管理的美屏软件，要求开机后操作者必须在我的软件里进行相关操作后才能使用其它应用程序，我现在的思路是开机后自动运行，然后屏蔽掉常用的系统热键如ALT+TAB CTRL+SHIFT+DEL等，在网上查了一下资料，很多人说要钩子来实现，各位大虾请给个详细的思想，最好能有具体的代码。谢谢！
分不够再加。

[JLinfeng]

不懂，我是来up的

[hopewoo]

网上很多啊. 自己看
下面是屏蔽了win键,其他都一样的

 [StructLayout(LayoutKind.Sequential)]
    public struct KBDLLHOOKSTRUCT
    {
        public int vkCode;
        public int scanCode;
        public int flags;
        public int time;
        public int dwExtraInfo;
    }
    public class HookApi
    {
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr SetWindowsHookEx
            (
                int hookid,
                HookBase.HookPro pfnhook,
                IntPtr hinst,
                int threadid
            );
        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        public static extern bool UnhookWindowsHookEx
            (
               IntPtr hhook
            );
        [DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
        public static extern bool CallNextHookEx
            (
                IntPtr hhook,
                int code,
                IntPtr wparam,
                IntPtr lparam
            );
        [DllImport("Kernel32.dll", EntryPoint = "RtlMoveMemory")]
        public static extern void CopyMemory
            (
                ref KBDLLHOOKSTRUCT Source,
                IntPtr Destination, int Length
            );
        public class HookBase
        {
            public delegate bool HookPro(int nCode, IntPtr wParam, IntPtr lParam); 
            static IntPtr hHook = IntPtr.Zero; 
            const int WH_KEYBOARD_LL = 13; 

            GCHandle _hookProcHandle;

            public delegate void keypresscode(int keycode, int modifierkeys);
            public keypresscode curkeypresscode;
            public bool KEYBOARD_HOOKPRO(int nCode, IntPtr wParam, IntPtr lParam)
            {
                KBDLLHOOKSTRUCT kb = new KBDLLHOOKSTRUCT();
                HookApi.CopyMemory(ref kb, lParam, 20);
                if (kb.vkCode == 91) { return true; }
                UNLOAD_WINDOWS_KETBOARD_HOOK();
                SET_WINDOWS_KEYBOARD_HOOK();
                return HookApi.CallNextHookEx(hHook, nCode, wParam, lParam);            }

            public void SET_WINDOWS_KEYBOARD_HOOK()
            {
                if (hHook == IntPtr.Zero)
                {
                    HookPro hk = new HookPro(this.KEYBOARD_HOOKPRO);
                    _hookProcHandle = GCHandle.Alloc(hk);
                    hHook = HookApi.SetWindowsHookEx(
                        WH_KEYBOARD_LL,
                        hk,
                        Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),
                        0);
                    if (hHook == IntPtr.Zero)
                    {
                        throw new Exception("安装钩子不成功！");
                    }
                }
            }
            public void UNLOAD_WINDOWS_KETBOARD_HOOK()
            {
                if (hHook != IntPtr.Zero)
                {
                    HookApi.UnhookWindowsHookEx(hHook);
                    _hookProcHandle.Free();
                    hHook = IntPtr.Zero;
                }
            }
        }
    }
    public class HookBase
    {
        public delegate bool HookPro(int nCode, IntPtr wParam, IntPtr lParam);
        static IntPtr hHook = IntPtr.Zero; 
        const int WH_KEYBOARD_LL = 13; 
        GCHandle _hookProcHandle;
        public delegate void keypresscode(int keycode, int modifierkeys);
        public keypresscode curkeypresscode;
        public bool KEYBOARD_HOOKPRO(int nCode, IntPtr wParam, IntPtr lParam)
        {
            KBDLLHOOKSTRUCT kb = new KBDLLHOOKSTRUCT();

            HookApi.CopyMemory(ref kb, lParam, 20);
            if (kb.vkCode == 91) { return true; }
            UNLOAD_WINDOWS_KETBOARD_HOOK();
            SET_WINDOWS_KEYBOARD_HOOK();
            return HookApi.CallNextHookEx(hHook, nCode, wParam, lParam);
        }
        public void SET_WINDOWS_KEYBOARD_HOOK()
        {
            if (hHook == IntPtr.Zero)
            {

                HookApi.HookBase.HookPro hk = new HookApi.HookBase.HookPro(this.KEYBOARD_HOOKPRO);
                _hookProcHandle = GCHandle.Alloc(hk);
                hHook = HookApi.SetWindowsHookEx(
                    WH_KEYBOARD_LL,
                    hk,
                    Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),
                    0);
                if (hHook == IntPtr.Zero)
                {
                    throw new Exception("安装钩子不成功！"); 
                }
            }
        }
        public void UNLOAD_WINDOWS_KETBOARD_HOOK()
        {
            if (hHook != IntPtr.Zero)
            {
                HookApi.UnhookWindowsHookEx(hHook);
                _hookProcHandle.Free();
                hHook = IntPtr.Zero;
            }
        }
    }

[hopewoo]

public bool KEYBOARD_HOOKPRO(int nCode, IntPtr wParam, IntPtr lParam)
{
KBDLLHOOKSTRUCT kb = new KBDLLHOOKSTRUCT();
HookApi.CopyMemory(ref kb, lParam, 20);
if (kb.vkCode == 91) { return true; }
UNLOAD_WINDOWS_KETBOARD_HOOK();
SET_WINDOWS_KEYBOARD_HOOK();
return HookApi.CallNextHookEx(hHook, nCode, wParam, lParam); }
改下这部分就OK了
实例化HookBase类.

[zhoulehua]

4楼不错。

[v_oneforever]

4楼的不错。。。先收藏一下。。。帮顶

[英雄在线]

学习下 帮顶

[zzxap]

第一步，钩子DLL的实现。我们首先要定义一个全局数据区（记住这是一个全局钩子），如下（放在cpp文件的上头）：

　　#pragma data_seg("mydata")
　　HHOOK glhHook = NULL; // 安装的鼠标钩子句柄
　　HINSTANCE glhInstance = NULL; // DLL实例句柄
　　#pragma data_seg()

　　然后在.def文件中声明这个数据区，如下：
　　SECTIONS
　　mydata READ WRITE SHARED

　　当这个DLL被某个进程载入时，程序从WinMain进入，此时我们需要把模块句柄保存下来，如下：
　　glhInstance = (HINSTANCE) hModule;

　　接下去，我们就要定义两个导出函数，以及钩子的处理函数。我们重点看一下这个钩子处理函数（另外两个导出函数比较简单，只是通过调用SetWindowsHookEx和UnhookWindowsHookEx实现安装/卸载钩子函数；只需注重SetWindowsHookEx第一个参数为WH_KEYBOARD_LL，第四个参数为0）。

　　// 低级键盘钩子处理函数
　　LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
　　{ 字串3

　　 BOOL fEatKeystroke = FALSE;
　　 PKBDLLHOOKSTRUCT p = NULL;

　　 if (nCode == HC_ACTION)
　　 {
　　 p = (PKBDLLHOOKSTRUCT) lParam;

　　 switch (wParam)
　　 {
　　 case WM_KEYDOWN:
　　 case WM_SYSKEYDOWN:
　　 case WM_KEYUP:
　　 case WM_SYSKEYUP:
　　 fEatKeystroke = (p->vkCode == VK_LWIN) ¦ ¦ (p->vkCode == VK_RWIN) ¦ ¦ // 屏蔽Win
字串6


　　 // 屏蔽Alt Tab
　　 ((p->vkCode == VK_TAB) && ((p->flags & LLKHF_ALTDOWN) != 0)) ¦ ¦
　　 // 屏蔽Alt Esc
　　 ((p->vkCode == VK_ESCAPE) && ((p->flags & LLKHF_ALTDOWN) != 0)) ¦ ¦
　　 // 屏蔽Ctrl Esc
　　 ((p->vkCode == VK_ESCAPE) && ((GetKeyState(VK_CONTROL) & 0x8000) != 0));
　　 break;
　　 default:
　　 break;

　　 }
　　 }

　　return (fEatKeystroke ? TRUE : CallNextHookEx(glhHook,nCode,wParam,lParam));
　　}

　　大家可以看到，当程序发现按下的是Win键或者Alt Tab组合键，就不再调用CallNextHookEx函数将这个消息传递下去。以此，我们做到了屏蔽这些按键的响应。
　　
　　第二步，钩子DLL的测试程序。在VC中创建一个基于对话框的应用程序。通过调用LoadLibrary("KeyMask.dll")载入钩子DLL，通过GetProcAddress(m_hDll,"StartKeyMask")和GetProcAddress(m_hDll,"StopKeyMask")导入两个安装/卸载钩子的函数。在主对话框上定义两个按钮分别调用这两个函数，如下： 字串8

　　当按下“Start_Hook”按钮，我们的钩子函数就起作用了。试一下Win键，或者Alt Tab组合键，没反应了吧？！“Stop_Hook”按钮可以解除这个钩子

[zzxap]

Microsoft.Win32.RegistryKey key = Microsoft.Win32.Registry.CurrentUser;
Microsoft.Win32.RegistryKey key1 = key.CreateSubKey("Software\Microsoft\Windows\CurrentVersion\Policies\System");
key1.SetValue("DisableTaskMgr", 1, Microsoft.Win32.RegistryValueKind.DWord);

[zzxap]

编辑注册表可以禁用任务管理器，找到“[HKEY_CURRENT_USER\Software\Microsoft\ Windows\CurrentVersion\Policies\System]”，新建“DisableTaskMgr”项（REG_DWORD），其值设置为1则禁止，为0则启用。

[accomp]

收藏

[mykelly6]

[Quote=引用 2 楼 wuhq030710914 的回复:]
重新定义系统热键
[/Quote]
对的，自己注册热键，然后在热键响应里面什么都不做就好了

[onenewsmile]

codeproject上搜索下

[onenewsmile]

protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
{
base.ProcessCmdKey(msg, keyData);
}

[macooidle]

ProcessCmdKey

[deyygywxf]

这儿有一个网站 前两天讨论的帖子 让ALT键处于长按下状态 用到了钩子 对你有帮助的
http://topic.csdn.net/u/20090325/20/3634c46e-b46f-4712-811b-d3e3daa6b8ad.html

[lvchun012]

//我前两天刚刚做的，屏蔽桌面都可以，不过小心使用啊，
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;

using System.Text;
using System.Diagnostics;
using System.Reflection;
using System.Windows.Forms;
using System.Runtime.InteropServices;

using System.Reflection;
using System.Security.Permissions;
using Microsoft.Win32;

namespace testHook
{
public partial class Form1 : Form
{
//委托
public delegate int HookProc(int nCode, int wParam, IntPtr lParam);
static int hHook = 0;
public const int WH_KEYBOARD_LL = 13;
//LowLevel键盘截获，如果是WH_KEYBOARD＝2，并不能对系统键盘截取，Acrobat Reader会在你截取之前获得键盘。
HookProc KeyBoardHookProcedure;
//键盘Hook结构函数
[StructLayout(LayoutKind.Sequential)]
public class KeyBoardHookStruct
{
public int vkCode;
public int scanCode;
public int flags;
public int time;
public int dwExtraInfo;
}
#region DllImport
//设置钩子
[DllImport("user32.dll")]
public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
//抽掉钩子
public static extern bool UnhookWindowsHookEx(int idHook);
[DllImport("user32.dll")]
//调用下一个钩子
public static extern int CallNextHookEx(int idHook, int nCode, int wParam, IntPtr lParam);

[DllImport("kernel32.dll")]
public static extern int GetCurrentThreadId();

[DllImport("kernel32.dll")]
public static extern IntPtr GetModuleHandle(string name);

[DllImport("User32.dll")]
public static extern IntPtr FindWindowEx(IntPtr ph, IntPtr ch, String cn, String wn);
[DllImport("User32.dll")]
public static extern bool ShowWindow(IntPtr hWnd, long nCmdShow);

private const uint spi_screensaverrunning = 97;
[DllImport("user32.dll", CharSet = CharSet.Auto)]
private static extern bool SystemParametersInfo(uint uiAction, uint uiParam, ref bool pvParam, uint fWinIni);

#endregion

#region 自定义事件
public void HookStart()
{
// 安装键盘钩子
if (hHook == 0)
{
KeyBoardHookProcedure = new HookProc(KeyBoardHookProc);
hHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyBoardHookProcedure,
GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName), 0);

//如果设置钩子失败.
if (hHook == 0)
{
HookClear();
//throw new Exception("set Hook failed!");
}
}
}

//取消钩子事件
public void HookClear()
{
bool retKeyboard = true;
if (hHook != 0)
{
retKeyboard = UnhookWindowsHookEx(hHook);
hHook = 0;
}
//如果去掉钩子失败.
if (!retKeyboard) throw new Exception("UnhookWindowsHookEx failed.");
}

//这里可以添加自己想要的信息处理
public static int KeyBoardHookProc(int nCode, int wParam, IntPtr lParam)
{
if (nCode >= 0)
{
KeyBoardHookStruct kbh = (KeyBoardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyBoardHookStruct));
if (kbh.vkCode == (int)Keys.S && (int)Control.ModifierKeys == (int)Keys.Control) // 截获Ctrl+S
{
return 1;
}
if (kbh.vkCode == (int)Keys.Y && (int)Control.ModifierKeys == (int)Keys.Control + (int)Keys.Alt) //截获Ctrl+Alt+Y
{
return 1;
}
if (kbh.vkCode == (int)Keys.LWin) //截获win
{
return 1;
}
if (kbh.vkCode == (int)Keys.Tab && (int)Control.ModifierKeys == (int)Keys.Alt) //截获Ctrl+Tab
{
return 1;
}
if (kbh.vkCode == (int)Keys.F4 && (int)Control.ModifierKeys == (int)Keys.Alt)//截获Alt + F4
{
return 1;
}

if (kbh.vkCode == (int)Keys.E && (int)Control.ModifierKeys == (int)Keys.LWin)//截获win + e
{
return 1;
}

if (kbh.vkCode == (int)Keys.Escape && (int)Control.ModifierKeys == (int)Keys.Alt)////截获Alt + esc
{
return 1;
}

if ((int)Control.ModifierKeys == (int)Keys.Control + (int)Keys.Alt + (int)Keys.Delete)//截获Ctrl+Alt+Delete 不成功 , 系统不返回键盘值
{
return 1;
}
if (kbh.vkCode == (int)Keys.Escape && (int)Control.ModifierKeys == (int)Keys.Control)////截获Ctrl + esc
{
return 1;
}
}
return CallNextHookEx(hHook, nCode, wParam, lParam);
}
#endregion

public void SetCtrlAltDeleteStatus(int value)
{
//1不可用 0可用

Microsoft.Win32.RegistryKey key = Microsoft.Win32.Registry.CurrentUser;
Microsoft.Win32.RegistryKey keySystem = key.CreateSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System");
keySystem.SetValue("DisableTaskMgr", 1, Microsoft.Win32.RegistryValueKind.DWord);

RegistryKey regKey;
regKey = Registry.CurrentUser.OpenSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System", true);
if (regKey == null)
{
regKey = Registry.CurrentUser.CreateSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System");
}
regKey.SetValue("DisableTaskMgr", value, RegistryValueKind.DWord);
}
private void DisableAll()
{
HookStart();
IntPtr handleTaskMask = FindWindowEx(IntPtr.Zero, IntPtr.Zero, "Shell_TrayWnd", null);
ShowWindow(handleTaskMask, 0);
IntPtr handleDeskTop = FindWindowEx(IntPtr.Zero, IntPtr.Zero, "Progman", null);
ShowWindow(handleDeskTop, 0);
SetCtrlAltDeleteStatus(1);
bool p = true;
SystemParametersInfo(spi_screensaverrunning, 1, ref p, 0);
}

private void RecoverAll()
{
HookClear();
IntPtr handle = FindWindowEx(IntPtr.Zero, IntPtr.Zero, "Shell_TrayWnd", null);
ShowWindow(handle, 1);
IntPtr handleDeskTop = FindWindowEx(IntPtr.Zero, IntPtr.Zero, "Progman", null);
ShowWindow(handleDeskTop, 1);
SetCtrlAltDeleteStatus(0);
bool p = true;
SystemParametersInfo(spi_screensaverrunning, 0, ref p, 0);
}
public Form1()
{
string xx = Environment.CurrentDirectory;
InitializeComponent();
DisableAll();
}

private void Form1_Load(object sender, EventArgs e)
{
// statrhook();
}



private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
RecoverAll();
//sotphook();
}
}
}

[lvchun012]

楼主结贴么？不结贴我会骂人的哦

[wangwffgqeg]

太复杂了

[夏林林]

#20楼
你那个程序alt+ctrl+delete是没办法禁止掉的

[地黄八幡]

[Quote=引用 19 楼 lvchun012 的回复:]
//我前两天刚刚做的，屏蔽桌面都可以，不过小心使用啊，
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;

using System.Text;
using System.Diagnostics;
……
[/Quote]
很好，爱死你了。