windows平台下获取网卡MAC地址、硬盘序列号、主板序列号、CPU ID、BIOS序列号

转自http://blog.csdn.net/jhqin/article/details/5548656，如有侵权，请联系本人删除，谢谢！！

头文件：WMI_DeviceQuery.h

/* ----------------------------------------------------------
文件名称：WMI_DeviceQuery.h

作者：秦建辉 

MSN：[e-mail] 

版本历史：
    V1.4    2010年05月17日
            修正了硬盘序列号处理中的错误。现在和EVEREST Ultimate Edition 5.5一致。 

    V1.3    2010年05月11日
            增加了对网卡原生MAC地址的查询。 

    V1.2    2010年05月05日
            增加对硬盘序列号的进一步处理。 

    V1.1    2010年04月30日
            修正微软MSDN例子错误，并增加对虚拟机网卡的判断。 

    V1.0    2010年04月27日
            完成正式版本。 

功能描述：
    基于WMI获取设备属性：
        0：网卡原生MAC地址
        1：硬盘序列号
        2：主板序列号
        3：CPU ID
        4：BIOS序列号
        5：主板型号
        6：网卡当前MAC地址 

接口函数：
    WMI_DeviceQuery
------------------------------------------------------------ */
#pragma once  

#include <windows.h>  

#ifndef MACRO_T_DEVICE_PROPERTY
    #define MACRO_T_DEVICE_PROPERTY  

    #define PROPERTY_MAX_LEN    128 // 属性字段最大长度
    typedef struct _T_DEVICE_PROPERTY
    {
        TCHAR szProperty[PROPERTY_MAX_LEN];
    } T_DEVICE_PROPERTY;
#endif  

#define WMI_QUERY_TYPENUM   7   // WMI查询支持的类型数  

#ifdef __cplusplus
extern "C"
{
#endif  

/*
功能：通过WMI获取设备属性
参数说明：
    iQueryType：需要查询的设备属性
            0：网卡原生MAC地址
            1：硬盘序列号
            2：主板序列号
            3：CPU ID
            4：BIOS序列号
            5：主板型号
            6：网卡当前MAC地址
    properties：存储设备属性值
    iSize：可存储的最大设备个数
返回值：
     -1：不支持的设备属性值
     -2：WMI连接失败
     -3：不正确的WQL查询语句
    >=0：获取的设备个数
*/
INT WMI_DeviceQuery( INT iQueryType, T_DEVICE_PROPERTY *properties, INT iSize );  

#ifdef __cplusplus
}
#endif

实现文件：WMI_DeviceQuery.cpp

#include "WMI_DeviceQuery.h"
#include <comutil.h>
#include <Wbemidl.h>
#include <tchar.h>
#include <strsafe.h>
#include <algorithm>
#include <atlconv.h>
#include <ntddndis.h>  

#pragma comment (lib, "comsuppw.lib")
#pragma comment (lib, "wbemuuid.lib")  

typedef struct _T_WQL_QUERY
{
    CHAR*   szSelect;       // SELECT语句
    WCHAR*  szProperty;     // 属性字段
} T_WQL_QUERY;  

// WQL查询语句
const T_WQL_QUERY szWQLQuery[] = {
    // 网卡原生MAC地址
    "SELECT * FROM Win32_NetworkAdapter WHERE (MACAddress IS NOT NULL) AND (NOT (PNPDeviceID LIKE 'ROOT%'))",
    L"PNPDeviceID",  

    // 硬盘序列号
    "SELECT * FROM Win32_DiskDrive WHERE (SerialNumber IS NOT NULL) AND (MediaType LIKE 'Fixed hard disk%')",
    L"SerialNumber",  

    // 主板序列号
    "SELECT * FROM Win32_BaseBoard WHERE (SerialNumber IS NOT NULL)",
    L"SerialNumber",      

    // 处理器ID
    "SELECT * FROM Win32_Processor WHERE (ProcessorId IS NOT NULL)",
    L"ProcessorId",  

    // BIOS序列号
    "SELECT * FROM Win32_BIOS WHERE (SerialNumber IS NOT NULL)",
    L"SerialNumber",  

    // 主板型号
    "SELECT * FROM Win32_BaseBoard WHERE (Product IS NOT NULL)",
    L"Product",  

    // 网卡当前MAC地址
    "SELECT * FROM Win32_NetworkAdapter WHERE (MACAddress IS NOT NULL) AND (NOT (PNPDeviceID LIKE 'ROOT%'))",
    L"MACAddress",
};  

