This is a VB.NET class that creates secure license keys that encode a Product ID, a Serial Number, and 16 bits of configuration data which can optionally be treated as a date value, such as for an expiration date for subscription-based licensing.
This solution is simpler and easier to use than my previous one from the article at Using VB to Create & Check License Keys, which uses a different approach entirely and has some challenges in a .NET environment.
Please note that earlier versions of this article used code that will result in keys that are not compatible with this code.
Software key codes are a popular way of authorizing use of a program. They need to be reasonably short, but secure from hacks intended to work around them. Allowing the flexibility to store an extra 16-bits of configuration data that can be used as either a raw number, a date, or as 16 boolean options is a very useful addition to many other approaches.
Using the Code
Included in the source project is a class called
LicKey.vb. Simply add this class and the
Encryption.vb source files to your project, then create an instance of a
Dim LK As New LicKey
To generate a code, simply set the
OptValue properties, and read the result with the
KeyCode property: Optionally, you can set the
Salt property to make your keys more unique than the default.
Private Sub AppMain_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
LK.SerialNo = 1
LK.ProductID = 1
LK.OptValue = 0
Dim Code As String = LK.KeyCode
tbKey.Text = Code
tbLen.Text = tbKey.Text.Length
Private Sub tbKey_TextChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles tbKey.TextChanged
LK.KeyCode = tbKey.Text.ToUpper
If LK.SerialNo = 0 Then
tbDecode.Text = "Invalid Key Entered"
tbDecode.Text = "Serial: " & LK.SerialNo.ToString & vbCrLf
tbDecode.Text = tbDecode.Text & "ProdID: " & LK.ProductID.ToString & vbCrLf
tbDecode.Text = tbDecode.Text & "OptVal: " & LK.OptValue.ToString & vbCrLf
The above creates an instance of the class named
LK, and sets the relevant parameters, and then reads out the encoded license key and displays it in a
tbKey, along with its length in a
Decoding a key is very easy as well. Once an instance is created, simply set the
KeyCode() property to the license key. If it is valid, then the
OptValue properties will hold the data that is encoded into the key. If it is invalid, then
OptValue will all be zero.
OptValue() property may be used in any of three modes. It may be treated as a simple 16-bit number, as a set of 16 options which can be read via the
OptionEnabled(x) method, set via
SetOption(x) method, or unset via the
UnsetOption(x) method. It may also be used in a date mode via the
Internally, the class generates and decodes keys that are AES-256 symmetrically encrypted with a key generated from the calling program's
Application.ProductName property. This ensures that all keys created for a particular product can only be used with that product - other use of the same library will generate an incompatible key code. The class internally holds two
Integer and one
UInt16 variables in a
SerialInf structure, which is converted to a byte array and then encrypted to generate a code, or a code is decrypted and marshaled into the structure.
Note that an invalid code cannot be decrypted, and will result in all zeroes in the structure.
Included in the solution is a simple demo application that shows all of the features of the class and can serve as the base for your own keycode generation and management system.
Many thanks go to wampus1 for his .NET Encryption Simplified article and class, which made the encryption/decryption of the key codes much easier.
- Created on 3/18/2014
- Updated on 7/9/2014 to add the Salt property and to make internal keys more deterministic.
This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.