Devolens

https://help.cryptolens.io/
Admin
Devolens is a comprehensive software licensing platform that helps developers add licensing to their...
Tokens:396,935
Snippets:4,220
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Full Example: Get Key via License Server in Java

Source: https://help.cryptolens.io/libraries/java

Demonstrates a complete example of retrieving a license key by routing the request through a specified license server URL. Includes error handling.

```java
String RSAPubKey = "<RSAKeyValue><Modulus>sGbvxwdlDbqFXOMlVUnAF5ew0t0WpPW7rFpI5jHQOFkht/326dvh7t74RYeMpjy357NljouhpTLA3a6idnn4j6c3jmPWBkjZndGsPL4Bqm+fwE48nKpGPjkj4q/yzT4tHXBTyvaBjA8bVoCTn+LiC4XEaLZRThGzIn5KQXKCigg6tQRy0GXE13XYFVz/x1mjFbT9/7dS8p85n8BuwlY5JvuBIQkKhuCNFfrUxBWyu87CFnXWjIupCD2VO/GbxaCvzrRjLZjAngLCMtZbYBALksqGPgTUN7ZM24XbPWyLtKPaXF2i4XRR9u6eTj5BfnLbKAU5PIVfjIS+vNYYogteQ==<Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";

String auth = APIKey.get("getkeyactivate");

APIError error = new APIError();

GetKeyModel model = new GetKeyModel(3349, "ICVLD-VVSZR-ZTICT-YKGXL");
model.LicenseServerUrl = "http://10.1.1.6:8080";

LicenseKey license = Key.GetKey(auth, RSAPubKey, model , error);

if (license == null) {
    System.out.println("The license does not work.");
    System.out.println("Error: " + error.message);
} else {
    System.out.println("The license is valid!");
    System.out.println("It will expire: " + license.Expires);
}
```

--------------------------------

### Run License Server on Linux/Mac

Source: https://help.cryptolens.io/feature/license-server/index

Execute this command to start the license server on Linux or Mac after installing the .NET 5 runtime or later. No sudo access is typically required.

```bash
dotnet LicenseServer.dll

```

--------------------------------

### Start License Server on Linux/Mac

Source: https://help.cryptolens.io/feature/license-server

Run the license server on Linux or Mac using the .NET CLI. Ensure .NET 5 runtime or later is installed.

```bash
dotnet LicenseServer.dll
```

--------------------------------

### Build Example Project with CMake

Source: https://help.cryptolens.io/api/cpp/index.html

Clones the Cryptolens C++ repository, navigates to the CMake example directory, builds the project using CMake and Make, and then runs the example activation.

```bash
git clone https://github.com/Cryptolens/cryptolens-cpp.git
cd cryptolens-cpp/examples/unix/cmake
mkdir build
cd build
cmake ..
make -j8
./example_activate
```

--------------------------------

### Install Cryptolens Go Library

Source: https://help.cryptolens.io/examples/key-verification

Get the Cryptolens Go library using the go get command.

```bash
go get github.com/Cryptolens/cryptolens-golang/cryptolens
```

--------------------------------

### Build C Examples with CMake

Source: https://help.cryptolens.io/libraries/c

Use these CMake commands to build the C client SDK examples from the repository root.

```bash
mkdir build
cd build
cmake ../examples
make
```

--------------------------------

### Start License Server with Configuration String

Source: https://help.cryptolens.io/feature/license-server/index

Use this command to start the license server when supplying the configuration string as a command-line argument.

```bash
LicenseSerer.exe -config <the configuration string>
```

--------------------------------

### Build and Run Example Project in Visual Studio

Source: https://help.cryptolens.io/api/cpp

Instructions for building and running the example project in Visual Studio after the library has been built. Requires setting the configuration and platform.

```csharp
Set configuration and platform in the same way as when building the library
  * Build and run the project.
```

--------------------------------

### Build C Example with GCC/Clang

Source: https://help.cryptolens.io/libraries/c

Compile the C example file manually using GCC or Clang. Ensure all necessary source files and include paths are specified.

```bash
gcc -Iinclude/ -Ithird_party/cJSON/ src/cryptolens.c src/data_object.c src/decode_base64.c src/error.c src/machine_code_computer_static.c src/request_handler_curl.c src/response_parser_cJSON.c src/signature_verifier_openssl.c third_party/cJSON/cJSON.c third_party/openbsd/base64.c third_party/openbsd/strlcpy.c -lcrypto -lssl -lcurl examples/example_activate.c
```

--------------------------------

### Build Example Projects with CMake

Source: https://help.cryptolens.io/api/cpp

Instructions for cloning the repository and building example projects using CMake on Linux. Requires libcurl and OpenSSL.

```bash
apt-get install libcurl4-openssl-dev libssl-dev
```

```bash
yum install libcurl-devel openssl-devel
```

```bash
git clone https://github.com/Cryptolens/cryptolens-cpp.git
```

```bash
cd cryptolens-cpp/examples/unix/cmake
```

```bash
mkdir build
```

```bash
cd build
```

```bash
cmake ..
```

```bash
make -j8
```

```bash
./example_activate
```

--------------------------------

### Get Product Variables Example

Source: https://help.cryptolens.io/api/dotnet/api/SKGL.SKM.html

Retrieves product variables like UID, PID, and HSUM for a given product. This method requires your username, password, and the product ID. Ensure System.Linq is included for the First() method.

