Узнать серийный номер системного диска

[tsar_]

1. От администратора запускал (через ПКМ)?
2. Прально, я в 9 посте сразу написал. Подсовывай букву в dpr-файле, какую нужно, например, как Alex11223 советовал, от переменной среды или через другие winapi функции.

[Gregor]

Пардон. да, забыл от админа запустить. И Спасибо конечно же

[NetSpace]

на, скомпилируй это в консольное приложение и запусти. у меня работает на Win 7. выводит и модель и серийник винчестера.

program SerialDrive;
uses Windows;
{$R *.RES}
{$APPTYPE CONSOLE}

const MAX_IDE_DRIVES=4;
      READ_ATTRIBUTE_BUFFER_SIZE=512;
      IDENTIFY_BUFFER_SIZE=512;
      READ_THRESHOLD_BUFFER_SIZE=512;
      DFP_GET_VERSION=$00074080;
      DFP_SEND_DRIVE_COMMAND=$0007c084;
      DFP_RECEIVE_DRIVE_DATA=$0007c088;
      CAP_IDE_ID_FUNCTION=1;
      CAP_IDE_ATAPI_ID=2;
      CAP_IDE_EXECUTE_SMART_FUNCTION=4;
      IDE_ATAPI_ID=$A1;
      IDE_ID_FUNCTION=$EC;
      IDE_EXECUTE_SMART_FUNCTION=$B0;
      SMART_CYL_LOW=$4F;
      SMART_CYL_HI=$C2;
      SMART_NO_ERROR=0;
      SMART_IDE_ERROR=1;
      SMART_INVALID_FLAG=2;
      SMART_INVALID_COMMAND=3;
      SMART_INVALID_BUFFER=4;
      SMART_INVALID_DRIVE=5;
      SMART_INVALID_IOCTL=6;
      SMART_ERROR_NO_MEM=7;
      SMART_INVALID_REGISTER=8;
      SMART_NOT_SUPPORTED=9;
      SMART_NO_IDE_DEVICE=10;
      SMART_READ_ATTRIBUTE_VALUES=$D0;
      SMART_READ_ATTRIBUTE_THRESHOLDS=$D1;
      SMART_ENABLE_DISABLE_ATTRIBUTE_AUTOSAVE=$D2;
      SMART_SAVE_ATTRIBUTE_VALUES=$D3;
      SMART_EXECUTE_OFFLINE_IMMEDIATE=$D4;
      SMART_ENABLE_SMART_OPERATIONS=$D8;
      SMART_DISABLE_SMART_OPERATIONS=$D9;
      SMART_RETURN_SMART_STATUS=$DA;
      ATTR_INVALID=0;
      ATTR_READ_ERROR_RATE=1;
      ATTR_THROUGHPUT_PERF=2;
      ATTR_SPIN_UP_TIME=3;
      ATTR_START_STOP_COUNT=4;
      ATTR_REALLOC_SECTOR_COUNT=5;
      ATTR_READ_CHANNEL_MARGIN=6;
      ATTR_SEEK_ERROR_RATE=7;
      ATTR_SEEK_TIME_PERF=8;
      ATTR_POWER_ON_HRS_COUNT=9;
      ATTR_SPIN_RETRY_COUNT=10;
      ATTR_CALIBRATION_RETRY_COUNT=11;
      ATTR_POWER_CYCLE_COUNT=12;
      ATTR_SOFT_READ_ERROR_RATE=13;
      ATTR_G_SENSE_ERROR_RATE=191;
      ATTR_POWER_OFF_RETRACT_CYCLE=192;
      ATTR_LOAD_UNLOAD_CYCLE_COUNT=193;
      ATTR_TEMPERATURE=194;
      ATTR_REALLOCATION_EVENTS_COUNT=196;
      ATTR_CURRENT_PENDING_SECTOR_COUNT=197;
      ATTR_UNCORRECTABLE_SECTOR_COUNT=198;
      ATTR_ULTRADMA_CRC_ERROR_RATE=199;
      ATTR_WRITE_ERROR_RATE=200;
      ATTR_DISK_SHIFT=220;
      ATTR_G_SENSE_ERROR_RATEII=221;
      ATTR_LOADED_HOURS=222;
      ATTR_LOAD_UNLOAD_RETRY_COUNT=223;
      ATTR_LOAD_FRICTION=224;
      ATTR_LOAD_UNLOAD_CYCLE_COUNTII=225;
      ATTR_LOAD_IN_TIME=226;
      ATTR_TORQUE_AMPLIFICATION_COUNT=227;
      ATTR_POWER_OFF_RETRACT_COUNT=228;
      ATTR_GMR_HEAD_AMPLITUDE=230;
      ATTR_TEMPERATUREII=231;
      ATTR_READ_ERROR_RETRY_RATE=250;
      PRE_FAILURE_WARRANTY=$1;
      ON_LINE_COLLECTION=$2;
      PERFORMANCE_ATTRIBUTE=$4;
      ERROR_RATE_ATTRIBUTE=$8;
      EVENT_COUNT_ATTRIBUTE=$10;
      SELF_PRESERVING_ATTRIBUTE=$20;
      NUM_ATTRIBUTE_STRUCTS=$30;
      MAX_KNOWN_ATTRIBUTES=12;
      AttrNames:array[0..35]of string=(
	'No Attribute Here       ', //0
	'Raw Read Error Rate     ', //1
	'Throughput Performance  ', //2
	'Spin Up Time            ', //3
	'Start/Stop Count        ', //4
	'Reallocated Sector Count', //5
	'Read Channel Margin     ', //6
	'Seek Error Rate         ', //7
	'Seek Time Performance   ', //8
	'Power On Hours Count    ', //9
	'Spin Retry Count        ', //10
	'Calibration Retry Count ', //11
	'Power Cycle Count       ', //12
        'Soft Read Error Rate',    //13
        'G-Sense Error Rate',      // 191
        'Power-Off Retract Cycle', //192
        'Load/Unload Cycle Count', //193
        'Temperature',              //194
        'Reallocation Events Count',    //196
        'Current Pending Sector Count', //197
        'Uncorrectable Sector Count',   //198
        'UltraDMA CRC Error Rate',      //199
        'Write Error Rate',         //200
        'Disk Shift',               //220
        'G-Sense Error Rate',       //221
        'Loaded Hours',             //222
        'Load/Unload Retry Count',  //223
        'Load Friction',            //224
        'Load/Unload Cycle Count',  //225
        'Load-in Time',             //226
        'Torque Amplification Count', //227
        'Power-Off Retract Count',    //228
        'GMR Head Amplitude',        //230
        'Temperature',               //231
        'Read Error Retry Rate',     //250
	'(Unknown attribute)');
        AttrNumberTable:array[0..34]of Byte=(0,1,2,3,4,5,6,7,8,9,10,11,12,13,191,192,193,194,196,197,198,199,200,220,221,222,223,224,225,226,227,228,230,231,250);

