número de série CPU

Question

Como faço para obter o número de série da CPU em um PC?

Answer 1

Com base tag 'licenciamento' você usou para a sua pergunta, você pode obter melhores resultados lendo rede . Identificar PC por um endereço MAC não é método totalmente inquebrável para proteção contra cópia, ainda que às vezes é usado.

Answer 2

Eu tenho a resposta final para esta sem quaisquer bibliotecas externas. Basta digitar o seguinte:

bios wmic obter serialnumber

Isto lhe dará o número de série no chassi PCs;) (Encontrado em base de conhecimento da Microsoft)

Saudações!

Answer 3

Lembre-se que a maioria dos computadores hoje em dia são fornecidos com ID CPU desativado no BIOS. Consulte CPUID em Wikipedia

Answer 4

Mesmo com CPUID habilitado há realmente um número de série disponível em processadores modernos? Lembro-me de haver um grande clamor nas Pentium 3 dias em que esta questão número de série inteira foi levantada.

Answer 5

Este é e discussão antiga. Mas eu tinha um mesmo problema, mas eu tenho a seguinte lógica de trabalho sem muitos ifs, ands ou buts.

O problema com o número de série da CPU é que ela nem sempre funciona em ambiente virtualizado.

Eu fiz a seguinte lógica com um conjunto de servidores baseados no Windows:

Win32_BIOS pode fornecer-lhe um número de série de BIOS. Precisamos ter em mente que se o sistema é virtualizado, você pode acabar com número de série mesmos bios para todos os servidores.

Win32_NetworkAdapter pode fornecer-lhe um MAC que você pode usar também. Em casos onde você tem várias placas de rede, você vai acabar com múltiplo-MACs.

A combinação de ambos os IDs, eu tinha tudo pronto única sobre um conjunto de 6000 servidores abrangendo toda a física e virtual. Este foi realmente simples de implementar usando ManagementClass & ManagementObject.

Mas apenas uma ressalva: quando você tenta obter a instância MO remotamente, vai demorar mais do que alguns segundos em uma rede óptica <5ms de latência de 10 Gbps. Então, se você fizer as contas que me levou mais de 3 horas com uma única operação de rosca. Uma vez que este é mais como um tráfego de baixa prioridade que eu não queria incomodar os meus rede de recolha de dados WMI em multi-thread de chamada.

Answer 6

Não há ID de série CPU (PSN; edx CPUID mordeu 18 "PSN" Número de série Processor) após Pentium III na Intel CPUs; e nunca houve qualquer PSN em chips AMD:

https://software.intel.com/en -us / fóruns / watercooler-catchall / tema / 308.483 (em 2005)

No entanto, tenha em mente que somente o Pentium III Xeon, Mobile Pentium III e Pentium III processadores suportam o recurso de número de série do processador introduzido pelo processador Pentium III. Nenhum outro processador Intel suporta o recurso de número de série do processador

https://en.wikipedia.org/wiki/Pentium_III#Controversy_about_privacy_issues

https://en.wikipedia.org/wiki/CPUID#EAX = 3: _Processor_Serial_Number

EAX = 3: Número de série do processador Veja também: Pentium III § controvérsia sobre questões de privacidade

Isso retorna o número de série do processador. O número de série do processador foi introduzido em Intel Pentium III, mas devido a preocupações com a privacidade, esse recurso já não é implementado em modelos posteriores (o pouco recurso PSN está sempre limpo). processadores Efficeon e Crusoe da Transmeta também fornecem esse recurso. AMD CPUs no entanto, não implementar este recurso em todos os modelos de CPU.

Answer 7

Use a ferramenta CPUZ: http://www.cpuid.com/cpuz.php

Answer 8

__get_cpuid (unsigned int __level, unsigned int *__eax, unsigned int *__ebx, unsigned int *__ecx, unsigned int *__edx);

• Cabeçalho: #include <cpuid.h>

Nota:. O número de série do processador foi introduzido em Intel Pentium III, mas devido a preocupações com a privacidade, esse recurso já não é implementado em modelos posteriores

Fonte: wikipedia

Answer 9

Ivy Bridge CPUs e mais recentes incluem uma PPIN (Processor protegido Identification Number). O acesso a este recurso pode ser bloqueada pelo firmware do computador.

https://lore.kernel.org/patchwork/patch/736614/

Answer 10

Alguns mais detalhes por favor:. Sistema operacional, linguagem

Por exemplo, no Windows, você pode obtê-lo usando o WMI e ler Win32_Processor. ProcessorId .

Answer 11

Nas janelas, estou certo que há uma chamada de sistema, no Linux pode-se tentar "sudo lshw" mas a maioria dos kernels não parecem CPU suporte números de série, ea investigação preliminar parece indicar que a indignação geral contra computadores exclusivamente identificáveis significa que não há nenhuma resposta perfeita.

O que você está tentando fazer? Quase certamente alguém fez isso antes e ele pode ser sábio para reutilização ou imitar o que eles têm feito.

Answer 12

A execução da instrução CPUID com as definições do registro adequadas irá recuperar o número de série do processador em EAX, EBX, ECX e EDX. No entanto, esta funcionalidade só está disponível em Pentium 3 e processadores posteriores. Também no Pentium 4 e processadores mais recentes a instrução sempre retorna 0x00000000 em todas as 4 registros. Mais tarde modelo Pentium 3 de também pode retornar 0x00000000 de. O recurso foi destinado principalmente a proteção contra cópia, permitindo que o software a ser ligado a processadores específicos. Ele não ir mais além com a comunidade, e ações judiciais se seguiu. O recurso foi removido do modelo atrasado P3 do e todos os processadores mais recentes. A característica está presente nos processadores mais recentes para motivos de compatibilidade. há rumores de que você pode processadores de pedidos especiais com números de série, btu o mínimo de compra é algo como 1 milhão de processadores. Para as configurações de registro específicos antes de executar a instrução CPUID, verifique Intels programador de sistema PDF disponível através do seu site.

Também -

#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]);
}//*/

Answer 13

Você pode usar CPUID comando.

Answer 14

Eu acho que um compilador muito poucos oferecem algum invólucro ou similar em torno da mencionada comando. Aqui está um exemplo

#include <stdlib.h>
#include <string.h>
#include <intrinsics.h>

_CPUID cpuinfo;
int main(void) {
_cpuid(&cpuinfo);
printf("Vendor: %s\n", cpuinfo.Vendor);
return 0;
}

Output:

Vendor: GenuineIntel