```csharp
public void GetProductVariables()
{
   var listOfProducts = SKGL.SKM.ListUserProducts("username", "password");

   //variables needed in for instance validation/activation
   //note, First requires System.Linq.
   var productVar = SKGL.SKM.GetProductVariables("username","password", listOfProducts.First().Value);

   Debug.WriteLine("The uid=" + productVar.UID + ", pid=" + productVar.PID + " and hsum=" + productVar.HSUM);
}
```

--------------------------------

### Build and Run Visual Studio Example Project

Source: https://help.cryptolens.io/libraries/cpp

Builds and runs the example project for Visual Studio after the Cryptolens library has been built. Ensure the correct platform and configuration are set.

```plaintext
Open *examples/VisualStudio/VisualStudio.sln*
Set configuration and platform in the same way as when building the library
Build and run the project.
```

--------------------------------

### Get Parameters Example

Source: https://help.cryptolens.io/api/dotnet/api/SKGL.SKM.html

Demonstrates how to manually access Web API parameters using the GetParameters method. Ensure you have the necessary input parameters and a valid signature.

```csharp
public void GetParamtersExample()
{
   var input = new System.Collections.Generic.Dictionary<string, string >();
   input.Add("uid", "1");
   input.Add("pid", "1");
   input.Add("hsum", "11111");
   input.Add("sid", "ABCD-EFGHI-GKLMN-OPQRS");
   input.Add("sign","true");

   var result = SKGL.SKM.GetParameters(input, "Validate");

   var keyinfo = SKGL.SKM.GetKeyInformationFromParameters(result);

   if(result.ContainsKey("error") && result["error"] != "")
   {
       // if we are here, something went wrong.
   }
}
```

--------------------------------

### Basic Library Setup

Source: https://help.cryptolens.io/api/cpp/index.html

Includes necessary headers, sets up a namespace alias, and initializes the Cryptolens handle.

```APIDOC
## Library Setup

### Includes and Namespace Alias
```cpp
#include <cryptolens/core.hpp>
#include <cryptolens/Error.hpp>
#include <cryptolens/Configuration_XXX.hpp>
#include <cryptolens/MachineCodeComputer_YYY.hpp>
namespace cryptolens = ::cryptolens_io::v20190401;
```

### Cryptolens Handle Initialization
```cpp
using Cryptolens = cryptolens::basic_Cryptolens
<cryptolens::Configuration_XXX<cryptolens::MachineCodeComputer_static>>;

cryptolens::Error e;
Cryptolens cryptolens_handle(e);

// Set signature verifier parameters (replace with your actual public keys)
cryptolens_handle.signature_verifier.set_modulus_base64(e, "ABCDEFGHI1234");
cryptolens_handle.signature_verifier.set_exponent_base64(e, "ABCD");

// Set machine code
cryptolens_handle.machine_code_computer.set_machine_code(e, "289jf2afs3");
```
```

--------------------------------

### Create and Start License Server as Windows Service

Source: https://help.cryptolens.io/feature/license-server/index

Commands to register and start the license server as a Windows service. Requires Administrator privileges. Ensure the binpath points to the correct executable and configuration.

```bash
sc create license-server binpath="D:\path\to\licenseserver\LicenseServer.exe" start=auto
net start license-server
```

--------------------------------

### Customer Portal Sign-up Link Example

Source: https://help.cryptolens.io/feature/customer-portal

This is an example of a sign-up link for associating a customer with the portal. It includes a customer ID and an activation code.

```text
https://app.cryptolens.io/Portal/@cryptolens.io/Associate?id=123&auth=activationcode
```

--------------------------------

### Example Access Token

Source: https://help.cryptolens.io/payment-form/automating-customer-and-license-creation

An example of an access token generated with CreateKey and AddCustomer permissions. Ensure you generate your own token with the required permissions.

```text
WyIxMjc0IiwieUN2RjYveDZTVktsVm9XZFhVcmtTdzZJSm1yTU1zTnZoTXdKQmNsSSJd
```

--------------------------------

### Install Devolens Codex Marketplace

Source: https://help.cryptolens.io/getting-started/build-with-ai

Install the Devolens Codex marketplace using curl. This script downloads and installs the marketplace. Restart Codex and install 'Devolens Licensing' from the Plugin Directory.

```bash
curl -fsSL https://raw.githubusercontent.com/Cryptolens/skills/main/install.sh | bash
```

--------------------------------

### Key Generation Example Link

Source: https://help.cryptolens.io/llms-full.txt

This link provides an example of how to construct the URL for generating a license key, typically used within a webhook or data request.

```url
https://help.cryptolens.io/examples/key-generation
```

--------------------------------

### Install Node.js Cryptolens SDK

Source: https://help.cryptolens.io/examples/key-verification

Install the Cryptolens SDK for Node.js by running this command in your terminal.

```bash
npm add cryptolens
```

--------------------------------

### Install Cryptolens Python Library (Python 3)

Source: https://help.cryptolens.io/llms-full.txt

Use pip to install the Cryptolens licensing library for Python 3 projects. This command fetches and installs the package and its dependencies.

```shellscript
pip install licensing

```

--------------------------------

### VB.NET: Application Start with License Verification

Source: https://help.cryptolens.io/llms-full.txt

This code snippet demonstrates how to load, activate, and verify a license key upon application startup. It checks for feature availability and expiration, falling back to a local copy if online access is unavailable, and handles cases where no license is found.

