Introduction

LIMAN SDK is a library of functions to add license protection to software applications. It offers an affordable, easy-to-use and industrial-strength solution against unauthorized use and duplication of software. It is distributed in the form of static and shared (dynamic) libraries ready to be embedded into a host application. It provides a framework to generate encrypted license keys and a set of functions to verify their validity. It is also equipped with protective features against tampering.

LIMAN SDK enables the creation and verification of

• machine-locked licenses
• user-locked licenses
• time-limited licenses for trials and subscription based software
• feature-based licenses

The licenses issued by LIMAN can also be configured to

• be valid for a specific group of products
• be valid for a specific version in the sense that major upgrades would require new licenses
• possess varying capacities restricting the data quantity processed.
• support custom features

The licensing framework is based on asymmetric cryptography, where license generation and verification require different keys. In asymmetric cryptography, key size is the primary measure of the cryptographic strength of the encryption. Although the keys are related mathematically (which is why they are often referred to as keypairs), it is virtually impossible to guess one with the knowledge of the other.

Most commonly, the private key is used to encrypt/sign the licenses, whereas the public key is used to decrypt/verify them. In such a framework, the public key would be embedded into the software application whereas the private key would be kept secret outside the software application.

Getting Started

This section gives an overview of the LIMAN SDK, instructions for getting started, sample applications and details concerning contact and support information. It also presents two utility applications that you will need

• to generate product-specific keypairs
• to generate product-specific license-keys to be sent out to your customers
• to determine hostid on client machines for generating node-locked licenses

Note
These utility applications would meet most of your requirements in managing the licenses you are distributing. You can extend their source-code and rebuild to better suit your needs.

Download

Obtain the distribution package specific to your platform from our web site https://www.baroks.com/downloads. The names of distribution packages for supported operating systems (OS) are listed below. The tag x.y stands for the version of LIMAN SDK.

Obtain Your License Key

You can purchase a LIMAN SDK license key from

https://www.baroks.com/buy

or request a time-limited trial license from

https://www.baroks.com/try

Once your order is completed, you will receive a confirmation email and a download link to your license key. The download file contains the license key embedded in a C/C++ code snippet. Follow the instructions in Installation section to incorporate it into LIMAN SDK.

Prepare the Development Environment

Prepare your development environment based on your platform.

• Windows/VisualStudio: download and install Visual Studio Community https://visualstudio.microsoft.com/vs/community/

• Windows/MinGW: download and install MinGW from the following links

  • https://www.mingw.org (for Windows 32-bit)
  • https://mingw-w64.org (for Windows 64-bit)
  • During MinGW installation, make sure to include gcc compiler toolchain
  • Prepend c:/MinGW/path/to/gcc directory to your %PATH% environment variable. Typically gcc is located under

    Copy to Clipboard
    c:/MinGW/mingw32/bin   
    
    or       
    
    c:/MinGW/mingw64/bin

Note

Windows allows environment variables to be configured permanently at both the User level and the System level, or temporarily in a command prompt.To temporarily set environment variables, open Command Prompt and use the set command:

Copy to Clipboard

C:> set PATH=c:/MinGW/mingw32/bin;%PATH%

or

Copy to Clipboard

C:> set PATH=c:/MinGW/mingw64/bin;%PATH%

To permanently modify the default environment variables, click Start and search for Edit Environment Variables , or open System properties, Advanced System Settings and click the Environment Variables button. In this dialog, you can add or modify User and System variables. To change System variables, you need non-restricted access to your machine (i.e. Administrator rights).

• Linux: Linux operating systems usually comes with GCC pre-installed. To verify if the compiler is installed on the machine, run the following command in the terminal
  Copy to Clipboard

  $ gcc --version
  If the compiler is found, this will return the information about the compiler version. Otherwise, use the following commands to install gcc on Ubuntu/Debian
  Copy to Clipboard

  $ sudo apt-get update $ sudo apt-get install build-essential manpages-dev
  On Fedora/RedHat
  Copy to Clipboard

  $ yum groupinstall 'Development Tools'

