hdd serial number?

Znaete li kak moje ot programa na C da se pro4ete seriinia nomer na tvyrdia disk? Ako ne to kyde da tyrsia za tova?

Blagodaria vi,

Hristo

Има такава функция в BIOS, в групата за входно-изходни операции. Вече не помна коя. Иначе къде може да се търси: PC TechHelp.

Probwaj towa pod NT i WIN2K raboti pod 98 ne raboti dobre ili hich:-)

#define PRINTING_TO_CONSOLE_ALLOWED


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <windows.h>
#include <conio.h>


#define TITLE "DiskId32"


// Required to ensure correct PhysicalDrive IOCTL structure setup
#pragma pack(1)


// Max number of drives assuming primary/secondary, master/slave topology
#define MAX_IDE_DRIVES 4
#define IDENTIFY_BUFFER_SIZE 512


// IOCTL commands
#define DFP_GET_VERSION 0x00074080
#define DFP_SEND_DRIVE_COMMAND 0x0007c084
#define DFP_RECEIVE_DRIVE_DATA 0x0007c088

#define FILE_DEVICE_SCSI 0x0000001b
#define IOCTL_SCSI_MINIPORT_IDENTIFY ((FILE_DEVICE_SCSI << 16) + 0x0501)
#define IOCTL_SCSI_MINIPORT 0x0004D008 // see NTDDSCSI.H for definition



// GETVERSIONOUTPARAMS contains the data returned from the
// Get Driver Version function.
typedef struct _GETVERSIONOUTPARAMS
{
BYTE bVersion; // Binary driver version.
BYTE bRevision; // Binary driver revision.
BYTE bReserved; // Not used.
BYTE bIDEDeviceMap; // Bit map of IDE devices.
DWORD fCapabilities; // Bit mask of driver capabilities.
DWORD dwReserved[4]; // For future use.
} GETVERSIONOUTPARAMS, *PGETVERSIONOUTPARAMS, *LPGETVERSIONOUTPARAMS;


// Bits returned in the fCapabilities member of GETVERSIONOUTPARAMS
#define CAP_IDE_ID_FUNCTION 1 // ATA ID command supported
#define CAP_IDE_ATAPI_ID 2 // ATAPI ID command supported
#define CAP_IDE_EXECUTE_SMART_FUNCTION 4 // SMART commannds supported


// IDE registers
typedef struct _IDEREGS
{
BYTE bFeaturesReg; // Used for specifying SMART "commands".
BYTE bSectorCountReg; // IDE sector count register
BYTE bSectorNumberReg; // IDE sector number register
BYTE bCylLowReg; // IDE low order cylinder value
BYTE bCylHighReg; // IDE high order cylinder value
BYTE bDriveHeadReg; // IDE drive/head register
BYTE bCommandReg; // Actual IDE command.
BYTE bReserved; // reserved for future use. Must be zero.
} IDEREGS, *PIDEREGS, *LPIDEREGS;


// SENDCMDINPARAMS contains the input parameters for the
// Send Command to Drive function.
typedef struct _SENDCMDINPARAMS
{
DWORD cBufferSize; // Buffer size in bytes
IDEREGS irDriveRegs; // Structure with drive register values.
BYTE bDriveNumber; // Physical drive number to send
// command to (0,1,2,3).
BYTE bReserved[3]; // Reserved for future expansion.
DWORD dwReserved[4]; // For future use.
BYTE bBuffer[1]; // Input buffer.
} SENDCMDINPARAMS, *PSENDCMDINPARAMS, *LPSENDCMDINPARAMS;


// Valid values for the bCommandReg member of IDEREGS.
#define IDE_ATAPI_IDENTIFY 0xA1 // Returns ID sector for ATAPI.
#define IDE_ATA_IDENTIFY 0xEC // Returns ID sector for ATA.


// Status returned from driver
typedef struct _DRIVERSTATUS
{
BYTE bDriverError; // Error code from driver, or 0 if no error.
BYTE bIDEStatus; // Contents of IDE Error register.
// Only valid when bDriverError is SMART_IDE_ERROR.
BYTE bReserved[2]; // Reserved for future expansion.
DWORD dwReserved[2]; // Reserved for future expansion.
} DRIVERSTATUS, *PDRIVERSTATUS, *LPDRIVERSTATUS;