```vb.net
NoLicense()

' The code below is based on https://help.cryptolens.io/examples/key-verification.

Dim license = New LicenseKey().LoadFromFile()
Dim publicKey = "{Your RSA Public key}"
Dim token = "{access token with permission to access the activate method}"

If license IsNot Nothing Then

    Dim result = Key.Activate(token:=token, parameters:=New ActivateModel() With {
                  .Key = license.Key,
                  .ProductId = 3349,
                  .Sign = True,
                  .MachineCode = Helpers.GetMachineCode()
                  })

    ' either we get a fresh copy of the license or we use the existing one (given it is no more than 90 days old)
    If (result.Result <> ResultType.Error And result.LicenseKey.HasValidSignature(publicKey).IsValid) Or license.HasValidSignature(publicKey, 90).IsValid() Then

        Button1.Enabled = license.HasFeature(1).IsValid() ' either we have feature1 or not.
        Button2.Enabled = license.HasFeature(2).IsValid() ' either we have feature2 or not.
        Button4.Enabled = license.HasFeature(3).IsValid() ' either we have feature3 or not.

        Text = "Digital Tools"

        If license.HasFeature(4).HasNotExpired().IsValid() Then
            ' feature 1 is a time limited, so we check that it has not expired.
            Text = "Digital Tools - " + license.DaysLeft().ToString() + " day(s) left"
        ElseIf license.HasNotFeature(4).IsValid() Then
            ' not time limited.

        Else
            MsgBox("Your license has expired and cannot be used.")
            NoLicense()

        End If

        license.SaveToFile()

    Else
        MsgBox("Your license has expired and cannot be used.")
    End If

Else
    ' no license found. you could tell the user to provide a license key.
End If
```

--------------------------------

### Install Cryptolens.Licensing NuGet Package (Package Manager)

Source: https://help.cryptolens.io/examples/key-verification

Use this command in the Visual Studio Package Manager Console to install the Cryptolens.Licensing NuGet package.

```powershell
PM> Install-Package Cryptolens.Licensing
```

--------------------------------

### Example Success Message with Variables

Source: https://help.cryptolens.io/payment-form/index

This is an example of a success message that can be displayed to the customer after a purchase. It includes placeholders for dynamic data like the license key and customer ID, which will be replaced by the Web API.

```text
Thank you for purchasing Product. Your key is [key].
Your customer code (when contacting our support team) is [customer_id].

```

--------------------------------

### Example Prompt for Codex

Source: https://help.cryptolens.io/getting-started/build-with-ai

Use the license-key-verification skill to add license key verification with cached offline fallback to your project.

```text
Use the license-key-verification skill to help me add license key verification with cached offline fallback to this project.
```

--------------------------------

### Example Success Message with Variables

Source: https://help.cryptolens.io/payments/forms/intro

This example shows a success message template that can be used in payment forms. It includes placeholders like [key] for the generated license key and [customer_id] for custom data returned from your web application.

```text
Thank you for purchasing Product. Your key is [key].
Your customer code (when contacting our support team) is [customer_id].
```

--------------------------------

### Get Current Unix Timestamp (C#)

Source: https://help.cryptolens.io/llms-full.txt

Demonstrates how to get the current time in Unix timestamp format using .NET's DateTimeOffset.

```csharp
var currentTime = DateTimeOffset.Now.ToUnixTimeSeconds()
```

--------------------------------

### Search Licenses by Key String (LINQ)

Source: https://help.cryptolens.io/llms-full.txt

Examples of how to search for license keys using their string representation, including exact matches and partial containment.

```plaintext
key="ITVBC-GXXNU-GSMTK-NIJBT"
```

```plaintext
key.contains("ITVBC")
```

```plaintext
ITVBC-GXXNU-GSMTK-NIJBT
```

--------------------------------

### Devolens Web API Request Example

Source: https://help.cryptolens.io/basics/webapi

This example shows a direct HTTPS request to the Web API to retrieve information about a license key. It is useful for custom backend integrations or unsupported programming languages. Ensure you replace placeholders like {access-token} with your actual credentials and product details.

```text
https://app.cryptolens.io/api/key/GetKey?token={access-token}&ProductId=1234&Key=MUYVD-LSEBY-CXHRQ-XFAGY&Sign=True
```

--------------------------------

### Activate License in Node.js

Source: https://help.cryptolens.io/llms-full.txt

This Node.js example shows how to activate a license key using the Cryptolens API. It utilizes promises for handling asynchronous operations and includes basic error logging. Remember to update the access token, RSA public key, Product ID, and license key.

```javascript
var RSAPubKey = "Your RSA Public key, which can be found here: https://app.cryptolens.io/User/Security";
var result = key.Activate(token="access token with permission to access the activate method", RSAPubKey, ProductId=3349, Key="GEBNC-WZZJD-VJIHG-GCMVD", MachineCode=Helpers.GetMachineCode());

result.then(function(license) {

    // success
    
    // Please see https://app.cryptolens.io/docs/api/v3/model/LicenseKey for a complete list of parameters.
    console.log(license.Created);

}).catch(function(error) {
    // in case of an error, an Error object is returned.
    console.log(error.message);
});
```

--------------------------------

### Nested Submodules Example

Source: https://help.cryptolens.io/feature/web-ui/feature-templates

Demonstrates how to add submodules to submodules by nesting arrays.

```json
["Module C", ["ModuleD", [["ModuleD1", ["Submodule D2", "Submodule D4"]]]]]
```

--------------------------------

### Create Data Object via Web API GET Request

Source: https://help.cryptolens.io/llms-full.txt

This is a direct Web API GET request URL to create a data object. It's useful when integrating with Payment Forms. 'IntValue' can be set to 0 for usage-based billing or a credit amount for upfront billing.

