根据USB 序列号 生成USB Key

在软件安装的时候,常常要验证软件的有效性,这时候发行产品的时候会附带一个USB Key,主程序运行的时候检查这个Key的合法性，如果通过验证，那么启动主程序。

下面的代码提供了实现该方法的途径：

1. /// <summary>
2.     /// USB 操作相关
3.     /// </summary>
4.     public class UsbUtility
5.     {
6.         const string Key_File_Name = "Usb.key";
7.         /// <summary>
8.         /// 获取优盘唯一序列号，可能需要以管理员身份运行程序
9.         /// </summary>
10.         /// <returns></returns>
11.         public static string GetUSBId()
12.         {
13.             ManagementObjectSearcher wmiSearcher = new ManagementObjectSearcher("Select * From Win32_USBHub");
14.             string id = "";
15.             foreach (ManagementObject wmi_USB in wmiSearcher.Get())
16.             {
17.                 string strPath = wmi_USB.Path.RelativePath;
18.                 string[] strArr = strPath.Split('/"');
19.                 string strTemp = strArr[1];
20.                 //VID_ 是真正的优盘标示
21.                 if (strTemp.StartsWith("USBVID_"))
22.                     id += strTemp + ";";
24.             }
25.             return id.TrimEnd(';');
26.         }
28.         /// <summary>
29.         /// 获取当前UsbKey，根据当前附加的序列号，生成 "序列号,UsbId"格式的字符串，并返回加密后的结果
30.         /// 如果没有找到设备，那么返回空字符串
31.         /// 如果返回值为空，请检查 message 的值。
32.         /// </summary>
33.         /// <param name="sourceNumber">要附加的序列号</param>
34.         /// <param name="message">生成的操作信息</param>
35.         /// <returns>当前加密后的UsbKey字符串</returns>
36.         public static string  GetCurrentUsbKey(string sourceNumber,out string message)
37.         {
38.             string strUsbId = GetUSBId();
39.             if (strUsbId != "")
40.             {
41.                 if (strUsbId.Split(';').Length == 1)
42.                 {
43.                     CheckCode cc = new CheckCode();
44.                     message = "OK";
45.                     string strTemp = sourceNumber+","+strUsbId ;
46.                     return cc.Encode(strTemp);
47.                 }
48.                 else
49.                 {
50.                     message = "当前有多个U盘，请拨除其它U盘。";
51.                     return "";
52.                 }
53.                 
54.             }
55.             message = "未找到U盘或者U盘没有物理序列号。";
56.             return "";
57.         }
59.         /// <summary>
60.         /// 将一个新的UsbKey写到当前U盘上
61.         /// </summary>
62.         /// <param name="sourceNumber">U盘所在盘符</param>
63.         /// <param name="sourceNumber">要附加的序列号</param>
64.         /// <param name="message">生成的操作信息</param>
65.         /// <returns></returns>
66.         public static bool WriteUsbKeyFile(string driveName, string sourceNumber,out string message)
67.         {
68.            string strCurrentUsbKey = GetCurrentUsbKey(sourceNumber, out message);
69.            if (strCurrentUsbKey != "")
70.            {
71.                if (driveName.EndsWith("//"))
72.                    driveName += "//";
73.                string strCurrKeyFileName = driveName + Key_File_Name;
74.                try
75.                {
76.                    using (StreamWriter writer = File.CreateText(strCurrKeyFileName))
77.                    {
78.                        writer.Write(strCurrentUsbKey);
79.                        writer.Flush();
80.                    }
81.                    message = "OK";
82.                    return true;
83.                }
84.                catch (Exception ex)
85.                {
86.                    message = ex.Message;
87.                }
88.            }
89.            return false;
90.         }
92.         /// <summary>
93.         /// 读取UsbKey文件的内容，返回内容格式为 "序列号,UsbId"格式的字符串
94.         /// 如果未能正确读取文件，返回空字符。
95.         /// </summary>
96.         /// <param name="driveName">U盘所在盘符</param>
97.         /// <param name="message">操作的消息</param>
98.         /// <returns>UsbKey文件的内容</returns>
99.         public static string  ReadUsbKeyFile(string driveName, out string message)
100.         {
101.             if (driveName.EndsWith("//"))
102.                 driveName += "//";
103.             string strCurrKeyFileName = driveName + Key_File_Name;
104.             message = "";
105.             try
106.             {
107.                 string strResult = "";
108.                 using (StreamReader reader = File.OpenText(strCurrKeyFileName))
109.                 {
110.                     strResult = reader.ReadToEnd();
111.                 }
112.                 if (strResult != "")
113.                 {
114.                     message = "OK";
115.                     CheckCode cc = new CheckCode();
116.                     return cc.Decode(strResult);
117.                 }
118.                 else
119.                 {
120.                     message = "未能正确读取文件，文件内容可能为空！";
121.                 }
122.                
123.             }
124.             catch (Exception ex)
125.             {
126.                 message = ex.Message;
127.             }
128.             return "";
129.         }
130.     }
134.     /// <summary>
135.     /// 检查编码情况
136.     /// </summary>
137.     class CheckCode
138.     {
139.         const string KEY_64 = "fasfgew";
140.         const string IV_64 = "JDLJMAMI"; //注意了，是8个字符，64位 
142.         /// <summary>
143.         /// 加密
144.         /// </summary>
145.         /// <param name="data"></param>
146.         /// <returns></returns>
147.         public string Encode(string data)
148.         {
149.             byte[] byKey = System.Text.ASCIIEncoding.ASCII.GetBytes(KEY_64);
150.             byte[] byIV = System.Text.ASCIIEncoding.ASCII.GetBytes(IV_64);
152.             DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
153.             int i = cryptoProvider.KeySize;
154.             MemoryStream ms = new MemoryStream();
155.             CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateEncryptor(byKey, byIV), CryptoStreamMode.Write);
157.             StreamWriter sw = new StreamWriter(cst);
158.             sw.Write(data);
159.             sw.Flush();
160.             cst.FlushFinalBlock();
161.             sw.Flush();
162.             return Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
164.         }
166.         /// <summary>
167.         /// 解密
168.         /// </summary>
169.         /// <param name="data"></param>
170.         /// <returns></returns>
171.         public string Decode(string data)
172.         {
173.             byte[] byKey = System.Text.ASCIIEncoding.ASCII.GetBytes(KEY_64);
174.             byte[] byIV = System.Text.ASCIIEncoding.ASCII.GetBytes(IV_64);
176.             byte[] byEnc;
177.             try
178.             {
179.                 byEnc = Convert.FromBase64String(data);
180.             }
181.             catch
182.             {
183.                 return null;
184.             }
186.             DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
187.             MemoryStream ms = new MemoryStream(byEnc);
188.             CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateDecryptor(byKey, byIV), CryptoStreamMode.Read);
189.             StreamReader sr = new StreamReader(cst);
190.             return sr.ReadToEnd();
191.         }
195.     }