• OSX: To set up a ‘C’ programming environment on Mac/OSX system, you have two options:
  1. Command Line Tools for Xcode
     • Download Command Line Tools for XCode from https://developer.apple.com/downloads/index.action. You will need an Apple developer ID.
     • After the file is downloaded on the machine, double click and follow the wizard and install the file. Always keep the default settings as suggested by the installation wizard.
     • After the installation process, open a terminal and run gcc -v command to check if everything is successfully installed.
  2. Homebrew package manager
     • Install homebrew (if not already installed)
       Copy to Clipboard

       /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
     • Run the following brew commands
       Copy to Clipboard

       $ brew update $ brew upgrade $ brew info gcc $ brew install gcc $ brew cleanup
     • After the installation process, open a terminal and run gcc -v command to check if everything is successfully installed.

Installation

In this setup, a 64-bit Linux installation is assumed. For other platforms, the steps would be identical except for package names and system commands to use for building, copying, etc…

1. Locate the liman-x.y-linux64x86.tar.gz file in your download folder. Copy this file into an installation directory of your choice (eg. /opt ) using the following command:

   Copy to Clipboard

   $ cp liman-x.y.z-linux64x86.tar.gz /opt
2. Change working directory to /opt and decompress liman-x.y-linux64x86.tar.gz using tar -xzvf command. This will create the root LIMAN SDK directory liman-x.y under /opt. It is your installation directory.
   Copy to Clipboard

   $ tar -xzvf liman-x.y.z-linux64x86.tar.gz
   The following sub-directories will be placed within the installation directory.

   • apps/  : contains project and source files for the sample applications in  programming language.

   • bin/ : contains utility scripts for license management.

   • lib/ : contains platform independent jar files to link with java applications

   • lib/ : core LIMAN library, utility executables.

   • include/ : contains include or header files, defining the function prototypes, needed to compile applications in different programming languages.

   • license/ : contains the license file (e.g. usr_liman_lic.c) required to use LIMAN SDK.

   • doc/ : contains documentation files.

3. Set the environment variable LIMAN_ROOT to point to the installation directory and update system path

   Copy to Clipboard

   $ export LIMAN_ROOT=/opt/liman-x.y.z $ export PATH=$PATH:$LIMAN_ROOT/bin:$LIMAN_ROOT/lib/linux64x86

   Note
   To execute these lines automatically at logon, append these lines to the end of your startup script (.bashrc or .bash_profile for bash shell). Alternatively, update $LIMAN_ROOT/bin/limsetenv.sh script with the above lines and have your startup script (.bashrc or .bash_profile) source from that file with the following line

   Copy to Clipboard

   source /opt/liman-x.y.z/bin/limsetenv.sh
4. Change working directory to $LIMAN_ROOT/lib/linux64x86. The contents of this directory are
   Copy to Clipboard

   drwxr-xr-x 3 mka staff 4.0K Jun 15 17:10 ./ drwxr-xr-x 3 mka staff 4.0K May 18 02:33 ../ -rwxr-xr-x 1 mka staff 604K May 18 01:37 libliman_core.a* -rwxr-xr-x 1 mka staff 104K May 18 01:37 libliman_wrap.a* -rwxr-xr-x 1 mka staff 18K May 3 03:49 liman.def* -rwxr-xr-x 1 mka staff 4.9K May 4 23:00 Makefile* -rwxr-xr-x 1 mka staff 1.3K May 3 20:07 README.txt*
5. Save the license-file you obtained from baroks.com as $LIMAN_ROOT/license/usr_liman_lic.c
   Copy to Clipboard

   $ cp ~/Downloads/usr_XXXXXXXX_lic.c $LIMAN_ROOT/license/usr_liman_lic.c

   Note
   ~/Downloads/usr_XXXXXXXX_lic.c is the file you obtained from baroks.com