```http
https://app.cryptolens.io/api/data/AddDataObjectToKey?token=accesstoken&name=usagecount&ProductId=3941&Key=FRQHQ-FSOSD-BWOPU-KJOWF&IntValue=0
```

--------------------------------

### Activate License with Floating License Options

Source: https://help.cryptolens.io/llms-full.txt

This example demonstrates how to activate a license with floating license capabilities enabled. It includes setting a floatingTimeInterval and optionally a maxOverdraft. The `Helpers.IsOnRightMachine` function is also shown with flags set for supporting floating licenses with overdraft.

```APIDOC
## Activate License with Floating License Options

### Description
Activates a license key, enabling floating license features by specifying `floatingTimeInterval` and `maxOverdraft` in the `ActivateModel`. It also shows how to correctly use `Helpers.IsOnRightMachine` for floating licenses with overdraft.

### Method
`Key.Activate`

### Parameters
#### Request Body
- **auth** (string) - Required - Authentication token.
- **RSAPubKey** (string) - Required - The RSA public key for license verification.
- **model** (ActivateModel) - Required - Model containing activation details:
  - **productId** (int) - Required - The product ID.
  - **licenseKey** (string) - Required - The license key to activate.
  - **machineCode** (string) - Required - The machine code.
  - **floatingTimeInterval** (int) - Optional - The interval in seconds for floating licenses.
  - **maxOverdraft** (int) - Optional - The maximum number of licenses that can exceed the bound.

### Request Example
```java
import io.cryptolens.methods.*;
import io.cryptolens.models.*;

public static void main(String args[]) {
    String RSAPubKey = "<RSAKeyValue><Modulus>sGbvxwdlDbqFXOMlVUnAF5ew0t0WpPW7rFpI5jHQOFkht/326dvh7t74RYeMpjy357NljouhpTLA3a6idnn4j6c3jmPWBkjZndGsPL4Bqm+fwE48nKpGPjkj4q/yzT4tHXBTyvaBjA8bVoCTnu+LiC4XEaLZRThGzIn5KQXKCigg6tQRy0GXE13XYFVz/x1mjFbT9/7dS8p85n8BuwlY5JvuBIQkKhuCNFfrUxBWyu87CFnXWjIupCD2VO/GbxaCvzrRjLZjAngLCMtZbYBALksqGPgTUN7ZM24XbPWyLtKPaXF2i4XRR9u6eTj5BfnLbKAU5PIVfjIS+vNYYogteQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
    String auth = "WyIyNjA5IiwiaWE5b0VFT3Q2eDlNR2FvbHBHK2VOYUZ4bzNjT3h5UkNrMCtiYnhPRSJd";

    LicenseKey license = Key.Activate(auth, RSAPubKey, new ActivateModel(3349, "MTMPW-VZERP-JZVNZ-SCPZM", Helpers.GetMachineCode(2), 300, 1));
    if (license == null || !Helpers.IsOnRightMachine(license, 2, true, true)) {
        System.out.println("The license does not work.");
    } else {
        System.out.println("The license is valid!");
        System.out.println("It will expire: " + license.Expires);
    }
}
```

### Response
#### Success Response (LicenseKey)
- **Expires** (string) - The expiration date of the license.
```

--------------------------------

### Get Customers using .NET Client

Source: https://help.cryptolens.io/api/dotnet/articles/v4016.html

Use the CustomerMethods.GetCustomers method to list customers. Ensure to handle potential API errors by checking the result. This example retrieves a maximum of 5 customers.

```csharp
var result = CustomerMethods.GetCustomers(AccessToken.AccessToken.GetCustomers, new GetCustomersModel { Limit=5 });

if(result == null || result.Result == ResultType.Error)
{
    Assert.Fail("API error");
}

Assert.IsTrue(result.Customers.Count == 5);

```

--------------------------------

### Extend License Validity via Web API

Source: https://help.cryptolens.io/licensing-models/subscription

This is a GET request example to the Cryptolens API to extend a license key's expiration date. It's used after a successful subscription payment to grant continued access.

```http
https://app.cryptolens.io/api/key/ExtendLicense?ProductId=123&Key=FRQHQ-FSOSD-BWOPU-KJOWF&NoOfDays=30&token=<access token with 'Extend License permission'>
```

--------------------------------

### Get Platform Independent Machine Code

Source: https://help.cryptolens.io/api/dotnet/articles/v4015.html

Use this method when targeting multiple platforms if you are using the NuGet package and need the new machine code method. Ensure you have the necessary setup if not using the 'Without System.Management' binaries.

```csharp
string machineCode = Helpers.GetMachineCodePI();
```

--------------------------------

### Initialize SDK with License Key (Track All Devices)

Source: https://help.cryptolens.io/licensing-models/sdk-licensing

Use this approach when the customer needs to supply a license key to unlock SDK functionality. The license key is provided during initialization.

```csharp
var math = new MathMethods("FULXY-NADQW-ZAMPX-PQHUT");

Console.WriteLine(math.Abs(5));
Console.WriteLine(math.Fibonacci(5));
```

--------------------------------

### Search Licenses by ID (LINQ)

Source: https://help.cryptolens.io/llms-full.txt

Examples of how to search for license keys using their unique ID with various comparison operators.

```plaintext
id=2
```

```plaintext
id=2 or id=3
```

```plaintext
id < 10
```

--------------------------------

### Generate Unique Identifier per Instance (C#)

Source: https://help.cryptolens.io/faq

