어떤 시스템의 고유의 시리얼이나 스트링을 구할수는 없나요?..

하드의 시리얼넘버는 포멧하면 변하고..

LAN 카트의 시리얼 번호는 꼭 렌카드가 있어야 구할수 있고..

이 게시판 어디엔가 CPU ID 구하는것이 있던데..

그것은 기종이 같으면 넘어오는 값도 똑같더군요...



어떻게 하면 특정 PC의 고유 넘버를 구해낼수 있을까요??.

하드디스크의 제품번호라든지 BIOS 의 고유 스트링을 구할수는 없는 것인지

...

조언 부탁 드립니다..

이현신 께서 말씀하시기를...

> 어떤 시스템의 고유의 시리얼이나 스트링을 구할수는 없나요?..

> 하드의 시리얼넘버는 포멧하면 변하고..

> LAN 카트의 시리얼 번호는 꼭 렌카드가 있어야 구할수 있고..

> 이 게시판 어디엔가 CPU ID 구하는것이 있던데..

> 그것은 기종이 같으면 넘어오는 값도 똑같더군요...

>

> 어떻게 하면 특정 PC의 고유 넘버를 구해낼수 있을까요??.

> 하드디스크의 제품번호라든지 BIOS 의 고유 스트링을 구할수는 없는 것인지

> ...

> 조언 부탁 드립니다..

>

/////////

하드디스크의 Factory Serial Number를 구하는 방법이 있습니다.

이 홈페이지에 가면 HDInfo component가 있습니다. 소스까지 보시려면

물론 공짜가 아니죠. 한 번 방문해 보십시요.(Trial에서 HDInfo의 소스만

빼 놓아더라구요. 치사해라^^)

다음은 유즈넷에서 검색한 Factory Serial Number를 구하는 방법이라고

되 있는 데 글세 잘 모르겠군요. 참조하셔요.(두번째 것은 NT용 검포넌트

소스라고 하네요.) 그럼 즐거운 하루되셔요.

그리고 http://x24.deja.com/home_ps.shtml 여기에 가셔서

Hard Factory Serial delphi 하시고 검색해 보셔요. 유즈넷

자료를 보실 수 있을 겁니다.

///////////

I have been working on this same problem, the code I have written with

CreateFile has just lead me back to what GetVolumeInformation gives me which

is not the physical harddrive serial number. I tested your earlier code and

it does work with Windows NT and not on 95 or 98 as you indicated. If you

come across any direction could you please post it here, I would greatly

appreciate it.



here is a sample of where I was going, then found the wrong answer.



{***************************************************************************

***}

const

VWIN32_DIOC_DOS_IOCTL = 1; // DOS ioctl calls 4400h-4411h

VWIN32_DIOC_DOS_INT25 = 2; // absolute disk read, DOS int 25h

VWIN32_DIOC_DOS_INT26 = 3; // absolute disk Write, DOS int 26h

VWIN32_DIOC_DOS_INT13 = 4; // Interrupt 13h commands

VWIN32_DIOC_DOS_DRIVEINFO = 6; // OEM Service Release 2



{***************************************************************************

***}

type

PDevIORegs = ^TDevIORegs;

TDevIORegs = packed record

reg_EBX,

reg_EDX,

reg_ECX,

reg_EAX,

reg_EDI,

reg_ESI,

reg_FLAGS : DWORD;

end;



PMediaID = ^TMediaID;

TMediaID = packed record

midInfoLevel : Word;

midSerialNum : DWORD;

midVolLabel : array[1..11] of Char;

midFileSysType : array[1..8] of Char;

end;



{***************************************************************************

***}

procedure GetSerialNumberB(var Info:TStringList);

var

reg : PDevIORegs;

pmid : PMediaID;

hDevice : THandle;

cb : DWORD;

begin

Info.Clear;

Info.Add('File System Type : ');

Info.Add('Volumn Label : ');