在主窗体，使用下面的代码调用：

1. private void btnMakeUsbKey_Click(object sender, EventArgs e)
2.         {
3.             string strMessage = "";
5.             MakeProductNumbers();
6.             if (UsbUtility.WriteUsbKeyFile(CurrentUSBDriveName, ProductNumbers, out strMessage))
7.             {
8.                 MessageBox.Show("Usb Key File 生成成功！");
9.             }
10.             else
11.             {
12.                 MessageBox.Show(strMessage);
13.             }
14.         }
16.         private void btnShowUsbKey_Click(object sender, EventArgs e)
17.         {
18.             string strMessage = "";
20.             string strText = UsbUtility.ReadUsbKeyFile(CurrentUSBDriveName, out strMessage);
21.             if (strText!="")
22.             {
23.                 MessageBox.Show(strText,"查看ＵＳＢＫＥＹ");
24.             }
25.             else
26.             {
27.                 MessageBox.Show(strMessage,"Error");
28.             }
29.         }
31.         private string _CurrentUSBDriveName = "";
33.         /// <summary>
34.         /// 当前USB 驱动器号
35.         /// </summary>
36.         public string CurrentUSBDriveName
37.         {
38.             get
39.             {
40.                 if (_CurrentUSBDriveName == "")
41.                 {
42.                     string[] strDrivers = Environment.GetLogicalDrives();
43.                     _CurrentUSBDriveName = strDrivers[strDrivers.Length - 1];
44.                 }
45.                 return _CurrentUSBDriveName;
46.             }
47.             set
48.             {
49.                 _CurrentUSBDriveName = value ;
50.             }
51.         }