Generate a new GUID for each application start to define a unique end user per instance, suitable for dynamic environments like Docker containers or VMs. This approach is recommended for floating license models.

```csharp
var machineCode = Guid.NewGuid();
```

--------------------------------

### Call API through License Server

Source: https://help.cryptolens.io/llms-full.txt

This example illustrates how to route API requests through a self-hosted license server by specifying the `LicenseServerUrl` parameter in the API model.

```APIDOC
## Call API through License Server

### Description
Enables routing API requests through a client-site license server by setting the `LicenseServerUrl` property on the API model.

### Method
`Key.GetKey` (example, other methods also support this)

### Parameters
#### Request Body
- **auth** (string) - Required - Authentication token.
- **RSAPubKey** (string) - Required - The RSA public key for license verification.
- **model** (GetKeyModel) - Required - Model containing request details:
  - **productId** (int) - Required - The product ID.
  - **licenseKey** (string) - Required - The license key.
  - **LicenseServerUrl** (string) - Optional - The URL of the license server.

### Request Example
```java
String RSAPubKey = "<RSAKeyValue><Modulus>sGbvxwdlDbqFXOMlVUnAF5ew0t0WpPW7rFpI5jHQOFkht/326dvh7t74RYeMpjy357NljouhpTLA3a6idnn4j6c3jmPWBkjZndGsPL4Bqm+fwE48nKpGPjkj4q/yzT4tHXBTyvaBjA8bVoCTn+LiC4XEaLZRThGzIn5KQXKCigg6tQRy0GXE13XYFVz/x1mjFbT9/7dS8p85n8BuwlY5JvuBIQkKhuCNFfrUxBWyu87CFnXWjIupCD2VO/GbxaCvzrRjLZjAngLCMtZbYBALksqGPgTUN7ZM24XbPWyLtKPaXF2i4XRR9u6eTj5BfnLbKAU5PIVfjIS+vNYYogteQ==<Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";

String auth = APIKey.get("getkeyactivate");

APIError error = new APIError();

GetKeyModel model = new GetKeyModel(3349, "ICVLD-VVSZR-ZTICT-YKGXL");
model.LicenseServerUrl = "http://10.1.1.6:8080";

LicenseKey license = Key.GetKey(auth, RSAPubKey, model , error);

if (license == null) {
    System.out.println("The license does not work.");
    System.out.println("Error: " + error.message);
} else {
    System.out.println("The license is valid!");
    System.out.println("It will expire: " + license.Expires);
}
```

### Response
#### Success Response (LicenseKey)
- **Expires** (string) - The expiration date of the license.
#### Error Response
- **error.message** (string) - Description of the error.
```

--------------------------------

### Provide Configuration String via Command Line

Source: https://help.cryptolens.io/feature/license-server/index

Use this command to start the license server with a configuration string passed as a command-line argument. Obtain the configuration string from the Cryptolens website.

```bash
dotnet LicenseServer.exe -config <paste configuration string here>
```

--------------------------------

### Activate Floating License with Overdraft (Java)

Source: https://help.cryptolens.io/llms-full.txt

Java example for activating a floating license with overdraft. Pass `FloatingTimeInterval` and `MaxOverdraft` to the `ActivateModel`. The `Helpers.IsOnRightMachine` method must be called with `true` for both `isFloatingLicense` and `allowOverdraft`.

```java
String RSAPubKey = "{Your RSA Public key}";
String auth = "Access token with permission to access the activate method";

// note the two new parameter, one for floating time interval (i.e. 100) and one telling how much we can exceed the max number of machines (i.e. by 1).
LicenseKey license = Key.Activate(auth, RSAPubKey, new ActivateModel(3349, "MTMPW-VZERP-JZVNZ-SCPZM", Helpers.GetMachineCode(), 100, 1));

// from node-locking example (NB: we need to provide an additional true flag in Helpers.IsOnRightMachine to support overdraft)
if (license == null || !Helpers.IsOnRightMachine(license, true, true)) {
    System.out.println("The license does not work.");
} else {
    System.out.println("The license is valid!");
    System.out.println("It will expire: " + license.Expires);
}
```

--------------------------------

### Feature Template Example

Source: https://help.cryptolens.io/feature/web-ui/feature-templates

An example of a feature template that includes nested submodules.

```json
["ModuleA", ["ModuleB", ["Submodule 1", "Submodule 2"]], "ModuleC"]
```

--------------------------------

### Install Devolens Skill Bundle for Claude Code

Source: https://help.cryptolens.io/getting-started/build-with-ai

Install the complete Devolens skill bundle from the Claude plugin marketplace. This command installs all twelve skills in the bundle. To update later, refresh the marketplace.

```text
/plugin marketplace add Cryptolens/skills
/plugin install devolens@devolens
```

--------------------------------

### Create Trial Key (C++)

Source: https://help.cryptolens.io/api/cpp/basic__Cryptolens_8hpp_source.html

Creates a trial license key for a given product. Requires token, product ID, and machine code. Returns the response string from the server or an empty string on error.

```cpp
template<typename Configuration>
std::string
basic_Cryptolens<Configuration>::create_trial_key_
( basic_Error & e
, std::string token
, int product_id
)
{
if (e) { return ""; }

std::string machine_code = machine_code_computer.get_machine_code(e);

auto request = request_handler.post_request(e, "app.cryptolens.io", "/api/Key/CreateTrialKey");

std::ostringstream product_id_; product_id_ << product_id;

std::string response =
request.add_argument(e, "token" , token.c_str())
.add_argument(e, "ProductId" , product_id_.str().c_str())
.add_argument(e, "MachineCode", machine_code.c_str())
.make(e);

if (e) { return ""; }

return response_parser.parse_create_trial_key_response(e, response);
}
```