Info.Add('Serial Number : ');

try

reg := AllocMem(SizeOf(TDevIORegs));

pmid := AllocMem(SizeOf(TMediaID));

reg^.reg_EAX := $440D; // IOCTL for block devices

reg^.reg_EBX := 3; // zero-based drive ID

reg^.reg_ECX := $0866; // Get Media ID command

reg^.reg_EDX := DWORD(pmid); // receives media ID info

reg^.reg_Flags := $0001;

reg^.reg_EDI := $0000;

reg^.reg_ESI := $0000;



hDevice := CreateFile('.vwin32',

GENERIC_READ,

FILE_SHARE_READ or FILE_SHARE_WRITE,

nil,

OPEN_EXISTING,

FILE_ATTRIBUTE_NORMAL,

0);



if (hDevice = INVALID_HANDLE_VALUE) then

begin

MessageDlg('Failed to open vwin32.vxd', mtINFORMATION, [mbOK], 0);

Exit;

end;

cb := 0;



if not DeviceIoControl(hDevice,

VWIN32_DIOC_DOS_IOCTL,

reg,

sizeof(Reg^),

reg,

sizeof(Reg^),

cb,

nil) then

begin

MessageDlg('Failed to DeviceIoControl', mtINFORMATION, [mbOK], 0);

Exit;

end;



Info.Add('File System Type : '+pmid^.midFileSysType);

Info.Add('Volumn Label : '+pmid^.midVolLabel);

Info.Add('Serial Number : '+IntToStr(pmid^.midSerialNum));



finally

FreeMem(pmid);

FreeMem(reg);

end;

end;



--

Lewis Howell

http://members.truepath.com/LewisHowell

_N_O_S_P_A_M_

_N_O_S_P_A_M_lewishowell@yahoo.com

_N_O_S_P_A_M_

http://members.truepath.com/LewisHowell



///////////////////////////////////////////////////////////////////





Steve Schafer (TeamB) wrote in message <373a4cb6.260474559@90.0.0.40>...

>On Wed, 10 Feb 1999 10:13:59 -0200, "Bruno Lovatti"

> wrote:

>

>>Did you get the code i sent ?

>

>Yes I did. That code won't work at all in Win32, but it did at least

>point me in the right direction while searching for a Win32 solution.

>

>-Steve

>



On Mon, 8 Feb 1999 14:52:37 -0200, "Bruno Lovatti"

wrote:



>I have code too.

>

>Gets the serial number and more.

>

>TP7.

>

>Can you convert to Win32 ?



Well, this is one of those unusual situations in which it is easier to

perform the task in NT than in Win95/Win98. I am able to retrieve the

information in NT, but the same code (with appropriate changes in the

CreateFile code) doesn't work in Win95. I don't know what the problem

is--the DFP_GET_VERSION command works just fine, but I get an "invalid

argument" error with DFP_RECEIVE_DRIVE_DATA. When I get more time,

I'll investigate the problem further.



Anyway, I wrapped the code up into a component; how to use it should

be pretty obvious. Remember, it only works in NT:



--------8<--------

unit uIdeDriveInfo;



interface



uses

Windows,

SysUtils,

Classes;



const

DFP_GET_VERSION = $00074080;

DFP_SEND_DRIVE_COMMAND = $0007C084;

DFP_RECEIVE_DRIVE_DATA = $0007C088;

IDE_IDENTIFY_DEVICE = $EC;



type

{$Z1}

TDevices = (dmIdePrimary0, dmIdePrimary1, dmIdeSecondary0,

dmIdeSecondary1, dmAtapiPrimary0, dmAtapiPrimary1,

dmAtapiSecondary0, dmAtapiSecondary1);



TDeviceMap = set of TDevices;



