Python – Can/Why Does A Hard Drive Serial Number Change

pythonwinapiwindows 8wmi

Our anti-piracy software identifies people according to their Hard Drive Serial. This I believe is a constant feature and will not change unless the user changes their primary physical drive – correct me if I am wrong? We use the WMI python module to obtain the users Hard Drive Serial Number.

For 2 of our test computers the Hard Drive serial number has changed. But we haven't changed their hard drive at all.

What could cause such a problem? Is our code that identifies the serial not comprehensive across windows operating systems? I did notice that this post mentions you can get the wrong serial if a standard user process retrieves the serial no. But in our case the error has occurred on an admin user aswell.

Some important information:

Both of these test nodes run Windows 8 Professional
One computer is a Toshiba laptop
The other computer is an Acer Iconia tablet
The tablet was recently updated from Windows 8 to Windows 8.1 and I noticed that the serial changed after this update
The laptop has an admin user who experienced the issue. The tablet has a standard user who experienced the issue.

Also is the Hard Drive Serial number the MAC address of the hardware device or something else?

Code to obtain the Hard Drive Serial number:

c = wmi.WMI()
for item in c.Win32_PhysicalMedia():
    if "PHYSICALDRIVE" in str(item.Tag).upper():
        serialNo = item.SerialNumber
        break

Edit: A short script that retrieves a users Hard Drive Serial number as a normal process and as an elevated/admin process.

Note: For me it outputs exactly the same serial number no matter as a user or as a admin. Does this script do the same for you aswell?

import os
import sys
import wmi
import win32com.shell.shell as shell
ASADMIN = 'asadmin'

def get_elevated_privleges():
    if sys.argv[-1] != ASADMIN:
        script = os.path.abspath(sys.argv[0])
        params = ' '.join([script] + sys.argv[1:] + [ASADMIN])
        shell.ShellExecuteEx(lpVerb='runas', lpFile=sys.executable, lpParameters=params)


def get_hard_drive_serial():
    c = wmi.WMI()
    for item in c.Win32_PhysicalMedia():
        if "PHYSICALDRIVE" in str(item.Tag).upper():
            return str(item.SerialNumber)

    return None


print "HD Serial as Regular User: " + get_hard_drive_serial()
get_elevated_privleges()
print "HD Serial as Admin User: " + get_hard_drive_serial()

Best Answer

Our anti-piracy software identifies people according to their Hard Drive Serial. This I believe is a constant feature and will not change unless the user changes their primary physical drive - correct me if I am wrong?

In normal usage the serial number should not change, but it is possible for a user to change it if they are trying to bypass your anti-piracy technique. See here for a list of tools that do this, aimed at people trying to bypass anti-cheat systems in games. So you have to consider whether the hard disk serial number is "good enough" to deter most people from pirating your software.

What could cause such a problem? Is our code that identifies the serial not comprehensive across windows operating systems?

See this forum thread. Results are varying depending on Windows version, on whether the code is run as admin or not, and whether the Win32_PhysicalMedia class is used or the Win32_DiskDrive class. Seems pretty unreliable, you may have to write your own abstraction layer to handle it yourself, as described in these forum posts.

I tried it myself and found I got two different serial numbers depending on admin vs normal and Win32_PhysicalMedia vs Win32_DiskDrive:

VB38bb50ab-0de50c12

and

42563833626230356261302d6564303531632032

Notice that the second string is actually a hex-encoded and byte-reversed version of the first string! Maybe the same is happening to you?

is the Hard Drive Serial number the MAC address of the hardware device or something else?

A MAC (Media Access Control) address only relates to network interfaces, nothing to do with hardid disks. The hard drive serial number is an arbitrary string set by the hard disk manufacturer - it can be anything and only has meaning to the manufacturer, it could even be blank if the manufacturer does not implement it.

Related Solutions

Python – Why does comparing strings using either ‘==’ or ‘is’ sometimes produce a different result

is is identity testing, == is equality testing. what happens in your code would be emulated in the interpreter like this:

>>> a = 'pub'
>>> b = ''.join(['p', 'u', 'b'])
>>> a == b
True
>>> a is b
False

so, no wonder they're not the same, right?

In other words: a is b is the equivalent of id(a) == id(b)

Python – List changes unexpectedly after assignment. Why is this and how can I prevent it

With new_list = my_list, you don't actually have two lists. The assignment just copies the reference to the list, not the actual list, so both new_list and my_list refer to the same list after the assignment.

To actually copy the list, you have various possibilities:

You can use the builtin list.copy() method (available since Python 3.3):
```
new_list = old_list.copy()
```
You can slice it:
```
new_list = old_list[:]
```
Alex Martelli's opinion (at least back in 2007) about this is, that it is a weird syntax and it does not make sense to use it ever. ;) (In his opinion, the next one is more readable).
You can use the built in list() function:
```
new_list = list(old_list)
```
You can use generic copy.copy():
```
import copy
new_list = copy.copy(old_list)
```
This is a little slower than list() because it has to find out the datatype of old_list first.
If the list contains objects and you want to copy them as well, use generic copy.deepcopy():
```
import copy
new_list = copy.deepcopy(old_list)
```
Obviously the slowest and most memory-needing method, but sometimes unavoidable.

Example:

import copy

class Foo(object):
    def __init__(self, val):
         self.val = val

    def __repr__(self):
        return 'Foo({!r})'.format(self.val)

foo = Foo(1)

a = ['foo', foo]
b = a.copy()
c = a[:]
d = list(a)
e = copy.copy(a)
f = copy.deepcopy(a)

# edit orignal list and instance 
a.append('baz')
foo.val = 5

print('original: %r\nlist.copy(): %r\nslice: %r\nlist(): %r\ncopy: %r\ndeepcopy: %r'
      % (a, b, c, d, e, f))

Result:

original: ['foo', Foo(5), 'baz']
list.copy(): ['foo', Foo(5)]
slice: ['foo', Foo(5)]
list(): ['foo', Foo(5)]
copy: ['foo', Foo(5)]
deepcopy: ['foo', Foo(1)]

Best Answer

Related Solutions

Python – Why does comparing strings using either ‘==’ or ‘is’ sometimes produce a different result

Python – List changes unexpectedly after assignment. Why is this and how can I prevent it

Related Topic