Developer's overview for generating license keys and activating software.
Mirrakey is an ActiveX dll that you can add to any COM compliant development project
to generate and authenticate license keys for your software application. Mirrakey
is flexible and includes an in-built client-side license key manager interface that
you can customize with your logo and relevant inputs for key validation. The License
Manager window (if you choose to use it) will save the registration information
on the client computer to an XML file for validation by your application. The validation
can be called at any time, such as the program launch or when a specific feature
is selected. As the software developer, the authentication trigger is your choice.
What Mirrakey can do...
Mirrakey can generate unique license keys based on one or more of three input parameters
plus up to eight options or features. The input parameter or properties are string
values that you can use for any values you require to identify your software, user
or both. The three properties have friendly names (ProductName, SerialNo & UserName)
but you can provide any string value for all or one of these properties to generate
a key. Of course, to generate a unique key, at least one property input must be
unique.
The decision regarding the input values is your decision based on your licensing
requirements. For example, you could use one of the following scenarios:
ProductName = "MyWidget"
UserName = customername@myemail.com
ProductName = "MyApp"
SerialNo = "12345676" (this could be a random number/string generated on installation
of your App).
ProductName = "MyProgram"
SerialNo = CPU ID (you could use some hardware identifier on the user's computer)
These are just some examples because the input parameters are up to you as the software
developer. Those parameters will depend on whether you generate the key manually
on request or use a website to automatically generate the license key and send it
to the client.
If you generate the key manually you can obviously enter the properties at that
time but more likely you will want to automate the process and generate the keys
on a website and send them to the client. Typically this would occur after payment
authentication. Payment authentication methods will vary depending on your payment
gateway provider but, after authentication, you will need to use the parameters
you require that have been submitted by your customer from your application. This
would typically be a HTTP or HTTPS post but could also be part of the query string
submitted to your URL.
After payment authentication, Mirrakey will generate the license key by calling
the "GenerateKey" method using one or more of the relevant properties (ProductName,
SerialNo & UserName) you have provided. The license key is then sent to the
client (usually by email) where they enter the information into the Mirrakey License
Manager form or a custom form you have created. If you choose to use the in-built
License Manager form, you show the form by calling the "ShowLicenseKeyManager" method.
The license information is then saved when the client enters the correct information
and clicks the "Register" button on the License Manager form. The information is
saved to an XML database and can be optionally encrypted.
With the license information saved on their computer, you can easily authenticate
your software by providing the known license properties and calling the "ValidateKey"
method, which will return true or false. Based on the return value, you can then
choose the appropriate action. ie. prompt to purchase, show a nag screen, restrict
features or whatever you deem is appropriate.
Using MirraKey for Software Activation
With a bit of programming imagination, Mirrakey can also be used to provide activation
for your software. For example:
You can use Mirrakey to generate an Activation Code using a unique identifier from
client's computer (such as the computer name, CPU ID etc.) and the License Key that
was created when your software was purchased. This is done by using the same "GenerateKey"
method after setting ActivationLicenseKey and ActivationUserID properties. The ActivationCode
can then be added your license file using the AddActivationCode method making it
easy to validate activation locally when your software starts or invokes specific
features. As the Activation code is unique to a user or hardware specific parameter,
copying the license file to another computer would invalidate the activation code.
You can also increase security by setting the EncryptionKey property and encrypting
the informaton stored in the XML license file.
So, in summary, after your software is purchased and the license key is added to
the license file you can initiate the activation process. This will require sending
the license key and user/pc identifier to your server where the Activation code
is generated and returned to your software. When the activation code is received
it is stored in the license file using the AddActivatonCode method. Each time your
software starts, it is a simple matter with only a few lines of code to check that
your software is licensed and activated.
The other factor you need to consider for implementing product activation is the
possibility that the same valid License Key for your software may be registered
more than once. The way to handle this is when the Activation Code is generated,
you add the License Key to a database together with the unique user/pc ID, activation
date and activation counter. With that information recorded, when the same License
Key tries to be activated you can verify the unique user/pc ID to allow or reject
activation. But you can also consider how many times you may allow activation for
the same License Key, as well as whether to allow activation after a certain time
period. This allows genuine clients to reactivate their software if they have purchased
a new computer after the time period you are comfortable with.
Remember, Mirrakey is a powerful tool for software licensing and is only limited by
your imagination.