--------------------------------

### Force Deactivate License (Floating)

Source: https://help.cryptolens.io/llms-full.txt

This example shows how to force deactivate a license, which can be used even for floating licenses to trigger an earlier deactivation than the automatic timeout.

```APIDOC
## Force Deactivate License (Floating)

### Description
Forces the deactivation of a license, applicable to both node-locked and floating licenses to ensure immediate deactivation.

### Method
`Key.Deactivate`

### Parameters
#### Request Body
- **auth** (string) - Required - Authentication token with Deactivate permission.
- **model** (DeactivateModel) - Required - Model containing deactivation details:
  - **productId** (int) - Required - The product ID.
  - **licenseKey** (string) - Required - The license key to deactivate.
  - **machineCode** (string) - Required - The machine code.
  - **force** (boolean) - Required - Set to `true` to force deactivation.

### Request Example
```java
import io.cryptolens.methods.*;
import io.cryptolens.models.*;

public static void main(String args[]) {
    String auth = "";

    boolean result = Key.Deactivate(auth, new DeactivateModel(3349, "MTMPW-VZERP-JZVNZ-SCPZM", Helpers.GetMachineCode(2), true));
    if (result == true) {
        System.out.println("Deactivation successful.");
    } else {
        System.out.println("Deactivation failed.");
    }
}
```

### Response
#### Success Response (boolean)
- **true** - Deactivation was successful.
- **false** - Deactivation failed.
```

--------------------------------

### Complex Feature Template Example

Source: https://help.cryptolens.io/feature/web-ui/feature-templates

An example of a complex feature template with multiple levels of nesting and sibling modules.

```json
["ModuleA", "ModuleC", ["ModuleD", [["ModuleD1", ["ModuleD1.1", "ModuleD1.2"]], ["ModuleD2", ["ModuleD2.1", "ModuleD2.2"] ], "ModuleD3", "ModuleD4" ]], "ModuleE"]
```

--------------------------------

### Create and Activate Trial License in Python

Source: https://help.cryptolens.io/libraries/python

Demonstrates creating a trial key and then activating it using the Cryptolens Python SDK. Ensure you have the necessary imports and machine code.

```python
from licensing.models import *
from licensing.methods import Key, Helpers

trial_key = Key.create_trial_key("WyIzODQ0IiwiempTRWs4SnBKTTArYUh3WkwyZ0VwQkVyeTlUVkRWK2ZTOS8wcTBmaCJd", 3941, Helpers.GetMachineCode(v=2))

if trial_key[0] == None:
    print("An error occurred: {0}".format(trial_key[1]))


RSAPubKey = "<RSAKeyValue><Modulus>sGbvxwdlDbqFXOMlVUnAF5ew0t0WpPW7rFpI5jHQOFkht/326dvh7t74RYeMpjy357NljouhpTLA3a6idnn4j6c3jmPWBkjZndGsPL4Bqm+fwE48nKpGPjkj4q/yzT4tHXBTyvaBjA8bVoCTnu+LiC4XEaLZRThGzIn5KQXKCigg6tQRy0GXE13XYFVz/x1mjFbT9/7dS8p85n8BuwlY5JvuBIQkKhuCNFfrUxBWyu87CFnXWjIupCD2VO/GbxaCvzrRjLZjAngLCMtZbYBALksqGPgTUN7ZM24XbPWyLtKPaXF2i4XRR9u6eTj5BfnLbKAU5PIVfjIS+vNYYogteQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>"
auth = "WyIyNTU1IiwiRjdZZTB4RmtuTVcrQlNqcSszbmFMMHB3aWFJTlBsWW1Mbm9raVFyRyJd=="

result = Key.activate(token=auth,\n                   rsa_pub_key=RSAPubKey,\n                   product_id=3349, \n                   key=trial_key[0],\n                   machine_code=Helpers.GetMachineCode(v=2))


if result[0] == None or not Helpers.IsOnRightMachine(result[0], v=2):
    print("An error occurred: {0}".format(result[1]))
else:
    print("Success")
    
    license_key = result[0]
    print("Feature 1: " + str(license_key.f1))
    print("License expires: " + str(license_key.expires))
```

--------------------------------

### Create and Verify Trial Key

Source: https://help.cryptolens.io/examples/verified-trials

Use `Key.CreateTrialKey` to generate a trial key and `Key.Activate` to verify it. Ensure `Helpers.IsOnRightMachine` returns true to confirm the trial belongs to the correct device.

```csharp
var newTrialKey = Key.CreateTrialKey("access token", new CreateTrialKeyModel { ProductId= 3941, MachineCode =Helpers.GetMachineCode() });

if(newTrialKey == null || newTrialKey.Result == ResultType.Error)
{
    Assert.Fail("Something went wrong when creating the trial key");
}

var activate = Key.Activate("access token", 
    new ActivateModel {
        ProductId = 3941,
        Sign = true,
        MachineCode = Helpers.GetMachineCode(),
        Key = newTrialKey.Key, Metadata = true
    });

if(activate == null || activate.Result == ResultType.Error)
{
    Assert.Fail("Something went wrong when verifying the trial key");
}

// now we can verify some basic properties
if (Helpers.IsOnRightMachine(activate.LicenseKey) && activate.Metadata.LicenseStatus.IsValid)
{
    // license verification successful.
    return;
}
```