// Structure returned by PhysicalDrive IOCTL for several commands
typedef struct _SENDCMDOUTPARAMS
{
DWORD cBufferSize; // Size of bBuffer in bytes
DRIVERSTATUS DriverStatus; // Driver status structure.
BYTE bBuffer[1]; // Buffer of arbitrary length in which to store the data read from the // drive.
} SENDCMDOUTPARAMS, *PSENDCMDOUTPARAMS, *LPSENDCMDOUTPARAMS;


// The following struct defines the interesting part of the IDENTIFY
// buffer:
typedef struct _IDSECTOR
{
USHORT wGenConfig;
USHORT wNumCyls;
USHORT wReserved;
USHORT wNumHeads;
USHORT wBytesPerTrack;
USHORT wBytesPerSector;
USHORT wSectorsPerTrack;
USHORT wVendorUnique[3];
CHAR sSerialNumber[20];
USHORT wBufferType;
USHORT wBufferSize;
USHORT wECCSize;
CHAR sFirmwareRev[8];
CHAR sModelNumber[40];
USHORT wMoreVendorUnique;
USHORT wDoubleWordIO;
USHORT wCapabilities;
USHORT wReserved1;
USHORT wPIOTiming;
USHORT wDMATiming;
USHORT wBS;
USHORT wNumCurrentCyls;
USHORT wNumCurrentHeads;
USHORT wNumCurrentSectorsPerTrack;
ULONG ulCurrentSectorCapacity;
USHORT wMultSectorStuff;
ULONG ulTotalAddressableSectors;
USHORT wSingleWordDMA;
USHORT wMultiWordDMA;
BYTE bReserved[128];
} IDSECTOR, *PIDSECTOR;


typedef struct _SRB_IO_CONTROL
{
ULONG HeaderLength;
UCHAR Signature[8];
ULONG Timeout;
ULONG ControlCode;
ULONG ReturnCode;
ULONG Length;
} SRB_IO_CONTROL, *PSRB_IO_CONTROL;


// Define global buffers.
BYTE IdOutCmd [sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1];


char *ConvertToString (DWORD diskdata [256], int firstIndex, int lastIndex);
void PrintIdeInfo (int drive, DWORD diskdata [256]);
BOOL DoIDENTIFY (HANDLE, PSENDCMDINPARAMS, PSENDCMDOUTPARAMS, BYTE, BYTE,
PDWORD);


