HDD serial number flipped every 2 bytes in Windows XP, Vista and 7 but not in Windows 8

Question

I need to get HDD serial number to use it as a key for licensing a software. I used diskid32 code in this url: http://www.winsim.com/diskid32/diskid32.html It used the DeviceIoControl Win32 API with the IO control code of IOCTL_STORAGE_QUERY_PROPERTY.

It worked. However, when I double check with the actual serial number printed on the HDD itself, I found that every 2 bytes of the number was flipped.

A simple solution could be to simply flip the bytes back. It worked in Windows XP, Vista and 7 but in windows 8 not need to be flipped!

I wish to know the exact reason why the bytes were flipped in Windows XP, Vista and 7, and why not flipped in Windows 8. What about next Windows?

Part of code with minor changes:

  int drive = 0;
  HANDLE hPhysicalDriveIOCTL = 0;
  char driveName [256];
  sprintf (driveName, "\\\\.\\PhysicalDrive%d", drive);
  //  Windows NT, Windows 2000, Windows XP - admin rights not required
  hPhysicalDriveIOCTL = CreateFile (driveName, 0,
                           FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                           OPEN_EXISTING, 0, NULL);
  if (hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE)
  {
     _STORAGE_PROPERTY_QUERY query;
     DWORD cbBytesReturned = 0;
     char buffer [10000];

     memset ((void *) & query, 0, sizeof (query));
     query.PropertyId = StorageDeviceProperty;
     query.QueryType = PropertyStandardQuery;

     memset (buffer, 0, sizeof (buffer));

     if ( DeviceIoControl (hPhysicalDriveIOCTL, IOCTL_STORAGE_QUERY_PROPERTY,
               & query,
               sizeof (query),
               & buffer,
               sizeof (buffer),
               & cbBytesReturned, NULL) )
     {
         _STORAGE_DEVICE_DESCRIPTOR * descrip = (_STORAGE_DEVICE_DESCRIPTOR *) & buffer;
         char serialNumber [1000];
         char modelNumber [1000];
         char vendorId [1000];
         char productRevision [1000];

         flipAndCodeBytes (buffer,
                           descrip -> SerialNumberOffset,
                           1, serialNumber );

        ...
     }

Win8 in general has a lot of fixes for old Windows bugs that were left on the shelf for compat reasons. Insulate yourself from this by using WMI, Win32_DiskDrive class, SerialNumber property. — Hans Passant, Feb 06 '13 at 14:39
While I agree with @HansPassant I would strongly discourage using serial numbers of harddrives as a unique identifier for your software, not because it is easily spoofable, but because a serial number is individual to the supplier of the product and you might therefore end up with duplicate product keys in a worst case scenario. The my knowledge the only "certified" unique identifier on a computer is the MAC address or an IPv6 address. What the problem is with all of these solutions is that they only tie you to a specific hardware component and not a specific box. — , Feb 12 '13 at 12:23
If you just need it to be kind-of unique to stop casual piracy, why bother flipping them at all? Every time you read it on the same computer it will match the initial flipped read. Though it might cause a problem if the user upgrades to windows 8 and selects "keep my programs and data" — Luke, Feb 13 '13 at 01:28
@Kris Network adapter may be not exist in some systems or my be disabled. Probability of duplication of HDD serial number in small business like my case is very low and can be ignored. — A.Danesh, Feb 13 '13 at 07:38
@Luke My main problem is some users upgrade their systems from windows 7 to windows 8 and previous activation code not work on their systems. If user only use windows 7 or 8 there isn't any problem at all. — A.Danesh, Feb 13 '13 at 07:41
@A.Danesh if your company is so small that it won't be an issue, and that some computers don't even have a netcard, then why use it at all? Then I take it you want to hardcode ID's into the software code? My suggestion to you would still be to make serial keys for your software instead, it will be a format that you control and not a format that is incredibly random in structure. Then all you need to do is add your custom serial key to the windows registry, which is incredibly easy. — , Feb 13 '13 at 11:36

score 3 · Answer 1 · answered Sep 12 '13 at 00:34

I use the same approach (and same code) in my software licensing. Yes, Windows 8 for some reason is returning flipped values for this method, I can't say why (so I can't answer your question).

My solution is the one that you pointed out: Flip the values again. So, after calling the "flipAndCodeBytes", you could test if is a Windows 8 OS, and flip the values.

In my case, it's working now (I got the same values for Windows XP/Vista/7 and Windows 8).

Good luck!

score 3 · Answer 2 · edited May 23 '17 at 12:33

3

Just turn off the flip using the "flip" flag of the flibAndCodeBytes function when windows 8 or greater.

bool shoulFlipBytes = true;
if(IsWin8OrLater()) shouldFlipBytes = false;

flipAndCodeBytes(buffer,
                 descrip->SerialNumberOffset,
                 shouldFlipBytes,
                 serialNumber);

You can use this to check for windows version:

#include <windows.h>

bool IsWin8OrLater() {
    DWORD version = GetVersion();
    DWORD major = (DWORD) (LOBYTE(LOWORD(version)));
    DWORD minor = (DWORD) (HIBYTE(LOWORD(version)));

    return (major > 6) || ((major == 6) && (minor >= 2));
}

According to http://msdn.microsoft.com/en-us/library/ms724832%28VS.85%29.aspx (Thanks to ChrisV Determine if O/S is Windows 7)

edited May 23 '17 at 12:33

Community

1
1

answered May 14 '14 at 09:47

zajac.m2

1,218
14
13

2

Or simply call [IsWindows8OrGreater](https://msdn.microsoft.com/en-us/library/windows/desktop/dn424961.aspx). – IInspectable Feb 25 '16 at 00:04
1

and of course ```bool shouldFlipBytes = ! IsWindows8OrGreater()``` – Sebastian Oct 31 '16 at 09:19

score 1 · Answer 3 · answered Feb 15 '13 at 02:22

Basically you're relying on data that's not strictly reliable to begin with. Drives may change over the lifetime of a computer; all the while getting exactly the right serial number isn't even important to your product.

One easy hack I can think of is to normalize the serial number, e.g. by sorting the digits; this will make more drives look alike, but I doubt it will become an issue.

Another way of looking at the problem is that the application should provision for serial number changes; the user could be informed about the licensing issue (for whatever reasons) and asked to contact the support department with a generated code (not necessarily the serial number itself). Given this code, support can then create a new license for the customer.

Another algorithm: Check the serial number. If it doesn't match, flip the bytes and check a second time. — Raymond Chen, Feb 15 '13 at 13:15

score 0 · Answer 4 · answered Sep 19 '14 at 21:55

Seem you have to check for windows version through API and add if() branch to your code if version is high enough

My devs found other problem with this method - that kind of IOCtl code relies on program is being run with administrator rights on Win7\Win8+. In cause of our software, it's service that is run with system rights and clients software that is strictly run with user rights

score 0 · Answer 5 · answered Feb 16 '15 at 17:37

For licensing-checking purposes, you really don't care. All you need to know is that some configurations result in flipping, some don't, and it can change during the lifetime of a license.

So accept both variants:

string serial = get_serial();
if (license_check(serial)) {
    licensed = true;
    return;
}
serial = swap_bytes(serial);
if (license_check(serial)) {
    licensed = true;
    return;
}

(I see Raymond suggested this in a comment)

No fragile OS check, no worries about whether it failed to flip right when the user applied for the license. Just happy users.

HDD serial number flipped every 2 bytes in Windows XP, Vista and 7 but not in Windows 8

5 Answers5

Linked