Add new API version v20190401

Author: svedi

CMakeLists.txt

@@ -4,7 +4,7 @@ project (cryptolens)
 set (CRYPTOLENS_BUILD_TESTS OFF CACHE BOOL "build tests?")
 set (CRYPTOLENS_CURL_EMBED_CACERTS OFF CACHE BOOL "embed the ca certs in the library instead of using system default files?")
 
-set (SRC  "src/ActivateError.cpp" "src/DataObject.cpp" "src/LicenseKey.cpp" "src/LicenseKeyChecker.cpp" "src/LicenseKeyInformation.cpp" "src/base64.cpp" "src/basic_SKM.cpp")
+set (SRC "src/ActivateError.cpp" "src/DataObject.cpp" "src/LicenseKey.cpp" "src/LicenseKeyChecker.cpp" "src/LicenseKeyInformation.cpp" "src/MachineCodeComputer_static.cpp" "src/basic_Cryptolens.cpp" "src/basic_SKM.cpp" "third_party/base64_OpenBSD/base64.cpp")
 set (LIBS "")
 
 find_package(OpenSSL)

README.md

@@ -2,7 +2,7 @@
 
 On this page, we have outlined several examples of how to get started with the Cryptolens Client API for C++.
 
-> **Note**, Cryptolens Client API for C++ currently supports **activation** and **deactivation** methods. Support for more methods is coming soon.
+> **Note**, Cryptolens Client API for C++ currently supports a subset of the full Cryptolens Web API. Please contact us (XXX: Add link) if you need something in particular.
 
 You can find the API documentation here: [https://help.cryptolens.io/api/cpp/](https://help.cryptolens.io/api/cpp/).
 
@@ -70,6 +70,8 @@ Now we can build the example project:
  * Set configuration and platform in the same way as when building the library
  * Build and run the project.
 
+Instructions for how to add the library to your own project can be found [here](https://help.cryptolens.io/cpp/). XXX: Fix link
+
 ## Library overview
 
 This section contains an overview of the standard way to implement the library in an
@@ -78,33 +80,44 @@ application. The first step is to include the appropriate headers:
 ```cpp
 #include <cryptolens/core.hpp>
 #include <cryptolens/Error.hpp>
-#include <cryptolens/RequestHandler_XXX.hpp>
-#include <cryptolens/SignatureVerifier_YYY.hpp>
+#include <cryptolens/Configuration_XXX.hpp>
+#include <cryptolens/MachineCodeComputer_YYY.hpp>
+
+namespace cryptolens = ::cryptolens_io::v20190401;
 ```
 
-We currently support the following RequestHandlers and SignatureVerifiers
+Besides including headers the above code sets up a namespace alias for the api version of the C++
+library we are using.
+
+The `Configuration` class allows for using different libraries for parsing JSON, making HTTPS
+requests, performing cryptographic operations as well as minor changes in the behaviour of the
+library. We currently support the following `Configurations` and `MachineCodeComputers`:
 
-| RequestHandler                | Description                                           |
-| ----------------------------- | ----------------------------------------------------- |
-| `RequestHandler_curl`         | Uses libcurl                                          |
-| `RequestHandler_WinHTTP`      | Uses the WinHTTP library available as part of Windows |
+| Configuration                         | Description                                           |
+| -----------------------------------   | ----------------------------------------------------- |
+| `Configuration_Unix`                 | Good default configuration for Unix-like based systems. Uses ArduinoJson 5, libcurl and OpenSSL. Checks if the license key has expired against the users system time. |
+| `Configuration_Unix_IgnoreExpires`   | Same as `Configuration_Unix`, but does not check if the license key has expired against the users system time. |
+| `Configuration_Windows`               | Good default configuration for Windows based systems. Uses ArduinoJson 5, WinHTTP and CryptoAPI. Checks if the license key has expired against the users system time. |
+| `Configuration_Windows_IgnoreExpires` | Same as `Configuration_Windows`, but does not check if the license key has expired against the users system time. |
 
-| SignatureVerifier             | Description                                     |
-| ----------------------------- | ----------------------------------------------- |
-| `SignatureVerifier_OpenSSL`   | Uses OpenSSL or LibreSSL                        |
-| `SignatureVerifier_CryptoAPI` | Uses the CryptoAPI available as part of Windows |
+| MachineCodeComputer             | Description                                     |
+| ------------------------------- | ----------------------------------------------- |
+| `MachineCodeComputer_static`    | Does not automatically compute a machine code, instead the machine code is set by calling a function |
 
 The next step is to create and set up a handle class responsible for making requests
 to the Cryptolens Web API.
 
 ```cpp
 using Cryptolens = cryptolens::basic_Cryptolens
-                     <cryptolens::RequestHandler_curl, cryptolens::SignatureVerifier_OpenSSL>;
+                     <cryptolens::Configuration_XXX<cryptolens::MachineCodeComputer_static>>;
 
-Cryptolens cryptolens_handle;
 cryptolens::Error e;
+Cryptolens cryptolens_handle(e);
+
 cryptolens_handle.signature_verifier.set_modulus_base64(e, "ABCDEFGHI1234");
 cryptolens_handle.signature_verifier.set_exponent_base64(e, "ABCD");
+
+cryptolens_handle.machine_code_computer.set_machine_code(e, "289jf2afs3");
 ```
 
 Here the strings `"ABCDEFGHI1234"` and `"ABCD"` needs to be replaced by your public keys. These
@@ -116,6 +129,8 @@ the following value on the website
 <RSAKeyValue><Modulus>ABCDEFGHI1234</Modulus><Exponent>ABCD</Exponent></RSAKeyValue>
 ```
 
+In this example we set the machine code used to `"289jf2afs3"`.
+
 Now that the handle class has been set up, we can attempt to activate a license key
 
 ```cpp
@@ -126,11 +141,9 @@ cryptolens::optional<cryptolens::LicenseKey> license_key =
     , // Cryptolens Access Token
       "WyI0NjUiLCJBWTBGTlQwZm9WV0FyVnZzMEV1Mm9LOHJmRDZ1SjF0Vk52WTU0VzB2Il0="
     , // Product id
-      "3646"
+      3646
     , // License Key
       "MPDWY-PQAOW-FKSCH-SGAAU"
-    , // Machine Code
-      "289jf2afs3"
     );
 
 if (e) {
@@ -150,8 +163,6 @@ The `activate` method takes several arguments:
     https://app.cryptolens.io/Product.
  1. The fourth argument is a string containing the license key string, in most cases this will be
     input by the user of the application in some application dependent fashion.
- 1. The last argument is an optional identifier for the device the application is running on, or
-    something similar.
 
 After the `activate` call we check if an error occurred by converting `e` to bool. If an error
 occured this returns true. If an error occurs, the optional containing the `LicenseKey` object
@@ -167,8 +178,8 @@ if (license_key->check()->has_expired(1234567)) {
   return 1;
 }
 
-if (license_key->check()-has_feature(1)) { std::cout << "Welcome! Pro version enabled!" << std::endl; }
-else                                     { std::cout << "Welcome!" << std::endl; }
+if (license_key->check()->has_feature(1)) { std::cout << "Welcome! Pro version enabled!" << std::endl; }
+else                                      { std::cout << "Welcome!" << std::endl; }
 ```
 
 
@@ -202,22 +213,24 @@ request to the Web API in the future. Thus we can proceed as during online activ
 but save the response as a string:
 
 ```cpp
-Cryptolens cryptolens_handle;
+cryptolens::Error e;
+Cryptolens cryptolens_handle(e);
+
 cryptolens_handle.signature_verifier.set_modulus_base64(e, "ABCDEFGHI1234");
 cryptolens_handle.signature_verifier.set_exponent_base64(e, "ABCD");
-...
+
+cryptolens_handle.machine_code_computer.set_machine_code(e, "289jf2afs3");
+
 cryptolens::optional<cryptolens::LicenseKey> license_key =
-  cryptolens_handle.activate(
+  cryptolens_handle.activate
     ( // Object used for reporting if an error occured
       e
     , // Cryptolens Access Token
       "WyI0NjUiLCJBWTBGTlQwZm9WV0FyVnZzMEV1Mm9LOHJmRDZ1SjF0Vk52WTU0VzB2Il0="
     , // Product id
-      "3646"
+      3646
     , // License Key
       "MPDWY-PQAOW-FKSCH-SGAAU"
-    , // Machine Code
-      "289jf2afs3"
     );
 if (e) { handle_error(e); return 1; }
 
@@ -229,10 +242,13 @@ to check the license later when offline, load the string *s* and recover the lic
 
 ```cpp
 cryptolens::Error e;
-Cryptolens cryptolens_handle;
+Cryptolens cryptolens_handle(e);
+
 cryptolens_handle.signature_verifier.set_modulus_base64(e, "ABCDEFGHI1234");
 cryptolens_handle.signature_verifier.set_exponent_base64(e, "ABCD");
 
+cryptolens_handle.machine_code_computer.set_machine_code(e, "289jf2afs3");
+
 cryptolens::optional<cryptolens::LicenseKey> license_key =
   cryptolens_handle.make_license_key(e, s);
 if (e) { handle_error(e); return 1; }
@@ -251,13 +267,16 @@ by using the `handle_activate()` function as follows
 ```cpp
 std::string web_api_response; // Some other part of the code creates and populates this object
 
-SignatureVerifier_XXX signature_verifier;
 cryptolens::Error e;
-signature_verifier.set_modulus_base64(e, "ABCDEFGHI1234");
-signature_verifier.set_exponent_base64(e, "ABCD");
+Cryptolens cryptolens_handle(e);
 
-cryptolens::optional<cryptolens::LicenseKey> key =
-  cryptolens::handle_activate(e, signature_verifier, web_api_resonse);
+cryptolens_handle.signature_verifier.set_modulus_base64(e, "ABCDEFGHI1234");
+cryptolens_handle.signature_verifier.set_exponent_base64(e, "ABCD");
+
+cryptolens_handle.machine_code_computer.set_machine_code(e, "289jf2afs3");
+
+cryptolens::optional<cryptolens::LicenseKey> license_key =
+  cryptolens_handle.make_license_key(e, web_api_response);
 if (e) { handle_error(e); return 1; }
 ```
 

examples/VisualStudio/Example_Activate/Example_Activate.cpp

@@ -1,38 +1,38 @@
 #include <iostream>
 
-#include "cryptolens\core.hpp"
-#include "cryptolens\Error.hpp"
-#include "cryptolens\RequestHandler_WinHTTP.hpp"
-#include "cryptolens\SignatureVerifier_CryptoAPI.hpp"
+#include <cryptolens/core.hpp>
+#include <cryptolens/Error.hpp>
+#include <cryptolens/Configuration_Windows.hpp>
+#include <cryptolens/MachineCodeComputer_static.hpp>
 
-namespace cryptolens = ::cryptolens_io::v20180502;
-using Cryptolens = cryptolens::basic_SKM<cryptolens::RequestHandler_WinHTTP, cryptolens::SignatureVerifier_CryptoAPI>;
+namespace cryptolens = ::cryptolens_io::v20190401;
+using Cryptolens = cryptolens::basic_Cryptolens<cryptolens::Configuration_Windows<cryptolens::MachineCodeComputer_static>>;
 
 /*
 * This example uses the basic_SKM class to make a request to the WebAPI
 * and then checks some properties of the license keys.
 */
-
 int main()
 {
-	Cryptolens cryptolens_handle;
 	cryptolens::Error e;
+	Cryptolens cryptolens_handle(e);
+
 	// Setting up the signature verifier with credentials from "Security Settings"
 	// on serialkeymanager.com
 	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");
 
+	cryptolens_handle.machine_code_computer.set_machine_code(e, "289jf2afs3");
+
 	cryptolens::optional<cryptolens::LicenseKey> license_key =
 		cryptolens_handle.activate(
 			e,
 			// SKM Access Token
 			"WyI0NjUiLCJBWTBGTlQwZm9WV0FyVnZzMEV1Mm9LOHJmRDZ1SjF0Vk52WTU0VzB2Il0=",
 			// Product id
-			"3646",
+			3646,
 			// License Key
-			"MPDWY-PQAOW-FKSCH-SGAAU",
-			// Machine Code
-			"289jf2afs3"
+			"MPDWY-PQAOW-FKSCH-SGAAU"
 		);
 
 	if (e) {

examples/VisualStudio/Example_External/Example_External.cpp

@@ -2,27 +2,29 @@
 
 #include <cryptolens/core.hpp>
 #include <cryptolens/Error.hpp>
-#include "cryptolens/RequestHandler_WinHTTP.hpp"
-#include <cryptolens/SignatureVerifier_CryptoAPI.hpp>
+#include <cryptolens/Configuration_Windows.hpp>
+#include <cryptolens/MachineCodeComputer_static.hpp>
+
+namespace cryptolens = ::cryptolens_io::v20190401;
+using Cryptolens = cryptolens::basic_Cryptolens<cryptolens::Configuration_Windows<cryptolens::MachineCodeComputer_static>>;
 
 /*
  * This example assumes the reply from the web server has fetched in some
  * other fasion, and then verifies the signature and finally checks
  * some properties on the license key.
  */
-
-namespace cryptolens = ::cryptolens_io::v20180502;
-using Cryptolens = cryptolens::basic_SKM<cryptolens::RequestHandler_WinHTTP, cryptolens::SignatureVerifier_CryptoAPI>;
-
 int main()
 {
-	Cryptolens cryptolens_handle;
 	cryptolens::Error e;
+	Cryptolens cryptolens_handle(e);
+
 	// Setting up the signature verifier with credentials from "Security Settings"
 	// on cryptolens.io
 	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");
 
+	cryptolens_handle.machine_code_computer.set_machine_code(e, "289jf2afs3");
+
 	// Reply from Cryptolens Web API
 	std::string cryptolens_reply("{\"licenseKey\":\"eyJQcm9kdWN0SWQiOjM2NDYsIklEIjo0LCJLZXkiOiJNUERXWS1QUUFPVy1GS1NDSC1TR0FBVSIsIkNyZWF0ZWQiOjE0OTAzMTM2MDAsIkV4cGlyZXMiOjE0OTI5MDU2MDAsIlBlcmlvZCI6MzAsIkYxIjpmYWxzZSwiRjIiOmZhbHNlLCJGMyI6ZmFsc2UsIkY0IjpmYWxzZSwiRjUiOmZhbHNlLCJGNiI6ZmFsc2UsIkY3IjpmYWxzZSwiRjgiOmZhbHNlLCJOb3RlcyI6bnVsbCwiQmxvY2siOmZhbHNlLCJHbG9iYWxJZCI6MzE4NzYsIkN1c3RvbWVyIjpudWxsLCJBY3RpdmF0ZWRNYWNoaW5lcyI6W3siTWlkIjoiIiwiSVAiOiIxNTUuNC4xMzQuMjciLCJUaW1lIjoxNDkxODk4OTE4fSx7Ik1pZCI6ImxvbCIsIklQIjoiMTU1LjQuMTM0LjI3IiwiVGltZSI6MTQ5MTg5ODk5NX0seyJNaWQiOiIyODlqZjJhZnNmIiwiSVAiOiIxNTUuNC4xMzQuMjciLCJUaW1lIjoxNDkxOTAwNTQ2fSx7Ik1pZCI6IjI4OWpmMmFmczMiLCJJUCI6IjE1NS40LjEzNC4yNyIsIlRpbWUiOjE0OTE5MDA2MzZ9XSwiVHJpYWxBY3RpdmF0aW9uIjpmYWxzZSwiTWF4Tm9PZk1hY2hpbmVzIjoxMCwiQWxsb3dlZE1hY2hpbmVzIjoiIiwiRGF0YU9iamVjdHMiOltdLCJTaWduRGF0ZSI6MTQ5NTAxOTc2Nn0=\",\"signature\":\"SqPm8dtTdVBrXrmJzXer7qq6dvdQfctJxP8mar+RO9p8QABsgWWaX+uH7aOGMBd42eg+2Omorv7Ks6V7itRhXPeeq5qWoKuefd+pTsFagvqiu2N/E2Np8fpt51aqmiygdHLECo42nJwVD8JzlN67hnvJTgY7iyDWhG7qFK9Slk+kEJjjK/0J1pJYI6nOi+7sgBV7ZRca+7DmiP6OmOjNfySps6PdiB7QbiSis5f24Xmc5OYyRe3fzZmAueqF3eymBK19XhYFroWXeT4tcNsBNJsv+YfItovGbJysLx+K4ppltd2GNwEFQgtE3ILGOUj7EVbeQmQXg9m2c5MTPyk8iA==\",\"result\":0,\"message\":\"\"}");
 

examples/VisualStudio/Example_Floating/Example_Floating.cpp

@@ -2,25 +2,27 @@
 
 #include <cryptolens/core.hpp>
 #include <cryptolens/Error.hpp>
-#include <cryptolens/RequestHandler_WinHTTP.hpp>
-#include <cryptolens/SignatureVerifier_CryptoAPI.hpp>
+#include <cryptolens/Configuration_Windows.hpp>
+#include <cryptolens/MachineCodeComputer_static.hpp>
 
-namespace cryptolens = ::cryptolens_io::v20180502;
-using Cryptolens = cryptolens::basic_SKM<cryptolens::RequestHandler_WinHTTP, cryptolens::SignatureVerifier_CryptoAPI>;
+namespace cryptolens = ::cryptolens_io::v20190401;
+using Cryptolens = cryptolens::basic_Cryptolens<cryptolens::Configuration_Windows<cryptolens::MachineCodeComputer_static>>;
 
 /*
  * This example uses the basic_SKM class to make a request to the WebAPI
  * and then checks some properties of the license keys.
  */
-
 void activate(char const* machine_code)
 {
-	Cryptolens cryptolens_handle;
 	cryptolens::Error e;
+	Cryptolens cryptolens_handle(e);
+
 	// Setting up the signature verifier with credentials from "Security Settings"
 	// on cryptolens.io
 	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");
+	cryptolens_handle.signature_verifier.set_exponent_base64(e, "AQAB");
+
+	cryptolens_handle.machine_code_computer.set_machine_code(e, machine_code);
 
 	cryptolens::optional<cryptolens::LicenseKey> license_key =
 		cryptolens_handle.activate_floating
@@ -29,11 +31,9 @@ void activate(char const* machine_code)
 			, // Cryptolens Access Token
 			"WyIxNDQzIiwiZXBCVGc1S2tOVmRielVibXAxaWdtdVNtOXlGTnR0ekhkN2lwRnVKQiJd"
 			, // Product id
-			"3934"
+			3934
 			, // License Key
 			"KRQNS-CSPNV-XRQBT-MTSBI"
-			, // Machine Code
-			machine_code
 			, // Floating interval
 			10
 		);

examples/VisualStudio/Example_Offline/Example_Offline.cpp

@@ -5,11 +5,11 @@
 
 #include <cryptolens/core.hpp>
 #include <cryptolens/Error.hpp>
-#include <cryptolens/RequestHandler_WinHTTP.hpp>
-#include <cryptolens/SignatureVerifier_CryptoAPI.hpp>
+#include <cryptolens/Configuration_Windows.hpp>
+#include <cryptolens/MachineCodeComputer_static.hpp>
 
-namespace cryptolens = ::cryptolens_io::v20180502;
-using Cryptolens = cryptolens::basic_SKM<cryptolens::RequestHandler_WinHTTP, cryptolens::SignatureVerifier_CryptoAPI>;
+namespace cryptolens = ::cryptolens_io::v20190401;
+using Cryptolens = cryptolens::basic_Cryptolens<cryptolens::Configuration_Windows<cryptolens::MachineCodeComputer_static>>;
 
 /*
  * This is an example of doing offline activation.
@@ -50,25 +50,26 @@ int write_license_key_to_file(LPCWSTR file_name)
 	/*
 	 * Standard code for performing online activation
 	 */
-	Cryptolens cryptolens_handle;
 	cryptolens::Error e;
+	Cryptolens cryptolens_handle(e);
+
 	// Setting up the signature verifier with credentials from "Security Settings"
 	// on cryptolens.io
 	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");
 
+	cryptolens_handle.machine_code_computer.set_machine_code(e, "289jf2afs3");
+
 	cryptolens::optional<cryptolens::LicenseKey> license_key =
 		cryptolens_handle.activate
 		( // Object used for reporting if an error occured
 			e
 			, // Cryptolens Access Token
 			"WyI0NjUiLCJBWTBGTlQwZm9WV0FyVnZzMEV1Mm9LOHJmRDZ1SjF0Vk52WTU0VzB2Il0="
 			, // Product id
-			"3646"
+			3646
 			, // License Key
 			"MPDWY-PQAOW-FKSCH-SGAAU"
-			, // Machine Code
-			"289jf2afs3"
 		);
 
 	if (e) {
@@ -104,8 +105,9 @@ int read_license_key_from_file(LPCWSTR file_name) {
 	/*
 	 * We need to set up the cryptolens_handle with the public keys as usual.
 	 */
-	Cryptolens cryptolens_handle;
 	cryptolens::Error e;
+	Cryptolens cryptolens_handle(e);
+
 	// Setting up the signature verifier with credentials from "Security Settings"
 	// on cryptolens.io
 	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==");