Numero di serie della CPU
https://stackoverflow.com/questions/90462
-
01-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Come posso ottenere il numero di serie della CPU in un PC?
Soluzione
In base al tag "licenza" che hai utilizzato per la tua domanda, potresti ottenere risultati migliori lettura dell'indirizzo MAC di rete.Identificare il PC tramite un indirizzo MAC non è un metodo totalmente indistruttibile per la protezione dalla copia, tuttavia a volte viene utilizzato.
Altri suggerimenti
Ho la risposta definitiva a questo senza librerie esterne.Basta digitare questo:
il bios wmic ottiene il numero di serie
Questo ti darà il numero di serie sul telaio PCS;) (trovato nella base di conoscenza di Microsoft)
Saluti!
Ricorda che la maggior parte dei computer al giorno d'oggi viene fornita con l'ID CPU disabilitato nel BIOS.Vedere CPUID su Wikipedia
Anche con CPUID abilitato esiste effettivamente un numero di serie disponibile nei processori moderni?Ricordo che ci fu una grande protesta nei giorni 3 del Pentium quando fu sollevata l'intera questione del numero di serie.
Questo è un vecchio thread.Ma ho avuto lo stesso problema, ma ho ottenuto che la seguente logica funzionasse senza troppi se e ma.
Il problema con il numero di serie della CPU è che non sempre funziona in un ambiente virtualizzato.
Ho eseguito la seguente logica con un set di server basati su Windows:
Win32_BIOS può fornirti un numero di serie del bios.Dobbiamo tenere presente che se il sistema è virtualizzato, potresti ritrovarti con lo stesso numero di serie del BIOS per tutti i server.
Win32_NetworkAdapter può fornirti un MAC che puoi utilizzare anche tu.Nei casi in cui disponi di più NIC, ti ritroverai con più MAC.
Combinando entrambi questi ID, ho ottenuto un set univoco su un set di 6000 server che si estendono tra fisici e virtuali.Questo è stato davvero semplice da implementare utilizzando ManagementClass & ManagementObject.
Ma solo un avvertimento:quando provi a ottenere il MO esempio in remoto, ci vorranno più di pochi secondi su una rete ottica a 10 Gbps con latenza <5 ms.Quindi, se fai i conti, mi ci sono volute più di 3 ore per un'operazione a thread singolo.Poiché questo è più simile a un traffico a bassa priorità, non volevo spammare la mia rete per la raccolta WMI dati su chiamate multi-thread.
Non esiste un ID seriale della CPU (PSN;CPUID edx bit 18 "psn" numero di serie del processore) dopo Pentium III nelle CPU Intel;e non c'è mai stato alcun psn nei chip AMD:
https://software.intel.com/en-us/forums/watercooler-catchall/topic/308483 (nel 2005)
Tuttavia, tenere presente che solo i processori Pentium III Xeon, Mobile Pentium III e Pentium III supportano la funzionalità del numero di serie del processore introdotta dal processore Pentium III.Nessun altro processore Intel supporta la funzionalità del numero di serie del processore
https://en.wikipedia.org/wiki/Pentium_III#Controversy_about_privacy_issues
https://en.wikipedia.org/wiki/CPUID#EAX=3:_Processor_Serial_Number
EAX=3:Numero di serie del processore Vedi anche:Pentium III § Polemica sulla questione della privacy
Ciò restituisce il numero di serie del processore.Il numero di serie del processore è stato introdotto su Intel Pentium III, ma a causa di problemi di privacy, questa funzionalità non è più implementata sui modelli successivi (il bit della funzionalità PSN viene sempre cancellato).Anche i processori Efficeon e Crusoe di Transmeta forniscono questa funzionalità.Le CPU AMD, tuttavia, non implementano questa funzionalità in nessun modello di CPU.
Utilizza lo strumento CPUZ: http://www.cpuid.com/cpuz.php
__get_cpuid (unsigned int __level, unsigned int *__eax, unsigned int *__ebx, unsigned int *__ecx, unsigned int *__edx);
- Intestazione:
#include <cpuid.h>
Nota: Il numero di serie del processore è stato introdotto su Intel Pentium III, ma per motivi di privacy questa funzionalità non è più implementata sui modelli successivi.
Fonte : Wikipedia
Le CPU Ivy Bridge e quelle successive includono tutte un PPIN (numero di identificazione del processore protetto).L'accesso a questa funzionalità può essere bloccato dal firmware del computer.
Qualche dettaglio in più per favore:sistema operativo, lingua.
Ad esempio su Windows puoi ottenerlo utilizzando WMI e reading Win32_Processor.ProcessorId.
In Windows, sono sicuro che ci sia una chiamata di sistema, in Linux si potrebbe provare "sudo lshw" ma la maggior parte dei kernel non sembra supportare i numeri di serie della CPU, e la ricerca preliminare sembra indicare che l'indignazione generale contro i computer identificabili in modo univoco significa che non ci sono non è una risposta perfetta.
Cosa stai cercando di fare?Quasi certamente qualcuno lo ha già fatto e potrebbe essere saggio riutilizzare o emulare ciò che ha fatto.
L'esecuzione dell'istruzione CPUID con le impostazioni di registro corrette recupererà il numero di serie del processore in EAX, EBX, ECX ed EDX.Tuttavia, questa funzionalità è disponibile solo su Pentium 3 e processori successivi.Anche su Pentium 4 e processori più recenti l'istruzione restituisce sempre 0x00000000 in tutti e 4 i registri.Anche i modelli successivi di Pentium 3 potrebbero restituire 0x00000000.La funzionalità mirava principalmente alla protezione dalla copia, consentendo di collegare il software a processori specifici.La cosa non andò bene con la comunità e ne seguirono azioni legali.La funzionalità è stata rimossa dall'ultimo modello P3 e da tutti i processori più recenti.La funzionalità è presente nei processori più recenti per motivi di compatibilità.Si dice che sia possibile ordinare processori speciali con numeri di serie, ma l'acquisto minimo è qualcosa come 1 milione di processori.Per le impostazioni di registro specifiche prima di eseguire l'istruzione CPUID, consultare il PDF del programmatore di sistema Intels disponibile tramite il relativo sito Web.
Anche -
#include <Windows.h>
#include <stdio.h>
#include <xmmintrin.h>
#include <iphlpapi.h>
#include <Rpc.h>
static void GetMACaddress(void);
static void uuidGetMACaddress(void);
int main(){
SYSTEM_INFO SysInfo;
GetSystemInfo(&SysInfo);
printf("Processors - %d\n" , SysInfo.dwNumberOfProcessors);
DWORD a , b , c , d , e;
DWORD BasicLeaves;
char* VendorID = (char*)malloc(20);
char* message = (char*)malloc(20);
_asm {
pusha
pushfd
pop eax
push eax
xor eax , 0x00200000
push eax
popfd
pushfd
pop ecx
pop eax
xor eax , ecx
mov [a] , eax
}
if(a & 0x00200000){
printf("CPUID opcode supported.\n");
} else {
printf("CPUID opcode not supported, exiting...\n");
return 0;
}
//DWORD* pa = &a[0];
//DWORD* pb = &a[1];
//DWORD* pc = &a[2];
//DWORD* pd = &a[3];
//a[4] = 0;
e = 0;
__asm {
mov eax , 0
cpuid
mov [BasicLeaves] , eax;
mov [b] , ebx;
mov [c] , ecx;
mov [d] , edx;
}
memcpy(&VendorID[0] , &b , 4);
memcpy(&VendorID[4] , &d , 4);
memcpy(&VendorID[8] , &c , 4);
VendorID[12] = 0;
printf("%d Basic Leaves\nVendorID - %s\n" , BasicLeaves , VendorID);
__asm {
mov eax , 1
cpuid
mov [a] , eax;
mov [b] , ebx;
mov [c] , ecx;
mov [d] , edx;
}
if(d & 0x00000001) printf("FPU\n");
if(d & 0x00000200) printf("APIC On-Chip\n");
if(d & 0x00040000) printf("Processor Serial Number Present\n");
if(d & 0x00800000) printf("MMX\n");
if(d & 0x01000000) printf("SSE\n");
if(d & 0x02000000) printf("SSE2\n");
if(d & 0x08000000) printf("Hyperthreading (HTT)\n");
if(c & 0x00000001) printf("SSE3\n");
if(c & 0x00000200) printf("SSSE3\n");
if(c & 0x00080000) printf("SSE4.1\n");
if(c & 0x00100000) printf("SSE4.2\n");
if(c & 0x02000000) printf("AES\n");
__asm {
mov eax , 0x80000000
cpuid
and eax , 0x7fffffff;
mov [a] , eax;
mov [b] , ebx;
mov [c] , ecx;
mov [d] , edx;
}
printf("%d Extended Leaves\n" , a);
printf("Processor Brand String - ");
__asm {
mov eax , 0x80000002
cpuid
mov [a] , eax;
mov [b] , ebx;
mov [c] , ecx;
mov [d] , edx;
}
memcpy(&message[0] , &a , 4);
memcpy(&message[4] , &b , 4);
memcpy(&message[8] , &c , 4);
memcpy(&message[12] , &d , 4);
message[16] = 0;
printf("%s" , message);
__asm {
mov eax , 0x80000003
cpuid
mov [a] , eax;
mov [b] , ebx;
mov [c] , ecx;
mov [d] , edx;
}
memcpy(&message[0] , &a , 4);
memcpy(&message[4] , &b , 4);
memcpy(&message[8] , &c , 4);
memcpy(&message[12] , &d , 4);
message[16] = 0;
printf("%s" , message);
__asm {
mov eax , 0x80000004
cpuid
mov [a] , eax;
mov [b] , ebx;
mov [c] , ecx;
mov [d] , edx;
popa
}
memcpy(&message[0] , &a , 4);
memcpy(&message[4] , &b , 4);
memcpy(&message[8] , &c , 4);
memcpy(&message[12] , &d , 4);
message[16] = 0;
printf("%s\n" , message);
char VolumeName[256]; DWORD VolumeSerialNumber; DWORD MaxComponentLength; DWORD FileSystemFlags; char FileSystemNameBuffer[256];
GetVolumeInformationA("c:\\" , VolumeName , 256 , &VolumeSerialNumber , &MaxComponentLength , &FileSystemFlags , (LPSTR)&FileSystemNameBuffer , 256);
printf("Serialnumber - %X\n" , VolumeSerialNumber);
GetMACaddress();
uuidGetMACaddress();
return 0;
}
// Fetches the MAC address and prints it
static void GetMACaddress(void){
IP_ADAPTER_INFO AdapterInfo[16]; // Allocate information
// for up to 16 NICs
DWORD dwBufLen = sizeof(AdapterInfo); // Save memory size of buffer
DWORD dwStatus = GetAdaptersInfo( // Call GetAdapterInfo
AdapterInfo, // [out] buffer to receive data
&dwBufLen); // [in] size of receive data buffer
//assert(dwStatus == ERROR_SUCCESS); // Verify return value is
// valid, no buffer overflow
PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo; // Contains pointer to
// current adapter info
do {
printf("Adapter MAC Address - %X-%X-%X-%X-%X-%X\n" , pAdapterInfo->Address[0] , pAdapterInfo->Address[1] , pAdapterInfo->Address[2] , pAdapterInfo->Address[3] , pAdapterInfo->Address[4] , pAdapterInfo->Address[5]);
printf("Adapter IP Address - %s\n" , pAdapterInfo->CurrentIpAddress);
printf("Adapter Type - %d\n" , pAdapterInfo->Type);
printf("Adapter Name - %s\n" , pAdapterInfo->AdapterName);
printf("Adapter Description - %s\n" , pAdapterInfo->Description);
uuidGetMACaddress();
printf("\n");
//PrintMACaddress(pAdapterInfo->Address); // Print MAC address
pAdapterInfo = pAdapterInfo->Next; // Progress through
// linked list
} while(pAdapterInfo); // Terminate if last adapter
}
// Fetches the MAC address and prints it
static void uuidGetMACaddress(void)
{
unsigned char MACData[6];
UUID uuid;
UuidCreateSequential( &uuid ); // Ask OS to create UUID
for (int i=2; i<8; i++) // Bytes 2 through 7 inclusive
// are MAC address
MACData[i - 2] = uuid.Data4[i];
printf("UUID MAC Address - %X-%X-%X-%X-%X-%X\n" , MACData[0] , MACData[1] , MACData[2] , MACData[3] , MACData[4] , MACData[5]);
}//*/
Puoi usare ID CPU comando.
Immagino che alcuni compilatore offrano un po 'di wrapper o simili al comando menzionato.Ecco un esempio
#include <stdlib.h>
#include <string.h>
#include <intrinsics.h>
_CPUID cpuinfo;
int main(void) {
_cpuid(&cpuinfo);
printf("Vendor: %s\n", cpuinfo.Vendor);
return 0;
}
Produzione:
Vendor: GenuineIntel
