根据机器码实现软件注册

偶然看到一篇关于根据电脑硬件的相关串号，作为软件序列号，然后根据自己设计的编码格式，得到不同的注册码的文章。

其中提到GetVolumeInformation得到硬盘的序列号，在格式化后，这个序列号会发生变化，想到我们自己设计的程序中，的确是偷懒，用了这个方法获取得到C盘的序列号

根据文章中的方法，要获取硬盘真正的序列号，我先把程序摘录下来，等之后空下来，再来看看是否真正可行，是否适用于各个不同的系统，不同的硬盘。

以下是从论坛里摘录下来的，没有经过编译验证，因为找不到转载出自何处，如果有所侵权，请通知我删除，我摘录了为了以后方便查看。

//----------------------------------------------------------------------转载----------------------------------------------------------------------//

//   读取硬盘序列号函数 
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   =   CreateFile   (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   =   CreateFile   (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)   ); 
}

//----------------------------------------------------------------------转载----------------------------------------------------------------------//