MFC获取电脑硬盘序列号（附源码）

最新推荐文章于 2024-09-19 09:22:03 发布
最新推荐文章于 2024-09-19 09:22:03 发布
阅读量7.7k 收藏 4
点赞数 4
分类专栏： MFC 文章标签： 硬盘 序列号
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhao_fu_lu/article/details/44243325
版权

在新建的工程里面添加一个类
即：以下一个类
GetHDSerial.cpp

// GetHDSerial.cpp: implementation of the CGetHDSerial class.
// Download by http://www.newxing.com/
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "GetHDSerial.h"


char  m_buffer[256];
WORD  m_serial[256];
DWORD m_OldInterruptAddress;
DWORDLONG m_IDTR;

// 等待硬盘空闲
static unsigned int WaitHardDiskIdle() 
{ 
    BYTE byTemp;

Waiting:
    _asm
    {
        mov dx, 0x1f7
        in al, dx
        cmp al, 0x80
        jb Endwaiting
        jmp Waiting
    }
Endwaiting:
    _asm
    {
        mov byTemp, al
    }
    return byTemp; 
} 

//中断服务程序
void  _declspec( naked )InterruptProcess(void)
{
     int   byTemp;
     int   i;
     WORD temp;
     //保存寄存器值
     _asm
     {
         push eax
         push ebx
         push ecx
         push edx
         push esi
     }

     WaitHardDiskIdle();//等待硬盘空闲状态
     _asm
     {
         mov dx, 0x1f6
         mov al, 0xa0
         out dx, al
     }
     byTemp = WaitHardDiskIdle(); //若直接在Ring3级执行等待命令，会进入死循环
     if ((byTemp&0x50)!=0x50) 
     {
        _asm  // 恢复中断现场并退出中断服务程序
        {
            pop esi
            pop edx
            pop ecx
            pop ebx
            pop eax
            iretd
        }
     }

     _asm
     {
         mov dx, 0x1f6 //命令端口1f6,选择驱动器0
         mov al, 0xa0
         out dx, al
         inc dx
         mov al, 0xec
         out dx, al //发送读驱动器参数命令
     }  
     byTemp = WaitHardDiskIdle(); 
     if ((byTemp&0x58)!=0x58) 
     {
        _asm  // 恢复中断现场并退出中断服务程序
        {
             pop esi
             pop edx
             pop ecx
             pop ebx
             pop eax
             iretd
        }
     }
     //读取硬盘控制器的全部信息
     for (i=0;i<256;i++) 
     {
         _asm
         {
             mov dx, 0x1f0
             in ax, dx
             mov temp, ax
         }
         m_serial[i] = temp; 
     }                                
     _asm
     {
         pop esi
         pop edx
         pop ecx
         pop ebx
         pop eax
         iretd
     }  
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CGetHDSerial::CGetHDSerial()
{

}

CGetHDSerial::~CGetHDSerial()
{

}
// 读取硬盘序列号函数
char* CGetHDSerial::GetHDSerial()
{   
  m_buffer[0]='\n';
  // 得到当前操作系统版本
  OSVERSIONINFO OSVersionInfo;
  OSVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  GetVersionEx( &OSVersionInfo);
  if (OSVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
  {   
      // Windows 9x/ME下读取硬盘序列号
      WORD m_wWin9xHDSerial[256];
      Win9xReadHDSerial(m_wWin9xHDSerial);  
      strcpy (m_buffer, WORDToChar (m_wWin9xHDSerial, 10, 19));
  }
  else
  {
      // Windows NT/2000/XP下读取硬盘序列号
      DWORD m_wWinNTHDSerial[256];  
      // 判断是否有SCSI硬盘
      if ( ! WinNTReadIDEHDSerial(m_wWinNTHDSerial)) 
           WinNTReadSCSIHDSerial(m_wWinNTHDSerial);  
      strcpy (m_buffer, DWORDToChar (m_wWinNTHDSerial, 10, 19));
  } 
  return m_buffer;
}

// Windows9X/ME系统下读取硬盘序列号
void _stdcall CGetHDSerial::Win9xReadHDSerial(WORD * buffer)
{   
    int i;      
    for(i=0;i<256;i++) 
        buffer[i]=0;
    _asm
    {
        push eax        
        //获取修改的中断的中断描述符（中断门）地址
        sidt m_IDTR 
        mov eax,dword ptr [m_IDTR+02h]        
        add eax,3*08h+04h
        cli
        //保存原先的中断入口地址
        push ecx
        mov ecx,dword ptr [eax]
        mov cx,word ptr [eax-04h]
        mov dword ptr m_OldInterruptAddress,ecx
        pop ecx
        //设置修改的中断入口地址为新的中断处理程序入口地址
        push ebx
        lea ebx,InterruptProcess    
        mov word ptr [eax-04h],bx
        shr ebx,10h
        mov word ptr [eax+02h],bx
        pop ebx
        //执行中断，转到Ring 0（类似CIH病毒原理）
        int 3h
        //恢复原先的中断入口地址
        push ecx
        mov ecx,dword ptr m_OldInterruptAddress
        mov word ptr [eax-04h],cx
        shr ecx,10h
        mov word ptr [eax+02h],cx
        pop ecx
        sti
        pop eax
    } 
    for(i=0;i<256;i++)      
        buffer[i]=m_serial[i];
}

// Windows 9x/ME系统下，将字类型（WORD）的硬盘信息转换为字符类型（char）
char * CGetHDSerial::WORDToChar (WORD diskdata [256], int firstIndex, int lastIndex)
{
   static char string [1024];
   int index = 0;
   int position = 0;

   // 按照高字节在前，低字节在后的顺序将字数组diskdata 中内容存入到字符串string中 
   for (index = firstIndex; index <= lastIndex; index++)
   {
      // 存入字中的高字节
      string [position] = (char) (diskdata [index] / 256);
      position++;
      // 存入字中的低字节
      string [position] = (char) (diskdata [index] % 256);
      position++;
   }
   //  添加字符串结束标志
   string [position] = '\0';

   //  删除字符串中空格
   for (index = position - 1; index > 0 && ' ' == string [index]; index--)
      string [index] = '\0';

   return string;
}

// Windows NT/2000/XP系统下，将双字类型（DWORD）的硬盘信息转换为字符类型（char）
char* CGetHDSerial::DWORDToChar (DWORD diskdata [256], int firstIndex, int lastIndex)
{
   static char string [1024];
   int index = 0;
   int position = 0;

   // 按照高字节在前，低字节在后的顺序将双字中的低字存入到字符串string中 
   for (index = firstIndex; index <= lastIndex; index++)
   {
      // 存入低字中的高字节
      string [position] = (char) (diskdata [index] / 256);
      position++;
      // 存入低字中的低字节
      string [position] = (char) (diskdata [index] % 256);
      position++;
   }
   //  添加字符串结束标志
   string [position] = '\0';

   //  删除字符串中空格
   for (index = position - 1; index > 0 && ' ' == string [index]; index--)
      string [index] = '\0';

   return string;
}

// Windows NT/2000/XP下读取IDE硬盘序列号
BOOL CGetHDSerial::WinNTReadIDEHDSerial(DWORD * buffer)
{
   BYTE IdOutCmd [sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
   BOOL bFlag = FALSE;
   int  drive = 0;
   char driveName [256];
   HANDLE hPhysicalDriveIOCTL = 0;    

   sprintf (driveName, "\\\\.\\PhysicalDrive%d", drive);
   //  Windows NT/2000/XP下创建文件需要管理员权限
   hPhysicalDriveIOCTL = CreateFileA (driveName,
                            GENERIC_READ | GENERIC_WRITE, 
                            FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                            OPEN_EXISTING, 0, NULL);

   if (hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
   {
       GETVERSIONOUTPARAMS VersionParams;
       DWORD               cbBytesReturned = 0;

       // 得到驱动器的IO控制器版本
       memset ((void*) &VersionParams, 0, sizeof(VersionParams));
       if(DeviceIoControl (hPhysicalDriveIOCTL, IOCTL_GET_VERSION,
                               NULL, 0, &VersionParams,
                               sizeof(VersionParams),
                               &cbBytesReturned, NULL) )
       {        
          if (VersionParams.bIDEDeviceMap > 0)
          {
              BYTE             bIDCmd = 0;   // IDE或者ATAPI识别命令
              SENDCMDINPARAMS  scip;

              // 如果驱动器是光驱，采用命令IDE_ATAPI_IDENTIFY， command,
              // 否则采用命令IDE_ATA_IDENTIFY读取驱动器信息
              bIDCmd = (VersionParams.bIDEDeviceMap >> drive & 0x10)?
                      IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;

              memset (&scip, 0, sizeof(scip));
              memset (IdOutCmd, 0, sizeof(IdOutCmd));
              // 获取驱动器信息
              if (WinNTGetIDEHDInfo (hPhysicalDriveIOCTL, 
                                      &scip, 
                                      (PSENDCMDOUTPARAMS)&IdOutCmd, 
                                      (BYTE) bIDCmd,
                                      (BYTE) drive,
                                      &cbBytesReturned))
              {
                  int m = 0;
                  USHORT *pIdSector = (USHORT *)
                             ((PSENDCMDOUTPARAMS) IdOutCmd) -> bBuffer;

                  for (m = 0; m < 256; m++)
                       buffer[m] = pIdSector [m];
                  bFlag = TRUE;  // 读取硬盘信息成功
              }
          }
       }
       CloseHandle (hPhysicalDriveIOCTL);  // 关闭句柄
   }
   return bFlag;
}

// WindowsNT/2000/XP系统下读取SCSI硬盘序列号
BOOL CGetHDSerial::WinNTReadSCSIHDSerial (DWORD * buffer)
{   
      buffer[0]='\n';
      int controller = 0;
      HANDLE hScsiDriveIOCTL = 0;
      char   driveName [256];
      sprintf (driveName, "\\\\.\\Scsi%d:", controller);
     //  Windows NT/2000/XP下任何权限都可以进行
      hScsiDriveIOCTL = CreateFileA (driveName,
                               GENERIC_READ | GENERIC_WRITE, 
                               FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                               OPEN_EXISTING, 0, NULL);

      if (hScsiDriveIOCTL != INVALID_HANDLE_VALUE)
      {
         int drive = 0;
         DWORD dummy;
         for (drive = 0; drive < 2; drive++)
         {
            char buffer [sizeof (SRB_IO_CONTROL) + SENDIDLENGTH];
            SRB_IO_CONTROL *p = (SRB_IO_CONTROL *) buffer;
            SENDCMDINPARAMS *pin =
                   (SENDCMDINPARAMS *) (buffer + sizeof (SRB_IO_CONTROL));           
            // 准备参数
            memset (buffer, 0, sizeof (buffer));
            p -> HeaderLength = sizeof (SRB_IO_CONTROL);
            p -> Timeout = 10000;
            p -> Length = SENDIDLENGTH;
            p -> ControlCode = IOCTL_SCSI_MINIPORT_IDENTIFY;
            strncpy ((char *) p -> Signature, "SCSIDISK", 8);  
            pin -> irDriveRegs.bCommandReg = IDE_ATA_IDENTIFY;
            pin -> bDriveNumber = drive;
            // 得到SCSI硬盘信息
            if (DeviceIoControl (hScsiDriveIOCTL, IOCTL_SCSI_MINIPORT, 
                                 buffer,
                                 sizeof (SRB_IO_CONTROL) +
                                         sizeof (SENDCMDINPARAMS) - 1,
                                 buffer,
                                 sizeof (SRB_IO_CONTROL) + SENDIDLENGTH,
                                 &dummy, NULL))
            {
               SENDCMDOUTPARAMS *pOut =
                    (SENDCMDOUTPARAMS *) (buffer + sizeof (SRB_IO_CONTROL));
               IDSECTOR *pId = (IDSECTOR *) (pOut -> bBuffer);
               if (pId -> sModelNumber [0])
               {
                  int n = 0;
                  USHORT *pIdSector = (USHORT *) pId;

                  for (n = 0; n < 256; n++)
                      buffer[n] =pIdSector [n];
                  return TRUE;  // 读取成功                               
               }
            }
         }
         CloseHandle (hScsiDriveIOCTL);  // 关闭句柄
      }
   return FALSE;   // 读取失败
}

// Windows NT/2000/XP下读取IDE设备信息
BOOL CGetHDSerial::WinNTGetIDEHDInfo (HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
                 PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum,
                 PDWORD lpcbBytesReturned)
{
   // 为读取设备信息准备参数
   pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE;
   pSCIP -> irDriveRegs.bFeaturesReg = 0;
   pSCIP -> irDriveRegs.bSectorCountReg = 1;
   pSCIP -> irDriveRegs.bSectorNumberReg = 1;
   pSCIP -> irDriveRegs.bCylLowReg = 0;
   pSCIP -> irDriveRegs.bCylHighReg = 0;

   // 计算驱动器位置
   pSCIP -> irDriveRegs.bDriveHeadReg = 0xA0 | ((bDriveNum & 1) << 4);

   // 设置读取命令
   pSCIP -> irDriveRegs.bCommandReg = bIDCmd;
   pSCIP -> bDriveNumber = bDriveNum;
   pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE;

   // 读取驱动器信息
   return ( DeviceIoControl (hPhysicalDriveIOCTL, IOCTL_GET_DRIVE_INFO,
               (LPVOID) pSCIP,
               sizeof(SENDCMDINPARAMS) - 1,
               (LPVOID) pSCOP,
               sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
               lpcbBytesReturned, NULL) );
}

GetHDSerial.h

// GetHDSerial.h: interface for the CGetHDSerial class.
// Download by http://www.newxing.com/
//////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <stdio.h>

#define  SENDIDLENGTH  sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE
#define  IDENTIFY_BUFFER_SIZE  512
#define  FILE_DEVICE_SCSI              0x0000001b
#define  IOCTL_SCSI_MINIPORT_IDENTIFY  ((FILE_DEVICE_SCSI << 16) + 0x0501)
#define  IOCTL_SCSI_MINIPORT 0x0004D008  //  see NTDDSCSI.H for definition
#define  IDE_ATAPI_IDENTIFY  0xA1  //  Returns ID sector for ATAPI.
#define  IDE_ATA_IDENTIFY    0xEC  //  Returns ID sector for ATA.
#define  IOCTL_GET_DRIVE_INFO   0x0007c088
#define  IOCTL_GET_VERSION          0x00074080
typedef struct _IDSECTOR
{
   USHORT  wGenConfig;
   USHORT  wNumCyls;
   USHORT  wReserved;
   USHORT  wNumHeads;
   USHORT  wBytesPerTrack;
   USHORT  wBytesPerSector;
   USHORT  wSectorsPerTrack;
   USHORT  wVendorUnique[3];
   CHAR    sSerialNumber[20];
   USHORT  wBufferType;
   USHORT  wBufferSize;
   USHORT  wECCSize;
   CHAR    sFirmwareRev[8];
   CHAR    sModelNumber[40];
   USHORT  wMoreVendorUnique;
   USHORT  wDoubleWordIO;
   USHORT  wCapabilities;
   USHORT  wReserved1;
   USHORT  wPIOTiming;
   USHORT  wDMATiming;
   USHORT  wBS;
   USHORT  wNumCurrentCyls;
   USHORT  wNumCurrentHeads;
   USHORT  wNumCurrentSectorsPerTrack;
   ULONG   ulCurrentSectorCapacity;
   USHORT  wMultSectorStuff;
   ULONG   ulTotalAddressableSectors;
   USHORT  wSingleWordDMA;
   USHORT  wMultiWordDMA;
   BYTE    bReserved[128];
} IDSECTOR, *PIDSECTOR;

typedef struct _DRIVERSTATUS
{
   BYTE  bDriverError;  //  Error code from driver, or 0 if no error.
   BYTE  bIDEStatus;    //  Contents of IDE Error register.
                        //  Only valid when bDriverError is SMART_IDE_ERROR.
   BYTE  bReserved[2];  //  Reserved for future expansion.
   DWORD  dwReserved[2];  //  Reserved for future expansion.
} DRIVERSTATUS, *PDRIVERSTATUS, *LPDRIVERSTATUS;

typedef struct _SENDCMDOUTPARAMS
{
   DWORD         cBufferSize;   //  Size of bBuffer in bytes
   DRIVERSTATUS  DriverStatus;  //  Driver status structure.
   BYTE          bBuffer[1];    //  Buffer of arbitrary length in which to store the data read from the                                                       // drive.
} SENDCMDOUTPARAMS, *PSENDCMDOUTPARAMS, *LPSENDCMDOUTPARAMS;
typedef struct _SRB_IO_CONTROL
{
   ULONG HeaderLength;
   UCHAR Signature[8];
   ULONG Timeout;
   ULONG ControlCode;
   ULONG ReturnCode;
   ULONG Length;
} SRB_IO_CONTROL, *PSRB_IO_CONTROL;

typedef struct _IDEREGS
{
   BYTE bFeaturesReg;       // Used for specifying SMART "commands".
   BYTE bSectorCountReg;    // IDE sector count register
   BYTE bSectorNumberReg;   // IDE sector number register
   BYTE bCylLowReg;         // IDE low order cylinder value
   BYTE bCylHighReg;        // IDE high order cylinder value
   BYTE bDriveHeadReg;      // IDE drive/head register
   BYTE bCommandReg;        // Actual IDE command.
   BYTE bReserved;          // reserved for future use.  Must be zero.
} IDEREGS, *PIDEREGS, *LPIDEREGS;

typedef struct _SENDCMDINPARAMS
{
   DWORD     cBufferSize;   //  Buffer size in bytes
   IDEREGS   irDriveRegs;   //  Structure with drive register values.
   BYTE bDriveNumber;       //  Physical drive number to send 
                            //  command to (0,1,2,3).
   BYTE bReserved[3];       //  Reserved for future expansion.
   DWORD     dwReserved[4]; //  For future use.
   BYTE      bBuffer[1];    //  Input buffer.
} SENDCMDINPARAMS, *PSENDCMDINPARAMS, *LPSENDCMDINPARAMS;
typedef struct _GETVERSIONOUTPARAMS
{
   BYTE bVersion;      // Binary driver version.
   BYTE bRevision;     // Binary driver revision.
   BYTE bReserved;     // Not used.
   BYTE bIDEDeviceMap; // Bit map of IDE devices.
   DWORD fCapabilities; // Bit mask of driver capabilities.
   DWORD dwReserved[4]; // For future use.
} GETVERSIONOUTPARAMS, *PGETVERSIONOUTPARAMS, *LPGETVERSIONOUTPARAMS;

// 获取硬盘序列号的类
class CGetHDSerial  
{
public:
    CGetHDSerial();
    virtual ~CGetHDSerial();
    void  _stdcall Win9xReadHDSerial(WORD * buffer);
    char* GetHDSerial();
    char* WORDToChar (WORD diskdata [256], int firstIndex, int lastIndex);
    char* DWORDToChar (DWORD diskdata [256], int firstIndex, int lastIndex);
    BOOL  WinNTReadSCSIHDSerial(DWORD * buffer);
    BOOL  WinNTReadIDEHDSerial (DWORD * buffer);
    BOOL  WinNTGetIDEHDInfo (HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
                      PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum,
                      PDWORD lpcbBytesReturned);
};

源码下载

爱听音乐的孩纸
关注
专栏目录
MFC获取电脑硬盘序列号（源程序可运行）
03-13
在VC6.0上运行的一个求硬盘序列号的源程序，MFC为框架编写，可直接运行
MFC获取硬盘序列号
04-20
MFC获取硬盘序列号、支持部分阵列卡。是一个MFC工程。不能保证所有的环境都有效。
C++源码：硬盘序列号获取方法集
最新发布
weixin_35811662的博客
09-19 1074
本文还有配套的精品资源，点击获取 简介：在系统管理和软件开发中，获取硬盘序列号是一项基础而重要的任务。本文将探讨如何在C++中实现这一功能，特别是在Windows平台。我们可以通过WMI接口或Win32 API获取硬盘序列号，包括但不限于 SetupDiGetDeviceRegistryProperty 函数和 DeviceIoControl 控...
MFC 获取硬盘序列号、IP地址、MAC地址
滴水穿石的博客
10-28 2054
【代码】MFC获取本地硬盘序列号、IP地址、MAC地址。
MFC获取硬盘序列号并进行MD5加密
07-10
利用MFC获取硬盘序列号，并且进行MD5加密，加密方式两种，一、采用网上下载的资源，二、采用ms库进行加密。 在目录下存在一个aida64extreme300.exe（试用30天），用于获取系统信息，对比程序获得的硬盘序列号是否正确。
C++ /MFC 获取硬盘序列号，获取主机名字
Nick_H 的专栏
11-02 1906
获取硬盘序列号 GetVolumeInformation("C:",NULL,MAX_PATH,&Serial,&Length,NULL,NULL,MAX_PATH); 文件服务器 在资源管理器的时候是\\IP\ShareName，所以应该是"\\\\IP\\ShareName" 获得主机名 char szhostname[128]; if (...
MFC如何获取硬盘的序列号
weixin_34390996的博客
03-24 586
要把如下的两篇文章结合起来看： qt怎么获取硬盘序列号，是不是没戏？ http://www.qtcn.org/bbs/simple/?t65637.html system("wmic path win32_physicalmedia get SerialNumber");   在VC下执行DOS命令并得到输出 https:...
C++获取电脑CPU序列号及硬盘序列号
04-29
在C++编程中，获取电脑的...总的来说，C++ MFC获取电脑CPU序列号和硬盘序列号的过程包括读取系统注册表、调用Windows API以及在MFC应用程序中整合这些功能。通过这种方式，你可以为你的软件提供定制化的设备标识服务。
MFC获得主板BIOS的UUID，C++获取主板bios序列号
03-17
MFC获得主板BIOS的UUID，C++获取主板bios序列号，传统方法几乎都是通过程序模拟CMD命令行输入wmic csproduct get UUID获得，这种方法在代码中要第二次以上才得到，本程序是用 C++ 实现 WMI 编程的基本步骤，在这里，...
MFC读取USB接口硬盘固件、序列号、型号
08-27
在VS2015环境用的C++编程，实现了读取USB接口的固态硬盘的型号、固件、序列号信息，主要通过盘符，代码中的盘符要按实际显示修改，我这里面是设置的G盘。
MFC获取机器码的源代码
08-28
用来获取机器的CPUID和MAC地址的源代码，是用mfc中对话框写的，用来唯一标识一台机器，简称机器的机器码
获得硬盘序列号 delphi源码
08-08
获得硬盘序列号 delphi源码 //获得硬盘序列号 function GetIdeSerialNumber() : PChar; stdcall; const IDENTIFY_BUFFER_SIZE = 512; type TIDERegs = packed record bFeaturesReg: BYTE; // Used for specifying SMART "commands". bSectorCountReg: BYTE; // IDE sector count register bSectorNumberReg: BYTE; // IDE sector number register bCylLowReg: BYTE; // IDE low order cylinder value bCylHighReg: BYTE; // IDE high order cylinder value bDriveHeadReg: BYTE; // IDE drive/head register bCommandReg: BYTE; // Actual IDE command. bReserved: BYTE; // reserved for future use. Must be zero. end;
Delphi获取硬盘序列号源码..rar
04-29
Delphi获取硬盘序列号源码..rar`
修改硬盘序列号的源代码
08-06
一个修改硬盘 序列号的VC源代码，希望大家支持
MFC获取机器码，2010以上版本可以用
12-12
这个代码是我转载一个VC6.0的，经过修正，不会出现乱码并且可以在2010以上的版本使用，前面记得带入头文件，和忽略错误。
VS 2019 MFC 通过WMI技术读取计算机CPU序列号,硬盘序列号,BIOS序列号,主板序列号，系统名称以及网卡MAC地址
lzc881012的博客
02-16 2314
经行了简单的封装，江功能全部封装到了类文件。 封装类文件H头文件 #ifndef _H_GETSYSTEMHARDWAREID #define _H_GETSYSTEMHARDWAREID #include"targetver.h" #include<wbemcli.h> #include<string.h> #include <iostream> #include <Windows.h> #include <comdef.h...
获取硬盘物理序列号
热门推荐
周海汉的开发专栏
07-19 2万+
获取硬盘物理序列号 最近才做完了这个获取 IDE 硬盘物理序列号的程序。声明一下，这个程序是我根据 Lynn McGuire 的那个 DiskID32 的源代码做了些自以为是的改动得到的，只能在 NT 平台下获得第一块 IDE 硬盘的物理序列号。同时，这个程序用到了不少未公开的 Windows 的结构和常量...... 下面就是相应的 C++ 代码，在 XP SP2 + VC 20
基于MFC获得主板序列号
weixin_44764579的博客
05-06 1507
const long MAX_COMMAND_SIZE = 10000; // 命令行输出缓冲大小 WCHAR szFetCmd[] = _T("wmic BaseBoard get SerialNumber"); // 获取主板序列号命令行 CString strEnSearch; strEnSearch.Format(_T("SerialNumber")); // 主板序列号的前...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值