Skip Navigation LinksOverview > Using SoftwareShield

Using SoftwareShield™

SoftwareShield™ manages your product’s distribution life-cycle. Whether you are deploying a single build of your software for both online and retail (brick and mortar) sales, or producing several versions with different licensing parameters and protection levels, SoftwareShield provides you all the tools you need.

Below, we briefly outline how the SoftwareShield's software licensing and copy protection system works with your software to enforce the business license you design with the SoftwareShield.

SoftwareShield's licensing is briefly reviewed below including the important concept of Serial Numbers and Activation Codes. An example scenario is also given that describes a typical transaction.

Licenses

There are three methods to protect and license your product using the SoftwareShield Digital Rights Management Kit:

  1. IronWrapped - This method is the simplest and very strong. It requires no changes to your code and it uses the sophisticated protection mechanisms of IronWrap. You can choose pre-defined license models or create your own customized model.
  2. Non-IronWrapped (aka: Embedded) - This method requires changes to your source code. In this method you interface with the SoftwareShield ClientProtector COM component from inside your game to define your own license enforcement model around the building blocks the ClientProtector provides. This method is extremely flexible and allows your team to realize virtually any license model you can imagine with a highly integrated UI right inside your application. However, the protection is somewhat less strong than with IronWrap.
  3. Hybrid (Combined approach) - This method combines the best of both worlds. In this method, you IronWrap your application (either using a pre-defined license model or not) and you can access the ClientProtector from inside your application to provide a highly integrated UI. No other DRM system provides such a high-level of protection combined with the complete and total flexibility of an embedded-type solution.

Read more on the License Models available with SoftwareShield.

Serial Numbers

Serial Numbers are 16 digit alphanumeric codes that represent a "token of ownership" of one or more copies of some aspect of your software. By itself and before it is activated, it is not associated with any particular user or machine, and itself represents the ownership. In other words, it is like a cheque made out to "cash" - anyone can use it. This "aspect of your software" can be either the right to use the entire software package or as detailed as a single use of a single function within that software.

Serial Numbers allow you to implement new license models , which are enforced with the use of SoftwareShield's Activator tools. You can use Serial Numbers to produce commercial off-the-shelf software (COTS) that is pre-packaged, boxed and sold at a retailer. The Serial Numbers you pre-generate for this purpose would be stored inside the box and used during customer activation to "turn on the software" on their machine. This allows you to get the benefit of making a sale to an arbitrary customer at a retailer, but still have the benefit of machine locking/FingerPrinting ensuring that the software can only be activated as many times as you permit.

You can use Serial Number to sell "bulk licenses" or "seats" in enterprise installations of your software. By generating Serial Numbers that have a number of Activations associated with them, you can effectively sell a set of seats to your application using a single Serial Number. This is referred to as the "Total Activations Permitted for a Serial Number". When end-users receive a Serial Number you sent them, they will be able to activate the provided number of seats (machines) - but no more. These Serial Numbers can be pre-generated with a set number of seats or can be dynamically generated with an arbitrary number of seats from either a simple HTTP GET call or a SOAP web-service.

Activation Codes

Activation codes are 12 digit codes that you generate. They contain all the necessary information to make pre-defined changes to the license that controls your application. By issuing Activation Codes to your customers, you change the way your application behaves. For example, allowing it to run in full-mode or adding 10 more pre-paid uses of a specific feature. The Activation Codes that the SoftwareShield Manual-Activator creates are encrypted in two layers. The first layer of information is a composition of three items which are compressed together and encrypted using the password (key) specific to this Authorization Code. The information inside the first layer is:

  1. A parameter value if necessary.
  2. A "shelf-life" if necessary. Which is a date whereon the code will expire and will not function for anyone.
  3. The users Finger Print code if necessary.

This encrypted first layer is compressed together with one more piece of information, the Authorization Code ID for which the code is to operate. The entire structure is then encrypted one more time using the global Authorization Code password (key).

Encryption of SoftwareShield protected resources is performed using any number of selected algorithms which are well known to be secure.

Some Activation Codes are "single-use" codes, so that once they are used on a given system - they can never be reused on that same system. Some Activation Codes have a "shelf-life". The "shelf-life of an Activation Code is a period of days that you set before issuing the license but can also override while issuing each Activation Code. The code must be used within this "shelf-life" - or it will expire. Expired Activation Codes will not work on any system whatsoever.

Example Scenario

Here are the basic steps to implementing a simple trial version of your software using SoftwareShield's IronWrap (available in the IronWrap Edition). In this example, your software may be run for 20 minutes of cumulative usage-time, but will not after it is expired unless the client purchases it from you:

  1. You choose to IronWrap your Software. You select Trial Model 2 (cumulative usage-time). You configure protection options, expire duration (20 minutes), and point the DRM Kit at the unprotected copy of your installation directory.
  2. You select all your binaries (say 5 different DLL's) and data files (say 100 sound files and 20 map files) to be embedded right inside the IronWrapped software.
  3. You prepare any UI elements you want to customize. These will be shown at run-time by the IronWrapping system before control is passed to the entry point of your protected software. These user interface elements may display anything from simple splash screens, to dynamically generated HTML reminder screens to error messages, to input dialogs that require user input.
  4. You hit "Compile". The SoftwareShield DRM Kit IronWraps your software using the License Project you defined and creates a "Release" directory containing the output - the protected software.
  5. You use the contents of the release directory to deploy your software.
  6. You test and debug it until you are satisfied.
  7. In your trial version installer package, you simply distribute the software as you would otherwise - except you do not distribute the 5 DLL's or 100 sound files or 20 map files. They are virtualized right inside the IronWrapped software itself. The software will not know the difference and will use these files as though they were on the disk.
  8. Your client receives your trial version (by download or CD/DVD) and installs it.
  9. Your client happily runs your program. Every time the program starts - the IronWrap system (among other tasks) displays UI elements that you configured in step 3. This will likely include a reminder of the remaining free trial time and an offer to purchase the product.
  10. After 20 minutes have gone by, when the user next starts the program, the IronWrapping system will discover that the expiry duration has lapsed - and ask the user to purchase or enter a Serial Number or Activation Code. If not provided correctly - the software will refuse to run.
  11. Once they have decided to purchase the program from you they visit your site (or affiliate) and purchase the product. Once you have successfully processed their payment your server side code links to the CheckPoint License Server and generates a new Serial Number for this purchase.
  12. Back at your customer's computer - they receive their Serial Number from you. They restart the program (if it wasn't running already since the last step could have all happened in a matter of minutes and enter the Serial Number. The IronWrapping system along with the ClientProtector validates the Serial Number against your CheckPoint License Server (through an HTTP interface) and if it is real, ensures that it has not been consumed and if so - consumes it and generates an Activation Code for the specific computer it is being delivered to.
  13. Now - every time the program starts, the IronWrapping system along with the ClientProtector opens the license to find that this is a fully functional version of the program, and executes without interruption. For a diagram of this example, see: Activation Methods.