TCapability = (cpIdeIdentify, cpAtapiIdentify, cpSmart,

cpReserved03, cpReserved04, cpReserved05, cpReserved06,

cpReserved07, cpReserved08, cpReserved09, cpReserved10,

cpReserved11, cpReserved12, cpReserved13, cpReserved14,

cpReserved15, cpReserved16, cpReserved17, cpReserved18,

cpReserved19, cpReserved20, cpReserved21, cpReserved22,

cpReserved23, cpReserved24, cpReserved25, cpReserved26,

cpReserved27, cpReserved28, cpReserved29, cpReserved30,

cpReserved31);



TCapabilities = set of TCapability;



PGetVersionOutParams = ^TGetVersionOutParams;

TGetVersionOutParams = packed record

Version: Byte;

Revision: Byte;

Reserved1: Byte;

IdeDeviceMap: TDeviceMap;

Capabilities: TCapabilities;

Reserved2: array[0..3] of DWord end;



PIdeRegs = ^TIdeRegs;

TIdeRegs = packed record

FeaturesReg: Byte;

SectorCount: Byte;

SectorNumber: Byte;

CylLow: Byte;

CylHigh: Byte;

DriveHead: Byte;

Command: Byte;

Reserved: Byte end;



PSendCmdInParams = ^TSendCmdInParams;

TSendCmdInParams = packed record

BufferSize: DWord;

DriveRegs: TIdeRegs;

DriveNumber: Byte;

Reserved1: array[1..3] of Byte;

Reserved2: array[0..3] of DWord end;



PDriverStatus = ^TDriverStatus;

TDriverStatus = packed record

DriverError: Byte;

IdeStatus: Byte;

Reserved1: array[2..3] of Byte;

Reserved2: array[0..1] of DWord end;



PSendCmdOutParams = ^TSendCmdOutParams;

TSendCmdOutParams = packed record

BufferSize: DWord;

DriverStatus: TDriverStatus;

Buffer: array[0..255] of Word end;



const

DriveNumberMin = 0;

DriveNumberMax = 3;



type

TDriveNumber = DriveNumberMin..DriveNumberMax;



TIdeDriveInfo = class(TComponent)

private

FCylinders: array[TDriveNumber] of Integer;

FFirmwareRevision: array[TDriveNumber] of String;

FHeads: array[TDriveNumber] of Integer;

FModelNumber: array[TDriveNumber] of String;

FRemovableMedia: array[TDriveNumber] of Boolean;

FSectorsPerTrack: array[TDriveNumber] of Integer;

FSerialNumber: array[TDriveNumber] of String;

protected

procedure CheckDriveNumber(Drive: TDriveNumber); virtual;

function GetCylinders(Drive: TDriveNumber): Integer; virtual;

function GetFirmwareRevision(Drive: TDriveNumber): String;

virtual;

function GetHeads(Drive: TDriveNumber): Integer; virtual;

function GetModelNumber(Drive: TDriveNumber): String; virtual;

function GetRemovableMedia(Drive: TDriveNumber): Boolean;

virtual;

function GetSectorsPerTrack(Drive: TDriveNumber): Integer;

virtual;

function GetSerialNumber(Drive: TDriveNumber): String; virtual;

procedure QueryDrive(Drive: TDriveNumber); virtual;

public

constructor Create(AOwner: TComponent); override;

property Cylinders[Drive: TDriveNumber]: Integer

read GetCylinders;

property FirmwareRevision[Drive: TDriveNumber]: String

read GetFirmwareRevision;

property Heads[Drive: TDriveNumber]: Integer read GetHeads;

property ModelNumber[Drive: TDriveNumber]: String

read GetModelNumber;

property RemovableMedia[Drive: TDriveNumber]: Boolean

read GetRemovableMedia;

property SectorsPerTrack[Drive: TDriveNumber]: Integer

read GetSectorsPerTrack;

property SerialNumber[Drive: TDriveNumber]: String

read GetSerialNumber; end;



EIdeDriveInfo = class(Exception);



procedure Register;



implementation



procedure Register;

begin

