Блокировка USB-накопителей

using System;
using System.Management;
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;      

namespace WMIConsole
{
    class Program
    {
        [DllImport("kernel32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
        public static extern SafeFileHandle CreateFile(
            string lpFileName,
            uint dwDesiredAccess,
            uint dwShareMode,
            IntPtr SecurityAttributes,
            uint dwCreationDisposition,
            uint dwFlagsAndAttributes,
            IntPtr hTemplateFile
        );

        public static SafeFileHandle ptr;

        const uint GENERIC_READ = 0x80000000;
        const uint GENERIC_WRITE = 0x40000000;
        const uint OPEN_EXISTING = 3;



        static void Main(string[] args)
        {
           
            ManagementEventWatcher watcher = null;
            try
            {
                // Bind to local machine
                ManagementScope scope = new ManagementScope("root\\CIMV2");
                scope.Options.EnablePrivileges = true; //set required privilege

                WqlEventQuery query = new WqlEventQuery();
                query.EventClassName = "__InstanceOperationEvent";
                query.WithinInterval = new TimeSpan(0, 0, 1);
                query.Condition = @"TargetInstance ISA 'Win32_DiskDrive'";
               
                watcher = new ManagementEventWatcher(scope, query);
                watcher.EventArrived += new EventArrivedEventHandler(watcher_EventArrived);
               
                watcher.Start();

                Console.ReadLine(); // block main thread for test purposes
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                if (watcher != null)
                    watcher.Stop();
            }
            return;
        }

        static void watcher_EventArrived(object sender, EventArrivedEventArgs e)
        {            
                       
            //Get the Event object and display its properties (all)
            foreach (PropertyData pd in e.NewEvent.Properties)
            {
                ManagementBaseObject mbo = null;
                if ((mbo = pd.Value as ManagementBaseObject) != null)
                {                  
                    ManagementClass devs = new ManagementClass(@"Win32_Diskdrive");
                    ManagementObjectCollection moc = devs.GetInstances();
                    foreach (ManagementObject mo in moc)
                    {
                        if (mo["DeviceId"].ToString() == mbo.GetPropertyValue("DeviceId").ToString())
                        {
                            foreach (ManagementObject b in mo.GetRelated("Win32_DiskPartition"))
                            {
                                foreach (ManagementObject c in b.GetRelated("Win32_LogicalDisk"))
                                {                                    
                                    ptr = CreateFile(@"\\.\" + c["Name"].ToString(), GENERIC_READ | GENERIC_WRITE,
                                        0, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
                                }
                            }
                        }
                    }
                }
            }  
        }
    }
}

[DllImport("kernel32.dll", SetLastError = true)]
        static extern IntPtr CreateFile(
            string lpFileName,
            uint dwDesiredAccess,
            uint dwShareMode,
            IntPtr lpSecurityAttributes,
            uint dwCreationDisposition,
            uint dwFlagsAndAttributes,
            IntPtr hTemplateFile);


IntPtr ptr;


[DllImport("kernel32.dll", SetLastError = true)]
static extern bool DeviceIoControl(
    IntPtr hDevice,
    uint dwIoControlCode,
    IntPtr lpInBuffer,
    uint nInBufferSize,
    [Out] IntPtr lpOutBuffer,
    uint nOutBufferSize,
    ref uint lpBytesReturned,
    IntPtr lpOverlapped);



        private void button1_Click(object sender, EventArgs e)
        {
            const uint FILE_SHARE_READ = 0x00000001;
            const uint FILE_SHARE_WRITE = 0x00000002;
            const uint OPEN_EXISTING = 3;
            const uint GENERIC_READ = 0x80000000;
            const uint GENERIC_WRITE = 0x40000000;

            const uint FSCTL_LOCK_VOLUME = 0x00090018;

            string str = @"\\.\E:";
           
            ptr = CreateFile(str, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero);
           
            uint byteReturned=0;
            DeviceIoControl(ptr, FSCTL_LOCK_VOLUME, IntPtr.Zero, 0, IntPtr.Zero, 0, ref byteReturned, IntPtr.Zero);

protected override void WndProc(ref Message m)
        {
            if ((m.WParam.ToInt32() == DBT_DEVICEARRIVAL)||(m.WParam.ToInt32() == DBT_DEVICEREMOVECOMPLETE))
            {
                //printDevices();
            }
            base.WndProc(ref m);
        }

        void printDevices()
        {
            listView1.Items.Clear();
            DriveIndexList.Clear();

            try
            {
                ManagementObjectSearcher searcher =
                    new ManagementObjectSearcher("root\\CIMV2",
                    "SELECT * FROM Win32_DiskDrive WHERE InterfaceType = 'USB'");


                foreach (ManagementObject queryObj in searcher.Get())
                {
                    listView1.Items.Add(new ListViewItem(new[] { queryObj["Caption"].ToString(), queryObj["Index"].ToString(), "" }));
                    DriveIndexList.Add((UInt32)queryObj["Index"]);
                }          

            }
            catch (ManagementException ee)
            {
                MessageBox.Show("An error occurred while querying for WMI data: " + ee.Message);
            }

        }

        private void btn_Add_Click(object sender, EventArgs e)
        {
            printDevices();
        }