Key verification

using SKM.V3;
using SKM.V3.Methods;
using SKM.V3.Models;

Imports SKM.V3
Imports SKM.V3.Methods
Imports SKM.V3.Models

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

# Python 2 library is currently contained in a single file,
# cryptolens_python2.py. You need to download it and place in the
# same folder where you have the rest of your code. It can then
# be imported as follows:
from cryptolens_python2 import *

import io.cryptolens.methods.*;
import io.cryptolens.models.*;

const key = require('cryptolens').Key;
const Helpers = require('cryptolens').Helpers;

import "github.com/Cryptolens/cryptolens-golang/cryptolens"

#include <cryptolens/core.hpp>
#include <cryptolens/Error.hpp>

// The library uses a configuration class to select which dependencies
// are used for various functions, such as making http requests and
// cryptographic functions. The configuration classes provided by the
// library are also parameterized by a machine code computer class
// which is responsible for computing the machine code for a device.
//
// The library provides includes pre-defined configuration classes:
//   For Unix based systems:
//     Configuration_Unix_IgnoreExpires
//     Configuration_Unix_CheckExpires
//   For Windows systems:
//     Configuration_Windows_IgnoreExpires
//     Configuration_Windows_CheckExpires
//
// In this example we will use the MachineCodeComputer_static where the
// machine code can be set by a call to the set_machine_code() method.
//
// For more details on configurations and machine code computer classes
// see the README.md for the library.
//
// The following lines should be updated to reflect the chosen
// configuration and machine code computer classes.
#include <cryptolens/Configuration_Class.hpp>
#include <cryptolens/MachineCodeComputer_static.hpp>

namespace cryptolens = ::cryptolens_io::v20190401;

// The following line sets up a type alias for the handle class
// which will be used to interact with the library.
//
// This line should be updated to reflect the chosen configuration and
// machine code computer classes.
using Cryptolens =
    cryptolens::basic_Cryptolens<
        cryptolens::Configuration_Class<cryptolens::MachineCodeComputer_static>
    >;

var licenseKey = "GEBNC-WZZJD-VJIHG-GCMVD"; // <--  remember to change this to your license key
var RSAPubKey = "enter the RSA Public key here";

var auth = "access token with permission to access the activate method";
var result = Key.Activate(token: auth, parameters: new ActivateModel()
{
    Key = licenseKey,
    ProductId = 3349,  // <--  remember to change this to your Product Id
    Sign = true,
    MachineCode = Helpers.GetMachineCodePI(v: 2)
});

if (result == null || result.Result == ResultType.Error || result.LicenseKey == null ||
    !result.LicenseKey.HasValidSignature(RSAPubKey).IsValid())
{
    // an error occurred or the key is invalid or it cannot be activated
    // (eg. the limit of activated devices was achieved)
    Console.WriteLine("The license does not work.");
}
else
{
    // Activation succeeded; add the license checks described below.
    Console.WriteLine("Activation successful.");
}

Console.ReadLine();

Dim licenseKey = "GEBNC-WZZJD-VJIHG-GCMVD" ' <--  remember to change this to your license key
Dim RSAPubKey = "enter the RSA Public key here"

Dim auth = "access token with permission to access the activate method"

Dim result = Key.Activate(token:=auth, parameters:=New ActivateModel() With {
                          .Key = licenseKey,
                          .ProductId = 3349, ' <--  remember to change this to your Product Id
                          .Sign = True,
                          .MachineCode = Helpers.GetMachineCodePI(v:=2)
                          })

If result Is Nothing OrElse result.Result = ResultType.[Error] OrElse result.LicenseKey Is Nothing OrElse
    Not result.LicenseKey.HasValidSignature(RSAPubKey).IsValid Then
    ' an error occurred or the key is invalid or it cannot be activated
    ' (eg. the limit of activated devices was achieved)
    Console.WriteLine("The license does not work.")

Else
    ' Activation succeeded; add the license checks described below.
    Console.WriteLine("Activation successful.")
End If

RSAPubKey = "enter the RSA Public key here"
auth = "access token with permission to access the activate method"

result = Key.activate(token=auth,\
                   rsa_pub_key=RSAPubKey,\
                   product_id=3349, \
                   key="ICVLD-VVSZR-ZTICT-YKGXL",\
                   machine_code=Helpers.GetMachineCode(v=2))

if result[0] == None:
    # an error occurred or the key is invalid or it cannot be activated
    # (eg. the limit of activated devices was achieved)
    print("The license does not work: {0}".format(result[1]))