RegisterComponents('Samples', [TIdeDriveInfo]) end;



constructor TIdeDriveInfo.Create(AOwner: TComponent);

var

I: TDriveNumber;

begin

inherited Create(AOwner);

for I := DriveNumberMin to DriveNumberMax do

QueryDrive(I) end;



procedure TIdeDriveInfo.CheckDriveNumber(Drive: TDriveNumber);

begin

if (Drive < DriveNumberMin) or (Drive > DriveNumberMax) then

raise EIdeDriveInfo.CreateFmt('The drive number (%d) is out ' +

'of range; the allowable range is %d to %d', [Drive,

DriveNumberMin, DriveNumberMax]) end;



function TIdeDriveInfo.GetCylinders(Drive: TDriveNumber): Integer;

begin

CheckDriveNumber(Drive);

Result := FCylinders[Drive] end;



function TIdeDriveInfo.GetFirmwareRevision(Drive: TDriveNumber):

String;

begin

CheckDriveNumber(Drive);

Result := FFirmwareRevision[Drive] end;



function TIdeDriveInfo.GetHeads(Drive: TDriveNumber): Integer;

begin

CheckDriveNumber(Drive);

Result := FHeads[Drive] end;



function TIdeDriveInfo.GetModelNumber(Drive: TDriveNumber): String;

begin

CheckDriveNumber(Drive);

Result := FModelNumber[Drive] end;



function TIdeDriveInfo.GetRemovableMedia(Drive: TDriveNumber):

Boolean;

begin

CheckDriveNumber(Drive);

Result := FRemovableMedia[Drive] end;



function TIdeDriveInfo.GetSectorsPerTrack(Drive: TDriveNumber):

Integer;

begin

CheckDriveNumber(Drive);

Result := FSectorsPerTrack[Drive] end;



function TIdeDriveInfo.GetSerialNumber(Drive: TDriveNumber): String;

begin

CheckDriveNumber(Drive);

Result := FSerialNumber[Drive] end;



procedure TIdeDriveInfo.QueryDrive(Drive: TDriveNumber);

var

BytesReturned: DWord;

CmdIn: TSendCmdInParams;

CmdOut: TSendCmdOutParams;

DriveName: String;

H: THandle;

I: Integer;

VersionInfo: TGetVersionOutParams;

begin

FCylinders[Drive] := 0;

FFirmwareRevision[Drive] := '';

FHeads[Drive] := 0;

FModelNumber[Drive] := '';

FRemovableMedia[Drive] := False;

FSectorsPerTrack[Drive] := 0;

FSerialNumber[Drive] := '';

DriveName := Format('.PHYSICALDRIVE%d', [Drive]);

H := CreateFile(PChar(DriveName), GENERIC_READ or GENERIC_WRITE, 0,

nil, OPEN_EXISTING, 0, 0);

if H = INVALID_HANDLE_VALUE then

Exit;

try

FillChar(VersionInfo, SizeOf(VersionInfo), 0);

BytesReturned := 0;

if not DeviceIoControl(H, DFP_GET_VERSION, nil, 0, @VersionInfo,

SizeOf(VersionInfo), BytesReturned, nil) then

Exit;

if not (cpIdeIdentify in VersionInfo.Capabilities) then

Exit;

FillChar(CmdIn, SizeOf(CmdIn), 0);

CmdIn.BufferSize := 0;

CmdIn.DriveRegs.Command := IDE_IDENTIFY_DEVICE;

CmdIn.DriveNumber := Drive;

FillChar(CmdOut, SizeOf(CmdOut), 0);

CmdOut.BufferSize := SizeOf(CmdOut.Buffer);

BytesReturned := 0;

if not DeviceIoControl(H, DFP_RECEIVE_DRIVE_DATA, @CmdIn,

SizeOf(CmdIn), @CmdOut, SizeOf(CmdOut), BytesReturned, nil) then

Exit;

with CmdOut do begin