6. Build the LIMAN SDK library with the following command.
   Copy to Clipboard

   $ make
   This step will link the core LIMAN library lib/linux64x86/libliman_core.a against your license-file and create a licensed version LIMAN SDK. After the build is complete, you will have the following files in the working directory
   Copy to Clipboard

   -rwxr-xr-x 1 mka staff 325K Jun 15 17:12 ahostid* -rw-r--r-- 1 mka staff 2.5K Jun 15 17:12 ahostid.o -rwxr-xr-x 1 mka staff 604K May 18 01:37 libliman_core.a* -rwxr-xr-x 1 mka staff 606K Jun 15 17:12 libliman_sdk.a* -rwxr-xr-x 1 mka staff 447K Jun 15 17:12 libliman_sdk.so* -rwxr-xr-x 1 mka staff 104K May 18 01:37 libliman_wrap.a* -rwxr-xr-x 1 mka staff 18K May 3 03:49 liman.def* -rwxr-xr-x 1 mka staff 340K Jun 15 17:12 limgen* -rw-r--r-- 1 mka staff 28K Jun 15 17:12 limgen.o -rwxr-xr-x 1 mka staff 344K Jun 15 17:12 limutil* -rw-r--r-- 1 mka staff 29K Jun 15 17:12 limutil.o -rwxr-xr-x 1 mka staff 4.9K May 4 23:00 Makefile* -rwxr-xr-x 1 mka staff 1.3K May 3 20:07 README.txt*
   This step completes the creation of LIMAN SDK library and utility executables integrated with your license-key. Take a note of the roles of the files in this folder
   Copy to Clipboard

   ahostid A utility to display the hostid of the current host. It accepts a single command-line argument argument to specify, in the form of a bitmask, the input that will be the basis of hostid computation. libliman_core.a Core LIMAN (static library), comes with the download package and has limited functionality. libliman_sdk.a Licensed LIMAN SDK (static library), created by linking \c libliman_core.a with your license. libliman_wrap.a Java and .NET extension module (static library). libliman_sdk.so Licensed LIMAN SDK (dynamic/shared library), created by linking \c libliman_sdk.a with \c libliman_wrap.a. This is the library you need when using with applications that require dynamic loading (Java, .NET, Python). limgen A utility application for license management limutil A utility application for performing several LIMAN-SDK tasks. Makefile A platform specific makefile to build LIMAN SDK and utility applications. README.txt A quick reference to building LIMAN SDK

Building a Product-Specific LIMAN SDK

The LIMAN SDK library lib/libliman_sdk.a you just built is not yet ready to be used to protect a particular application. In order to achieve that, the following component needs to be created and linked against lib/libliman_sdk.a.

Once this step is completed, you will have a custom build of LIMAN SDK to protect your product.

Note
This is the step where a product-specific keypair is required. You can create as many keypairs as you need, and protect as many products as you need.

For the purposes of this illustration, we will embed LIMAN SDK into a hypothetical product called TESTAPP.

Use limutil tool to generate a new product-license-base.  A product-license-base is a set of attributes and files associated with a specific product pertaining to license protection. In particular, it involves

• A string of at most 12 characters that uniquely identifies a product. This could be specified by the user or be generated randomly by limutil.
• The method of cryptography to be used. The default is RSA encryption.
• A private and public keypair of specified size associated with the product. Default key size is 2048.

To display the list of available command-line options of limutil, type.

The following output will be displayed

NoteThis step considers a hypothetical product/application called TESTAPP for license-protection.

Run limutil to generate the product-license-base. Change the default key size to a different value if required. An RSA key size of 2048 bits is the default. This key size is considered safe by US-NIST until the year 2030. See this special publication for further information.

Now, you can verify that TESTAPP's keypair is written to subfolder ./TESTAPP. The folder will contain four files in it.

Two of the files have extension .key in which private and public keys are encoded in hexadecimal format. The other two contain the same keys embedded in a C/C++ function ready to be included in a C/C++ application.

The file TESTAPP_public_key.c is one of the components to be embedded into the product-specific LIMAN SDK and will eventually be linked against TESTAPP application.

The file TESTAPP_private*.* files will continue to live outside TESTAPP application and will be used by only the license generator (See License Generation section).