type PGetVersionOutParams=^TGetVersionOutParams;
     _GETVERSIONOUTPARAMS=packed record
         bVersion:BYTE;
         bRevision:BYTE;
         bReserved:BYTE;
         bIDEDeviceMap:BYTE;
         fCapabilities:DWORD;
         dwReserved:array [0..3]of DWORD;
     end;
     TGetVersionOutParams=_GETVERSIONOUTPARAMS;
     GETVERSIONOUTPARAMS=_GETVERSIONOUTPARAMS;
     PIDERegs= ^TIDERegs;
     _IDEREGS=packed record
        bFeaturesReg:BYTE;
	bSectorCountReg:BYTE;
	bSectorNumberReg:BYTE;
	bCylLowReg:BYTE;
	bCylHighReg:BYTE;
	bDriveHeadReg:BYTE;
	bCommandReg:BYTE;
	bReserved:BYTE;
     end;
     TIDERegs=_IDEREGS;
     IDEREGS=_IDEREGS;
     PSendCMDInParams=^TSendCMDInParams;
     _SENDCMDINPARAMS=packed record
        cBufferSize:DWORD;
        irDriveRegs:IDEREGS;
        bDriveNumber:BYTE;
        bReserved:array [0..2]of BYTE;
        dwReserved:array[0..3]of DWORD;
        bBuffer:array[0..0]of BYTE;
     end;
     TSendCMDInParams=_SENDCMDINPARAMS;
     SENDCMDINPARAMS=_SENDCMDINPARAMS;
     PDriverStatus=^TDriverStatus;
     _DRIVERSTATUS=packed record
        bDriverError:BYTE;
        bIDEStatus:BYTE;
        bReserved:array[0..1]of BYTE;
        dwReserved:array[0..1]of DWORD;
     end;
     TDriverStatus=_DRIVERSTATUS;
     DRIVERSTATUS=_DRIVERSTATUS;
     PIdSector=^TIdSector;
     _IDSECTOR=packed record
        wGenConfig:WORD;
        wNumCyls:WORD;
        Reserved:WORD;
        wNumHeads:WORD;
        wBytesPerTrack:WORD;
        wBytesPerSector:WORD;
        wSectorsPerTrack:WORD;
        wVendorUnique:array[0..2]of WORD;
        sSerialNumber:array[0..19]of Char;
        wBufferType:WORD;
        wBufferSize:WORD;
        wECCSize:WORD;
        sFirmwareRev:array[0..7]of Char;
        sModelNumber:array[0..39]of Char;
        wMoreVendorUnique:WORD;
        wDoubleWordIO:WORD;
        wCapabilities:WORD;
        wReserved1:WORD;
        wPIOTiming:WORD;
        wDMATiming:WORD;
        wBS:WORD;
        wNumCurrentCyls:WORD;
        wNumCurrentHeads:WORD;
        wNumCurrentSectorsPerTrack:WORD;
        ulCurrentSectorCapacity:ULONG;
        wMultSectorStuff:WORD;
        ulTotalAddressableSectors:ULONG;
        wSingleWordDMA:WORD;
        wMultiWordDMA:WORD;
        bReserved:array[0..127]of BYTE;
     end;