// 通过“PNPDeviceID”获取网卡原生MAC地址
static BOOL WMI_DoWithPNPDeviceID( const TCHAR *PNPDeviceID, TCHAR *MacAddress, UINT uSize )
{
    TCHAR   DevicePath[MAX_PATH];
    HANDLE  hDeviceFile;
    BOOL    isOK = FALSE;  

    // 生成设备路径名
    StringCchCopy( DevicePath, MAX_PATH, TEXT("////.//") );
    StringCchCat( DevicePath, MAX_PATH, PNPDeviceID );
    StringCchCat( DevicePath, MAX_PATH, TEXT("#{ad498944-762f-11d0-8dcb-00c04fc3358c}") );  

    // 将“PNPDeviceID”中的“/”替换成“#”，以获得真正的设备路径名
    std::replace( DevicePath + 4, DevicePath + 4 + _tcslen(PNPDeviceID), TEXT('//'), TEXT('#') );   

    // 获取设备句柄
    hDeviceFile = CreateFile( DevicePath,
        0,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        NULL,
        OPEN_EXISTING,
        0,
        NULL);  

    if( hDeviceFile != INVALID_HANDLE_VALUE )
    {
        ULONG   dwID;
        BYTE    ucData[8];
        DWORD   dwByteRet;        

        // 获取网卡原生MAC地址
        dwID = OID_802_3_PERMANENT_ADDRESS;
        isOK = DeviceIoControl( hDeviceFile, IOCTL_NDIS_QUERY_GLOBAL_STATS, &dwID, sizeof(dwID), ucData, sizeof(ucData), &dwByteRet, NULL );
        if( isOK )
        {   // 将字节数组转换成16进制字符串
            for( DWORD i = 0; i < dwByteRet; i++ )
            {
                StringCchPrintf( MacAddress + (i << 1), uSize - (i << 1), TEXT("%02X"), ucData[i] );
            }  

            MacAddress[dwByteRet << 1] = TEXT('/0');  // 写入字符串结束标记
        }  

        CloseHandle( hDeviceFile );
    }  

    return isOK;
}  

static BOOL WMI_DoWithHarddiskSerialNumber( TCHAR *SerialNumber, UINT uSize )
{
    UINT    iLen;
    UINT    i;  

    iLen = _tcslen( SerialNumber );
    if( iLen == 40 )    // InterfaceType = "IDE"
    {   // 需要将16进制编码串转换为字符串
        TCHAR ch, szBuf[32];
        BYTE b;       

        for( i = 0; i < 20; i++ )
        {   // 将16进制字符转换为高4位
            ch = SerialNumber[i * 2];
            if( (ch >= '0') && (ch <= '9') )
            {
                b = ch - '0';
            }
            else if( (ch >= 'A') && (ch <= 'F') )
            {
                b = ch - 'A' + 10;
            }
            else if( (ch >= 'a') && (ch <= 'f') )
            {
                b = ch - 'a' + 10;
            }
            else
            {   // 非法字符
                break;
            }  

            b <<= 4;  

            // 将16进制字符转换为低4位
            ch = SerialNumber[i * 2 + 1];
            if( (ch >= '0') && (ch <= '9') )
            {
                b += ch - '0';
            }
            else if( (ch >= 'A') && (ch <= 'F') )
            {
                b += ch - 'A' + 10;
            }
            else if( (ch >= 'a') && (ch <= 'f') )
            {
                b += ch - 'a' + 10;
            }
            else
            {   // 非法字符
                break;
            }  

            szBuf[i] = b;
        }  

        if( i == 20 )
        {   // 转换成功
            szBuf[i] = L'/0';
            StringCchCopy( SerialNumber, uSize, szBuf );
            iLen = _tcslen( SerialNumber );
        }
    }  

    // 每2个字符互换位置
    for( i = 0; i < iLen; i += 2 )
    {
        std::swap( SerialNumber[i], SerialNumber[i+1] );
    }  

    // 去掉空格
    std::remove( SerialNumber, SerialNumber + _tcslen(SerialNumber) + 1, L' ' );  

    return TRUE;
}  

static BOOL WMI_DoWithProperty( INT iQueryType, TCHAR *szProperty, UINT uSize )
{
    BOOL isOK = TRUE;  

    switch( iQueryType )
    {
    case 0:     // 网卡原生MAC地址
        isOK = WMI_DoWithPNPDeviceID( szProperty, szProperty, uSize );
        break;  

    case 1:     // 硬盘序列号
        isOK = WMI_DoWithHarddiskSerialNumber( szProperty, uSize );
        break;  

    case 6:     // 网卡当前MAC地址
        // 去掉冒号
        std::remove( szProperty, szProperty + _tcslen(szProperty) + 1, L':' );
        break;  

    default:
        // 去掉空格
        std::remove( szProperty, szProperty + _tcslen(szProperty) + 1, L' ' );
    }  

    return isOK;
}  

