RHEL Installation Numbers
Looking for Free RHEL?
Then go elsewhere. In fact please consider using CentOS. CentOS is a completely free rebuild of RHEL and is almost identical to RHEL in every way save the removal of the Red Hat logos, graphics, and Installation Numbers.
Note that RHEL 6 does not require the use of Installation Numbers.
Red Hat’s Installation Numbers
Red Hat Enterprise Linux 5 introduces “Installation Numbers.” Its basically an activation code that you receive from Red Hat’s web site when you buy RHEL and configures the installer to install the bits you bought. Its also sent to RHN when you register to subscribe your machine to the proper sub channels so that you get errata for the bits you bought.
This is Open Source. Anaconda, the installer is GPL’d and needs to be able to parse these codes. Tools on the system also need to be able to parse these codes when they communicate with RHN. So there’s no hiding of the magic behind these installation numbers. In fact you can find this very easily on a RHEL 5 machine.
$ head /usr/lib/python2.4/site-packages/instnum.py
#!/usr/bin/python
# instnum.py - parse and decode RHEL Installation Numbers
# Copyright (c) 2006 Red Hat, Inc.
# Authors: Dave Lehman
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
The full source: instnum.py
Its even covered under the GPL. I’ve included a link to the complete file for your reading pleasure. It contains detailed documentation for how these codes work. To quote:
16 hex digits:
KK KK KK CC OO OS VT PP
| | | || |- Product defining the format.
| | | ||- Virt limit code used to look up the limit
| | | | in a dictionary. The least bit actually is
| | | | used for the Type field.
| | | |- Socket (phys. CPUs) limit code used to look
| | | up the limit in the list of all possible limits.
| | |- Option code to look up the combination of
| | options in a dictionary.
| |- Checksum - Keyed hash Key and the other fields.
|- Key generated with Peter's algorithm
On a bit level it looks like this:
60 56 52 48 44 40 36 32 28 24 20 16 12 8 4 0
0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60
KKKK KKKK KKKK KKKK KKKK KKKK CCCC CCCC OOOO OOOO OOOO OOSS SSVV VTTP PPPP PPPP
Bits:
Key part:
[40 - 63] - K
- Key generated with the old HACK algorithm. Source of entropy
and used to 'encrypt' parts of the payload.
Checksum:
[32 - 39] - C
- Checksum - first two hex digits of the keyed sha1 hash of the
payload with the key.
Payload:
[18 - 31] - O
- Options - Index of the actual option combination in the list
of all possible combinations for the product. Xored with the
highest 14 bits of the key.
[14 - 17] - S
- Socket (physical CPU) limit. Encoded as the index of the
limit in the list of all possible socket limits. Xored with
the next highest 4 bit of the key.
[11 - 13] - V
- Virt Limit - Limit of the number of virtual instances allowed.
Encoded as the index of the limit in the list of all possible
virtualization limits. Xored with the next highest 3 bits of
the key.
[9 - 10] - T
- EN type - 0 => does not create Entitlement,
1 => creates Entitlement,
2 => installeronly.
Not Xored.
[0 - 8] - P
- Product code - 0 for Server and 1 for Client. Defines the
format. Xored with the lowest 9 bits of the key.
See the file for even more gory details about how these codes work.
Generating Installtion Numbers
I’ve written some of my own code to help generate Installation Numbers:
#!python
# genkey.py - Generate fake RHEL 5 installation numbers
# Copyright (c) 2007 Jack Neely
# Authors: Jack Neely
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
import hmac
import sha
# 24 bits
key = 0x0
# The following class taken from ASPN:
# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/113799
class BitField(object):
def __init__(self,value=0):
self._d = value
def __getitem__(self, index):
return (self._d >> index) & 1
def __setitem__(self,index,value):
value = (value&1L)<> start) & mask
def __setslice__(self, start, end, value):
mask = 2L**(end - start) -1
value = (value & mask) << start
mask = mask << start
self._d = (self._d & ~mask) | value
return (self._d >> start) & mask
def __int__(self):
return self._d
def checksum(regkey):
keystr = "%06x" % regkey[40:64]
payloadstr = "%08x" % regkey[0:32]
hash = hmac.new(keystr, payloadstr, sha)
sum = hash.hexdigest()[:2]
return int(sum, 16)
def generateKey(key, options, sockets, virtlimit, type, product):
"""Create an installation number based from the given codes.
All parameters are int."""
# Okay we are using python slices here so 0:3 represents bits 0, 1, and 2
# and does not include/modify bit 3
regkey = BitField()
# Make the payload
regkey[18:32] = options
regkey[14:18] = sockets
regkey[11:14] = virtlimit
regkey[9:11] = type
regkey[0:9] = product
# Tack on the key
regkey[40:64] = key
# calculate checksum
regkey[32:40] = checksum(regkey)
return "%016x" % int(regkey)
def main():
print "a client key"
print generateKey(key, 0x5, 0xf, 0xf, 0x2, 0x1)
print
print "a server key"
print generateKey(key, 0x1, 0xf, 0xf, 0x2, 0x0)
print
print "A server key with Cluster"
print generateKey(key, 0x2, 0xf, 0xf, 0x2, 0x0)
print
print "A server key with ClusterStorage"
print generateKey(key, 0x3, 0xf, 0xf, 0x2, 0x0)
print
print "server with HPC"
print generateKey(key, 0x4, 0xf, 0xf, 0x2, 0x0)
print
print "server with Directory"
print generateKey(key, 0x5, 0xf, 0xf, 0x2, 0x0)
print
print "server with SMB"
print generateKey(key, 0x6, 0xf, 0xf, 0x2, 0x0)
if __name__ == "__main__":
main()
Download: genkey.py
Once you know where to place the bits and generate the checksum its pretty easy. This generates the following table of keys. Each key below has unlimited CPU sockets and unlimited VM guests.
------------------------------- ---------------------
Client 0000000e0017fc01
Red Hat Global Desktop 000000990007fc02
Server 000000e90007fc00
Server with Cluster 00000065000bfc00
Server with ClusterStorage 000000ab000ffc00
Server with HPC 000000e30013fc00
Server with Directory 000000890017fc00
Server with SMB 00000052001bfc00
------------------------------- ---------------------
These codes are purposely generated with the key field equal to 0. They are perfectly valid but anyone in the “know” should be able to realize these are not installtion numbers from Red Hat. Creating codes with other key values (used to more obscure the fields and generate many different codes that unlock the same features) or creating a handy web app that I would post here is left as an exercise for the reader.
The codes don’t really contain much information. Instead they contain a series of indexes into tables containing feature combinations, socket limits, etc. Those tables are all in the above instnum.py file. For socket limits and VM limits a value of -1 represents an unlimited value. What’s the 2’s complment of 1? 0xFF. The type and product fields are not indexes. Values for the type field represent if the code can create an RHN entitlement and the product field is simply 2 for RHGD, 1 for Client, or 0 for Server. That’s how I create the hex values used in the generateKey() function.
Looking at Your Installation Numbers
Finally any key you create or have been given by Red Hat can be examined by the code in instnum.py. This gives you all the gory details about what the key activates. For example, I’ll run it on my first Client key.
$ python instnum.py 0000000e0017fc01
Product: RHEL Client
Type: Installer Only
Options: NoSLA FullProd Virt Workstation
Allowed CPU Sockets: Unlimited
Allowed Virtual Instances: Unlimited
Package Repositories: Client VT Workstation
key: 0 '000000'
checksum: 14 '0e'
options: 4865 'NoSLA FullProd Virt Workstation'
socklimit: -1 'Unlimited'
virtlimit: -1 'Unlimited'
type: 2 'Installer Only'
product: 1 'client'
{'Virt': 'VT', 'Workstation': 'Workstation', 'Base': 'Client'}
0000-000e-0017-fc01
From a normal RHEL 5 install you can also call this script like so:
$ python /usr/lib/python2.4/site-packages/instnum.py [Installation Number]