• The other component that goes into the product-specific LIMAN SDK is the LIMAN SDK license key sent to you via email. This key is embedded in a C/C++ function which should be compiled and linked to core LIMAN library (libliman_core.a). If you haven’t received your LIMAN SDK license key, please visit https://www.baroks.com/try to get it. Your license key will be sent to you via email. Once you receive it, copy it into $LIMAN_ROOT/license directory and perform the following step to create the product-specific library libliman_<PRODUCT>_sdk.a. Note that we continue to assume that product TESTAPP is being targeted.
  Copy to Clipboard

  $ make product PRODUCT=TESTAPP
  This final step will build the product-specific LIMAN SDK libliman_TESTAPP_sdk.a. TESTAPP application will eventually be linked against this library to enable LIMAN powered license protection. In a Java or .NET application, libliman_TESTAPP_sdk.so (on Linux), libliman_TESTAPP_sdk.dylib (on OSX), or libliman_TESTAPP_sdk.dll (on Windows) would be used.For housekeeping purposes, libliman_TESTAPP_sdk.a is placed in lib/TESTAPP directory so that it is not mixed-up with other libraries built for other products or platforms. If you decide to switch to another private and public key pair, you will need to rebuild libliman_TESTAPP_sdk.a with a new keypair as described in Building a Product-Specific LIMAN SDK section. It is recommended to use different keypairs for different products or different versions of the same product.
  

  Note If product code is not specified explicitly, then limutil will generate a random string of 12-characters to be associated with the product-license-base generated. To see this, execute the following

  Copy to Clipboard

  $ limutil --genkey --keysize=2048

  Product-id is ‘FC16ADA16362’. Written private key in FC16ADA16362/FC16ADA16362_private.key. Written public key in FC16ADA16362/FC16ADA16362_public.key. Written private key as C/C++ code in FC16ADA16362/FC16ADA16362_private_key.c. Written public key as C/C++ code in FC16ADA16362/FC16ADA16362_public_key.c.When the product code is generated randomly, it will take a different value in each run. Therefore, the string value you see will be different than the above. To confirm the product-license-base for FC16ADA16362 was generated successfully, execute the following command.

  Copy to Clipboard

  $ ls -la ./FC16ADA16362 -rw-r--r-- 1 mka staff 515 2014-09-08 16:04 FC16ADA16362_private.key -rw-r--r-- 1 mka staff 3076 2014-09-08 16:04 FC16ADA16362_private_key.c -rw-r--r-- 1 mka staff 513 2014-09-08 16:04 FC16ADA16362_public.key -rw-r--r-- 1 mka staff 2881 2014-09-08 16:04 FC16ADA16362_public_key.c

You will need to repeat this setup process for each product you want to protect with LIMAN SDK. In a hypothetical 3-product business, you will typically have the following directory structure after the setup. The product codes are assumed to be randomly generated by limutil. Running the following two more times

three product-license-bases, each with its own subfolder, will be created.

To build the LIMAN SDK for all products, run the following

The product-specific LIMAN libraries are now ready to be linked against by their respective products.

Your products should now be linked against the associated libliman_<PRODUCT>_sdk.a and the license generator limgen should use the private key associated with that product. For instance, the product 52ADB5129389 should be linked against libliman_52ADB5129389_sdk.a and limgen should use 52ADB5129389_private.key to generate licenses.

Note The libliman_<PRODUCT>_sdk.a library is meant to be used with a specific product, it should not be used for protecting multiple products.

License Generation

License generation involves creating an encrypted license key that contains the following information

• A string with LIMPAR_MAX_LEN_PRODUCTID characters that uniquely identifies a product (like a barcode, brand name and/or model number)
• An integer platform identifier that specifies the platform or architecture. (e.g. Windows 32-bit, Linux 64-bit, etc..) for which the license is good for.
• An integer specifying the major version number.
• An integer specifying the minor version number.
• An integer specifying the size of license (e.g. when the software’s capabilities should vary with license size. A typical example is when a database application could process at most a prespeficed number of records for a given license size).
• An integer constant specifying the type of license (e.g. educational, trial, commerical).
• An integer specifying the number of concurrent seats/users allowed by the license (reserved for future use).
• An integer specifying the expiry date of the license in YYYYMMDD format (optional).
• A string with LIMPAR_MAX_LEN_SERIAL characters specifying the serial number for the product (optional).
• A string with LIMPAR_MAX_LEN_UUID characters specifying a universally unique identifier for the product (optional).
• A string with LIMPAR_MAX_LEN_HOSTID characters specifying the host-id of the host machine (optional).
• A byte (char) array of 4 elements to specify additional features using bitmasks (optional). Each byte can characterize 8 features.

LIMAN SDK has two data types which needs to be initialized before any license-related operation could be performed.

• pLIMENV is the LIMAN SDK environment object. This object is created with
  • lim_create_env()
• pLIMLIC is the LIMAN SDK license object which can be created with one of the three functions
  • lim_create_lic()
  • lim_create_lic_fromfile()
  • lim_create_lic_fromkey()

The steps to create a license key can be summarized as below