[NetSpace]

TIdSector=_IDSECTOR;
     IDSECTOR=_IDSECTOR;
     PSendCMDOutParams=^TSendCMDOutParams;
     _SENDCMDOUTPARAMS=packed record
        cBufferSize:DWORD;
        DriverStatus:DRIVERSTATUS;
        bBuffer:array[0..0] of BYTE;                                       											// drive.
     end;
     TSendCMDOutParams=_SENDCMDOUTPARAMS;
     SENDCMDOUTPARAMS=_SENDCMDOUTPARAMS;
     PDriveAttribute=^TDriveAttribute;
     _DRIVEATTRIBUTE=packed record
        bAttrID:BYTE;
        wStatusFlags:WORD;
        bAttrValue:BYTE;
        bWorstValue:BYTE;
        bRawValue:array[0..5]of BYTE;
        bReserved:BYTE;
     end;
     TDriveAttribute=_DRIVEATTRIBUTE;
     DRIVEATTRIBUTE=_DRIVEATTRIBUTE;
     PAttrThreshold=^TAttrThreshold;
     _ATTRTHRESHOLD=packed record
        bAttrID:BYTE;
        bWarrantyThreshold:BYTE;
        bReserved:array[0..9]of BYTE;
     end;
     TAttrThreshold=_ATTRTHRESHOLD;
     ATTRTHRESHOLD=_ATTRTHRESHOLD;
     SMARTAttributes=packed array[0..NUM_ATTRIBUTE_STRUCTS-1] of TDriveAttribute;
     PSMARTAttributes=^SMARTAttributes;
     SMARTThresholds=packed array[0..NUM_ATTRIBUTE_STRUCTS-1]of TAttrThreshold;
     PSMARTThresholds=^SMARTThresholds;

function OpenSMART:THandle;
var ver:TOSVERSIONINFO;
begin
   result:=0;
   ver.dwOSVersionInfoSize:=Sizeof(ver);
   GetVersionEx(ver);
   if(ver.dwPlatformId=VER_PLATFORM_WIN32_NT)then result:=CreateFile('\\.\PhysicalDrive0',GENERIC_READ or GENERIC_WRITE,FILE_SHARE_READ or FILE_SHARE_WRITE,nil,OPEN_EXISTING,0,0);
end;

