DELPHI7.0 Obtenez le code du disque dur, du processeur et du numéro de série de la carte réseau

Auteur：Eve Cole Date de mise à jour：2025-02-02 12:36:01

Copiez le code comme suit :

//Déclaration des variables de référence et TYPE

utilise

Windows, messages, SysUtils, variantes, classes, graphiques, contrôles, formulaires,

Boîtes de dialogue, StdCtrls, nb30 ; {Citation importante}

taper

PASTAT = ^TASTAT;

TASTAT=enregistrement

adaptateur : TAdapterStatus;

nom_buf : TNameBuffer;

fin;

TForm1 = classe(TForm)

Bouton1 : TButton ;

Edit1 : TEdit ;

Étiquette1 : TLabel ;

Étiquette2 : TLabel ;

Étiquette3 : TLabel ;

Edit2 : TEdit ;

Edit3 : TEdit ;

Bouton2 : TButton ;

Edit4 : TEdit ;

Étiquette4 : TLabel ;

procédure Button1Click (Expéditeur : TObject);

procédure Button2Click (Expéditeur : TObject);

privé

{Déclarations privées}

publique

{Déclarations publiques}

fin;

var

Formulaire1 : TForm1 ;

mise en œuvre

{$R *.dfm}

taper

TCPUID = tableau[1..4] de Longint ;

//Obtenir le numéro de série du disque dur :

function GetIdeSerialNumber: pchar; //Obtenir le numéro de série d'usine du disque dur ;

const IDENTIFY_BUFFER_SIZE = 512 ;

taper

TIDERegs = record emballé

bFeaturesReg : OCTET ;

bSectorCountReg : OCTET ;

bSectorNumberReg : OCTET ;

bCylLowReg : OCTET ;

bCylHighReg : OCTET ;

bDriveHeadReg : OCTET ;

bCommandReg : OCTET ;

bRéservé : BYTE ;

fin;

TSendCmdInParams = enregistrement compressé

cTaille du tampon : DWORD ;

irDriveRegs : TIDERegs ;

bNuméro de lecteur : BYTE ;

bRéservé : tableau[0..2] d'octet ;

dwReserved : tableau[0..3] de DWORD ;

bBuffer : tableau[0..0] d'octet ;

fin;

TIdSector = enregistrement compressé

wGenConfig : Word ;

wNumCyls : Mot ;

wRéservé : Word ;

wNumHeads : Mot ;

wBytesPerTrack : Word ;

wBytesParSecteur : Word ;

wSecteursParTrack : Word ;

wVendorUnique : tableau[0..2] de Word ;

sSerialNumber : tableau[0..19] de CHAR ;

wBufferType : Mot ;

wBufferSize : Word ;

wECCTaille : Mot ;

sFirmwareRev : tableau[0..7] de Char ;

sModelNumber : tableau[0..39] de Char ;

wMoreVendorUnique : Word ;

wDoubleWordIO : Mot ;

wCapacités : Word ;

wRéservé1 : Mot ;

wPIOTiming : Mot ;

wDMATiming : Word ;

wBS : Mot ;

wNumCurrentCyls : Mot ;

wNumCurrentHeads : Mot ;

wNumCurrentSectorsPerTrack : Word ;

ulCurrentSectorCapacity : DWORD ;

wMultSectorStuff : Word ;

ulTotalAddressableSectors : DWORD ;

wSingleWordDMA : Mot ;

wMultiWordDMA : Mot ;

bRéservé : tableau[0..127] de BYTE ;

fin;

PIdSecteur = ^TIdSecteur;

TDriverStatus = enregistrement compressé

bDriverError : octet ;

bIDEStatus : octet ;

bRéservé : tableau[0..1] d'octet ;

dwReserved : tableau[0..1] de DWORD ;

fin;

TSendCmdOutParams = enregistrement compressé

cTaille du tampon : DWORD ;

Statut du pilote : TDriverStatus ;

bBuffer : tableau[0..0] de BYTE ;

fin;

var

hAppareil : Thandle ;

cbBytesReturned : DWORD ;

SCIP : TSendCmdInParams ;

aIdOutCmd : tableau[0..(SizeOf(TSendCmdOutParams) + IDENTIFY_BUFFER_SIZE-1)-1] d'octet ;

IdOutCmd : TSendCmdOutParams aIdOutCmd absolu ;

