Editions and Project Type

SoftwareShield has a highly modular design that it allows you to use any part of the following optional components:

• Ironwrapper

  SoftwareShield's application binary-based \emph{Ironwrapper} wrapping technology provides a protection layer without modifying the application's source code. It is a standalone low-level component that is driven by SoftwareShield IDE when building license project, however it can also be invoked directly via its command line interface.

• SDK and License

  SoftwareShield implements multiple built-in license models, secure license storage and online / offline activation, all these license logics are implemented in the SoftwareShield runtime, a dynamic library (gsCore.dll on Windows and libgsCore.dylib on Mac) that can be integrated with application's source code.

• License UI

  By default, SoftwareShield provides built-in license UI for a license project, the license UI implements event listeners allowing end user to activate application entities, dealing with runtime errors, transferring license to another machine, etc. You can customize the default UI template to fit your own need, such as GUI layout, images.

Project Types

According to features used, SoftwareShield supports 4 types of license projects:

Standard: Wrap + License + Built-in UI

This is the default project type mostly used by SoftwareShield customers.

The typical work-flow of using Standard project type is:

1. Create a new license project;
2. Specify application to protect;
3. Define entity and license model;
4. Customize built-in UI_HTML UI;
5. Build the license project;

After building the project, the protected application binary is ready for QA, there is no need to have access to your application's source code, everything works at binary level. However, in some scenarios that you want to query license information and change your application's behavior according to the active license status, you can integrate SoftwareShield SDK with your application's source code, compile the application as usual (but now the application binary needs SoftwareShield runtime, gsCore.dll or libgsCore.dylib, to run properly), copy the new application binaries to license project's "Src/" folder, build the license project again, then the output application will be tightly integrated with SoftwareShield SDK and protected by Ironwrapper.

Custom: Wrap + License + My own UI

This project type is similar to Standard Project Type that it also uses Ironwrapper to protect its binaries, however, it integrates tightly with SDK at source code level and implements its own license GUI to support application activation, error handling, etc.

For example, as a game developer, you want the game players have a consistent user experience, the SoftwareShield built-in license UI might looks weird or alien to end users so you can develop the license UI inside your game based on the selected game rendering engine (OpenGL, DirectX, Flash, Director, etc.).

The typical work-flow of using Custom project type is:

1. Create a new license project;
2. Specify original application to protect;
3. Define entity and license model;
4. Build the license project to get the license file in %ProjectDir%/Release/ folder;
5. Copy the license file to Application Development Environment;
6. Integrate application with SoftwareShield SDK and license file;
7. Replace the original application binaries with SDK-integrated new application binaries in %ProjectDir%/Src/;
8. Build the license project;

When developing your own application-specific license GUI, you are assumed to have full knowledge of your application's source code and know when and how to render the in-app UI to avoid any possible runtime conflicts encountered by using a SoftwareShield built-in UI template, so the Execution Mode does not make sense and is not used in custom project type.

License Only: No Wrapping

This project type does not use SoftwareShield Ironwrapper technology, when the project is built, a license file is generated as the only output. It is used when you only want to integrate with the SDK for license purpose, and the application does not need wrapping protection, or you are using third party solution to protect your binaries.

The work-flow of License Only project type is:

1. Create a new license project;
2. Define entity and license model;
3. Build the license project to get the license file in %ProjectDir%/Release/ folder;

Wrap Only: No License

Wrap-only project type is a special one that only use SoftwareShield low-level Ironwrapper feathre and does not use any high-level license components. You may choose this project type when you have your own or use other third party license solution and only want to protect the application binaries with Ironwrapper.

The work-flow of Wrap Only project type is:

1. Create a new license project;
2. Specify original application to protect;
3. Build the license project;

SoftwareShield Editions

SoftwareShield has two different editions:

Professional Edition

This edition can be used to protect application which:

1. Does not need SDK Integration; The Professional edition works on the binary level, no source code integration is necessary.

   However, the SDK OOP api can be accessed to retrieve current license status, but the license activating / transferring apis are not supported for professional edition.

2. Does not need in-app license GUI; The built-in license GUI templates are implemented based on HTML/Javascript, which can be customized by developers, we provide complete javascript APIs to support license status retrieving, activating, transferring, etc.

The supported license project types are Standard and Wrap-Only.

Enterprise Edition

Enterprise Edition supports all kinds of license projects, if you want to develop your own license UI inside your application, or develop your own license logic to tightly Integrate with SoftwareShield SDK, you must use this edition.