• Create a new environment instance by calling lim_create_env().
• Read the private key associated with the product by calling lim_read_private_key().
• Create an empty license instance by calling lim_create_lic().
• Call lim_load_lic() after setting up the following arguments to be passed
  • Product code.
  • Platform identifier.
  • Major and minor version number.
  • License size (optional).
  • License type (optional).
  • An expiry date (optional).
  • A serial number created with lim_gen_rkey() or your own serial-generation code. It should have at most LIMPAR_MAX_LEN_SERIAL characters.
  • Create a random UUID for the license with lim_gen_uuid() (optional). It should have at most LIMPAR_MAX_LEN_UUID non-hyphen characters.
  • The host-id of the node (machine) the license will be installed on. This is required only if the license will be node-locked. Request this information from your customer.
  • Set up optional features (optional).
• Call lim_write_lickey() to export the license key to a file.
• Call lim_free_lic() and lim_free_env() to free the memory used.
• Send the license key to your customer.

These steps are illustrated in sample application limgen. It is located in apps/c/limgen directory. Run the following command to build it

After the build is complete, type

to display the list of available command-line options. The setup of the license key is achieved by setting associated command-line options. You can use this utility for most of your license generation needs. Alternatively, you can modify it to suit your needs or extend it to a GUI application.

Using Bitmasks to Enable Optional License Features

Your application may have different features and functionalities which require to be licensed separately. LIMAN SDK allows you to enable a maximum of 32 optional features in a license key. This is achieved by setting the elements of a byte (char) array with 4 elements to specific bitmask values during license generation and thereby enabling/disabling required features. Each byte (char) is assigned to a 8-bit bitmask value in the range [0..255]. By default all elements are set to zero. After this array is set up, it is passed to lim_load_lic() to incorporate these features into the license key.

We illustrate the workings with a hypothetical case for a single byte. It is straightforward to extended the same logic to four bytes. Suppose your application offers 8 different techniques for sorting records of data. Because they have varying efficiencies and requirements, you may want to price them individually. This will require you to set up the license keys with feature-availability information. Your customers may want to purchase one or some or all or none of these features depending on your licensing model. Let the following be the sort techniques offered by your hypothetical application

• Quick Sort
• Merge Sort
• Heap Sort
• Insertion Sort
• Intro Sort
• Block Sort
• Shell Sort
• Bubble Sort

For a particular license key, availability of each feature could be represented with a specific bit in a byte of license data. Consider the following byte (char) variable and how each bit is designated to a specific sorting method (feature). This 8-bit data block would be one of the components of the input passed to the license generation phase. So, it has to be set up according to customer’s license requirements. Initially, all bits are set to zero (empty) meaning that none of the sorting methods (features) are available to the license holder.

Suppose your customer requested a license with Quick Sort, Heap Sort and Block Sort. This is accomodated by switching on the bits associated with these features in a single byte (char) variable.

Note

Specific bits of a byte can be modified by ( | ) , (~) , (^) and (&) operators.

This 8-bit data block corresponds to binary number $ (00100101)_2 $ which equals $ 2^0 + 2^2 + 2^5$ = $ 1 + 4 + 32 = 37$ in base-10. In $LIMAN_ROOT/include/liman.h symbolic constants are provided for each bit position

A code similar to the following could be used to set up desired features. This task would typically be performed by the license generation application, e.g. limgen. This particular code turns on bits 0, 2 and 5 in feature[0] and enables the associated sort methods. In this example, other features feature[1], feature[2] and feature[3] are also set to various values for illustration purposes.

After the license key is generated and sent to the customer, the application will check the available features by a code snippet similar to the following.

You can test this scenario by running limgen using lg_testapp.sh, which is the license generation script for TESTAPP application. This script will create a license keyfile, TESTAPP/usr_<product>.lic, with properties specified in lg_testapp.sh.

Note

If command line option –hostid option was specified, you would have seen a warning that the license is not valid, implying that it is good only for the client machine with hostid=. This is a message you will see for all node-locked licenses you generate for client machines.

This license is written into TESTAPP folder and ready to be used with testapp application. Running testapp with specified license file will produce the given output. As indicated by the application log, only licensed sort methods are confirmed to be available with the specified license

See testapp.c implementation for details, especially how other features are checked to control the flow of the code.

License Key Format

The licenses generated by LIMAN SDK will be in the following format. They contain an encryption of the data specifying license properties. The actual license key is the string contained within BEGIN LICENSE KEY and END LICENSE KEY lines. The creation of license keys require your private key, which should remain private on your local site and should not be shared with the outside world. The validation will be performed by your application using the public key embedded in libliman_TESTAPP_sdk.a.