function DoIdentify(hSMARTIOCtl:THandle;SCIP:PSendCMDInParams;SCOP:PSendCMDOutParams;IDCmd:byte;DriveNum:byte;lpcbBytesReturned:DWORD):boolean;
begin
   SCIP^.cBufferSize:=IDENTIFY_BUFFER_SIZE;
   SCIP^.irDriveRegs.bFeaturesReg:=0;
   SCIP^.irDriveRegs.bSectorCountReg:=1;
   SCIP^.irDriveRegs.bSectorNumberReg:=1;
   SCIP^.irDriveRegs.bCylLowReg:=0;
   SCIP^.irDriveRegs.bCylHighReg:=0;
   SCIP^.irDriveRegs.bDriveHeadReg:=$A0 or((DriveNum and 1)shl 4);
   SCIP^.irDriveRegs.bCommandReg:=IDCmd;
   SCIP^.bDriveNumber:=DriveNum;
   SCIP^.cBufferSize:=IDENTIFY_BUFFER_SIZE;
   result:=DeviceIoControl(hSMARTIOCtl,DFP_RECEIVE_DRIVE_DATA,@SCIP^,SizeOf(SENDCMDINPARAMS)-1,@SCOP^,SizeOf(SENDCMDOUTPARAMS)+IDENTIFY_BUFFER_SIZE-1,lpcbBytesReturned,nil);
end;

function DoEnableSMART(hSMARTIOCtl:THandle;SCIP:PSendCMDInParams;SCOP:PSendCMDOutParams;DriveNum:byte;lpcbBytesReturned:DWORD):boolean;
begin
   SCIP^.cBufferSize:=0;
   SCIP^.irDriveRegs.bFeaturesReg:=SMART_ENABLE_SMART_OPERATIONS;
   SCIP^.irDriveRegs.bSectorCountReg:=1;
   SCIP^.irDriveRegs.bSectorNumberReg:=1;
   SCIP^.irDriveRegs.bCylLowReg:=SMART_CYL_LOW;
   SCIP^.irDriveRegs.bCylHighReg:=SMART_CYL_HI;
   SCIP^.irDriveRegs.bDriveHeadReg:=$A0 or((DriveNum and 1)shl 4);
   SCIP^.irDriveRegs.bCommandReg:=IDE_EXECUTE_SMART_FUNCTION;
   SCIP^.bDriveNumber:=DriveNum;
   result:=DeviceIoControl(hSMARTIOCtl,DFP_SEND_DRIVE_COMMAND,@SCIP^,SizeOf(SENDCMDINPARAMS)-1,@SCOP^,SizeOf(SENDCMDOUTPARAMS)-1,lpcbBytesReturned,nil);
end;  

function DoReadAttributesCmd(hSMARTIOCtl:THandle;SCIP:PSendCMDInParams;SCOP:PSendCMDOutParams;DriveNum:byte):boolean;
var cbBytesReturned:DWORD;
begin
   SCIP^.cBufferSize:=READ_ATTRIBUTE_BUFFER_SIZE;
   SCIP^.irDriveRegs.bFeaturesReg:=SMART_READ_ATTRIBUTE_VALUES;
   SCIP^.irDriveRegs.bSectorCountReg:=1;
   SCIP^.irDriveRegs.bSectorNumberReg:=1;
   SCIP^.irDriveRegs.bCylLowReg:=SMART_CYL_LOW;
   SCIP^.irDriveRegs.bCylHighReg:=SMART_CYL_HI;
   SCIP^.irDriveRegs.bDriveHeadReg:=$A0 or((DriveNum and 1)shl 4);
   SCIP^.irDriveRegs.bCommandReg:=IDE_EXECUTE_SMART_FUNCTION;
   SCIP^.bDriveNumber:=DriveNum;
   result:=DeviceIoControl(hSMARTIOCtl,DFP_RECEIVE_DRIVE_DATA,@SCIP^,SizeOf(SENDCMDINPARAMS)-1,@SCOP^,SizeOf(SENDCMDOUTPARAMS)+READ_ATTRIBUTE_BUFFER_SIZE-1,cbBytesReturned,nil);
end;

