Form2.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;
using System.Windows.Forms;

namespace 锁定
{
    public partial class Lock : System.Windows.Forms.Form
    {
        private Timer usbCheckTimer;
        private Hook h = new Hook();

        // 声明一个 TextBox 控件用于输入密码
        private TextBox password;

        public Lock()
        {
            InitializeComponent();
            this.Load += Form2_Load;
            this.FormClosing += Form2_FormClosing;

            // 初始化 password TextBox 控件
            password = new TextBox();
            password.Location = new Point(50, 50);
            password.Width = 200;
            this.Controls.Add(password);
        }

        private void Form2_Load(object sender, EventArgs e)
        {
            FullScreen();
            LockScreen();
            h.Hook_Start();
            password.Focus();

            // 设置定时器每秒检查一次USB设备
            usbCheckTimer = new Timer();
            usbCheckTimer.Interval = 1000; // 每秒检查一次
            usbCheckTimer.Tick += UsbCheckTimer_Tick;
            usbCheckTimer.Start();
        }

        private void Form2_FormClosing(object sender, FormClosingEventArgs e)
        {
            UnlockScreen();
            h.Hook_Clear();
            usbCheckTimer.Stop();
        }

        private void LockScreen()
        {
            this.TopMost = true;
            BlockInput(true);
        }

        private void UnlockScreen()
        {
            this.TopMost = false;
            BlockInput(false);
        }

        private void FullScreen()
        {
            this.FormBorderStyle = FormBorderStyle.None;
            this.WindowState = FormWindowState.Maximized;
        }

        protected override void WndProc(ref Message m)
        {
            const int WM_KEYDOWN = 0x0100;
            const int WM_SYSKEYDOWN = 0x0104;

            if (m.Msg == WM_KEYDOWN || m.Msg == WM_SYSKEYDOWN)
            {
                Keys key = (Keys)(int)m.WParam & Keys.KeyCode;

                // 检查是否是数字键、Tab键或换行键
                if ((key >= Keys.D0 && key <= Keys.D9) ||
                    (key >= Keys.NumPad0 && key <= Keys.NumPad9) ||
                    key == Keys.Enter || key == Keys.Tab)
                {
                    base.WndProc(ref m);
                    return;
                }

                // 忽略其他键盘消息
                return;
            }

            base.WndProc(ref m);
        }

        private void KillTaskmgr()
        {
            Process[] processes = Process.GetProcesses();
            foreach (Process process in processes)
            {
                if (process.ProcessName == "taskmgr" || process.ProcessName == "cmd")
                {
                    try
                    {
                        process.Kill();
                    }
                    catch { }
                }
            }
        }

        private void tm_lock_Tick(object sender, EventArgs e)
        {
            KillTaskmgr();
        }

        private void UsbCheckTimer_Tick(object sender, EventArgs e)
        {
            DriveInfo[] allDrives = DriveInfo.GetDrives();
            foreach (DriveInfo d in allDrives)
            {
                if (d.IsReady && d.DriveType == DriveType.Removable)
                {
                    string filePath = Path.Combine(d.RootDirectory.FullName, "MakeKey.exe");
                    if (File.Exists(filePath))
                    {
                        var keys = RunMakeKeyExecutable(filePath);
                        ValidatePassword(keys);
                    }
                }
            }
        }

        private List<string> RunMakeKeyExecutable(string filePath)
        {
            var process = new Process();
            process.StartInfo.FileName = filePath;
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.RedirectStandardOutput = true;
            process.StartInfo.CreateNoWindow = true;
            process.Start();

            string output = process.StandardOutput.ReadToEnd();
            process.WaitForExit();

            return output.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).ToList();
        }

        private void ValidatePassword(List<string> passwords)
        {
            DateTime currentDate = DateTime.Now;
            string formattedDate = currentDate.ToString("ddMMmmHHyy");
            long dateNumber;
            long.TryParse(formattedDate, out dateNumber);
            Random ran = new Random();
            string expectedHash = ComputeHash((dateNumber * ran.Next(1, 10000)).ToString());
            if (passwords.Contains(expectedHash))
            {
                UnlockScreen();
                h.Hook_Clear();
                Application.Exit();
                return;
            }
        }

        private static string ComputeHash(string input)
        {
            using (SHA256 sha256 = SHA256.Create())
            {
                byte[] bytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(input));
                StringBuilder builder = new StringBuilder();
                for (int i = 0; i < bytes.Length; i++)
                {
                    builder.Append(bytes[i].ToString("x2"));
                }
                return builder.ToString();
            }
        }

        [DllImport("user32.dll")]
        private static extern bool BlockInput(bool fBlockIt);
    }

    public class Hook
    {
        public delegate int HookProc(int nCode, int wParam, IntPtr lParam);
        static int hHook = 0;
        public const int WH_KEYBOARD_LL = 13;
        HookProc KeyBoardHookProcedure;

        [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);
        #endregion

        public void Hook_Start()
        {
            if (hHook == 0)
            {
                KeyBoardHookProcedure = new HookProc(KeyBoardHookProc);

                hHook = SetWindowsHookEx(WH_KEYBOARD_LL,
                           KeyBoardHookProcedure,
                          GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName), 0);

                if (hHook == 0)
                {
                    Hook_Clear();
                    throw new Exception();
                }
            }
        }

        public void Hook_Clear()
        {
            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));

                int v = kbh.vkCode;
                switch (v)
                {
                    case 27: // ESC键
                    case 91: // 左徽标键
                    case 92: // 右徽标键
                    case 93: // 鼠标右键快捷键
                    case 164:
                    case 9:  // TAB键
                    case 10: // Shift键
                    case 17: // Ctrl键
                    case 18: // Alt键
                    case 162:
                    case 110: // .键
                    case 46: // Delete键
                    case 115: // F4键
                    case 241: // F1键
                        return 1;
                }
            }
            return CallNextHookEx(hHook, nCode, wParam, lParam);
        }
    }
}