else:
    # The SDK verified the signature; apply the remaining license checks below.
    print("Activation successful.")

String RSAPubKey = "enter the RSA Public key here";
String auth = "access token with permission to access the activate method";

LicenseKey license = Key.Activate(auth, RSAPubKey, 
                      new ActivateModel(3349,  // <--  remember to change this to your Product Id
                      "ICVLD-VVSZR-ZTICT-YKGXL", // <--  remember to change this to your license key
                      Helpers.GetMachineCode(2)));

if (license == null) {
    System.out.println("The license does not work.");
} else {

    // The SDK verified the signature; apply the remaining license checks below.
    System.out.println("Activation successful.");
    System.out.println("It will expire: " + license.Expires);
}

var RSAPubKey = "YOUR_RSA_PUBLIC_KEY";
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) {

    // Apply the full validation checklist before enabling functionality.
    
    // 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);
});

token := "WyI0NjUiLCJBWTBGTlQwZm9WV0FyVnZzMEV1Mm9LOHJmRDZ1SjF0Vk52WTU0VzB2Il0="
publicKey := "<RSAKeyValue><Modulus>khbyu3/vAEBHi339fTuo2nUaQgSTBj0jvpt5xnLTTF35FLkGI+5Z3wiKfnvQiCLf+5s4r8JB/Uic/i6/iNjPMILlFeE0N6XZ+2pkgwRkfMOcx6eoewypTPUoPpzuAINJxJRpHym3V6ZJZ1UfYvzRcQBD/lBeAYrvhpCwukQMkGushKsOS6U+d+2C9ZNeP+U+uwuv/xu8YBCBAgGb8YdNojcGzM4SbCtwvJ0fuOfmCWZvUoiumfE4x7rAhp1pa9OEbUe0a5HL+1v7+JLBgkNZ7Z2biiHaM6za7GjHCXU8rojatEQER+MpgDuQV3ZPx8RKRdiJgPnz9ApBHFYDHLDzDw==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>"

licenseKey, err := cryptolens.KeyActivate(token, cryptolens.KeyActivateArguments{
	ProductId:   3646,
	Key:         "MPDWY-PQAOW-FKSCH-SGAAU",
	MachineCode: "289jf2afs3",
})
if err != nil || !licenseKey.HasValidSignature(publicKey) {
	fmt.Println("License key activation failed!")
	return
}

// Some dependencies like curl may require additional setup code, see the examples

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

// Set up signature verification with your RSA public key from QuickStart Credentials.
cryptolens_handle.signature_verifier.set_modulus_base64(e, "khbyu3/vAEBHi339fTuo2nUaQgSTBj0jvpt5xnLTTF35FLkGI+5Z3wiKfnvQiCLf+5s4r8JB/Uic/i6/iNjPMILlFeE0N6XZ+2pkgwRkfMOcx6eoewypTPUoPpzuAINJxJRpHym3V6ZJZ1UfYvzRcQBD/lBeAYrvhpCwukQMkGushKsOS6U+d+2C9ZNeP+U+uwuv/xu8YBCBAgGb8YdNojcGzM4SbCtwvJ0fuOfmCWZvUoiumfE4x7rAhp1pa9OEbUe0a5HL+1v7+JLBgkNZ7Z2biiHaM6za7GjHCXU8rojatEQER+MpgDuQV3ZPx8RKRdiJgPnz9ApBHFYDHLDzDw==");
cryptolens_handle.signature_verifier.set_exponent_base64(e, "AQAB");

// This line is only for MachineCodeComputer_static and sets the machine code used
cryptolens_handle.machine_code_computer.set_machine_code(e, "5bccbfb6567abdcf998b7c74190183ac315720a4fd4da56bac4f31be571bbb30");

// Request activation; apply the full validation checklist before enabling functionality.
cryptolens::optional<cryptolens::LicenseKey> license_key =
  cryptolens_handle.activate
    ( e // Object used for reporting if an error occured
    , "WyI0NjUiLCJBWTBGTlQwZm9WV0FyVnZzMEV1Mm9LOHJmRDZ1SjF0Vk52WTU0VzB2Il0=" // Cryptolens Access Token
    , 3646 // Product id
    , "MPDWY-PQAOW-FKSCH-SGAAU" // License Key
    );

if (e) {
  // An error occured. For more details on how errors are reported see
  // the library documentation and examples.
}