.NET获取硬盘序列号的几个方法

最近作软件注册，收集了很多.NET相关的获取硬盘物理序列号的方法，主要分为使用WMI方式和API方式。但这些方法均可能有问题。

1，使用WMI方式，有的机器根本取不到硬盘序列号，有的方式在Vista下面会报错。

常用的使用WMI的方式主要有下面一些方式：

  1. class HardDrive
  2.     {
  3.         private string model = null;
  4.         private string type = null;
  5.         private string serialNo = null;
  7.         public string Model
  8.         {
  9.             get {return model;}
  10.             set {model = value;}
  11.         }
  13.         public string Type
  14.         {
  15.             get {return type;}
  16.             set {type = value;}
  17.         }
  19.         public string SerialNo
  20.         {
  21.             get {return serialNo;}
  22.             set {serialNo = value;}
  23.         }
  24.     }
  26.     class TestProgram
  27.     {
  28.         /// <summary>
  29.         /// The main entry point for the application.
  30.         /// </summary>
  31.         [STAThread]
  32.         static void Main(string[] args)
  33.         {
  34.             //在Vista下面失败
  35.             ArrayList hdCollection = new ArrayList();
  37.             ManagementObjectSearcher searcher = new
  38.                 ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive");
  40.             foreach(ManagementObject wmi_HD in searcher.Get())
  41.             {
  42.                 HardDrive hd = new HardDrive();
  43.                 hd.Model    = wmi_HD["Model"].ToString();
  44.                 hd.Type     = wmi_HD["InterfaceType"].ToString();
  46.                 hdCollection.Add(hd);
  47.             }
  49.             searcher = new
  50.                 ManagementObjectSearcher("SELECT * FROM Win32_PhysicalMedia");
  52.             int i = 0;
  53.             foreach(ManagementObject wmi_HD in searcher.Get())
  54.             {
  55.                 // get the hard drive from collection
  56.                 // using index
  57.                 HardDrive hd = (HardDrive)hdCollection[i];
  59.                 // get the hardware serial no.
  60.                 if (wmi_HD["SerialNumber"] == null)
  61.                     hd.SerialNo = "None";
  62.                 else
  63.                     hd.SerialNo = wmi_HD["SerialNumber"].ToString();
  65.                 ++i;
  66.             }
  68.             // Display available hard drives
  69.             foreach(HardDrive hd in hdCollection)
  70.             {
  71.                 Console.WriteLine("Model/t/t: " + hd.Model);
  72.                 Console.WriteLine("Type/t/t: " + hd.Type);
  73.                 Console.WriteLine("Serial No./t: " + hd.SerialNo);
  74.                 Console.WriteLine();
  75.             }
  77.             // Pause application
  78.             Console.WriteLine("Press [Enter] to exit...");
  79.             Console.ReadLine();
  80.         }
  81.     }

 上面的方式先查询Win32_DiskDrive，然后再查询 Win32_PhysicalMedia，经过测试，这种方式不能保证在所有机器上均取得硬盘序列号，而且在Vista下面还会出错，程序直接抛出无法处理的异常。

 

