The final security scheme for an application depends on the specific task. However, the basic principle can be outlined as follows:

• The application is "bound" to the license using automated protection tools, loadable code, and a special API.
• The license is stored in the memory of Guardant Sign/Code Chip.
• During operation, the secure application continuously exchanges information with the key. If the key contains an invalid or expired license, the software will not function.

The approach to securing and licensing applications over a network is as follows:

• A dedicated server or workstation is equipped with an intermediary program — Guardant network license manager.
• A network electronic Guardant Sign/Code Chip is also installed on this device, server or workstation.
• The application is secured either through automated protection tools or via a special API.
• The License Manager and the key will strictly monitor the number of connections based on the licenses programmed by the developer.

Data transmitted over the network protocol is protected at the hardware level. This means that it is encrypted using session keys generated between the secure application and the electronic key, with no intermediaries involved.

To prepare and import the code, developers have to follow these steps:

• The developer selects functional blocks of their application that will be loaded into the secure memory of the key and executed directly within the security key. This technology is called "Loadable Code".
• To convert the application code into a loadable format, it must either be ported or initially written as a separate module in C. At this stage, developers can also integrate API calls to utilize the key's built-in functions: invoking cryptographic algorithms, reading/writing data from the Code Chip’s memory cells, and more.
• Using the GCC compiler and Guardant SDK utilities, the loadable code is then built and written into the key's memory.
• Once this is done, the secure application simply needs to execute the code stored in the key at the required time and await the execution result to be returned from the key. This means that the functional blocks transferred into the loadable code are fully executed within the key, elevating protection against hacking and analysis to a fundamentally new level.