```python
from licensing.models import *
from licensing.methods import Key, Helpers

trial_key = Key.create_trial_key("WyIzODQ0IiwiempTRWs4SnBKTTArYUh3WkwyZ0VwQkVyeTlUVkRWK2ZTOS8wcTBmaCJd", 3941, Helpers.GetMachineCode(v=2))

if trial_key[0] == None:
    print("An error occurred: {0}".format(trial_key[1]))

RSAPubKey = "<RSAKeyValue><Modulus>sGbvxwdlDbqFXOMlVUnAF5ew0t0WpPW7rFpI5jHQOFkht/326dvh7t74RYeMpjy357NljouhpTLA3a6idnn4j6c3jmPWBkjZndGsPL4Bqm+fwE48nKpGPjkj4q/yzT4tHXBTyvaBjA8bVoCTnu+LiC4XEaLZRThGzIn5KQXKCigg6tQRy0GXE13XYFVz/x1mjFbT9/7dS8p85n8BuwlY5JvuBIQkKhuCNFfrUxBWyu87CFnXWjIupCD2VO/GbxaCvzrRjLZjAngLCMtZbYBALksqGPgTUN7ZM24XbPWyLtKPaXF2i4XRR9u6eTj5BfnLbKAU5PIVfjIS+vNYYogteQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>"
auth = "WyIyNTU1IiwiRjdZZTB4RmtuTVcrQlNqcSszbmFMMHB3aWFJTlBsWW1Mbm9raVFyRyJd=="

result = Key.activate(token=auth,\n                   rsa_pub_key=RSAPubKey,\n                   product_id=3349, \n                   key=trial_key[0],\n                   machine_code=Helpers.GetMachineCode(v=2))


if result[0] == None or not Helpers.IsOnRightMachine(result[0], v=2):
    print("An error occurred: {0}".format(result[1]))
else:
    print("Success")
    
    license_key = result[0]
    print("Feature 1: " + str(license_key.f1))
    print("License expires: " + str(license_key.expires))
```

--------------------------------

### Install Licensing Package for Python 3

Source: https://help.cryptolens.io/examples/key-verification

Install the Cryptolens Python SDK using pip for Python 3 environments.

```bash
pip install licensing
```

--------------------------------

### Use New GetKey Method with License Server

Source: https://help.cryptolens.io/api/dotnet/articles/v4041.html

Demonstrates how to use the updated GetKey method to connect to a local floating license server. Ensure the license server URL is correctly specified.

```csharp
var result = Key.GetKey(token: "", productId: 3349, key: "", LicenseServerUrl: "http://192.168.0.2:8080");

// obtaining the license key (and verifying the signature automatically).
var license = LicenseKey.FromResponse("RSAPubKey", result);
```

--------------------------------

### Launch License Server with Multiple Offline Files/Folders

Source: https://help.cryptolens.io/feature/license-server/index

Provide a semicolon-separated list of files and folders to load into the license server's offline cache.

```bash
C:\> LicenseServer.exe 8080 10 work-offline "C:\Users\User Name\Downloads";"C:\temp\file.skm"

```

--------------------------------

### Start License Server with Custom Port

Source: https://help.cryptolens.io/feature/license-server/index

Launch the license server executable and specify a custom port (e.g., 5000). This command should be run from an administrator command prompt.

```bash
C:\> LicenseServer.exe 5000
```

--------------------------------

### Enable License Caching on Windows

Source: https://help.cryptolens.io/feature/license-server/index

Launch the license server with caching enabled by specifying the port and the cache duration in days. Ensure the cache lifetime is compatible with `signatureExpirationInterval` if used.

```cmd
C:\> LicenseServer.exe 8080 10

```

--------------------------------

### Install Dependencies for CMake (Debian/Ubuntu)

Source: https://help.cryptolens.io/api/cpp/index.html

Installs libcurl and OpenSSL development packages required for compiling the C++ client with CMake on Debian/Ubuntu systems.

```bash
apt-get install libcurl4-openssl-dev libssl-dev
```

--------------------------------

### Get Messages from Stable Channel (C#)

Source: https://help.cryptolens.io/llms-full.txt

Retrieves messages from the 'stable' channel if any new messages exist. Requires an access token with 'GetMessages' permission. Handles cases where updates are not found, new messages are available, or no messages exist.

```csharp
var currentVersion = 1538610060;
var result = Message.GetMessages("access token with GetMessages permission", new GetMessagesModel { Channel = "stable", Time = currentVersion } );

if (!Helpers.IsSuccessful(messages))
{
    // we could not check for updates
    Console.WriteLine("Sorry, we could not check for updates.");
}
else if (result.Messages.Count > 0)
{
    // there are some new messages, we pick the newest one 
    // (they are sorted in descending order)
    Console.WriteLine(result.Messages[0].Content);
}
else
{
    // No messages, so they have the latest version.
    Console.WriteLine("You have the latest version.");
}

Console.Read();
```

--------------------------------

### Get Messages from Stable Channel (Java)

Source: https://help.cryptolens.io/llms-full.txt

Retrieves messages from the 'stable' channel if any new messages exist. Requires an access token with 'GetMessages' permission. Handles cases where updates are not found, new messages are available, or no messages exist.

```java
long currentVersion = 1538610060;
GetMessagesResult result = Message.GetMessages("access token with GetMessages permission", new GetMessagesModel("stable", currentVersion));

if(!Helpers.IsSuccessful(result)) {
    // we could not check for updates
    System.out.println("Sorry, we could not check for updates.");
} else if(result.Messages.size() > 0) {
    // there are some new messages, we pick the newest one
    System.out.println(result.Messages.get(0).Content);
} else{
    // No messages, so they have the latest version.
    System.out.println("You have the latest version.");
}
```