Contact and Support Information

LIMAN SDK is licensed and supported by Baroks Inc. (https://www.baroks.com). General information regarding LIMAN SDK can be found at the Baroks website

https://www.baroks.com/document

For technical support, send questions to

Questions regarding licensing information or other information about Baroks products can be sent to

Appendix A: Error Codes

The list of errors in LIMAN SDK along with a brief description is given in the following. The symbolic constants are defined in include/liman.h header file.

Modules

LIMAN SDK Functions

Functions Table

PRECALL
int
STDCALL

lim_exd_bstream (pLIMENV pEnv,
char *pachBufferIn, 
int nBytesIn, 
char *pachBufferOut, 
int *pnBytesOut, 
int nDirection)

PRECALL
pLIMENV
STDCALL

lim_create_env(int nKeySize,
int nHashSize,
int *pnErr)

PRECALL
int
STDCALL

lim_load_lic(pLIMLIC pLic,
const char *szProductCode,
int mPlatformId,
int nMajorVersion,
int nMinorVersion,
int mSizeId,
int mTypeId,
int nUsers,
int nExpiration,
const char *pcFeatures,
const char *szSerial,
const char *szUUID,
const char *szHost,
const char *szUserid,
int nHostIdMask)

PRECALL
int
STDCALL

lim_free_lic (pLIMLIC *ppLic)

PRECALL
int
STDCALL

lim_delete_lic (pLIMLIC pLic)

PRECALL
int
STDCALL

lim_free_env (pLIMENV *ppEnv)

PRECALL
int
STDCALL

lim_delete_env(pLIMENV pEnv)

PRECALL
int
STDCALL

lim_print_lic (pLIMLIC pLic, char *strbuf)

PRECALL
int
STDCALL

lim_get_hash16 (const char *pachBuffer,
int nBytesIn,
char *szHash)

PRECALL
int
STDCALL

lim_get_hash12 (const char *pachBuffer,
int nBytesIn,
char *szHash)

PRECALL
int
STDCALL

lim_get_hash8 (const char *pachBuffer,
int nBytesIn,
char *szHash)

PRECALL
int
STDCALL

lim_get_sha (const char *pachBufferIn,
int nBytesIn,
char *pachBufferOut,
int nHashSize)

PRECALL
int
STDCALL

lim_get_licsha (pLIMLIC pLic, char *pachBufferOut)

PRECALL
int
STDCALL

lim_get_libsha (pLIMENV pEnv, char *pachBufferOut)

PRECALL
int
STDCALL

lim_get_hostid(char *szStr255, int nHostIdMask)

PRECALL
int
STDCALL

lim_get_macid (char *szStr255, int id)

PRECALL
int
STDCALL

lim_get_cpuid (char *szStr255)

PRECALL
int
STDCALL

lim_get_verkey (int *pnMajor,
int *pnMinor,
int *pnRelease,
int *pnRevision,
char *szComment)

PRECALL
int
STDCALL

lim_get_verstr (char *szComment)

PRECALL
int
STDCALL

lim_gen_rkey (pLIMENV pEnv,
int nSeed,
int nLen,
int nBase,
char *szRandKey)

PRECALL
int
STDCALL

lim_gen_uuid (pLIMENV pEnv,
int nSeed,
char *szRandUUID)

PRECALL
int
STDCALL

lim_gen_product_id (pLIMENV pEnv,
int nSeed,
char *szRandProductId)

PRECALL
int
STDCALL

lim_get_keypair (pLIMENV pEnv,
char *szP,
char *szQ,
char *szN)

PRECALL
int
STDCALL

lim_new_keypair (pLIMENV pEnv, int nKeySize)

PRECALL
int
STDCALL

lim_gen_keypair (int nKeySize,
int nSeed,
const char *szProductCode)

PRECALL
int
STDCALL

lim_gen_keypair_ecp (int nKeySize, int nSeed)

PRECALL
int
STDCALL

lim_write_keypair (pLIMENV pEnv,
const char *szPrivateKeyFile,
const char *szPublicKeyFile)

PRECALL
int
STDCALL

lim_write_keypair_carr (pLIMENV pEnv,
const char *szPrivateKeyFile,
const char *szPublicKeyFile)

PRECALL
int
STDCALL

lim_hash_file (const char *szFile,
char *szHash,
int nHashSize)

PRECALL
int
STDCALL

lim_read_public_key (pLIMENV pEnv,
const char *szPublicKeyFile)

PRECALL
pLIMLIC
STDCALL

lim_create_lic (pLIMENV pEnv, int *pnErr)

PRECALL
int
STDCALL

lim_read_private_key (pLIMENV pEnv,
const char *szPrivateKeyFile)

PRECALL
int
STDCALL

lim_load_public_key (pLIMENV pEnv,
const char *szPublicKey)

PRECALL
int
STDCALL

lim_load_private_key (pLIMENV pEnv,
const char *szPrivateKeyP,
const char *szPrivateKeyQ)

PRECALL
int
STDCALL

lim_parse_keypair (pLIMENV pEnv)

PRECALL
int
STDCALL

lim_assert_valid (pLIMLIC pLic)

PRECALL
int
STDCALL

lim_days_to_expiry (pLIMLIC pLic)

PRECALL
const
char
*STDCALL

lim_product_id (pLIMLIC pLic)

PRECALL
int
STDCALL

lim_has_feature (pLIMLIC pLic,
int idSlot,
int mFeature)

PRECALL
int
STDCALL

lim_is_verified (pLIMLIC pLic)

PRECALL
char
*STDCALL

lim_get_lickey (pLIMLIC pLic)

PRECALL
pLIMLIC
STDCALL

lim_create_lic_fromfile (pLIMENV pEnv,
const char *szKeyFile,
int *pnErr)

PRECALL
pLIMLIC
STDCALL

lim_create_lic_fromkey (pLIMENV pEnv,
const char *szKey,
int *pnErr)

PRECALL
int
STDCALL

lim_copy_lic2str (pLIMLIC pLic, char *szKey)

PRECALL
int
STDCALL

lim_copy_str2lic (const char *szBuffer,
pLIMLIC pLic)

PRECALL
int
STDCALL

lim_keys_loaded (pLIMENV pEnv)

PRECALL
int
STDCALL

lim_write_lickey (pLIMLIC pLic,
const char *szKeyFile)

PRECALL
int
STDCALL

lim_write_lickey_carr (pLIMLIC pLic,
const char *szKeyFile)

PRECALL
int
STDCALL

lim_sign_lic (pLIMLIC pLic)

PRECALL
int
STDCALL

lim_veri_lic (pLIMLIC pLic)

PRECALL
int
STDCALL

lim_set_licreq (pLIMLIC pLic,
int mPlatformId,
char *szProductCode,
int nMajorVersion,
int nMinorVersion,
int mSizeId,
int mTypeId)

PRECALL
int
STDCALL

lim_major_version (pLIMLIC pLic)

PRECALL
int
STDCALL

lim_minor_version (pLIMLIC pLic)

PRECALL
int
STDCALL

lim_platform_id (pLIMLIC pLic)

PRECALL
int
STDCALL

lim_size_id (pLIMLIC pLic)

PRECALL
char
*STDCALL

lim_lic_id (pLIMLIC pLic)

PRECALL
int
STDCALL

lim_type_id (pLIMLIC pLic)

PRECALL
int
STDCALL

lim_set_rsa_dir (pLIMENV pEnv, int nFlag)

PRECALL
int
STDCALL

lim_write_secretmsg (pLIMENV pEnv,
const char *szPlainMsg,
const char *szSecretMsgFile)

PRECALL
int
STDCALL

lim_get_userid (char *szUserId)

PRECALL
int
STDCALL

lim_get_dmiuuid (char *szDMIUUD)

PRECALL
char
*STDCALL

lim_canonical_uuid (const char *szUUID)

Detailed Description

License Manager SDK Functions.

This group contains API functions in LIMAN SDK.

Function Documentation

---

LIMAN Error Handling Functions

LIMAN Error Handling Functions. More…

Functions

Detailed Description

---

LIMAN Error Handling Functions.

Function Documentation

---

---

Host identifiers

Macros

Detailed Description

---

List of host identifiers to create locked licenses.

Macro Definition Documentation

---

---

Miscellenous constants

Macros

Detailed Description

---

List of constants.

Macro Definition Documentation

---

---

String lengths

Macros

Detailed Description

---

List of string lengths for various data.

Macro Definition Documentation

---

---

Error codes

Macros

Detailed Description

---

Error codes in LIMAN SDK. See Appendix A for descriptions.

Macro Definition Documentation

---