另外，还可以使用另外一WMI方式，就是查询 PNPDeviceID 的 signature，代码如下：

  1. /// <summary>
  2.        /// 获取硬盘唯一序列号（不是卷标号），可能需要以管理员身份运行程序
  3.        /// </summary>
  4.        /// <returns></returns>
  5.         public static string GetHdId()
  6.         {
  7.             ManagementObjectSearcher wmiSearcher = new ManagementObjectSearcher();
  8.             /*
  9.              * PNPDeviceID   的数据是由四部分组成的：   
  10.   1、接口，通常有   IDE，ATA，SCSI；   
  11.   2、型号   
  12.   3、（可能）驱动版本号   
  13.   4、（可能）硬盘的出厂序列号   
  14.              * 
  15.              * 
  16.              */
  19.             //signature 需要程序以管理员身份运行（经过测试，2003系统上非管理员身份也可以运行，查相关资料说，可能在2000系统上获取的值为空）
  21.             wmiSearcher.Query = new SelectQuery(
  22.             "Win32_DiskDrive",
  23.             "",
  24.             new string[] { "PNPDeviceID", "signature" }
  25.             );
  26.             ManagementObjectCollection myCollection = wmiSearcher.Get();
  27.             ManagementObjectCollection.ManagementObjectEnumerator em =
  28.             myCollection.GetEnumerator();
  29.             em.MoveNext();
  30.             ManagementBaseObject mo = em.Current;
  31.             //string id = mo.Properties["PNPDeviceID"].Value.ToString().Trim();
  32.             string id = mo.Properties["signature"].Value.ToString().Trim();
  33.             return id;
  34.         }

 

有人说，使用 signature 需要程序以管理员身份运行（经过测试，2003系统上非管理员身份也可以运行），而且查询相关资料说，可能在2000系统上获取的值为空。

使用这种方式，在Vista上面工作良好。

经过测试，使用 signature  均能够取得硬盘序列号，但是跟 Win32_PhysicalMedia 查询出来的号不一样。目前我也不能肯定 使用 signature  能够100%取道硬盘序列号。

 

使用WMI方式需要客户机开启WMI服务，但这个往往不能保证，所以使用这种方式有一定局限性。

 

2，使用API方式。

在网上找到一片资料，说使用 RING3调用 API DeviceIoControl()来获取硬盘信息，下面是原话：

硬盘序列号（Serial Number）不等于卷标号（Volume Name），后者虽然很容易得到，但是格式化分区后就会重写，不可靠。遗憾的是很多朋友往往分不清这一点。

要得到硬盘的物理序列号，可以通过WMI，也就是Win32_PhysicalMedia.SerialNumber。可惜的是Windows 98/ME的WMI并不支持这个类，访问时会出现异常。

受陆麟的例子的启发，我们还可以通过S.M.A.R.T.接口，直接从RING3调用 API DeviceIoControl()来获取硬盘信息，而不需要写VXD或者DRIVER。这样这个问题就解决了，我对它进行了封装，大量使用了 P/Invoke技术，一个完整的Library。支持Windows 98-2003。

使用上很简单：

HardDiskInfo hdd = AtapiDevice.GetHddInfo(0); // 第一个硬盘
Console.WriteLine("Module Number: {0}", hdd.ModuleNumber);
Console.WriteLine("Serial Number: {0}", hdd.SerialNumber);
Console.WriteLine("Firmware: {0}", hdd.Firmware);
Console.WriteLine("Capacity: {0} M", hdd.Capacity);

 

感谢原文作者的贡献，（在这里我已经不知道原文作者是谁了，网上的文章都是转载的），经过测试，这种方式比较准确，但是需要管理员权限运行。