--------------------------------

### Activate License with Floating Options

Source: https://help.cryptolens.io/getting-started/java

This example demonstrates how to activate a license with floating license capabilities, including setting a floating time interval and maximum overdraft. It also shows how to correctly configure the `IsOnRightMachine` check for floating licenses.

```APIDOC
## Activate License with Floating Options

### Description
Enables floating licenses by passing `floatingTimeInterval` to `ActivateModel`. Optionally allows exceeding the bound with `maxOverdraft`. For floating licenses with overdraft, `Helpers.IsOnRightMachine` requires two boolean flags set to true.

### Method
`Key.Activate`

### Parameters
#### Request Body
- **auth** (string) - Required - Authentication token.
- **RSAPubKey** (string) - Required - RSA public key for license verification.
- **activateModel** (ActivateModel) - Required - Model containing activation details:
  - **productId** (int) - Required - The product ID.
  - **licenseKey** (string) - Required - The license key.
  - **machineCode** (string) - Required - The machine code.
  - **floatingTimeInterval** (int) - Optional - Time interval in seconds for floating licenses.
  - **maxOverdraft** (int) - Optional - Maximum number of licenses that can exceed the bound.

### Request Example
```java
import io.cryptolens.methods.*;
import io.cryptolens.models.*;

public static void main(String args[]) {
    String RSAPubKey = "<RSAKeyValue><Modulus>sGbvxwdlDbqFXOMlVUnAF5ew0t0WpPW7rFpI5jHQOFkht/326dvh7t74RYeMpjy357NljouhpTLA3a6idnn4j6c3jmPWBkjZndGsPL4Bqm+fwE48nKpGPjkj4q/yzT4tHXBTyvaBjA8bVoCTnu+LiC4XEaLZRThGzIn5KQXKCigg6tQRy0GXE13XYFVz/x1mjFbT9/7dS8p85n8BuwlY5JvuBIQkKhuCNFfrUxBWyu87CFnXWjIupCD2VO/GbxaCvzrRjLZjAngLCMtZbYBALksqGPgTUN7ZM24XbPWyLtKPaXF2i4XRR9u6eTj5BfnLbKAU5PIVfjIS+vNYYogteQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
    String auth = "WyIyNjA5IiwiaWE5b0VFT3Q2eDlNR2FvbHBHK2VOYUZ4bzNjT3h5UkNrMCtiYnhPRSJd";

    LicenseKey license = Key.Activate(auth, RSAPubKey, new ActivateModel(3349, "MTMPW-VZERP-JZVNZ-SCPZM", Helpers.GetMachineCode(2), 300, 1));
    if (license == null || !Helpers.IsOnRightMachine(license, 2, true, true)) {
        System.out.println("The license does not work.");
    } else {
        System.out.println("The license is valid!");
        System.out.println("It will expire: " + license.Expires);
    }
}
```

### Response
#### Success Response (LicenseKey)
- **Expires** (string) - The expiration date of the license.
```

--------------------------------

### Get Messages from Stable Channel (VB.NET)

Source: https://help.cryptolens.io/llms-full.txt

Retrieves messages from the 'stable' channel if any new messages exist. Requires an access token with 'GetMessages' permission. Handles cases where updates are not found, new messages are available, or no messages exist.

```vbnet
Dim currentVersion = 1538610060
Dim result = Message.GetMessages("access token with GetMessages permission", New GetMessagesModel() With {
                                     .Channel = "stable",
                                     .Time = currentVersion
                                   })

If Not Helpers.IsSuccessful(result) Then
    ' we could not check for updates
    Console.WriteLine("Sorry, we could not check for updates.")
ElseIf result.Messages.Count > 0 Then
    ' there are some new messages, we pick the newest one
    ' (they are sorted in descending order)
    Console.WriteLine(result.Messages(0).Content)
Else
    ' No messages, so they have the latest version.
    Console.WriteLine("You have the latest version.")
End If
```

--------------------------------

### Get Messages from Stable Channel (Python)

Source: https://help.cryptolens.io/llms-full.txt

Retrieves messages from the 'stable' channel if any new messages exist. Requires an access token with 'GetMessages' permission. Handles cases where updates are not found, new messages are available, or no messages exist.

```python
currentVersion = 1538610060
res = Message.get_messages("access token with GetMessages permission","stable", currentVersion)

if res[0] == None:
    # we could not check for updates
    print("Sorry, we could not check for updates.")
elif len(res[0]) > 0:
    # there are some new messages, we pick the newest one 
    # (they are sorted in descending order)
    print(res[0][0]["content"])
else:
    #No messages, so they have the latest version.
    print("You have the latest version.")
```

--------------------------------

### Install Dependencies for CMake (Fedora/Red Hat)

Source: https://help.cryptolens.io/api/cpp/index.html

Installs libcurl and OpenSSL development packages required for compiling the C++ client with CMake on Fedora/Red Hat systems.

```bash
yum install libcurl-devel openssl-devel
```

--------------------------------

### Build License Server from Source

Source: https://help.cryptolens.io/feature/license-server/index

Compile the license server from source code using the dotnet CLI. Ensure you are in the directory containing the LicenseServerCore.sln file.

```bash
dotnet build LicenseServerCore.sln --configuration Release
```
Tokens:
Raw