VC++获取网卡MAC、硬盘序列号、CPU ID、BIOS编号
以下代码可以取得系统特征码(网卡MAC、硬盘序列号、CPU ID、BIOS编号)
BYTE szSystemInfo[4096]; // 在程序执行完毕后,此处存储取得的系统特征码
UINT uSystemInfoLen = 0; // 在程序执行完毕后,此处存储取得的系统特征码的长度
// 网卡MAC 地址,注意: MAC 地址是可以在注册表中修改的
{
UINT uErrorCode=0;
IP_ADAPTER_INFO iai;
ULONG uSize = 0;
DWORD dwResult = GetAdaptersInfo( &iai, &uSize );
if( dwResult == ERROR_BUFFER_OVERFLOW )
{
IP_ADAPTER_INFO* piai=( IP_ADAPTER_INFO* )HeapAlloc( GetProcessHeap( ), 0, uSize );
if( piai != NULL )
{
dwResult = GetAdaptersInfo( piai, &uSize );
if( ERROR_SUCCESS == dwResult )
{
IP_ADAPTER_INFO* piai2 = piai;
while(piai2!=NULL &&(uSystemInfoLen+piai2->AddressLength )< 4096U)
{
CopyMemory(szSystemInfo+uSystemInfoLen,piai2->Address, piai2->AddressLength );
uSystemInfoLen += piai2->AddressLength;
piai2 = piai2->Next;
}
}
else
{
uErrorCode = 0xF0000000U + dwResult;
}
VERIFY( HeapFree( GetProcessHeap( ), 0, piai ) );
}
else
{
return FALSE;
}
}
else
{
uErrorCode = 0xE0000000U + dwResult;
}
if( uErrorCode != 0U )
{
return FALSE;
}
}
// 硬盘序列号,注意:有的硬盘没有序列号
{
OSVERSIONINFO ovi = { 0 };
ovi.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
GetVersionEx( &ovi );
if( ovi.dwPlatformId != VER_PLATFORM_WIN32_NT )
{
// Only Windows 2000, Windows XP, Windows Server 2003...
return FALSE;
}
else
{
if( !WinNTHDSerialNumAsPhysicalRead( szSystemInfo, &uSystemInfoLen, 1024 ) )
{
WinNTHDSerialNumAsScsiRead( szSystemInfo, &uSystemInfoLen, 1024 );
}
}
}
// CPU ID
{
BOOL bException = FALSE;
BYTE szCpu[16] = { 0 };
UINT uCpuID = 0U;
__try
{
_asm
{
mov eax, 0
cpuid
mov dword ptr szCpu[0], ebx
mov dword ptr szCpu[4], edx
mov dword ptr szCpu[8], ecx
mov eax, 1
cpuid
mov uCpuID, edx
}
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
bException = TRUE;
}
if( !bException )
{
CopyMemory( szSystemInfo + uSystemInfoLen, &uCpuID, sizeof( UINT ) );
uSystemInfoLen += sizeof( UINT );
uCpuID = strlen( ( char* )szCpu );
CopyMemory( szSystemInfo + uSystemInfoLen, szCpu, uCpuID );
uSystemInfoLen += uCpuID;
}
}
// BIOS 编号,支持AMI, AW ARD, PHOENIX
{
SIZE_T ssize;
LARGE_INTEGER so;
so.LowPart=0x000f0000;
so.HighPart=0x00000000;
ssize=0xffff;
wchar_t strPH[30]=L\\device\\physicalmemory;
DWORD ba=0;
UNICODE_STRING struniph;
struniph.Buffer=strPH;
struniph.Length=0x2c;
struniph.MaximumLength =0x2e;
OBJECT_ATTRIBUTES obj_ar;
obj_ar.Attributes =64;
obj_ar.Length =24;
obj_ar.ObjectName=&struniph;
obj_ar.RootDirectory=0;
obj_ar.SecurityDescriptor=0;
obj_ar.SecurityQualityOfService =0;
HMODULE hinstLib = LoadLibrary("ntdll.dll");
ZWOS ZWopenS=(ZWOS)GetProcAddress(hinstLib,"ZwOpenSection");
ZWMV ZWmapV=(ZWMV)GetProcAddress(hinstLib,"ZwMapViewOfSection");
ZWUMV ZWunmapV=(ZWUMV)GetProcAddress(hinstLib,"ZwUnmapViewOfSection");
//调用函数,对物理内存进行映射
HANDLE hSection;
if( 0 == ZWopenS(&hSection,4,&obj_ar) &&
0 == ZWmapV(
( HANDLE )hSection, //打开Section时得到的句柄
( HANDLE )0xFFFFFFFF, //将要映射进程的句柄,
&ba, //映射的基址
0,
0xFFFF, //分配的大小
&so, //物理内存的地址
&ssize, //指向读取内存块大小的指针
1, //子进程的可继承性设定
0, //分配类型
2 //保护类型
) )
//执行后会在当前进程的空间开辟一段64k的空间,并把f000:0000到f000:ffff处的内容映射到这里//映射的基址由ba返回,如果映射不再有用,应该用ZwUnmapViewOfSection断开映射
{
BYTE* pBiosSerial = ( BYTE* )ba;
UINT uBiosSerialLen = FindAwardBios( &pBiosSerial );
if( uBiosSerialLen == 0U )
{
uBiosSerialLen = FindAmiBios( &pBiosSerial );
if( uBiosSerialLen == 0U )
{
uBiosSerialLen = FindPhoenixBios( &pBiosSerial );
}
}
if( uBiosSerialLen != 0U )
{
CopyMemory( szSystemInfo + uSystemInfoLen, pBiosSerial, uBiosSerialLen );
uSystemInfoLen += uBiosSerialLen;
}
ZWunmapV( ( HANDLE )0xFFFFFFFF, ( void* )ba );
}
}
// 完毕,系统特征码已取得。
以下是其中用到的某些结构及函数的定义:
#define FILE_DEVICE_SCSI 0x0000001b
#define IOCTL_SCSI_MINIPORT_IDENTIFY ( ( FILE_DEVICE_SCSI << 16 ) + 0x0501 )
#define IOCTL_SCSI_MINIPORT 0x0004D008
#define IDENTIFY_BUFFER_SIZE 512
#define SENDIDLENGTH ( sizeof( SENDCMDOUTPARAMS ) + IDENTIFY_BUFFER_SIZE )
#define IDE_ATAPI_IDENTIFY 0xA1 // Returns ID sector for ATAPI.
#define IDE_ATA_IDENTIFY 0xEC // Returns ID sector for ATA.
#define DFP_RECEIVE_DRIVE_DA TA 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 _DRIVERSTA TUS
{
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, *LPDRIVERSTA TUS; 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;
//////////////////////////////////////////////////////////////////////
//结构定义
typedef struct _UNICODE_STRING
{
USHORT Length;//长度
USHORT MaximumLength;//最大长度
PWSTR Buffer;//缓存指针
} UNICODE_STRING,*PUNICODE_STRING;
typedef struct _OBJECT_ATTRIBUTES
{
ULONG Length;//长度18h
HANDLE RootDirectory;// 00000000
PUNICODE_STRING ObjectName;//指向对象名的指针
ULONG Attributes;//对象属性00000040h
PVOID SecurityDescriptor; // Points to type SECURITY_DESCRIPTOR,0
PVOID SecurityQualityOfService; // Points to type SECURITY_QUALITY_OF_SERVICE,0 } OBJECT_A TTRIBUTES;
typedef OBJECT_ATTRIBUTES *POBJECT_A TTRIBUTES;
//函数指针变量类型
typedef DWORD (__stdcall *ZWOS )( PHANDLE,ACCESS_MASK,POBJECT_A TTRIBUTES);
typedef DWORD (__stdcall *ZWMV )( HANDLE,HANDLE,PVOID,ULONG,ULONG,PLARGE_INTEGER,PSIZE_T,DWORD,ULONG,ULON G);
typedef DWORD (__stdcall *ZWUMV )( HANDLE,PVOID);
BOOL WinNTHDSerialNumAsScsiRead( BYTE* dwSerial, UINT* puSerialLen, UINT uMaxSerialLen )
{
BOOL bInfoLoaded = FALSE;
for( int iController = 0; iController < 2; ++ iController )
{
HANDLE hScsiDriveIOCTL = 0;
char szDriveName[256];
// Try to get a handle to PhysicalDrive IOCTL, report failure
// and exit if can't.
sprintf( szDriveName, "\\\\.\\Scsi%d:", iController );
// Windows NT, Windows 2000, any rights should do
hScsiDriveIOCTL = CreateFile( szDriveName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, 0, NULL);
// if (hScsiDriveIOCTL == INV ALID_HANDLE_V ALUE)
// printf ("Unable to open SCSI controller %d, error code: 0x%lX\n",
// controller, GetLastError ());
if( hScsiDriveIOCTL != INV ALID_HANDLE_V ALUE )
{
int iDrive = 0;
for( iDrive = 0; iDrive < 2; ++ iDrive )
{
char szBuffer[sizeof( SRB_IO_CONTROL ) + SENDIDLENGTH] = { 0 };
SRB_IO_CONTROL* p = ( SRB_IO_CONTROL* )szBuffer;
SENDCMDINPARAMS* pin = ( SENDCMDINPARAMS* )( szBuffer + sizeof( SRB_IO_CONTROL ) );
DWORD dwResult; https://www.sodocs.net/doc/331288273.html,/
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_A TA_IDENTIFY;
pin->bDriveNumber = iDrive;
if( DeviceIoControl( hScsiDriveIOCTL, IOCTL_SCSI_MINIPORT,
szBuffer,
sizeof( SRB_IO_CONTROL ) + sizeof( SENDCMDINPARAMS ) - 1,
szBuffer,
sizeof( SRB_IO_CONTROL ) + SENDIDLENGTH, IT资讯之家https://www.sodocs.net/doc/331288273.html,
&dwResult, NULL ) )
{
SENDCMDOUTPARAMS* pOut = ( SENDCMDOUTPARAMS* )( szBuffer + sizeof( SRB_IO_CONTROL ) );
IDSECTOR* pId = ( IDSECTOR* )( pOut->bBuffer );
if( pId->sModelNumber[0] )
{
if( * puSerialLen + 20U <= uMaxSerialLen )
{
// 序列号
CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )pId ) + 10, 20 );
// Cut off the trailing blanks
for( UINT i = 20; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i )
{}
* puSerialLen += i;
// 型号
CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )pId ) + 27, 40 );
// Cut off the trailing blanks
for( i = 40; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i )
{}
* puSerialLen += i; https://www.sodocs.net/doc/331288273.html,
bInfoLoaded = TRUE;
}
else
{
::CloseHandle( hScsiDriveIOCTL );
return bInfoLoaded;
}
}
}
}
::CloseHandle( hScsiDriveIOCTL );
}
}
return bInfoLoaded;
}
BOOL DoIdentify( HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum,
PDWORD lpcbBytesReturned )
{
// Set up data structures for IDENTIFY command.
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;
// calc the drive number.
pSCIP->irDriveRegs.bDriveHeadReg = 0xA0 | ( ( bDriveNum & 1 ) << 4 );
// The command can either be IDE identify or ATAPI identify.
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 );
}
BOOL WinNTHDSerialNumAsPhysicalRead( BYTE* dwSerial, UINT* puSerialLen, UINT uMaxSerialLen ) {
#define DFP_GET_VERSION 0x00074080
BOOL bInfoLoaded = FALSE;
for( UINT uDrive = 0; uDrive < 4; ++ uDrive )
{
HANDLE hPhysicalDriveIOCTL = 0;
// Try to get a handle to PhysicalDrive IOCTL, report failure
// and exit if can't.
char szDriveName [256];
sprintf( szDriveName, "\\\\.\\PhysicalDrive%d", uDrive );
// Windows NT, Windows 2000, must have admin rights
hPhysicalDriveIOCTL = CreateFile( szDriveName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
if( hPhysicalDriveIOCTL != INV ALID_HANDLE_VALUE )
{
GETVERSIONOUTPARAMS VersionParams = { 0 };
DWORD cbBytesReturned = 0;
// Get the version, etc of PhysicalDrive IOCTL
if( DeviceIoControl( hPhysicalDriveIOCTL, DFP_GET_VERSION,
NULL,
0,
&VersionParams,
sizeof( GETVERSIONOUTPARAMS ),
&cbBytesReturned, NULL ) )
{
// If there is a IDE device at number "i" issue commands
// to the device
if( VersionParams.bIDEDeviceMap != 0 )
{
BYTE bIDCmd = 0; // IDE or ATAPI IDENTIFY cmd
SENDCMDINPARAMS scip = { 0 };
// Now, get the ID sector for all IDE devices in the system.
// If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
// otherwise use the IDE_ATA_IDENTIFY command
bIDCmd = ( VersionParams.bIDEDeviceMap >> uDrive & 0x10 ) ? IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
BYTE IdOutCmd[sizeof( SENDCMDOUTPARAMS ) + IDENTIFY_BUFFER_SIZE - 1] = { 0 };
if( DoIdentify( hPhysicalDriveIOCTL,
&scip,
( PSENDCMDOUTPARAMS )&IdOutCmd,
( BYTE )bIDCmd,
( BYTE )uDrive,
&cbBytesReturned ) )
{ if( * puSerialLen + 20U <= uMaxSerialLen )
{
CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )( ( ( PSENDCMDOUTPARAMS )IdOutCmd )->bBuffer ) ) + 10, 20 ); // 序列号
// Cut off the trailing blanks
for( UINT i = 20; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i ) {}
* puSerialLen += i;
CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )( ( ( PSENDCMDOUTPARAMS )IdOutCmd )->bBuffer ) ) + 27, 40 ); // 型号
// Cut off the trailing blanks
for( i = 40; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i ) {}
* puSerialLen += i;
bInfoLoaded = TRUE;
}
else
{
::CloseHandle( hPhysicalDriveIOCTL );
return bInfoLoaded;
}
}
}
}
CloseHandle( hPhysicalDriveIOCTL );
}
}
return bInfoLoaded;
}
UINT FindAwardBios( BYTE** ppBiosAddr )
{
BYTE* pBiosAddr = * ppBiosAddr + 0xEC71;
BYTE szBiosData[128];
CopyMemory( szBiosData, pBiosAddr, 127 );
szBiosData[127] = 0;
int iLen = lstrlen( ( char* )szBiosData );
if( iLen > 0 && iLen < 128 )
{
//AWard: 07/08/2002-i845G-ITE8712-JF69VD0CC-00
//Phoenix-Award: 03/12/2002-sis645-p4s333
if( szBiosData[2] == '/' && szBiosData[5] == '/' )
{
BYTE* p = szBiosData;
while( * p )
{
if( * p < ' ' || * p >= 127 )
{
break;
}
++ p;
}
if( * p == 0 )
{
* ppBiosAddr = pBiosAddr;
return ( UINT )iLen;
}
}
}
return 0;
}
UINT FindAmiBios( BYTE** ppBiosAddr )
{
BYTE* pBiosAddr = * ppBiosAddr + 0xF478;
BYTE szBiosData[128];
CopyMemory( szBiosData, pBiosAddr, 127 );
szBiosData[127] = 0;
int iLen = lstrlen( ( char* )szBiosData );
if( iLen > 0 && iLen < 128 )
{
// Example: "AMI: 51-2300-000000-00101111-030199-"
if( szBiosData[2] == '-' && szBiosData[7] == '-' )
{
BYTE* p = szBiosData;
while( * p )
{
if( * p < ' ' || * p >= 127 )
{
break;
}
++ p;
}
if( * p == 0 )
{
* ppBiosAddr = pBiosAddr;
return ( UINT )iLen;
}
}
}
return 0;
}
UINT FindPhoenixBios( BYTE** ppBiosAddr )
{
UINT uOffset[3] = { 0x6577, 0x7196, 0x7550 };
for( UINT i = 0; i < 3; ++ i )
{
BYTE* pBiosAddr = * ppBiosAddr + uOffset[i];
BYTE szBiosData[128];
CopyMemory( szBiosData, pBiosAddr, 127 );
szBiosData[127] = 0;
int iLen = lstrlen( ( char* )szBiosData );
if( iLen > 0 && iLen < 128 )
{
// Example: Phoenix "NITELT0.86B.0044.P11.9910111055"
if( szBiosData[7] == '.' && szBiosData[11] == '.' )
{
BYTE* p = szBiosData;
while( * p )
{
if( * p < ' ' || * p >= 127 )
{
break;
}
++ p;
}
if( * p == 0 )
{
* ppBiosAddr = pBiosAddr;
return ( UINT )iLen;
}
}
}
}
return 0;
}
Windows中获取MAC地址的几种方法 1.NDIS(DDK)通过驱动程序获取MAC地址 ndis规范中说明,网卡驱动程序支持ioctl_ndis_query_stats接口 参数如下: OID_802_3_PERMANENT_ADDRESS :物理地址 OID_802_3_CURRENT_ADDRESS :mac地址 于是我们的方法就得到了。 首先,看看注册表,找一找网卡有几块,分别是什么设备名。 具体位置和os有关,2000下在hlm\software\microsoft\windows nt\current version\networkcards。 然后createfile(devicename,...)注意,要用linkname,因此 还要加上"////.//device//". 接着 deviceiocontrol(hmac,IOCTL_NDIS_QUERY_STA TS, OID_802_3_PERMANENT_ADDRESS/OID_802_3_CURRENT_ADDRESS...) 具体的情况可以参看ddk下的 OID_802_3_CURRENT_ADDRESS条目 https://www.sodocs.net/doc/331288273.html,API-2得到MAC (MSDN推荐方法) #include
机器码获取生成注册码 通过获取硬盘的物理序列号和网卡MAC地址,为您的程序提供了获取唯一的机器码,你可以根据此码,生成自己产品注册码,有效防止软件的盗版可以自己根据获取到的硬盘序列号和网卡MAC地址进行一定的加密算法生成,唯一的机器码. 给自己的软件制作注册码.从今天起,您开发的的任何软件如果您愿意都可以为之加密 --为您的软件制作一款注册机!当您看完这篇文章时, 您就可以理直气壮的告诉您的用户 : "喂, 想用我的软件是吧 ? 掏钱!". 呵呵, 这当然只是给自己壮胆的话, 现在连万能注册机都有了, 人家还怕啥 ? 不过只要您想想微软, 人家再牛B的加密技术都会被国人"鄙视"? 但人家不也在中国大把大把的捞钱吗?OK, 不扯了, 我们进入正题.同一般的软件注册一样, 我们这里的注册是这样进行的: 1. 首先根据用户的硬件信息生成24位的机器码 -- 相当于种子,用于生成随机数 2. 采用注册机根据特征数字生成一个24位注册码 -- 相当于伪随机数生成器, 输出长度自己定, 最后用一个格式化函数,将随机数映射到ASCII字符集合 3. 用户输入注册码注册成功 假设客户很喜欢您的软件, 也假设他没有破解, 他需要通过以下方式向您取得注册码: (1).如果他能上网, 他需要把机器码用Email发给您; (2).如果他不能上网, 他可以把机器码用手机短信的方式发给您. (3).如果他没有手机, 他可以带着机器码然后坐火车到您的办公室想您要一个注册码. --第3条只是为了让您看帖子的时候别太枯燥了, 抱歉. 现在, 您拿到了客户的机器码后, 如果您同时也收到了他汇的钱, 呵呵, 好像给软件加密就是为了要钱吧? 那么您就可以用客户的机器码生成一个唯一的注册码再用同样的方式给用户, 最后, 用户输入注册码即可! 需要强调的是客户机器的硬件信息获取方式是有很多种选择的. 这里我们选择最放心的两个硬件: CUP的序列号和硬盘的卷标号. 好了,下面您就可以一步一步制作一款软件注册机了. 步骤一: 获得CUP序列号和硬盘序列号的实现代码如下:Java代码 #region 获取cpu的序列号 public string getCpu() { string strCpu = null; ManagementClass myCpu = new ManagementClass("win32_Processor");
2、C#编程要点 Microsoft提供的WMI(Windows Management Instrumentation)中提供了一个Win32_NetworkAdapterConfiguration的类,定义了获取MAC地址的方法,因此只要构造一个定义为Win32_NetworkAdapter Configuration的WMI类,从中取出MAC地址的值即可。在C#中管理WMI主要使用ManagementClass类。编写程序过程要注意以下两个要点。 1)、命名空间的添加 由于System.Management的动态链接库不是C#中默认加载的,所以要添加System.Management的命名空间前要添加System.Management.dll链接库。依次选择:“项目”→“添加引用”→“.NET”菜单栏,加入System.Management。确认添加了动态链接库后添加命名空间: usingSystem.Management; 2)、MAC地址的获取 根据前面的介绍,要构造一个ManagementClass类管理定义为Win32_NetworkAdapter Configuration的WMI类,然后将ManagementClass类中的所有变量的值返回给属于ManagementObjectCollection类的变量,ManagementObjectCollection类用于表示WMI实例的不同集合,将不同集合中的各个MAC地址读出,就可获得多网卡的MAC地址。 构造ManagementClass,函数原型如下: public ManagementClass(string path); 参数:path表示WMI的路径。 要返回ManagementClass所有实例的集合,使用GetInstances(),函数原型如下: public ManagementObjectCollectionGetInstances(); 例如:获得本机上多网卡的MAC地址: ManagementClass mc; //定义一个ManagementClass类 //将ManagementClass类变量定义为Win32_NetworkAdapter Configuration,以便获得//网络信息 mc=new ManagementClass(” Win32_NetworkAdapterConfiguration”); //使用ManagementObjectCollection记录mc中的所有信息,包括多个网卡信息 ManagementObjectCollectionmoc=mc. GetInstances(); //取得ManagementObjectCollection中的不同网卡配置信息,判断如果该网卡可用就//去读取MAC地址 foreach(ManagementObjectmo in moc) { if(mo[“IPEnabled”].ToString()= =”True”) Console.WriteLine(”MAC address”+mo[“MacAddress”].ToString()); } using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Management; namespace ConsoleApplication3
public class MacUtils { /** * 通过ip获取mac地址 * @param ipAddress 客户端ip * @return mac地址 */ public static String getMACAddressByIp(String ipAddress) { String str = "", macAddress = ""; try { Process pp = Runtime.getRuntime().exec("arp -a " + ipAddress); InputStreamReader ir = new InputStreamReader(pp.getInputStream(), "gbk"); BufferedReader br = new BufferedReader(ir); while ((str = br.readLine()) != null) { if (str.indexOf(ipAddress) > 1) { str = str.trim(); macAddress = str.substring(str.indexOf(" "), str.length()); macAddress = macAddress.trim(); macAddress = macAddress.substring(0,17); break; } } pp.destroy(); br.close(); ir.close(); } catch (Exception ex) { return "Can't Get MAC Address!"; }
VC++获取网卡MAC、硬盘序列号、CPU ID、BIOS编号 以下代码可以取得系统特征码(网卡MAC、硬盘序列号、CPU ID、BIOS编号) BYTE szSystemInfo[4096]; // 在程序执行完毕后,此处存储取得的系统特征码 UINT uSystemInfoLen = 0; // 在程序执行完毕后,此处存储取得的系统特征码的长度 // 网卡MAC 地址,注意: MAC 地址是可以在注册表中修改的 { UINT uErrorCode=0; IP_ADAPTER_INFO iai; ULONG uSize = 0; DWORD dwResult = GetAdaptersInfo( &iai, &uSize ); if( dwResult == ERROR_BUFFER_OVERFLOW ) { IP_ADAPTER_INFO* piai=( IP_ADAPTER_INFO* )HeapAlloc( GetProcessHeap( ), 0, uSize ); if( piai != NULL ) { dwResult = GetAdaptersInfo( piai, &uSize ); if( ERROR_SUCCESS == dwResult ) { IP_ADAPTER_INFO* piai2 = piai; while(piai2!=NULL &&(uSystemInfoLen+piai2->AddressLength )< 4096U) { CopyMemory(szSystemInfo+uSystemInfoLen,piai2->Address, piai2->AddressLength ); uSystemInfoLen += piai2->AddressLength; piai2 = piai2->Next; } } else { uErrorCode = 0xF0000000U + dwResult; } VERIFY( HeapFree( GetProcessHeap( ), 0, piai ) ); } else { return FALSE; } } else { uErrorCode = 0xE0000000U + dwResult; } if( uErrorCode != 0U ) { return FALSE; } }
用纯JAVA语言编程读取MAC地址的实现 本文介绍如何在WindowXP/NT/2000环境中,编写纯Java程序,执行外部命令IPCONFIG,并通过分析该命令的输入流而获得本机的MAC地址的编程方法。 1 引言 用Java编写的程序,可以很方便地运行在各种平台的环境。但在实际的开发过程中,有时不得不涉及一些底层的编程。比如为了防止软件盗用,我们希望软件只能在指定计算机上运行,所以需要程序读取该机区分于其它计算机的硬件特征,如MAC地址等。作为一种跨平台语言,给Java语言提出了挑战。本文正是针对该问题,提出一种直接用纯Java语言,读去MAC地址的编程方法。 我们知道,在每一个Java应用程序中都存在着一个与其运行环境相联系的Runtime对象。该对象可执行外部命令、查可用内存等。而多数操作系统都提供有查询该机MAC地址的命令。如在Microsoft的操作系统中,命令IPCONFIG等。本文的思路是在程序中运行一个外部命令,将该命令的运行结果作为一个流(Stream),读取并分析之,进而实现获取MAC地址的目的。 2 Runtime类 在每一个Java 应用程序里面,都有惟一的一个Runtime 对象。通过这个Runtime 对象,应用程序可以与其运行环境发生相互作用。 一般不实例化一个Runtime对象。但是可以通过调用静态方法Runtime.getRuntime( )而获得对当前Runtime对象的引用。Runtime 类的大多数方法是实例方法。 Runtime 对象的作用主要有:执行外部命令;返回空闲内存;运行垃圾回收器;加载动态库等。 Applets和其他不可信赖的程序由于没有引起一个安全异常(SecurityException)而不能调用任何的Runtime方法。 下面的例子演示了怎样使用Runtime 对象运行一个外部命令。 以下是引用片段: : Process process = Runtime.getRuntime().exec("cmd.exe /c dir"); process.waitFor(); : Runtime.getRuntime()返回当前应用程序的Runtime对象,该对象的exec()方法指示Java虚拟机创建一个子进程执行指定的可执行程序,并返回与该子进程对应的Process对象实例。通过Process可以控制该子进程的执行或获取该子进程的信息。第二条语句的目的是等待子进程完成后再往下执行。
取得系统中网卡MAC地址的三种方法 第一种方法使用Microsoft的Netbios API。这是一套通过Winsock提供底层网络支持的命令。使用Netbios的最大缺点是您必须在系统中安装了Netbios 服务(如果您在windows网络中启用了文件共享的话,这就不是问题了)。除此此 外,这种方法又快又准确。 Netbios API只包括了一个函数,就叫做Netbios。这个函数使用网络控制块(network control block)结构作为参数,这个结构告诉函数要做什么。结构的定义如下: typedef struct _NCB { UCHAR ncb_command; UCHAR ncb_retcode; UCHAR ncb_lsn; UCHAR ncb_num; PUCHAR ncb_buffer; WORD ncb_length; UCHAR ncb_callname[NCBNAMSZ]; UCHAR ncb_name[NCBNAMSZ]; UCHAR ncb_rto; UCHAR ncb_sto; void (CALLBACK *ncb_post) (struct _NCB *); UCHAR ncb_lana_num; UCHAR ncb_cmd_cplt; #ifdef _WIN64 UCHAR ncb_reserve[18]; #else UCHAR ncb_reserve[10]; #endif HANDLE ncb_event; } NCB, *PNCB; 重点在于ncb_command 成员。这个成员告诉Netbios该作什么。我们使用三个命令来探测MAC地址。他们在MSDN的定义如下: 命令描述: NCBENUM Windows NT/2000: 列举系统中网卡的数量。使用此命令后,ncb_buffer 成员指向由LANA_ENUM结构填充的缓冲区。 NCBENUM 不是标准的 NetBIOS 3.0 命令。 NCBRESET 重置网卡。网卡在接受新的NCB命令之前必须重置。 NCBASTAT 接受本地或远程接口卡的状态。使用此命令后,ncb_buffer成员指向由ADAPTER_STATUS结构填充的缓冲区,随后是NAME_BUFFER结构的数组。
最近作软件注册,收集了很多.NET相关的获取硬盘物理序列号的方法,主要分为使用WMI方式和API方式。但这些方法均可能有问题。 1,使用WMI方式,有的机器根本取不到硬盘序列号,有的方式在Vista下面会报错。 常用的使用WMI的方式主要有下面一些方式: class HardDrive { private string model = null; private string type = null; private string serialNo = null; public string Model { get {return model;} set {model = value;} } public string Type { get {return type;} set {type = value;} } public string SerialNo { get {return serialNo;} set {serialNo = value;} } } class TestProgram { ///
ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive"); foreach(ManagementObject wmi_HD in searcher.Get()) { HardDrive hd = new HardDrive(); hd.Model = wmi_HD["Model"].ToString(); hd.Type = wmi_HD["InterfaceType"].ToString(); hdCollection.Add(hd); } searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PhysicalMedia"); int i = 0; foreach(ManagementObject wmi_HD in searcher.Get()) { // get the hard drive from collection // using index HardDrive hd = (HardDrive)hdCollection[i]; // get the hardware serial no. if (wmi_HD["SerialNumber"] == null) hd.SerialNo = "None"; else hd.SerialNo = wmi_HD["SerialNumber"].ToString(); ++i; } // Display available hard drives foreach(HardDrive hd in hdCollection) { Console.WriteLine("Model\t\t: " + hd.Model); Console.WriteLine("Type\t\t: " + hd.Type); Console.WriteLine("Serial No.\t: " + hd.SerialNo); Console.WriteLine(); } // Pause application Console.WriteLine("Press [Enter] to exit..."); Console.ReadLine(); } }
获取以太网卡的MAC地址 【实验目的】 1、通过设计获取以太网卡物理地址的程序,初步掌握在应用层访问底层软硬件接口和属性的方法。 2、设计一个程序,使得能够获取本机安装的以太网卡的物理地址。 3、设计一个简单的应用程序,使得该程序只能在装有指定地址网卡的微机上运行。 【实验性质】 综合与设计性实验 【实验条件】 装有以胎网卡并配置网络协议的微机 【实验导读】 1、MAC地址MAC地址是每一个连接到LAN的端口或设备所需要的规范化的数据链 路层地址。MAC地址字长6B(注意也有2B的),由IEEE控制。在数据链路层,数据帧传输的寻址是依照网卡地址进行的。网卡地址可以采用局部地址或全局地址,以太网使用6B即48位的全局地址。对于共享型以太网,传输通过广播实现,各个网卡按照自己的物理地址接受属于自己的数据帧。而在交换式以太网,交换机通过逆向学习方式建立动态的MAC地址--端口映射表,根据该表进行数据帧的转发。当映射表中没有相应表项时再广播发送到各个端口。这种传输机制当然要求网卡MAC地址的唯一性。对一些应用程序来说,获取MAC地址有时是必要的。 【实验内容】 1、Linux编程要点 在Linux下编写获取本机网卡地址的程序,比较简单的方法是利用套接口(socket)和IO接口(ioctl)函数来获取网卡信息,需要引用如下文件: #include
VC 之获取硬盘序列号 上一回,一帆风给大家讲了讲如何读取计算机的MAC地址,这次聊聊怎么获取硬盘序列号。硬盘物理序列号是硬盘的出厂序列号,它是全球都是唯一的,不会随着系统的安装、硬盘的格式化等操作而改变,跟mac地址一样都具有唯一性。1,第一步:创建设备对象,得到设备句柄,设备为硬盘。 { CString sFilePath; sFilePath.Format("\\\\.\\PHYSICALDRIVE%d", driver); HANDLE hFile=::CreateFile(sFilePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); DWORD dwBytesReturned; GETVERSIONINPARAMS gvopVersionParams; DeviceIoControl(hFile, //向设备对象发送SMART_GET_VERSION设备请求,获取硬盘属性 SMART_GET_VERSION, NULL, 0, &gvopVersionParams, sizeof(gvopVersionParams), &dwBytesReturned, NULL); if(gvopVersionParams.bIDEDeviceMap <= 0) return -2; 2。第二步,发送SMART_RCV_DRIVE_DATA设备请求,获取硬盘详细信息。 // IDE or ATAPI IDENTIFY cmd int btIDCmd = 0; SENDCMDINPARAMS InParams; int nDrive =0; btIDCmd = (gvopVersionParams.bIDEDeviceMap >> nDrive & 0x10) ? IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY; // 输出参数 BYTE btIDOutCmd[sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1]; if(DoIdentify(hFile, &InParams,
获取手机的mac地址的简单实现 public static String getMacAddress(Context context) { // 获取mac地址: String macAddress = "000000000000"; try { WifiManager wifiMgr = (WifiManager) context .getSystemService(Context.WIFI_SERVICE); WifiInfo info = (null == wifiMgr ? null : wifiMgr .getConnectionInfo()); if (null != info) { if (!TextUtils.isEmpty(info.getMacAddress())) macAddress = info.getMacAddress().replace(":", ""); else return macAddress; } } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace();
return macAddress; } return macAddress; } 注:添加权限 方法二: public String getLocalMacAddress() { WifiManager wifi = (WifiManager)getSystemService(Context.WIFI_SERVICE); WifiInfo info = wifi.getConnectionInfo(); return info.getMacAddress(); }
作者自己已经在vs2008下编译通过,此代码获取的是机器的硬盘物理序列号(唯一的,即使格式化硬盘也不变) main.cpp #include "GetHDSerial.h" #include
取得IP的方法很多,比如"局域网查看工具",我推荐用“局域网花名册”网上随便搜索一下就有了。 取得MAC地址的方法:WIN+R,输入CMD,用"NBTSTAT -A IP地址" 查看。不过,我试过好像这能查看自己的ip和mac,如下 C:\Documents and Settings\hike>nbtstat -A 211.69.244.171 本地连接: Node IpAddress: [211.69.244.171] Scope Id: [] NetBIOS Remote Machine Name Table Name Type Status --------------------------------------------- 9D15D457A66C432<00> UNIQUE Registered 9D15D457A66C432<20> UNIQUE Registered WORKGROUP <00> GROUP Registered MAC Address = 00-E0-4A-01-BE-9C 如果查看别人的会显示: C:\Documents and Settings\hike>nbtstat -A 211.69.244.188 本地连接: Node IpAddress: [211.69.244.171] Scope Id: [] Host not found. 取得自己电脑IP与MAC的方法:WIN+R,输入CMD,用"IPCONFIG /ALL" 查看,还有一个快速查看mac的命令:“getmac”,也挺方便的。 下面是我强烈推荐的查看别人ip和mac的命令: 先用ping,ping通每一台机器,然后用arp -a 可列出所有刚才ping通的机器的网卡号。
vb获取硬盘序列号:利用硬盘序列号计算软件注册码-vb教程 疯狂代码 https://www.sodocs.net/doc/331288273.html,/ ?:http:/https://www.sodocs.net/doc/331288273.html,/VisualBasic/Article15611.html 盘序列号计算软件注册码。在模块中加入下列声明: Public Declare Function GetVolumeInformation Lib \"kernel32\" _ Alias \"GetVolumeInformationA\" (ByVal lpRootPathName As String, _ ByVal lpVolumeNameBuffer As String, ByVal nVolumeNameSize As Long, _ lpVolumeSerialNumber As Long, lpMaximumComponentLength As Long, _ lpFileSystemFlags As Long, ByVal lpFileSystemNameBuffer As String, _ ByVal nFileSystemNameSize As Long) As Long ′得到某一磁盘分区的信息,如C:窗体代码如下: Option Explicit Private Regid, Localid As LongPrivate Sub CmdLocalID_Click() ′根据C盘序列号得到原ID Dim Driver, VolName, Fsys As String Dim volNumber, MCM, FSF As Long Driver = \"c:\\\" Dim res As Long res = GetVolumeInformation(Driver, VolName, 127, volNumber, MCM, FSF, Fsys, 127) ′volNumber是C盘序列号 Localid = volNumber / 2 + 123456789 Text1.Text = Localid End SubPrivate Sub CmdRegID_Click() ′根据原ID算出注册ID If IsNumeric(Text1.Text) Then Regid = CLng(Text1.Text) / 4 * 3 + 987654321 Else ′error End If Text2.Text = Regid End SubPrivate Sub CmndCheckID_Click() ′验证注册ID Dim Driver, VolName, Fsys As String Dim volNumber, MCM, FSF As Long Driver = \"c:\\\" Dim res As Long
Public class MacUtils{ //这个方法运行时间太长 public static String callCmd(String[] cmd) { String result = ""; String line = ""; try { Process proc = Runtime.getRuntime().exec(cmd); InputStreamReader is = new InputStreamReader(proc.getInputStream()); BufferedReader br = new BufferedReader(is); while ((line = br.readLine()) != null) { result += line; } } catch (Exception e) { e.printStackTrace(); } return result; } /** * @param cmd 第一个命令 * @param another 第二个命令 * @return第二个命令的执行结果 */ public static String callCmd(String[] cmd, String[] another) { String result = "";
String line = ""; try { Runtime rt = Runtime.getRuntime(); Process proc = rt.exec(cmd); proc.waitFor(); // 已经执行完第一个命令,准备执行第二个命令 proc = rt.exec(another); InputStreamReader is = new InputStreamReader(proc.getInputStream()); BufferedReader br = new BufferedReader(is); while ((line = br.readLine()) != null) { result += line; } } catch (Exception e) { e.printStackTrace(); } return result; } /** * * @param ip 目标ip,一般在局域网内 * @param sourceString 命令处理的结果字符串 * @param macSeparator mac分隔符号 * @return mac地址,用上面的分隔符号表示
Linux下获取CPUID、硬盘序列号与 MAC地址 在很多系统软件的开发中,需要使用一些系统的唯一性信息。所以,得到主机的CPUID、硬盘序列号及网卡的MAC地址,就成个一件很重要的应用。 本人经过一番google即自己的钻研,基本上实现了这几个功能。需要的准备知识有: 1.GCC的嵌入汇编,具体的GCC嵌入汇编知识,请参考相关手册 2.ioctl系统调用,具体的调用方法,请查看手册页 获取CPUID 按照网上提供的说明,CPUID并不是所有的Intel CPU都支持的。如果支持,汇编调用为:eax置0000_0003,调用cpuid。 以下为实现代码(在我的CPU上,并没有得到): #define cpuid(in,a,b,c,d) asm("cpuid": "=a" (a), "=b" (b), "=c" (c), "=d" (d) : "a" (in)); static int getcpuid (char *id, size_t max) { int i; unsigned long li, maxi, maxei, ebx, ecx, edx, unused; cpuid (0, maxi, unused, unused, unused); maxi &= 0xffff; if (maxi < 3) { return -1; } cpuid (3, eax, ebx, ecx, edx); snprintf (id, max, "%08lx %08lx %08lx %08lx", eax, ebx, ecx, edx); fprintf (stdout, "get cpu id: %s\n", id); return 0; } 获取硬盘序列号 这个的实现,采用的是读取/etc/mtab文件,找到/(即根目录)挂载的设备文件,然后打开它,再用系统调用 ioctl来实现的。 ioctl第二个参数为HDIO_GET_IDENTITY, 获得指定文件描述符的标志号 ioctl的第三个参数为struct hd_driveid *,在linux/hdreg.h中,struct hd_driveid 的声明有 struct hd_driveid { unsigned short config; /* lots of obsolete bit flags */ unsigned short cyls; /* Obsolete, "physical" cyls */ unsigned short reserved2; /* reserved (word 2) */ unsigned short heads; /* Obsolete, "physical" heads */ unsigned short track_bytes; /* unformatted bytes per track */ unsigned short sector_bytes; /* unformatted bytes per sector */ unsigned short sectors; /* Obsolete, "physical" sectors per track */ unsigned short vendor0; /* vendor unique */ unsigned short vendor1; /* vendor unique */
#include 如何获得本机MAC地址(网卡地址) 世界上每一台计算机都有唯一的MAC地址与其对应,MAC地址是计算机的身份标示,找出MAC地址可以实现IP地址与MAC地址的绑定,防止IP地址被盗用。 方法一: 条件:计算机装载网卡驱动 第一步:鼠标点击“开始”->“运行”,图1所示 图 1 第二步:在图1中,点击“运行(R)...”,出现运行窗口,在“打开”命令行中输入cmd,如图2所示: 图 2 第三步:在图2中,点击“确定”按钮,出现命令窗口,在命令窗口中键入命令:ipconfig /all,回车,显示图3 图 3 第四步:请您记录下图3红圈中显示的本机MAC地址(网卡地址),去掉“-”符号,字母用小写,即0005.5d72.ac05 注:MAC地址由“0、1、2、3、4、5、6、7、8、9”和小写字母“a、b、c、d、e、f”组成,共12位 方法二:快捷方式 条件:计算机连接外部网络 第一步:鼠标点击“我的电脑”->“网上邻居”,图1所示 第二步:鼠标点击“网上邻居”后,如图点击“查看网络连接”或是“更改适配器的设置”。 第三步:双击“本地连接”(或右击“本地连接”,选择状态)。 第四步:在如图的“本地连接状态”中选择“支持” 第五步:如图选择点击“详细信息”,出现的“实际地址”(有效地址) 就是所要查找的“MAC地址”,将其记录,请您记录下图3红圈中显示的本机MAC地址(网卡地址),去掉“-”符号,字母用小写,即000c.6e65.8ac8 注:MAC地址由“0、1、2、3、4、5、6、7、8、9”和小写字母“a、b、c、d、e、f”组成,共12位如何获得本机MAC地址