procédure ChangeByteOrder(var Data; Size: Integer);//Le processus dans la fonction

var

ptr : Pchar ;

je : entier ;

c : Char ;

commencer

ptr := @Données;

pour I := 0 à (Taille shr 1) - 1 commence

c := ptr^;

ptr^ := (ptr + 1)^;

(ptr + 1)^ := c;

Inc(ptr, 2);

fin;

début //corps de la fonction

Résultat := '';

si SysUtils.Win32Platform = VER_PLATFORM_WIN32_NT alors

début // Windows NT, Windows 2000

hDevice := CreateFile('//./PhysicalDrive0', GENERIC_READ ou GENERIC_WRITE,

FILE_SHARE_READ ou FILE_SHARE_WRITE, nul, OPEN_EXISTING, 0, 0);

fin

sinon // Version Windows 95 OSR2, Windows 98

hDevice := CreateFile('//./SMARTVSD', 0, 0, nil, Create_NEW, 0, 0);

si hDevice = INVALID_HANDLE_VALUE alors Quittez ;

essayer

FillChar(SCIP, SizeOf(TSendCmdInParams) - 1, #0);

FillChar(aIdOutCmd, SizeOf(aIdOutCmd), #0);

cbBytesReturned := 0;

avec SCIP faire

commencer

cBufferSize := IDENTIFY_BUFFER_SIZE;

avec irDriveRegs faire

commencer

bSectorCountReg := 1;

bSectorNumberReg := 1;

bDriveHeadReg := $A0;

bCommandReg := $EC;

fin;

sinon DeviceIoControl(hDevice, $0007C088, @SCIP, SizeOf(TSendCmdInParams) - 1,@aIdOutCmd, SizeOf(aIdOutCmd), cbBytesReturned, nil) alors Quittez ;

enfin

CloseHandle(hDevice);

fin;

avec PIdSector (@IdOutCmd.bBuffer) ^ faites

commencer

ChangeByteOrder(sSerialNumber, SizeOf(sSerialNumber));

(Pchar (@sSerialNumber) + SizeOf(sSerialNumber))^:= #0;

Résultat := Pchar (@sSerialNumber);

fin;

//================================================= =================

//Numéro de série du processeur :

FONCTION GetCPUID : TCPUID ;

asme

PUSH EBX {Enregistrer le registre concerné}

POUSSER EDI

MOV EDI, EAX {@Résultat}

MOUVEMENT EAX,1

DW $A20F {Commande CPUID}

STOSD {CPUID[1]}

MOUVEMENT EAX,EBX

STOSD {CPUID[2]}

MOUVEMENT EAX,ECX

STOSD {CPUID[3]}

MOUVEMENT EAX,EDX

STOSD {CPUID[4]}

POP EDI {Restaurer les registres}

POPEBX

FIN;

fonction GetCPUIDStr:String ;

var

ID CPU : TCPUID ;

commencer

CPUID :=ObtenirCPUID ;

Résultat :=IntToHex(CPUID[1],8)+IntToHex(CPUID[2],8)+IntToHex(CPUID[3],8)+IntToHex(CPUID[4],8);

fin;

///================================================ = ===================================

///Obtenir MAC (carte réseau non intégrée) :

fonction NBGetAdapterAddress(a: Integer) : chaîne ;

var

NCB : TNCB ; // Bloc de contrôle Netbios // Bloc de contrôle NetBios

ADAPTER : TADAPTERSTATUS ; // État de l'adaptateur Netbios//Obtenir l'état de la carte réseau

LANAENUM : TLANAENUM ; // Netbios lana

intIdx : Integer ; // Valeur de travail temporaire // Variable temporaire

cRC : Char ; // Code de retour Netbios // Valeur de retour NetBios

strTemp: string; // Chaîne temporaire // Variable temporaire

commencer

//Initialiser

Résultat := '';

essayer

// Bloc de contrôle zéro

ZeroMemory (@NCB, SizeOf(NCB));

// Émet la commande enum

NCB.ncb_command := Chr(NCBENUM);

cRC := NetBios (@NCB);

// Réémet la commande enum

NCB.ncb_buffer := @LANAENUM;

NCB.ncb_length := SizeOf(LANAENUM);

cRC := NetBios (@NCB);

si ord(cRC) <> 0 alors

sortie;

//Réinitialiser l'adaptateur

ZeroMemory (@NCB, SizeOf(NCB));

NCB.ncb_command := Chr(NCBRESET);

NCB.ncb_lana_num := LANAENUM.lana[a];

cRC := NetBios (@NCB);

si ord(cRC) <> 0 alors

sortie;

// Récupère l'adresse de l'adaptateur

ZeroMemory (@NCB, SizeOf(NCB));

NCB.ncb_command := Chr(NCBASTAT);

NCB.ncb_lana_num := LANAENUM.lana[a];

StrPCopy(NCB.ncb_callname, '*');

NCB.ncb_buffer := @ADAPTER;

NCB.ncb_length := SizeOf(ADAPTER);

cRC := NetBios (@NCB);

// Le convertit en chaîne

strTemp := '';

pour intIdx := 0 à 5 faire

strTemp := strTemp + InttoHex(Integer(ADAPTER.adapter_address[intIdx]), 2);

Résultat := strTemp;

enfin

fin;

//================================================= ==========================

//Récupérer l'adresse MAC (carte réseau intégrée et carte réseau non intégrée) :

fonction Getmac:chaîne ;

var

BCN : TNCB ;

s:chaîne;

adapter : TASTAT ;

lanaEnum : TLanaEnum;

i, j, m : entier ;

strPart, strMac : chaîne ;

commencer

FillChar(ncb, SizeOf(TNCB), 0);

ncb.ncb_command := Char(NCBEnum);

ncb.ncb_buffer := PChar (@lanaEnum);

ncb.ncb_length := SizeOf(TLanaEnum);

s:=Netbios (@ncb);

pour i := 0 à entier(lanaEnum.length)-1 faire

commencer

FillChar(ncb, SizeOf(TNCB), 0);

ncb.ncb_command := Char(NCBReset);

ncb.ncb_lana_num := lanaEnum.lana[i];

Netbios (@ncb);

FillChar(ncb, SizeOf(TNCB), 0);

ncb.ncb_command := Chr(NCBAstat);

ncb.ncb_lana_num := lanaEnum.lana[i];

ncb.ncb_callname := '* ';

ncb.ncb_buffer := PChar (@adapt);

ncb.ncb_length := SizeOf(TASTAT);

m:=0;

si (Win32Platform = VER_PLATFORM_WIN32_NT) alors

m:=1;

si m=1 alors

commencer

si Netbios (@ncb) = Chr(0) alors

strMac := '';

pour j := 0 à 5 faire

commencer

strPart := IntToHex(integer(adapt.adapter.adapter_address[j]), 2);

strMac := strMac + strPart + '-';

fin;

SetLength(strMac, Longueur(strMac)-1);

fin;

si m=0 alors

si Netbios (@ncb) <> Chr(0) alors

commencer

strMac := '';

pour j := 0 à 5 faire

commencer

strPart := IntToHex(integer(adapt.adapter.adapter_address[j]), 2);

strMac := strMac + strPart + '-';

fin;

SetLength(strMac, Longueur(strMac)-1);

fin;

résultat :=strmac ;

fin;

fonction PartitionString(StrV,PrtSymbol: string) : TStringList ;

var

iTemp : entier ;

commencer

résultat := TStringList.Create;

iTemp := pos(PrtSymbol,StrV);

tandis que iTemp>0 commence

si iTemp>1 alors result.Append(copy(StrV,1,iTemp-1));

delete(StrV,1,iTemp+length(PrtSymbol)-1);

iTemp := pos(PrtSymbol,StrV);

fin;

si Strv<>'' alors result.Append(StrV);

fin;

fonction MacStr():String;

var

Str:TStrings;

je:Entier;

MacStr:Chaîne ;

commencer

MacStr:='';

Str:=TStringList.Create;

Str:=PartitionString(Getmac,'-');

pour i:=0 à Str.Count-1 faire

MacStr:=MacStr+Str[i];

Résultat :=MacStr;

fin;

//===============================================

//Exemple d'appel

procédure TForm1.Button1Click(Expéditeur : TObject);

commencer

Edit3.Text:=strpas(GetIdeSerialNumber);//Obtenir le numéro du disque dur

Edit2.text:=GetCPUIDStr;//numéro de série du processeur

edit4.Text:=NBGetAdapterAddress(12);//Carte réseau non intégrée

Edit1.text:=MacStr;//Cartes réseau intégrées et non intégrées

fin;