Using the GameShield System
This section is a brief overview of how the GameShield system works
with your game to enforce the license you design with the GameShield License Manager.
Licensing is briefly reviewed
including the important concept of Serial
Numbers and Activation
Codes. An example scenario is given that describes
a typical transaction.
There are three methods to protect and license your
product using the GameShield DRM Kit:
-
IronWrapped - This method is the simplest
and very strong. It requires no changes to your code. It uses the sophisticated
protection of IronWrapping. However, you will be restricted to one of the pre-defined
license models (behaviour).
- Non-IronWrapped (aka: Embedded) - This method requires changes
to your source code. In this method you interface with the ClientProtector COM
server 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 than IronWrapping.
- Hybrid - This method combines the best of both worlds. In
this method, you IronWrap your game (either using a pre-defined license model
or not) as well, you access the ClientProtector from inside your application to
provide a highly integrated UI. This method is the strongest and just as flexible
as the above (embedded) method.
The Hybrid approach is the pinnacle of DRM capability. No other system
provides such a high-level of protection combined with the complete and total
flexibility of an embedded-type solution. You get 100% of the protection with
100% of the flexibility. No other DRM system even comes close to this.
"Licensing" therefore is the enforcement of the business rules you
design for your game, realized through either the underlying IronWrap mechanism
or through a cooperative effort between your application, the GameShield ClientProtector
component and (optionally) the IronWrap mechanism.
You design and develop your licenses and protected games using the GameShield
License Manager application.
Back to Top
Serial Numbers are 12 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. Before the Serial Number is activated - it
is 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 the CheckPoint License Server). 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.
Back to Top
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 GameShield
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:
- A parameter value if necessary.
- A "shelf-life" if necessary. Which is a date whereon the code will expire
and will not function for anyone.
- 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 GameShield 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.
Back to Top
Example Scenario:
For example, here are the basic steps to implementing a simple trial version
of your game using IronWrapping. In this example, your game may be played for
20 minutes of cumulative play-time, but will not after it is expired unless the
client purchases it from you:
- You choose to IronWrap your Game. You select Trial Model 2 (cumulative play
time). You configure protection options, expire duration (20 minutes), and point
the DRM Kit at the unprotected copy of your installation directory.
- 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 game.
- 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 game. 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.
- You hit "Compile". The GameShield DRM Kit IronWraps your game using
the License Project you defined and creates a "Release" directory containing
the output - the protected game.
- You use the contents of the release directory to deploy your game.
- You test and debug it until you are satisfied.
- In your trial version installer package, you simply distribute the game 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 game itself.
The game will not know the difference and will use these files as though they
were on the disk.
- Your client receives your trial version (by download or CD/DVD) and installs
it.
- 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 play-time
and an offer to purchase the product.
- 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 game will refuse to run.
- 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.
- 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.
- 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 and observe the use-case "CheckPoint Activation".
Back to Top
|
Licenses