首页 > 代码库 > 硬盘ID以及CPUID 号
硬盘ID以及CPUID 号
#include "reg.h"
#include <dos.h>
#include <stdio.h>
#include "resource.h"
char sInputCode[256];
char sRegCode[256];
char sPCCode[256];
char sCoder[256];
#define IDD_EDIT 201
#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 DFP_RECEIVE_DRIVE_DATA 0x0007c088
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;
WORD serial[256];
DWORD OldInterruptAddress;
DWORDLONG IDTR;
static unsigned int WaitHardDiskIde()
{
BYTE xx;
Waiting:
__asm{
mov dx, 0x1f7
in al, dx
cmp al, 0x80
jb Endwaiting
jmp Waiting
}
Endwaiting:
__asm{
mov xx, al
}
return xx;
}
void __declspec( naked ) InterruptProcess(void)//中断服务程序
{
int xx;
int i;
WORD temp;
//保存寄存器值
__asm
{
push eax
push ebx
push ecx
push edx
push esi
}
WaitHardDiskIde();//等待硬盘空闲状态
__asm{
mov dx, 0x1f6
mov al, 0xa0
out dx, al
}
xx = WaitHardDiskIde(); //若直接在Ring3级执行等待命令，会进入死循环
if ((xx&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 //发送读驱动器参数命令
}
xx = WaitHardDiskIde();
if ((xx&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
}
serial[i] = temp;
}
__asm{
pop esi
pop edx
pop ecx
pop ebx
pop eax
iretd
}
//_asm iretd
}
static char *ConvertToString (WORD diskdata [256], int firstIndex, int lastIndex)
{
static char string [1024];
int index = 0;
int position = 0;
// each integer has two characters stored in it backwards
for (index = firstIndex; index <= lastIndex; index++)
{
// get high byte for 1st character
string [position] = (char) (diskdata [index] / 256);
position++;
// get low byte for 2nd character
string [position] = (char) (diskdata [index] % 256);
position++;
}
// end the string
string [position] = ‘\0‘;
// cut off the trailing blanks
for (index = position - 1; index > 0 && ‘ ‘ == string [index]; index--)
string [index] = ‘\0‘;
return string;
}
static char *ConvertToString2 (DWORD diskdata [256], int firstIndex, int lastIndex)
{
static char string [1024];
int index = 0;
int position = 0;
// each integer has two characters stored in it backwards
for (index = firstIndex; index <= lastIndex; index++)
{
// get high byte for 1st character
string [position] = (char) (diskdata [index] / 256);
position++;
// get low byte for 2nd character
string [position] = (char) (diskdata [index] % 256);
position++;
}
// end the string
string [position] = ‘\0‘;
// cut off the trailing blanks
for (index = position - 1; index > 0 && ‘ ‘ == string [index]; index--)
string [index] = ‘\0‘;
return string;
}
void _stdcall ReadIdeSerialNumber()
{
_asm
{
push eax
//获取修改的中断的中断描述符（中断门）地址
sidt IDTR
mov eax,dword ptr [IDTR+02h]
add eax,3*08h+04h
cli
//保存原先的中断入口地址
push ecx
mov ecx,dword ptr [eax]
mov cx,word ptr [eax-04h]
mov dword ptr 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 OldInterruptAddress
mov word ptr [eax-04h],cx
shr ecx,10h
mov word ptr [eax+02h],cx
pop ecx
sti
pop eax
}
}
BOOL DoIDENTIFY (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, DFP_RECEIVE_DRIVE_DATA,
(LPVOID) pSCIP,
sizeof(SENDCMDINPARAMS) - 1,
(LPVOID) pSCOP,
sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
lpcbBytesReturned, NULL) );
}
int WinNTHDSerialNumAsPhysicalRead (DWORD * buffer)
{
#define DFP_GET_VERSION 0x00074080
BYTE IdOutCmd [sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];
int done = FALSE;
int drive = 0;
HANDLE hPhysicalDriveIOCTL = 0;
char driveName [256];
sprintf (driveName, "\\\\.\\PhysicalDrive%d", drive);
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;
memset ((void*) &VersionParams, 0, sizeof(VersionParams));
if ( ! DeviceIoControl (hPhysicalDriveIOCTL, DFP_GET_VERSION,
NULL,
0,
&VersionParams,
sizeof(VersionParams),
&cbBytesReturned, NULL) ) ;
if (VersionParams.bIDEDeviceMap > 0)
{
BYTE bIDCmd = 0; // IDE or ATAPI IDENTIFY cmd
SENDCMDINPARAMS scip;
bIDCmd = (VersionParams.bIDEDeviceMap >> drive & 0x10) ? \
IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
memset (&scip, 0, sizeof(scip));
memset (IdOutCmd, 0, sizeof(IdOutCmd));
if ( DoIDENTIFY (hPhysicalDriveIOCTL,
&scip,
(PSENDCMDOUTPARAMS)&IdOutCmd,
(BYTE) bIDCmd,
(BYTE) drive,
&cbBytesReturned))
{
int ijk = 0;
USHORT *pIdSector = (USHORT *)
((PSENDCMDOUTPARAMS) IdOutCmd) -> bBuffer;
for (ijk = 0; ijk < 256; ijk++)
buffer[ijk] = pIdSector [ijk];
done = TRUE;
}
}
CloseHandle (hPhysicalDriveIOCTL);
}
return done;
}
static int Win9xHDSerialNumRead(WORD * buffer)
{
int i;
for(i=0;i<256;i++)
buffer[i]=0;
ReadIdeSerialNumber();
for(i=0;i<256;i++)
buffer[i]=serial[i];
return 1;
}
int WinNTHDSerialNumAsScsiRead (DWORD * buffer)
{
buffer[0]=‘\n‘;
int controller = 0;
HANDLE hScsiDriveIOCTL = 0;
char driveName [256];
sprintf (driveName, "\\\\.\\Scsi%d:", controller);
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;
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));
DWORD dummy;
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;
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 ijk = 0;
USHORT *pIdSector = (USHORT *) pId;
for (ijk = 0; ijk < 256; ijk++)
buffer[ijk] =(char)pIdSector [ijk];
return 1;
}
}
}
CloseHandle (hScsiDriveIOCTL);
}
return -1;
}
void ChangeByteOrder(LPSTR lpString, int nLen)
{
CHAR c;
for(int i = 0; i < nLen; i += 2)
{
c = lpString[i];
lpString[i] = lpString[i+1];
lpString[i+1] = c;
}
}
BOOL WINAPI GetHDSerialNum(char *p)
{
char buffer[256];
buffer[0]=‘\n‘;
OSVERSIONINFO OSVersionInfo;
OSVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx( &OSVersionInfo);
if (OSVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
{
return FALSE;
}
else
{
DWORD m_wStr[256];
if ( ! WinNTHDSerialNumAsPhysicalRead(m_wStr))
{
return FALSE;
}
strcpy (buffer, ConvertToString2 (m_wStr, 10, 19));
}
strcpy(p,buffer);
return TRUE;
}
BOOL WINAPI GetProcessorSerialNumber(unsigned int processor, unsigned int &psn_00_31, unsigned int &psn_32_63, unsigned int &psn_64_95)
{
unsigned int wCPU_SerialNo_00_31 = 0;
unsigned int wCPU_SerialNo_32_63 = 0;
unsigned int wCPU_SerialNo_64_93 = 0;
#define PSN_FLAG 0x4000
int errCode = 0;
int psn_falg = PSN_FLAG;
DWORD dwThreadAffinitiMask = (0x1 << processor);
SetThreadAffinityMask(GetCurrentThread(), dwThreadAffinitiMask);
_asm
{
pushad
mov eax,0
cpuid
cmp ebx, ‘uneG‘
jne wrong_processor
cmp edx, ‘Ieni‘
jne wrong_processor
cmp ecx, ‘letn‘
jne wrong_processor
// get CPU feature flag..
mov eax,1
cpuid
mov wCPU_SerialNo_64_93,eax
and edx,PSN_FLAG
cmp edx,PSN_FLAG
jne psn_not_supported_or_disabled
// get the PSN
mov eax,3
cpuid
mov wCPU_SerialNo_32_63,edx
mov wCPU_SerialNo_00_31,ecx
jmp _exit_
wrong_processor:
mov errCode, 1;
jmp _exit_;
psn_not_supported_or_disabled:
mov errCode, 2;
_exit_:
popad
}
psn_00_31 = wCPU_SerialNo_00_31;
psn_32_63 = wCPU_SerialNo_32_63;
psn_64_95 = wCPU_SerialNo_64_93;
dwThreadAffinitiMask = 0xffffffff;
SetThreadAffinityMask(GetCurrentThread(), dwThreadAffinitiMask);
if(errCode==0) return TRUE;
else return FALSE;
}
BOOL ReadKey( char *szVal )
{
char szKey[64];
char szSubkey[64];
strcpy(szKey,"SOFTWARE\\XHSNPDRV");
strcpy(szSubkey,"KEY");
DWORD dwDataSize,dwDataType;
HKEY hKey,hKeyRoot=HKEY_LOCAL_MACHINE;
dwDataSize=64;
dwDataType=REG_SZ;
if(RegOpenKeyEx(hKeyRoot,szKey,(DWORD)0,KEY_ALL_ACCESS,&hKey)!=ERROR_SUCCESS)
return FALSE;
if(RegQueryValueEx(hKey, (LPTSTR)szSubkey, (LPDWORD)NULL, (LPDWORD)&dwDataType
, (LPBYTE)szVal, (LPDWORD)&dwDataSize) ==ERROR_SUCCESS)
return TRUE;
else
return FALSE;
}
BOOL WriteKey(char *szVal)
{
char szKey[64];
char szSubkey[64];
strcpy(szKey,"SOFTWARE\\XHSNPDRV");
strcpy(szSubkey,"KEY");
DWORD dwDataSize,dwDataType;
HKEY hKey,hKeyRoot = HKEY_LOCAL_MACHINE;
dwDataSize=64;
dwDataType=REG_SZ;
if(RegOpenKeyEx(hKeyRoot,szKey,(DWORD)0,KEY_ALL_ACCESS,&hKey)!=ERROR_SUCCESS)
{
if(RegCreateKey(hKeyRoot, szKey, &hKey) != ERROR_SUCCESS)
return FALSE;
}
if(RegSetValueEx(hKey, szSubkey, (DWORD)0, (DWORD)dwDataType
,(CONST BYTE *)szVal, (DWORD)(strlen(szVal)+1))==ERROR_SUCCESS)
return TRUE;
else
return FALSE;
}
LRESULT APIENTRY RegDlgProc(HWND hDlg, INT message, UINT wParam, LONG lParam)
{
switch (message)
{
case WM_INITDIALOG:
SetDlgItemText(hDlg, IDC_EDIT_MACHINECODE, sPCCode);
BringWindowToTop(hDlg);
return TRUE;
case WM_COMMAND:
{
switch(LOWORD(wParam))
{
case IDOK:
GetDlgItemText( hDlg, IDC_EDIT_REG, sInputCode, 256);
if(strcmp(sCoder, sInputCode)==0)
{
WriteKey(sInputCode); // 输入的与计算出的KEY一致则写入注册表
EndDialog( hDlg, 1 );
}
else
{
MessageBox(NULL,"您输入的注册码不正确，请重新输入！","错误",MB_ICONWARNING);
}
break;
case IDCANCEL:
EndDialog(hDlg, 0);
break;
default:
return FALSE;
}
return (TRUE);
}
}
return (FALSE);
UNREFERENCED_PARAMETER(lParam);
}
void Code(char *m)
{
char c[256];
int t1[256], t2[256];
int num = strlen(m);
memset(c, 0, 256);
for (int i=0; m[i]!=‘\0‘; i++)
{
if (m[i]>=‘0‘ && m[i]<=‘9‘)
{
if ((m[i]-80)%2 == 0)
{
m[i] = m[i] - 48 + ‘H‘;
}
else
{
m[i] = m[i] - 48 + ‘A‘;
}
}
else if ((m[i]>=‘A‘ && m[i]<=‘Z‘) || (m[i]>=‘a‘ && m[i]<=‘z‘))
{
m[i] = m[i];
}
else
{
m[i] = m[i]%9 + ‘O‘;
}
if (m[i]>=‘A‘ && m[i]<=‘Z‘)
{
t1[i]=m[i]-65;
}
else if (m[i]>=‘a‘ && m[i]<=‘z‘)
{
t1[i]=m[i]-97;
}
else
{
t1[i]=-1;
}
if (t1[i] != -1)
t2[i] = (t1[i]+3)%26;
else
t2[i] = -1;
if (t2[i] != -1)
c[i] = t2[i]+65;
else
c[i] = m[i];
}
memcpy(m , c , num) ;
}
BOOL RegisterDrv(HINSTANCE hInstance)
{
memset(sInputCode, 0, 512);
memset(sPCCode, 0, 512);
memset(sRegCode, 0, 512);
// 读取硬盘序列号
char sHDNum[256];
memset(sHDNum, 0, 256);
BOOL re1 = GetHDSerialNum(sHDNum);
if (!re1)
{
strcpy(sHDNum, "YHGSIXIGSh");
}
else
{
for (int j=0; j<strlen(sHDNum); j++)
{
if (sHDNum[j] == ‘ ‘)
{
sHDNum[j] = ‘0‘;
}
}
}
// 读取CPU号
char sCPUNum[256];
memset(sCPUNum, 0, 256);
unsigned int psn_00_31;
unsigned int psn_32_63;
unsigned int psn_64_95;
int re2 = GetProcessorSerialNumber(0, psn_00_31, psn_32_63, psn_64_95);
if (re2)
{
sprintf(sCPUNum,"%.8x",psn_64_95+psn_32_63+psn_00_31);
}
else
{
strcpy(sCPUNum, "XINHUA");
}
// 组成机器码 sPCCode
for(int i=0; (i<strlen(sHDNum) || i<strlen(sCPUNum)) && i<100; i++)
{
char h, c, sum;
if( i>=strlen(sHDNum))
{
h = ‘0‘;
}
else
{
h = sHDNum[i];
}
if( i>=strlen(sCPUNum))
{
c = ‘0‘;
}
else
{
c = sCPUNum[i];
}
if (i%2 == 0)
{
sum = h;
}
else
{
sum = c;
}
sPCCode[i] = sum;
}
// 加密
memset(sCoder, 0, 256);
strcpy(sCoder, sPCCode);
Code(sCoder);
// 读取注册表中注册码
char sRegCode[256];
memset(sRegCode, 0, 256);
if (ReadKey(sRegCode))
{
if (strcmp(sCoder, sRegCode) == 0)
{
return TRUE;
}
}
long re = DialogBox(hInstance, MAKEINTRESOURCE(IDD_DLG_REG),
NULL, (DLGPROC)RegDlgProc);
if (re != 1)
{
return FALSE;
}
return TRUE;
}
硬盘ID以及CPUID 号