function StrMove(Dest:PChar;const Source:PChar;Count:Cardinal):PChar;assembler;
asm
        PUSH    ESI
        PUSH    EDI
        MOV     ESI,EDX
        MOV     EDI,EAX
        MOV     EDX,ECX
        CMP     EDI,ESI
        JA      @@1
        JE      @@2
        SHR     ECX,2
        REP     MOVSD
        MOV     ECX,EDX
        AND     ECX,3
        REP     MOVSB
        JMP     @@2
@@1:    LEA     ESI,[ESI+ECX-1]
        LEA     EDI,[EDI+ECX-1]
        AND     ECX,3
        STD
        REP     MOVSB
        SUB     ESI,3
        SUB     EDI,3
        MOV     ECX,EDX
        SHR     ECX,2
        REP     MOVSD
        CLD
@@2:    POP     EDI
        POP     ESI
end;

var HSmart:THandle;
    VersionParams:TGetVersionOutParams;
    i:integer;
    cbBytesReturned:DWORD;
    SN,MN:string;//серийный номер, номер модели

procedure ChangeByteOrder(szString:PChar;StrSize:Integer);
var i:Integer;
    Temp:Char;
begin
   for i:=0 to(StrSize-1)div 2 do
   begin
      Temp:=szString[i*2];
      szString[i*2]:=szString[i*2+1];
      szString[i*2+1]:=Temp;
   end;
end;

function DisplayIdInfo(Ids:PIdSector;DriveNum:byte):string;
var szOutBuffer:array[0..40]of Char;
begin
   //----- номер модели --------------------------------------------------------
   MN:='';
   ChangeByteOrder(Ids^.sModelNumber,SizeOf(Ids^.sModelNumber));
   StrMove(szOutBuffer,Ids^.sModelNumber,SizeOf(Ids^.sModelNumber));
   MN:=szOutBuffer;
   while(Pos(' ',MN)<>0)do Delete(MN,Pos(' ',MN),1);//убираем лишние прбелы
   if(MN<>'')then WriteLn('HDD '+'Nomer Modeli: '+MN);
   //----- серийный номер ------------------------------------------------------
   SN:='';
   ChangeByteOrder(Ids^.sSerialNumber,SizeOf(Ids^.sSerialNumber));
   StrMove(szOutBuffer,Ids^.sSerialNumber,SizeOf(Ids^.sSerialNumber));
   SN:=szOutBuffer;
   while(Pos(' ',SN)<>0)do Delete(SN,Pos(' ',SN),1);//убираем лишние прбелы
   if(SN<>'')then WriteLn('    Nomer Serial: '+SN);
end;

function PrintDriveInfo(DriveNum:byte):string;
var IdOutCmd:pointer;
    bIDCmd:byte;
    Scip:PSendCMDInParams;
begin
   result:='';
   if((VersionParams.bIDEDeviceMap shr DriveNum and 1)>0)then
   begin
      if((VersionParams.bIDEDeviceMap shr DriveNum and $10)>0)then bIDCmd:=IDE_ATAPI_ID
      else bIDCmd:=IDE_ID_FUNCTION;
      New(Scip);
      GetMem(IdOutCmd,sizeof(SENDCMDOUTPARAMS)+IDENTIFY_BUFFER_SIZE-1);
      try
         cbBytesReturned:=0;
         if(DoIDENTIFY(HSmart,Scip,IdOutCmd,bIDCmd,DriveNum,cbBytesReturned))then result:=DisplayIdInfo(Pointer(longint(IdOutCmd)+sizeof(SENDCMDOUTPARAMS)-1),DriveNum);
      finally                                                                                                                                                      
      FreeMem(IdOutCmd);                                                                                                                                            
      FreeMem(Scip);
      end;
   end;
end;

begin
   HSmart:=OpenSMART;
   if(HSmart<>INVALID_HANDLE_VALUE)and(DeviceIoControl(HSmart,DFP_GET_VERSION,nil,0,@VersionParams,sizeof(VersionParams),cbBytesReturned,nil))then
   for i:=0 to MAX_IDE_DRIVES-1 do PrintDriveInfo(i);
   CloseHandle(HSmart);
   ReadLn;
end.