int ReadPhysicalDriveInNT (void)
{
int done = FALSE;
int drive = 0;

for (drive = 0; drive < MAX_IDE_DRIVES; drive++)
{
HANDLE hPhysicalDriveIOCTL = 0;

// Try to get a handle to PhysicalDrive IOCTL, report failure
// and exit if can't.
char driveName [256];

sprintf (driveName, "\\\\.\\PhysicalDrive%d", drive);

// Windows NT, Windows 2000, must have admin rights
hPhysicalDriveIOCTL = CreateFile (driveName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, 0, NULL);
// if (hPhysicalDriveIOCTL == INVALID_HANDLE_VALUE)
// printf ("Unable to open physical drive %d, error code: 0x%lX\n",
// drive, GetLastError ());

if (hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
{
GETVERSIONOUTPARAMS VersionParams;
DWORD cbBytesReturned = 0;

// Get the version, etc of PhysicalDrive IOCTL
memset ((void*) &VersionParams, 0, sizeof(VersionParams));

if ( ! DeviceIoControl (hPhysicalDriveIOCTL, DFP_GET_VERSION,
NULL,
0,
&VersionParams,
sizeof(VersionParams),
&cbBytesReturned, NULL) )
{
// printf ("DFP_GET_VERSION failed for drive %d\n", i);
// continue;
}

// If there is a IDE device at number "i" issue commands
// to the device
if (VersionParams.bIDEDeviceMap > 0)
{
BYTE bIDCmd = 0; // IDE or ATAPI IDENTIFY cmd
SENDCMDINPARAMS scip;
//SENDCMDOUTPARAMS OutCmd;

// Now, get the ID sector for all IDE devices in the system.
// If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
// otherwise use the IDE_ATA_IDENTIFY command
bIDCmd = (VersionParams.bIDEDeviceMap >> drive & 0x10) ? \
IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;

memset (&scip, 0, sizeof(scip));
memset (IdOutCmd, 0, sizeof(IdOutCmd));

if ( DoIDENTIFY (hPhysicalDriveIOCTL,
&scip,
(PSENDCMDOUTPARAMS)&IdOutCmd,
(BYTE) bIDCmd,
(BYTE) drive,
&cbBytesReturned))
{
DWORD diskdata [256];
int ijk = 0;
USHORT *pIdSector = (USHORT *)
((PSENDCMDOUTPARAMS) IdOutCmd) -> bBuffer;

for (ijk = 0; ijk < 256; ijk++)
diskdata [ijk] = pIdSector [ijk];

PrintIdeInfo (drive, diskdata);

done = TRUE;
}
}

CloseHandle (hPhysicalDriveIOCTL);
}
}

return done;
}


// DoIDENTIFY
// FUNCTION: Send an IDENTIFY command to the drive
// bDriveNum = 0-3
// bIDCmd = IDE_ATA_IDENTIFY or IDE_ATAPI_IDENTIFY
BOOL DoIDENTIFY (HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum,
PDWORD lpcbBytesReturned)
{
// Set up data structures for IDENTIFY command.
pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE;
pSCIP -> irDriveRegs.bFeaturesReg = 0;
pSCIP -> irDriveRegs.bSectorCountReg = 1;
pSCIP -> irDriveRegs.bSectorNumberReg = 1;
pSCIP -> irDriveRegs.bCylLowReg = 0;
pSCIP -> irDriveRegs.bCylHighReg = 0;

// Compute the drive number.
pSCIP -> irDriveRegs.bDriveHeadReg = 0xA0 | ((bDriveNum & 1) << 4);

// The command can either be IDE identify or ATAPI identify.
pSCIP -> irDriveRegs.bCommandReg = bIDCmd;
pSCIP -> bDriveNumber = bDriveNum;
pSCIP -> cBufferSize = IDENTIFY_BUFFER_SIZE;

return ( DeviceIoControl (hPhysicalDriveIOCTL, DFP_RECEIVE_DRIVE_DATA,
(LPVOID) pSCIP,
sizeof(SENDCMDINPARAMS) - 1,
(LPVOID) pSCOP,
sizeof(SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE - 1,
lpcbBytesReturned, NULL) );
}


// ---------------------------------------------------

// (* Output Bbuffer for the VxD (rt_IdeDinfo record) *)
typedef struct _rt_IdeDInfo_
{
BYTE IDEExists[4];
BYTE DiskExists[8];
WORD DisksRawInfo[8*256];
} rt_IdeDInfo, *pt_IdeDInfo;


// (* IdeDinfo "data fields" *)
typedef struct _rt_DiskInfo_
{
BOOL DiskExists;
BOOL ATAdevice;
BOOL RemovableDevice;
WORD TotLogCyl;
WORD TotLogHeads;
WORD TotLogSPT;
char SerialNumber[20];
char FirmwareRevision[8];
char ModelNumber[40];
WORD CurLogCyl;
WORD CurLogHeads;
WORD CurLogSPT;
} rt_DiskInfo;


#define m_cVxDFunctionIdesDInfo 1


// ---------------------------------------------------


int ReadDrivePortsInWin9X (void)
{
int done = FALSE;

HANDLE VxDHandle = 0;
pt_IdeDInfo pOutBufVxD = 0;
DWORD lpBytesReturned = 0;

// 1. Make an output buffer for the VxD
rt_IdeDInfo info;
pOutBufVxD = &info;

// *****************
// KLUDGE WARNING!!!
// HAVE to zero out the buffer space for the IDE information!
// If this is NOT done then garbage could be in the memory
// locations indicating if a disk exists or not.
ZeroMemory (&info, sizeof(info));

// 1. Try to load the VxD
// VxDHandle = CreateFile (_T("\\\\.\\DSIdeInf.VXD"), 0, 0, 0,
VxDHandle = CreateFile ("\\\\.\\IDE21201.VXD", 0, 0, 0,
0, FILE_FLAG_DELETE_ON_CLOSE, 0);

if (VxDHandle != INVALID_HANDLE_VALUE)
{
// 2. Run VxD function
DeviceIoControl (VxDHandle, m_cVxDFunctionIdesDInfo,
0, 0, pOutBufVxD, sizeof(pt_IdeDInfo), &lpBytesReturned, 0);

// 3. Unload VxD
CloseHandle (VxDHandle);
}
else
MessageBox (NULL, "ERROR: Could not open IDE21201.VXD file",
TITLE, MB_ICONSTOP);

// 4. Translate and store data
unsigned long int i = 0;
for (i=0; i<8; i++)
{
if((pOutBufVxD->DiskExists) && (pOutBufVxD->IDEExists[i/2]))
{
DWORD diskinfo [256];
for (int j = 0; j < 256; j++)
diskinfo [j] = pOutBufVxD -> DisksRawInfo [i * 256 + j];

// process the information for this buffer
PrintIdeInfo (i, diskinfo);
done = TRUE;
}
}

return done;
}


#define SENDIDLENGTH sizeof (SENDCMDOUTPARAMS) + IDENTIFY_BUFFER_SIZE


int ReadIdeDriveAsScsiDriveInNT (void)
{
int done = FALSE;
int controller = 0;

for (controller = 0; controller < 2; controller++)
{
HANDLE hScsiDriveIOCTL = 0;
char driveName [256];

// Try to get a handle to PhysicalDrive IOCTL, report failure
// and exit if can't.
sprintf (driveName, "\\\\.\\Scsi%d:", controller);

// Windows NT, Windows 2000, any rights should do
hScsiDriveIOCTL = CreateFile (driveName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, 0, NULL);
// if (hScsiDriveIOCTL == INVALID_HANDLE_VALUE)
// printf ("Unable to open SCSI controller %d, error code: 0x%lX\n",
// controller, GetLastError ());

if (hScsiDriveIOCTL != INVALID_HANDLE_VALUE)
{
int drive = 0;

for (drive = 0; drive < 2; drive++)
{
char buffer [sizeof (SRB_IO_CONTROL) + SENDIDLENGTH];
SRB_IO_CONTROL *p = (SRB_IO_CONTROL *) buffer;
SENDCMDINPARAMS *pin =
(SENDCMDINPARAMS *) (buffer + sizeof (SRB_IO_CONTROL));
DWORD dummy;

memset (buffer, 0, sizeof (buffer));
p -> HeaderLength = sizeof (SRB_IO_CONTROL);
p -> Timeout = 10000;
p -> Length = SENDIDLENGTH;
p -> ControlCode = IOCTL_SCSI_MINIPORT_IDENTIFY;
strncpy ((char *) p -> Signature, "SCSIDISK", 8);

pin -> irDriveRegs.bCommandReg = IDE_ATA_IDENTIFY;
pin -> bDriveNumber = drive;

if (DeviceIoControl (hScsiDriveIOCTL, IOCTL_SCSI_MINIPORT,
buffer,
sizeof (SRB_IO_CONTROL) +
sizeof (SENDCMDINPARAMS) - 1,
buffer,
sizeof (SRB_IO_CONTROL) + SENDIDLENGTH,
&dummy, NULL))
{
SENDCMDOUTPARAMS *pOut =
(SENDCMDOUTPARAMS *) (buffer + sizeof (SRB_IO_CONTROL));
IDSECTOR *pId = (IDSECTOR *) (pOut -> bBuffer);
if (pId -> sModelNumber [0])
{
DWORD diskdata [256];
int ijk = 0;
USHORT *pIdSector = (USHORT *) pId;

for (ijk = 0; ijk < 256; ijk++)
diskdata [ijk] = pIdSector [ijk];

PrintIdeInfo (controller * 2 + drive, diskdata);

done = TRUE;
}
}
}
CloseHandle (hScsiDriveIOCTL);
}
}

return done;
}


char HardDriveSerialNumber [1024];


void PrintIdeInfo (int drive, DWORD diskdata [256])
{
char string1 [1024];

// copy the hard drive serial number to the buffer
strcpy (string1, ConvertToString (diskdata, 10, 19));
if (0 == HardDriveSerialNumber [0] &&
// serial number must be alphanumeric
// (but there can be leading spaces on IBM drives)
(isalnum (string1 [0]) || isalnum (string1 [19])))
strcpy (HardDriveSerialNumber, string1);

#ifdef PRINTING_TO_CONSOLE_ALLOWED

switch (drive / 2)
{
case 0: printf ("\nPrimary Controller - ");
break;
case 1: printf ("\nSecondary Controller - ");
break;
case 2: printf ("\nTertiary Controller - ");
break;
case 3: printf ("\nQuaternary Controller - ");
break;
}

switch (drive % 2)
{
case 0: printf ("Master drive\n\n");
break;
case 1: printf ("Slave drive\n\n");
break;
}

printf ("Drive Model Number________________: %s\n",
ConvertToString (diskdata, 27, 46));
printf ("Drive Serial Number_______________: %s\n",
ConvertToString (diskdata, 10, 19));
printf ("Drive Controller Revision Number__: %s\n",
ConvertToString (diskdata, 23, 26));

printf ("Controller Buffer Size on Drive___: %u bytes\n",
diskdata [21] * 512);

printf ("Drive Type________________________: ");
if (diskdata [0] & 0x0080)
printf ("Removable\n");
else if (diskdata [0] & 0x0040)
printf ("Fixed\n");
else printf ("Unknown\n");

printf ("Physical Geometry: "
"%u Cylinders %u Heads %u Sectors per track\n",
diskdata [1], diskdata [3], diskdata [6]);

#else // PRINTING_TO_CONSOLE_ALLOWED

// nothing to do

#endif // PRINTING_TO_CONSOLE_ALLOWED

}


char *ConvertToString (DWORD diskdata [256], int firstIndex, int lastIndex)
{
static char string [1024];
int index = 0;
int position = 0;

// each integer has two characters stored in it backwards
for (index = firstIndex; index <= lastIndex; index++)
{
// get high byte for 1st character
string [position] = (char) (diskdata [index] / 256);
position++;

// get low byte for 2nd character
string [position] = (char) (diskdata [index] % 256);
position++;
}

// end the string
string [position] = '\0';

// cut off the trailing blanks
for (index = position - 1; index > 0 && ' ' == string [index]; index--)
string [index] = '\0';

return string;
}


long getHardDriveComputerID ()
{
int done = FALSE;
// char string [1024];
__int64 id = 0;
OSVERSIONINFO version;

strcpy (HardDriveSerialNumber, "");

memset (&version, 0, sizeof (version));
version.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
GetVersionEx (&version);
if (version.dwPlatformId == VER_PLATFORM_WIN32_NT)
{
// this works under WinNT4 or Win2K if you have admin rights
done = ReadPhysicalDriveInNT ();

// this should work in WinNT or Win2K if previous did not work
// this is kind of a backdoor via the SCSI mini port driver into
// the IDE drives
if ( ! done) done = ReadIdeDriveAsScsiDriveInNT ();
}
else
{
// this works under Win9X and calls a VXD
int attempt = 0;

// try this up to 10 times to get a hard drive serial number
for (attempt = 0;
attempt < 10 && ! done && 0 == HardDriveSerialNumber [0];
attempt++)
done = ReadDrivePortsInWin9X ();
}

if (done)
{
char *p = HardDriveSerialNumber;

//WriteConstantString ("HardDriveSerialNumber", HardDriveSerialNumber);

// ignore first 5 characters from western digital hard drives if
// the first four characters are WD-W
if ( ! strncmp (HardDriveSerialNumber, "WD-W", 4)) p += 5;
for ( ; p && *p; p++)
{
if ('-' == *p) continue;
id *= 10;
switch (*p)
{
case '0': id += 0; break;
case '1': id += 1; break;
case '2': id += 2; break;
case '3': id += 3; break;
case '4': id += 4; break;
case '5': id += 5; break;
case '6': id += 6; break;
case '7': id += 7; break;
case '8': id += 8; break;
case '9': id += 9; break;
case 'a': case 'A': id += 10; break;
case 'b': case 'B': id += 11; break;
case 'c': case 'C': id += 12; break;
case 'd': case 'D': id += 13; break;
case 'e': case 'E': id += 14; break;
case 'f': case 'F': id += 15; break;
case 'g': case 'G': id += 16; break;
case 'h': case 'H': id += 17; break;
case 'i': case 'I': id += 18; break;
case 'j': case 'J': id += 19; break;
case 'k': case 'K': id += 20; break;
case 'l': case 'L': id += 21; break;
case 'm': case 'M': id += 22; break;
case 'n': case 'N': id += 23; break;
case 'o': case 'O': id += 24; break;
case 'p': case 'P': id += 25; break;
case 'q': case 'Q': id += 26; break;
case 'r': case 'R': id += 27; break;
case 's': case 'S': id += 28; break;
case 't': case 'T': id += 29; break;
case 'u': case 'U': id += 30; break;
case 'v': case 'V': id += 31; break;
case 'w': case 'W': id += 32; break;
case 'x': case 'X': id += 33; break;
case 'y': case 'Y': id += 34; break;
case 'z': case 'Z': id += 35; break;
}
}
}

#ifdef PRINTING_TO_CONSOLE_ALLOWED

printf ("\nComputer ID_______________________: %I64d\n", id);

#endif

return (long) id;
}


int main (int argc, char * argv [])
{
long id = getHardDriveComputerID ();
getch();
return 0;
}

Абе пич, какъв е този ужас бе??? Това е едно извикване с ASM /или всеки нормален език дето поддържа INT-ове/

mov AX,6900h ; 69h - disk serial number, 00 - read /01 - write/
mov BL,80h ; drive - 0 current, 1 - a, 2 -b, 80h - hdd1, 81h - hdd2 ...
mov DX,offset BPB ; [DS:DX]=buffer for BIOS param block /if AL=0/

BPB:
dw 00 ; info level
dd 00 ; disk serial number xxxx-xxxx
db 0,0,0,0,0,0,0,0,0,0,0 ; volume label
db 0,0,0,0,0,0,0,0 ; fylesystem 'FATxx '

След извикване CF съдържа резултата от операцията /0 true, 1 false/

Информацията е взета от HelpPC 2.10 - 1991
[линк]

Blagodaria vi na vsi4ki, no kakvo shte stane ako niakoi prihvane tova prekysvane predi da izpylni moiata programa i mi vryshta falshiv serien nomer (vzet ot niakoe drugo PC)? Tova e nedopustimo... Moje bi triabva da govoria napravo s IDE draivera? No kak?

Hristo

be pod win32 she mu e malko trudno da go prehvane kakto si iska... vij reshenieto na asm i si karai taka. edinstvenia nachin da te izlyjat e da se zarejda TSR predi Win ama tva oznachava che she lyjat ne samo teb a vsichki ostanali programi

Ако искаш да правиш защита от копиране, има доста по-забавни методи... Ама не си питал... Да гледаш серийния номер на HDD-то е забавно, ама донякъде, щото е лесно и да се чете, и да се смени... Имаше една книжка на пл. Славейков - "Защита от копиране" от руски автор. Мноооого ценна, може да ти свърши добра работа

1. Kak taka shte se smeni sn# na hdd? Toi ne e li v ROM na diska ?!?!
2. Mojesh li da mi kajesh neshto pove4e za taia knijka (avtor ili neshto ...)

10x


Hristo

Stava vypros za DOS, ne win32, taka 4e ne e problem za nikoi da me izlyje (s TSR), a osven tova edinstvenata programa e nashata (estesveno, tova e DOS).

Hristo

Серийния номер за който говоря е съставен от две двубайтови числа. В примера с една и съща функция можеш да го прочетеш, и да го смениш. Сериен номер в ROM-а на HDD-то сигурно има, но аз не знам вариант с който да го четеш. Би трябвало да е универсален - т.е. да е функция на BIOS например за да си сигурен че става за всички видове дискове - иначе защитата ти ще е доста капризна. Иначе всеки отделен производител слага серийни номера и възможности да ги четеш, но аз не знам универсален начин. Книжката за която говоря беше от някакъв руснак, и там добре са описани някои методи за защита от ниско ниво, както и най-интересните теоретични моменти.
Защитата от копиране има много интересни аспекти, но за днес ми стига. Ако има интерес може да се дискутира утре.

Blagodaria otnovo na vsi4ki,
toku-shto razbrah 4e moga vmesto HDD serial number da izpolzvam CPU serial number ili BIOS signature. Tova e mnog po-sigurno i iasno, taka 4e tova e reshenieto. Edinstveno malko kofti 4e stava samo za procesori >= P2(CPU) no tova ne e problem v moia slu4ai.

Hristo

abe... dobre e ama ne syvsem - chovek reshava da si upgrade-ne CPU-to (koeto chesto se sluchva)... i krai - tvoita programa reshava che e piratsko kopie.
po-dobre da pravish checksum na BIOS-a i s/n na HDD-to ednovremenno. HDD se smenia mnogo po riadko a i kato se smeni i bez drugo trebva da se preinstall-va software-to

kak puk ne.... i kato se update-ne BIOSa kwo?
moito dyno ima live BIOS Update - pod windoz si proweriawsh se edna programka
za nowi BIOSi... oswen towa mai imashe niakakwa tablica ECSD
w koiato se pishat razni prostotiii....
t.e. kato si smenish videoto i weche shte imash nowa check-suma ot BIOS...

eh... pak li s tebe she sporim be... mai se taka ni vyrvi
mi to po taia logika nema nachin za nishto shtoto vsichko se promenia. vyprosyt e koe e po-chesto? osven tva az ne sym nastoiaval che tva e nai-dobroto - prosto tva mi hrumna v momenta, inache ako pomislia sym siguren che ima i po-dobri reshenia

Друг начин е да се отбележи физическото положение на инсталирания файл в HDD-то, и параметрите на самия диск. Тогава всяко прекопиране ще бъде достатъчно сложно. Не че и това не се избягва, но купуването на абсолютно същия диск и твърдо копиране е в състояние да откаже повечето хора.
Е, и тук има минуси - например като се скапе OS и се наложи преинсталиране. Най-сочния и гаден вариант за защита е с Internet-update, например задължително през месец.
Но като всяко друго нещо, една защита трябва да е изградена според цената на това, което защитава.

ne go priemai lichno ;)
ama e dosdno da imash programka sys podobna zashtita.
samo provokira crackerskite sposobnosti u niakoi hora :)
ako programata mu e cenna, 24 chasa sled puskaneto i weche niakoi
shte ia e cracknal... ako ne e, zashto da ia zashtitawa?
istinata e che niama kak da si zashtitish software...
shtom i microsoft nemogat - iawno i s mnogo pari problema ne se reshawa :)
wsyshnost az samo iskah da mu obyrna wnimanie che shte syzdade problemi
na userite. wyw firmata w koiato rabotia ima podobni probelmi, i userite
se nauchiha weche, ima niakoi deto mai wseki mesec si formatirat HDD :)))
(nashta typa zashtita e s nomera ot boot-sectora...)
samo che po nego se generira drug nomer koito triabwa da ni kajat
za da im dadem kod za registracia :)
i te se nauuchiha - kato iskat da si kopirat programata na drug komputyr
dzwyn po telefona - alo formatirah si diska daite mi pak nomer...

ste reche fizichesko systoqnie? Clusteri, sectori i takiwa raboti li?

За книгата - А. Щербаков - Защита от копиране. Издадена е от издателство "Образец", Русе, 1993 г. Можеш да я намериш в книжарницата на ТУ - София, на символична цена. Щом бачкаш под ДОС, може би ще имаш полза от нея ...

Успех!

Mixy

А какво става, когато потребителя си пусне Norton SpeedDisk ?!?

Mixy

Пичове, тука явно програмистите не са с голям опит, защото ставаше дума за серийния номер на твърдия диск, а не за серийния номер на дяла (partition) на ДОС/Windows - FAT16/32......
Ако още не загрявате за к'во иде реч, свалете си програмката "[линк]" и вижте серийните номера на домашните си дискове.

А към Христо - ако искаш да четеш истинския сериен номер на HDD - прочети ATA-3 спецификацията, команда Identify (код 0xECh).

Успех.
Между другото аз също имам споменатата книжка, там единствено за флопи са интересни методите, за HDD са несигурни.

Ако има желаещи, мога да постна цяла статия как се правят слаби битове със стандартно флопи (игра с регистрите на контролера - записваш данни и по едно време по средата на записа правиш RESET на контролера, който е мигновен, и така.....)