属性 CurrentUSBDriveName 会返回当前最后一个驱动器号，我们认为它是优盘，但是这不是很保险。为此，我们需要监视系统合适插入了U盘，并取得它的盘符。

在主窗体中（一定要在主窗体中，不能再用户控件中），加入下面的代码：

1. public const int WM_DEVICECHANGE = 0x219;
2.         public const int DBT_DEVICEARRIVAL = 0x8000;
3.         public const int DBT_CONFIGCHANGECANCELED = 0x0019;
4.         public const int DBT_CONFIGCHANGED = 0x0018;
5.         public const int DBT_CUSTOMEVENT = 0x8006;
6.         public const int DBT_DEVICEQUERYREMOVE = 0x8001;
7.         public const int DBT_DEVICEQUERYREMOVEFAILED = 0x8002;
8.         public const int DBT_DEVICEREMOVECOMPLETE = 0x8004;
9.         public const int DBT_DEVICEREMOVEPENDING = 0x8003;
10.         public const int DBT_DEVICETYPESPECIFIC = 0x8005;
11.         public const int DBT_DEVNODES_CHANGED = 0x0007;
12.         public const int DBT_QUERYCHANGECONFIG = 0x0017;
13.         public const int DBT_USERDEFINED = 0xFFFF;
17.         protected override void WndProc(ref Message m)
18.         {
19.             try
20.             {
21.                 if (m.Msg == WM_DEVICECHANGE)
22.                 {
23.                     switch (m.WParam.ToInt32())
24.                     {
25.                         case WM_DEVICECHANGE:
26.                             break;
27.                         case DBT_DEVICEARRIVAL://U盘插入
28.                             DriveInfo[] s = DriveInfo.GetDrives();
29.                             foreach (DriveInfo drive in s)
30.                             {
31.                                 if (drive.DriveType == DriveType.Removable)
32.                                 {
33.                                     mpnUC.CurrentUSBDriveName  = drive.Name.ToString();
34.                                     //
35.                                     MessageBox.Show("U盘已插入，盘符为:" + drive.Name.ToString() + "/r/n");
37.                                     break;
38.                                 }
39.                             }
40.                             break;
41.                         case DBT_CONFIGCHANGECANCELED:
42.                             break;
43.                         case DBT_CONFIGCHANGED:
44.                             break;
45.                         case DBT_CUSTOMEVENT:
46.                             break;
47.                         case DBT_DEVICEQUERYREMOVE:
48.                             break;
49.                         case DBT_DEVICEQUERYREMOVEFAILED:
50.                             break;
51.                         case DBT_DEVICEREMOVECOMPLETE: //U盘卸载
52.                             MessageBox.Show("U盘已卸载！");
53.                             break;
54.                         case DBT_DEVICEREMOVEPENDING:
55.                             break;
56.                         case DBT_DEVICETYPESPECIFIC:
57.                             break;
58.                         case DBT_DEVNODES_CHANGED:
59.                             break;
60.                         case DBT_QUERYCHANGECONFIG:
61.                             break;
62.                         case DBT_USERDEFINED:
63.                             break;
64.                         default:
65.                             break;
66.                     }
67.                 }
68.             }
69.             catch (Exception ex)
70.             {
71.                 MessageBox.Show(ex.Message);
72.             }
73.             base.WndProc(ref m);
74.         }

mpnUC 是一个用户控件，我们设置了它的  CurrentUSBDriveName  属性。

OK，允许程序，我们就生成了一个USB Key 了。