// 基于Windows Management Instrumentation（Windows管理规范）
INT WMI_DeviceQuery( INT iQueryType, T_DEVICE_PROPERTY *properties, INT iSize )
{
    HRESULT hres;
    INT iTotal = 0;  

    // 判断查询类型是否支持
    if( (iQueryType < 0) || (iQueryType >= sizeof(szWQLQuery)/sizeof(T_WQL_QUERY)) )
    {
        return -1;  // 查询类型不支持
    }  

    // 初始化COM
    hres = CoInitializeEx( NULL, COINIT_MULTITHREADED );
    if( FAILED(hres) )
    {
        return -2;
    }  

    // 设置COM的安全认证级别
    hres = CoInitializeSecurity(
        NULL,
        -1,
        NULL,
        NULL,
        RPC_C_AUTHN_LEVEL_DEFAULT,
        RPC_C_IMP_LEVEL_IMPERSONATE,
        NULL,
        EOAC_NONE,
        NULL
        );
    if( FAILED(hres) )
    {
        CoUninitialize();
        return -2;
    }  

    // 获得WMI连接COM接口
    IWbemLocator *pLoc = NULL;
    hres = CoCreateInstance(
        CLSID_WbemLocator,
        NULL,
        CLSCTX_INPROC_SERVER,
        IID_IWbemLocator,
        reinterpret_cast<LPVOID*>(&pLoc)
        );
    if( FAILED(hres) )
    {
        CoUninitialize();
        return -2;
    }  

    // 通过连接接口连接WMI的内核对象名"ROOT//CIMV2"
    IWbemServices *pSvc = NULL;
    hres = pLoc->ConnectServer(
         _bstr_t( L"ROOT//CIMV2" ),
         NULL,
         NULL,
         NULL,
         0,
         NULL,
         NULL,
         &pSvc
         );
    if( FAILED(hres) )
    {
        pLoc->Release();
        CoUninitialize();
        return -2;
    }  

    // 设置请求代理的安全级别
    hres = CoSetProxyBlanket(
        pSvc,
        RPC_C_AUTHN_WINNT,
        RPC_C_AUTHZ_NONE,
        NULL,
        RPC_C_AUTHN_LEVEL_CALL,
        RPC_C_IMP_LEVEL_IMPERSONATE,
        NULL,
        EOAC_NONE
        );
    if( FAILED(hres) )
    {
        pSvc->Release();
        pLoc->Release();
        CoUninitialize();
        return -2;
    }  

    // 通过请求代理来向WMI发送请求
    IEnumWbemClassObject *pEnumerator = NULL;
    hres = pSvc->ExecQuery(
        bstr_t("WQL"),
        bstr_t( szWQLQuery[iQueryType].szSelect ),
        WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
        NULL,
        &pEnumerator
        );
    if( FAILED(hres) )
    {
        pSvc->Release();
        pLoc->Release();
        CoUninitialize();
        return -3;
    }  

    // 循环枚举所有的结果对象
    while( pEnumerator )
    {
        IWbemClassObject *pclsObj = NULL;
        ULONG uReturn = 0;  

        if( (properties != NULL) && (iTotal >= iSize) )
        {
            break;
        }  

        pEnumerator->Next(
            WBEM_INFINITE,
            1,
            &pclsObj,
            &uReturn
            );  

        if( uReturn == 0 )
        {
            break;
        }  

        if( properties != NULL )
        {   // 获取属性值
            VARIANT vtProperty;  

            VariantInit( &vtProperty );
            pclsObj->Get( szWQLQuery[iQueryType].szProperty, 0, &vtProperty, NULL, NULL );
            StringCchCopy( properties[iTotal].szProperty, PROPERTY_MAX_LEN, W2T(vtProperty.bstrVal) );
            VariantClear( &vtProperty );  

            // 对属性值做进一步的处理
            if( WMI_DoWithProperty( iQueryType, properties[iTotal].szProperty, PROPERTY_MAX_LEN ) )
            {
                iTotal++;
            }
        }
        else
        {
            iTotal++;
        }  

        pclsObj->Release();
    } // End While  

    // 释放资源
    pEnumerator->Release();
    pSvc->Release();
    pLoc->Release();
    CoUninitialize();  

    return iTotal;
}