for I := 10 to 19 do

Buffer[I] := (Lo(Buffer[I]) shl 8) + Hi(Buffer[I]);

for I := 23 to 46 do

Buffer[I] := (Lo(Buffer[I]) shl 8) + Hi(Buffer[I]);

FRemovableMedia[Drive] := (Buffer[0] and $80) <> 0;

FCylinders[Drive] := Buffer[1];

FHeads[Drive] := Buffer[3];

FSectorsPerTrack[Drive] := Buffer[6];

SetLength(FSerialNumber[Drive], 20);

Move(Buffer[10], FSerialNumber[Drive][1],

Length(FSerialNumber[Drive]));

FSerialNumber[Drive] := Trim(FSerialNumber[Drive]);

SetLength(FFirmwareRevision[Drive], 8);

Move(Buffer[23], FFirmwareRevision[Drive][1],

Length(FFirmwareRevision[Drive]));

FFirmwareRevision[Drive] := Trim(FFirmwareRevision[Drive]);

SetLength(FModelNumber[Drive], 40);

Move(Buffer[27], FModelNumber[Drive][1],

Length(FModelNumber[Drive]));

FModelNumber[Drive] := Trim(FModelNumber[Drive]);

end;

finally

CloseHandle(H) end end;



end.

--------8<--------

이현신 께서 말씀하시기를...

> 어떤 시스템의 고유의 시리얼이나 스트링을 구할수는 없나요?..

> 하드의 시리얼넘버는 포멧하면 변하고..

> LAN 카트의 시리얼 번호는 꼭 렌카드가 있어야 구할수 있고..

> 이 게시판 어디엔가 CPU ID 구하는것이 있던데..

> 그것은 기종이 같으면 넘어오는 값도 똑같더군요...

>

> 어떻게 하면 특정 PC의 고유 넘버를 구해낼수 있을까요??.

> 하드디스크의 제품번호라든지 BIOS 의 고유 스트링을 구할수는 없는 것인지

> ...

> 조언 부탁 드립니다..

>



안녕하세요 김영대입니다

저번에 한번 올렸던 내용같은데...



각 시스템의 유일한 식별자를 찾으신다면 제한적일수는 있지만

HDD의 Volume Serial Number 를 사용하시거나 아니면

Network 카드의 MAC address 를 사용해 보세요



그리고 대부분의 CPU 에는 serial number 가 없습니다

BIOS 에도 copyright, release date, version number 등등의 자료가 있습니다



그러나 HDD의 Volume Serial Number 는 포맷하면 다시 갱신되므로

좀 위험하고 한가지 괜찮은 것은 GUID 를 사용하는 것입니다

GUID의 뒤 6 byte는 네트워크 카드가 있다면 MAC address 이고

no-networking 이나 PPP 의 경우에도 생성되므로 정확히는

모르지만 id 가 생성되는걸로 봐서는(이건 제가 테스트를 못해봤습니다)

사용해볼만 합니다



unit Unit1;



interface



uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls, ActiveX;



type

TForm1 = class(TForm)

Edit1: TEdit;

Button1: TButton;

procedure Button1Click(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;



var

Form1: TForm1;



implementation

{$R *.DFM}



// Tip: 델파이 IDE에서 Ctrl-Shift-G 를 눌러보세요...

// GUID가 생성 되는데 뒤에 6숫자(2자리씩 12 바이트) 는 네트워크 환경이

// 있다면 MAC-address 와 같습니다

function GetNicAddr: AnsiString;

const

GUID_MAX = 72;

var

guid: TGuid;

buf: array[0..GUID_MAX] of WideChar;

begin

CoCreateGuid(guid);

StringFromGUID2(guid, buf, GUID_MAX);

Result := Copy(WideCharToString(buf),26,12);

end;



procedure TForm1.Button1Click(Sender: TObject);

begin

Edit1.Text := GetNicAddr;

end;



end.