下面把代码分享：

    1. using System;
    2. using System.Runtime.InteropServices;
    3. using System.Text;
    5. namespace HardwareUtility
    6. {
    7.     [Serializable]
    8.     public struct HardDiskInfo
    9.     {
    10.         /// <summary>
    11.         /// 型号
    12.         /// </summary>
    13.         public string ModuleNumber;
    14.         /// <summary>
    15.         /// 固件版本
    16.         /// </summary>
    17.         public string Firmware;
    18.         /// <summary>
    19.         /// 序列号
    20.         /// </summary>
    21.         public string SerialNumber;
    22.         /// <summary>
    23.         /// 容量，以M为单位
    24.         /// </summary>
    25.         public uint Capacity;
    26.     }
    28.     #region Internal Structs
    30.     [StructLayout(LayoutKind.Sequential, Pack = 1)]
    31.     internal struct GetVersionOutParams
    32.     {
    33.         public byte bVersion;
    34.         public byte bRevision;
    35.         public byte bReserved;
    36.         public byte bIDEDeviceMap;
    37.         public uint fCapabilities;
    38.         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
    39.         public uint[] dwReserved; // For future use.
    40.     }
    42.     [StructLayout(LayoutKind.Sequential, Pack = 1)]
    43.     internal struct IdeRegs
    44.     {
    45.         public byte bFeaturesReg;
    46.         public byte bSectorCountReg;
    47.         public byte bSectorNumberReg;
    48.         public byte bCylLowReg;
    49.         public byte bCylHighReg;
    50.         public byte bDriveHeadReg;
    51.         public byte bCommandReg;
    52.         public byte bReserved;
    53.     }
    55.     [StructLayout(LayoutKind.Sequential, Pack = 1)]
    56.     internal struct SendCmdInParams
    57.     {
    58.         public uint cBufferSize;
    59.         public IdeRegs irDriveRegs;
    60.         public byte bDriveNumber;
    61.         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
    62.         public byte[] bReserved;
    63.         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
    64.         public uint[] dwReserved;
    65.         public byte bBuffer;
    66.     }
    68.     [StructLayout(LayoutKind.Sequential, Pack = 1)]
    69.     internal struct DriverStatus
    70.     {
    71.         public byte bDriverError;
    72.         public byte bIDEStatus;
    73.         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
    74.         public byte[] bReserved;
    75.         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
    76.         public uint[] dwReserved;
    77.     }
    79.     [StructLayout(LayoutKind.Sequential, Pack = 1)]
    80.     internal struct SendCmdOutParams
    81.     {
    82.         public uint cBufferSize;
    83.         public DriverStatus DriverStatus;
    84.         public IdSector bBuffer;
    85.     }
    87.     [StructLayout(LayoutKind.Sequential, Pack = 1, Size = 512)]
    88.     internal struct IdSector
    89.     {
    90.         public ushort wGenConfig;
    91.         public ushort wNumCyls;
    92.         public ushort wReserved;
    93.         public ushort wNumHeads;
    94.         public ushort wBytesPerTrack;
    95.         public ushort wBytesPerSector;
    96.         public ushort wSectorsPerTrack;
    97.         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
    98.         public ushort[] wVendorUnique;
    99.         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)]
    100.         public byte[] sSerialNumber;
    101.         public ushort wBufferType;
    102.         public ushort wBufferSize;
    103.         public ushort wECCSize;
    104.         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
    105.         public byte[] sFirmwareRev;
    106.         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)]
    107.         public byte[] sModelNumber;
    108.         public ushort wMoreVendorUnique;
    109.         public ushort wDoubleWordIO;
    110.         public ushort wCapabilities;
    111.         public ushort wReserved1;
    112.         public ushort wPIOTiming;
    113.         public ushort wDMATiming;
    114.         public ushort wBS;
    115.         public ushort wNumCurrentCyls;
    116.         public ushort wNumCurrentHeads;
    117.         public ushort wNumCurrentSectorsPerTrack;
    118.         public uint ulCurrentSectorCapacity;
    119.         public ushort wMultSectorStuff;
    120.         public uint ulTotalAddressableSectors;
    121.         public ushort wSingleWordDMA;
    122.         public ushort wMultiWordDMA;
    123.         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)]
    124.         public byte[] bReserved;
    125.     }
    127.     #endregion
    129.     /// <summary>
    130.     /// ATAPI驱动器相关
    131.     /// </summary>
    132.     public class AtapiDevice
    133.     {
    135.         #region DllImport
    137.         [DllImport("kernel32.dll", SetLastError = true)]
    138.         static extern int CloseHandle(IntPtr hObject);
    140.         [DllImport("kernel32.dll", SetLastError = true)]
    141.         static extern IntPtr CreateFile(
    142.             string lpFileName,
    143.             uint dwDesiredAccess,
    144.             uint dwShareMode,
    145.             IntPtr lpSecurityAttributes,
    146.             uint dwCreationDisposition,
    147.             uint dwFlagsAndAttributes,
    148.             IntPtr hTemplateFile);
    150.         [DllImport("kernel32.dll")]
    151.         static extern int DeviceIoControl(
    152.             IntPtr hDevice,
    153.             uint dwIoControlCode,
    154.             IntPtr lpInBuffer,
    155.             uint nInBufferSize,
    156.             ref GetVersionOutParams lpOutBuffer,
    157.             uint nOutBufferSize,
    158.             ref uint lpBytesReturned,
    159.             [Out] IntPtr lpOverlapped);
    161.         [DllImport("kernel32.dll")]
    162.         static extern int DeviceIoControl(
    163.             IntPtr hDevice,
    164.             uint dwIoControlCode,
    165.             ref SendCmdInParams lpInBuffer,
    166.             uint nInBufferSize,
    167.             ref SendCmdOutParams lpOutBuffer,
    168.             uint nOutBufferSize,
    169.             ref uint lpBytesReturned,
    170.             [Out] IntPtr lpOverlapped);
    172.         const uint DFP_GET_VERSION = 0x00074080;
    173.         const uint DFP_SEND_DRIVE_COMMAND = 0x0007c084;
    174.         const uint DFP_RECEIVE_DRIVE_DATA = 0x0007c088;
    176.         const uint GENERIC_READ = 0x80000000;
    177.         const uint GENERIC_WRITE = 0x40000000;
    178.         const uint FILE_SHARE_READ = 0x00000001;
    179.         const uint FILE_SHARE_WRITE = 0x00000002;
    180.         const uint CREATE_NEW = 1;
    181.         const uint OPEN_EXISTING = 3;
    183.         #endregion
    185.         #region GetHddInfo
    187.         /// <summary>
    188.         /// 获得硬盘信息
    189.         /// </summary>
    190.         /// <param name="driveIndex">硬盘序号</param>
    191.         /// <returns>硬盘信息</returns>
    192.         /// <remarks>
    193.         /// 参考lu0的文章：http://lu0s1.3322.org/App/2k1103.html
    194.         /// by sunmast for everyone
    195.         /// thanks lu0 for his great works
    196.         /// 在Windows 98/ME中，S.M.A.R.T并不缺省安装，请将SMARTVSD.VXD拷贝到%SYSTEM%/IOSUBSYS目录下。
    197.         /// 在Windows 2000/2003下，需要Administrators组的权限。
    198.         /// </remarks>
    199.         /// <example>
    200.         /// AtapiDevice.GetHddInfo()
    201.         /// </example>
    202.         public static HardDiskInfo GetHddInfo(byte driveIndex)
    203.         {
    204.             switch (Environment.OSVersion.Platform)
    205.             {
    206.                 case PlatformID.Win32Windows:
    207.                     return GetHddInfo9x(driveIndex);
    208.                 case PlatformID.Win32NT:
    209.                     return GetHddInfoNT(driveIndex);
    210.                 case PlatformID.Win32S:
    211.                     throw new NotSupportedException("Win32s is not supported.");
    212.                 case PlatformID.WinCE:
    213.                     throw new NotSupportedException("WinCE is not supported.");
    214.                 default:
    215.                     throw new NotSupportedException("Unknown Platform.");
    216.             }
    217.         }
    219.         #region GetHddInfo9x
    221.         private static HardDiskInfo GetHddInfo9x(byte driveIndex)
    222.         {
    223.             GetVersionOutParams vers = new GetVersionOutParams();
    224.             SendCmdInParams inParam = new SendCmdInParams();
    225.             SendCmdOutParams outParam = new SendCmdOutParams();
    226.             uint bytesReturned = 0;
    228.             IntPtr hDevice = CreateFile(
    229.                 @"//./Smartvsd",
    230.                 0,
    231.                 0,
    232.                 IntPtr.Zero,
    233.                 CREATE_NEW,
    234.                 0,
    235.                 IntPtr.Zero);
    236.             if (hDevice == IntPtr.Zero)
    237.             {
    238.                 throw new Exception("Open smartvsd.vxd failed.");
    239.             }
    240.             if (0 == DeviceIoControl(
    241.                 hDevice,
    242.                 DFP_GET_VERSION,
    243.                 IntPtr.Zero,
    244.                 0,
    245.                 ref vers,
    246.                 (uint)Marshal.SizeOf(vers),
    247.                 ref bytesReturned,
    248.                 IntPtr.Zero))
    249.             {
    250.                 CloseHandle(hDevice);
    251.                 throw new Exception("DeviceIoControl failed:DFP_GET_VERSION");
    252.             }
    253.             // If IDE identify command not supported, fails
    254.             if (0 == (vers.fCapabilities & 1))
    255.             {
    256.                 CloseHandle(hDevice);
    257.                 throw new Exception("Error: IDE identify command not supported.");
    258.             }
    259.             if (0 != (driveIndex & 1))
    260.             {
    261.                 inParam.irDriveRegs.bDriveHeadReg = 0xb0;
    262.             }
    263.             else
    264.             {
    265.                 inParam.irDriveRegs.bDriveHeadReg = 0xa0;
    266.             }
    267.             if (0 != (vers.fCapabilities & (16 >> driveIndex)))
    268.             {
    269.                 // We don't detect a ATAPI device.
    270.                 CloseHandle(hDevice);
    271.                 throw new Exception(string.Format("Drive {0} is a ATAPI device, we don't detect it", driveIndex + 1));
    272.             }
    273.             else
    274.             {
    275.                 inParam.irDriveRegs.bCommandReg = 0xec;
    276.             }
    277.             inParam.bDriveNumber = driveIndex;
    278.             inParam.irDriveRegs.bSectorCountReg = 1;
    279.             inParam.irDriveRegs.bSectorNumberReg = 1;
    280.             inParam.cBufferSize = 512;
    281.             if (0 == DeviceIoControl(
    282.                 hDevice,
    283.                 DFP_RECEIVE_DRIVE_DATA,
    284.                 ref inParam,
    285.                 (uint)Marshal.SizeOf(inParam),
    286.                 ref outParam,
    287.                 (uint)Marshal.SizeOf(outParam),
    288.                 ref bytesReturned,
    289.                 IntPtr.Zero))
    290.             {
    291.                 CloseHandle(hDevice);
    292.                 throw new Exception("DeviceIoControl failed: DFP_RECEIVE_DRIVE_DATA");
    293.             }
    294.             CloseHandle(hDevice);
    296.             return GetHardDiskInfo(outParam.bBuffer);
    297.         }
    299.         #endregion
    301.         #region GetHddInfoNT
    303.         private static HardDiskInfo GetHddInfoNT(byte driveIndex)
    304.         {
    305.             GetVersionOutParams vers = new GetVersionOutParams();
    306.             SendCmdInParams inParam = new SendCmdInParams();
    307.             SendCmdOutParams outParam = new SendCmdOutParams();
    308.             uint bytesReturned = 0;
    310.             // We start in NT/Win2000
    311.             IntPtr hDevice = CreateFile(
    312.                 string.Format(@"//./PhysicalDrive{0}", driveIndex),
    313.                 GENERIC_READ | GENERIC_WRITE,
    314.                 FILE_SHARE_READ | FILE_SHARE_WRITE,
    315.                 IntPtr.Zero,
    316.                 OPEN_EXISTING,
    317.                 0,
    318.                 IntPtr.Zero);
    319.             if (hDevice == IntPtr.Zero)
    320.             {
    321.                 throw new Exception("CreateFile faild.");
    322.             }
    323.             if (0 == DeviceIoControl(
    324.                 hDevice,
    325.                 DFP_GET_VERSION,
    326.                 IntPtr.Zero,
    327.                 0,
    328.                 ref vers,
    329.                 (uint)Marshal.SizeOf(vers),
    330.                 ref bytesReturned,
    331.                 IntPtr.Zero))
    332.             {
    333.                 CloseHandle(hDevice);
    334.                 throw new Exception(string.Format("Drive {0} may not exists.", driveIndex + 1));
    335.             }
    336.             // If IDE identify command not supported, fails
    337.             if (0 == (vers.fCapabilities & 1))
    338.             {
    339.                 CloseHandle(hDevice);
    340.                 throw new Exception("Error: IDE identify command not supported.");
    341.             }
    342.             // Identify the IDE drives
    343.             if (0 != (driveIndex & 1))
    344.             {
    345.                 inParam.irDriveRegs.bDriveHeadReg = 0xb0;
    346.             }
    347.             else
    348.             {
    349.                 inParam.irDriveRegs.bDriveHeadReg = 0xa0;
    350.             }
    351.             if (0 != (vers.fCapabilities & (16 >> driveIndex)))
    352.             {
    353.                 // We don't detect a ATAPI device.
    354.                 CloseHandle(hDevice);
    355.                 throw new Exception(string.Format("Drive {0} is a ATAPI device, we don't detect it.", driveIndex + 1));
    356.             }
    357.             else
    358.             {
    359.                 inParam.irDriveRegs.bCommandReg = 0xec;
    360.             }
    361.             inParam.bDriveNumber = driveIndex;
    362.             inParam.irDriveRegs.bSectorCountReg = 1;
    363.             inParam.irDriveRegs.bSectorNumberReg = 1;
    364.             inParam.cBufferSize = 512;
    366.             if (0 == DeviceIoControl(
    367.                 hDevice,
    368.                 DFP_RECEIVE_DRIVE_DATA,
    369.                 ref inParam,
    370.                 (uint)Marshal.SizeOf(inParam),
    371.                 ref outParam,
    372.                 (uint)Marshal.SizeOf(outParam),
    373.                 ref bytesReturned,
    374.                 IntPtr.Zero))
    375.             {
    376.                 CloseHandle(hDevice);
    377.                 throw new Exception("DeviceIoControl failed: DFP_RECEIVE_DRIVE_DATA");
    378.             }
    379.             CloseHandle(hDevice);
    381.             return GetHardDiskInfo(outParam.bBuffer);
    382.         }
    384.         #endregion
    386.         private static HardDiskInfo GetHardDiskInfo(IdSector phdinfo)
    387.         {
    388.             HardDiskInfo hddInfo = new HardDiskInfo();
    390.             ChangeByteOrder(phdinfo.sModelNumber);
    391.             hddInfo.ModuleNumber = Encoding.ASCII.GetString(phdinfo.sModelNumber).Trim();
    393.             ChangeByteOrder(phdinfo.sFirmwareRev);
    394.             hddInfo.Firmware = Encoding.ASCII.GetString(phdinfo.sFirmwareRev).Trim();
    396.             ChangeByteOrder(phdinfo.sSerialNumber);
    397.             hddInfo.SerialNumber = Encoding.ASCII.GetString(phdinfo.sSerialNumber).Trim();
    399.             hddInfo.Capacity = phdinfo.ulTotalAddressableSectors / 2 / 1024;
    401.             return hddInfo;
    402.         }
    404.         private static void ChangeByteOrder(byte[] charArray)
    405.         {
    406.             byte temp;
    407.             for (int i = 0; i < charArray.Length; i += 2)
    408.             {
    409.                 temp = charArray[i];
    410.                 charArray[i] = charArray[i + 1];
    411.                 charArray[i + 1] = temp;
    412.             }
    413.         }
    415.         #endregion
    416.     }
    417. }

posted on 2013-06-02 23:35  Sandy Lee  阅读(865)  评论(0)  编辑  收藏  举报

导航