EUTRONSEC S p A AAI USB SMART KEY User Manual SmartKeyUserManual
EUTRONSEC S.p.A. USB SMART KEY SmartKeyUserManual
UserManual.wiki
>
EUTRONSEC S p A
>
AAI User Manual
Users Manual
Navigation menu
Upload a User Manual
Namespaces
Wiki Guide
HTML
PDF
Info
Views
User Manual
Discussion / Help
Navigation
![26 In the case of Windows-based programs, cryptography makes it possible to avoid exporting and unlawful copying of one's resources. This is necessary, because there are many Windows-based programs that allow extraction of their resources (icons, cursors, dialogues, menus, bitmaps, toolbars, etc.) and also the copying and reuse of such resources. 8.3.4 Parameter-based protection SmartKey users can use a protection based on a multiplicity of parameters in addition to that offered by cryptography. This ensures that the protected program operates only when the dongle being used is the same as the one originally used for creating the file. This is because each dongle has a unique set of parameters including Id-Code, Label, Password and Memory. However, parameter-based protection is an option that can be easily disabled, except for the Label. Use of the Label is obligatory. When a protected program is operating and the dongle's optional parameters are disabled, only the Label is controlled, while the other parameters are overlooked. With a good combination of labels only, the program is successfully executed. 8.3.5 Message displayed in absence of the dongle (key) If the protected program is activated in the absence of the relevant SmartKey, it stops and the following default message is shown: No Key. This message is not fixed. In common with messages associated with other functions, the GSS.EXE utility makes it possible to also replace the standard message with a personalized one. 8.3.6 Limitation of number of executions and licenses Use of SmartKey is not limited just to programs protected against unauthorized accesses. SmartKey also enables you to set the number of executions and licenses permitted for the protected program. This function is particularly useful for issuing demo versions of a program. It provides users with the possibility of limited use of the program. When the set number of executions is reached, the program stops operating. Moreover, the possibility of limiting the number of licenses guarantees that the program is used inline with the licenses policy. This function is available with the SmartKey NET version. 8.3.7 Automatic cryptography of data files To make a program completely safe against unauthorized accesses, not only must one protect the executable program, but also all the relevant data/databases (.DBF, .DAT, etc.) associated with it. Thanks to GSS technology, SmartKey now lets you do all this. When a data string is sent to the dongle, the pre-programmed algorithm is used to encrypt it. The GSS utility is used mainly for this purpose. When it is being started, the encrypted program automatically decrypts the encrypted files. When not in use, these files are again encrypted. 8.3.8 Protection of programs on a network In addition to protecting programs operating in standalone mode, SmartKey also provides security for programs based on a Local Area Network. As a protected program is used in an absolutely transparent way for the end-user, both a local and a network dongle can be used. The GSS technology first searches for the device on the local ports. If it does not find a dongle, it begins to communicate with a Lan device. SmartKey NET was developed in particular with this in mind. The software supplied with the dongle enables networked computers to send the request to a single SmartKey NET. Consequently, there is no longer any need to use as many dongles as the number of stations connected to the network. 8.3.9 Protecting files executable in series It may sometimes be necessary to automatically protect several executable files, in a single operation. In this situation, GSSLINE.EXE, which is the DOS line command version of the GSS.EXE utility, is very useful. This is the syntax for executing GSSLINE: gssline CFG_FILE EXE_FILE [DATA_FILE...] DESTINATION_DIR CFG_FILE The configuration file. EXE_FILE or DATA_FILE The name of the .EXE or data file to be protected. DESTINATION_DIR The path where the final protected .EXE file is located. Table 6 When typing in the command line, the following must be considered:](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-26.png)
![28 9 Manual protection Manual protection is based on the use of the functions of the library of the development kit supplied by Eutronsec. The functions for SmartKey or API are implemented both as static libraries and as dynamic libraries (DLL, in the case of Windows). From a functional point of view, there is no difference between the two types of library. The dynamic libraries offer a lower degree of security because an expert hacker could understand when the protected program uses the dynamic library. This danger is cut down with static libraries because the link occurs when the executable file is generated. Use of the APIs and implementation of powerful protection techniques make it possible to protect your work also against the menace of expert IT pirates with refined analysis instruments. It is very important to know these techniques, because a hacker could overcome the security systems through a banal weak point of the code. For example, the possibility of obtaining the Label or Password by analyzing the executable file must be absolutely avoided. The chapter 10 illustrates and gives examples of some of these protection techniques and is an essential addition to the current chapter. The software drivers make it possible to activate a set of commands, each of which implements one of the following security operating modes: • Locating mode: detects if the dongle is present, and on which parallel or USB port. • Scrambling mode: algorithmically verifies if the Id-Code is correct. • Reading mode: reads the Secure Data. • Block Reading mode: reads the Secure Data in blocks. • Writing mode: writes the Secure Data. • Block Writing mode: writes the Secure Data in blocks. • Fixing mode: fixes the contents of the dongle so that they can no longer be modified. • Encryption mode: activates the coding algorithm programmed by the user. • Programming mode: reprograms the contents of the dongle. • AES mode: algorithmically authenticates the SmartKey. The Eutronsec development kit contains the smartdem program that uses some of the commands explained in the following paragraphs. The program is the console type, and was written in C. It can be compiled with any C compiler in the following environments: Linux, Mac OS X 10.x and Windows. The source code contained in smartdem.c is the same for all the operating systems, but the compiling mode is different. This is why smartdem.c is located in the following directory: • Sdk\Manual_Protection\Standalone_Windows_Libraries_And_Examples\GenericWin32Obj\, compilation with static linkage designed for the Windows environment. • Sdk\Manual_Protection\Others\, compilation designed for the Linux and Mac OS X 10.x environments. 9.1 Execution method of SmartKey commands The execution method for SmartKey commands occurs through the exchange of a data field between the program and the SmartKey driver. The data field has a fixed format and contains all information necessary for executing the command and any result. It is defined as a structure (or record) with the following fields: struct smartkey { word lpt; word command; byte label[16]; byte password[16]; byte data[64]; word fail_counter; word status; byte ext_data[352]; }](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-28.png)
![30 LABEL Label Output LPT Port STATUS Status ==0 SmartKey dongle found !=0 SmartKey dongle not found Table 7 Parameters for the LOCATING MODE command 9.2.1 Parameter transfer Parameters to be transferred to execute a LOCATING operation, including search on all parallel and USB ports, for a dongle with a Label named "SMARTKEY". COMMAND 4C 00 Locating ("L") LABEL 53 4D 41 52 54 4B 45 59 00 00 00 00 00 00 00 00 Label ("SMARTKEY") Table 8 Exchange of information for the LOCATING MODE command If a dongle containing the passed Label is present on a port, the LPT field will count its identifier. 9.3 Scrambling mode The SCRAMBLING mode supported by all SmartKey dongle models, is based on individual customization for every client of the Id-Code register. Its function is to algorithmically discover if the Id-Code is correct. The Identification Code contained in the Id-Code register is used as the fundamental parameter of a mathematical coding function (SCRAMBLING): a set of data are sent, processed and returned appropriately encrypted in a unique manner for every Id-Code. Dongle presence can therefore be verified by comparing the processed datum to the expected one. Dongles with different Id-Codes use different codes and, therefore, input data being equal, the returned data will be different. This means that a table comparing sent data (Original Data) and returned data (Scrambled Data) can be associated with every different Id-Code. The algorithm used is high security non-linear. The exchange of information is organized like this: Models ALL Input COMMAND ‘S’ LPT Port LABEL Label DATA[0..7] Original data (8 bytes) Output DATA[0..7] Scrambled data (8 bytes) STATUS Status ==0 Success !=0 Error Table 9 Parameters for the SCRAMBLING MODE command. If a LOCATING operation had been effected, the correct value is automatically assigned to the LPT field. This means that the programmer does not have to assign a value to that field. The SCRAMBLING function does not change the contents of the Secure Data, but uses the Data software parameter as a variable in support of the exchange of Original and Scrambled Data. 9.3.1 Parameter transfer Parameters to be transferred to execute a SCRAMBLING operation, including search for the dongle on the LPT1 parallel port:](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-30.png)
![33 9.6 Block Reading mode The BLOCK READING mode enables reading portions of the Secure Data, for example, one, two or a few words rather than the entire field. This saves a few fractions of a second compared to full reading with the READING MODE. The BLOCK_READING command is the only reading command which gives access to all the dongle memory. The exchange of information is organized like this: Models PR, EP, SP, XM, NET Input COMMAND ‘BR’ LPT Port LABEL Label PASSWORD Password DATA[0,1] Pointer at the first word to be read (from 0 to 31 for models with 64 bytes of memory, from 0 to 63 for 128 bytes, from 0 to 207 for 416 bytes, from 0 to 447 for 896 bytes) (2 bytes) DATA[2,3] Number of words to be read (from 1 to 16) (2 bytes) Output DATA[4,…] Values to be read in the area indicated by the two previous parameters (2 - 32 bytes) STATUS Status ==0 Success !=0 Error Table 15 BLOCK READING command parameters If the Password passed to the dongle is incorrect, Secure Data and Fail Counter are pseudo-randomly generated. 9.6.1 Parameter transfer Parameters to be transferred to execute a BLOCK READING operation on a dongle present on the LPT1 parallel port. 15 words must be read (000F hex equal to 30 bytes) starting from the twelfth word (address 11 = 000B hex). Remember that, in the parameter transfer structure, the first two bytes of the Data field are reserved for the address of the first word to be read, and the subsequent two bytes contain the number of words to be read. The read data block will be contained from in the fifth byte onward, at the end of the operation. LPT 01 00 Port COMMAND 52 42 Block Reading ("BR") LABEL 53 4D 41 52 54 4B 45 59 00 00 00 00 00 00 00 00 Label ("SMARTKEY") PASSWORD 45 55 54 52 4F 4E 00 00 00 00 00 00 00 00 00 00 Password("EUTRON") DATA 0B 00 0F 00 Address and Number of Words Table 16 Exchange of information for the BLOCK READING command 9.7 Block Writing mode The BLOCK WRITING function makes it possible to write portions of Secure Data, e.g. one, two or a few words rather than the whole field. This saves a few fractions of a second compared to complete writing with the WRITING MODE. The BLOCK_WRITING command is the only writing command which gives access to all the dongle memory. The exchange of information is organized like this: Models PR, EP, SP, XM, NET Input COMMAND ‘BW’](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-33.png)
![34 LPT Port LABEL Label PASSWORD Password DATA[0,1] Pointer at the first word to be written (from 0 to 31 for models with 64 bytes of memory, from 0 to 63 for 128 bytes, from 0 to 207 for 416 bytes, from 0 to 447 for 896 bytes) (2 bytes) DATA[2,3] Number of words to be written (from 1 to 16) (2 bytes) DATA[4,…] Values to be written in the area indicated by the two previous parameters (2 - 32 bytes) Output STATUS Status ==0 Success !=0 Error Table 17 BLOCK WRITING MODE command parameters If the Password passed to the dongle is incorrect, the data present in the Secure Data register are not changed. 9.7.1 Parameter transfer Parameters to be transferred to execute a BLOCK WRITING operation on a dongle present on the LPT1 parallel port. 10 words must be written (000A hex equal to 20 bytes) starting from the first word (address 0 = 0000 hex). Remember that, in the parameter transfer structure, the first two bytes of the Data field are reserved for the address of the first word to be written, and the subsequent two bytes contain the number of words. The bytes to be written are contained from in the fifth byte onward. LPT 01 00 Port COMMAND 46 00 Fixing Mode ("F") LABEL 53 4D 41 52 54 4B 45 59 00 00 00 00 00 00 00 00 Label ("SMARTKEY") PASSWORD 45 55 54 52 4F 4E 00 00 00 00 00 00 00 00 00 00 Password ("EUTRON") DATA 0B 00 0F 00 XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX XX Address, Number of Words, and Data Table 18 Exchange of information for the BLOCK WRITING MODE command 9.8 Fixing mode Fixing data means preventing further programming of the Label, Password and Secure Data registers. In practice, previously programmed data can be frozen. After the FIXING mode has been executed, SmartKey's contents can no longer be changed in any way. The data fixing mode, together with the Fail Counter Register is available only on models EP, SP, XM and NET. The possibility of fixing data enables a software-house to generate totally personalized, no longer alterable dongles. Attempts to change the contents are therefore discouraged, e.g. to vary access priority to databanks or to enable non specified software modules. The fixing operation should not be performed in testing, otherwise you would no longer be able to re-program the dongle. We therefore recommend that the possibility of fixing the contents programmed in the dongle should only be evaluated during the final stage of implementing the protection. Important: bear in mind that the additional functions involving memory writing will not be available. This command cannot be executed from lan, it works only with a local connection with the SmartKey.](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-34.png)
![36 Contrary to the SCRAMBLING mode, the algorithm is programmed in the dongle with SmartKey's ENCRYPTING function and occupies the Expanded Secure Data register, in reverse order, starting from the last byte of the field. The ENCRYPTING mode is certainly the most versatile and secure function of the SmartKey dongles. However, this is also the most complex function calling for a good knowledge of logical operators. We therefore advise you to first implement the other modes, which guarantee a very high level of security. Think of the ENCRYPTING function as an arm for use in situations with a very high probability of attack by technologically wise hackers. Use of the ENCRYPTING function entails comparing the Encrypted Data obtained from the dongle, to the data calculated inside the software, applying the algorithm to the Original Data. If the comparison proves successful, one can be certain that one's dongle is fitted on the PC, and, therefore, execution of the program can continue. The ENCRYPTING function does not alter the contents of the Secure Data, but uses the software Data parameter as a variable for supporting the exchange of Original and Encrypted Data. The exchange of information is organized like this: Models SP, XM, NET Input COMMAND ‘E’ LPT Port LABEL Label PASSWORD Password DATA[0..7] Original data (8 bytes) Output DATA[0..7] Encrypted data (8 bytes) STATUS Status ==0 Success !=0 Error Table 21 ENCRYPTING MODE command parameters The algorithm is stored in the Expanded Secure Data field, in reverse direction starting from the last byte of that field. You should check that the algorithm is located in that field, to avoid accidentally overwriting it during a WRITING operation. 9.9.1 Parameter transfer Parameters to be transferred to execute an ENCRYPTING operation, with the dongle on the LPT1 parallel port: LPT 01 00 Port COMMAND 45 00 Encrypting ("E") LABEL 53 4D 41 52 54 4B 45 59 00 00 00 00 00 00 00 00 Label ("SMARTKEY") PASSWORD 45 55 54 52 4F 4E 00 00 00 00 00 00 00 00 00 00 Password ("EUTRON") DATA XX XX XX XX XX XX XX XX Data to encrypt (8 byte) Table 22 Exchange of information for the ENCRYPTING MODE command At the end of the operation, the first 8 bytes of the Data field are replaced by the Encrypted Data, which depend on both the Original Data and on the algorithm previously programmed in the dongle. 9.9.2 Definition of the algorithm The logical operators which can be used to build your own security algorithm are as follows: OPERATOR DEFINITION SYMBOL Left Rotate Rotate to the left <](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-36.png)
![38 The PROGRAMMING facility allows you to set up your own program dedicated to preconfiguring the dongles, usually connected to a database, in order to associated the content of each dongle with a customers and/or products list. To program new Labels and Passwords, you do not have to know the previous Password (whereas you must know the current Label), because the operation automatically resets the set Secure Data field (it is filled with 00 hex). For obvious reasons linked to security, the Fail Counter is not reset. If you have forgotten to value of the current Label during the tests, you can return to the default situation with the SPC utility. The PROGRAMMING mode is necessary for off-line programming of the dongle. We therefore advise you not to use it on-line in the software to be protected, both for reasons of safety and to prevent a programming error from activating the function on a different SmartKey in the system. Furthermore, it is normally sufficient to act on the dongle with the READING and WRITING functions that limit their action to the Secure Data field. This command cannot be executed from lan, it works only with a local connection with the SmartKey. The exchange of information is organized like this: Models PR, EP, SP, XM NET Input COMMAND ‘P’ LPT Port LABEL New Label PASSWORD New Password DATA[0..15] Current label (16 bytes) Output STATUS Status ==0 Success !=0 Error Table 25 PROGRAMMING MODE command parameters 9.10.1 Parameter transfer Parameters needing to be transferred to execute a PROGRAMMING operation, with access to the dongle on the LPT1 parallel port, and programming of Label and Password. Let's suppose that the LABEL saved before the operation was "LABELOLD": LPT 01 00 Port COMMAND 50 00 Programming("P") LABEL 53 4D 41 52 54 4B 45 59 00 00 00 00 00 00 00 00 Label ("SMARTKEY") PASSWORD 45 55 54 52 4F 4E 00 00 00 00 00 00 00 00 00 00 Password ("EUTRON") DATA 4C 41 42 45 4C 4F 4C 44 00 00 00 00 00 00 00 00 Current Label (“LABELOLD”) Table 26 Exchange of information for the PROGRAMMING MODE command If the dongle is found on the indicated port, the Label and Password values are transferred to the dongle, whereas the Secure Data in the dongle are automatically reset. The current LABEL uses the first 16 bytes of the Data field, which are normally used for transferring Secure Data. 9.11 Comparing mode The COMPARING mode was introduced to simplify use of the dongles and to help those addressing software protection technique for the first time.](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-38.png)
![40 Models ALL Input COMMAND ‘M’ LPT Port LABEL Label Output DATA[0] SmartKey model = '1', FX = '2', PR = '3', EP = '9', SP = 'A', NET = 'D', XM DATA[1] Memory available on the dongle = '0', 0 bytes = '1', 64 bytes = '2', 128 bytes = '3', 416 bytes = '4', 896 bytes = '8', 8192 bytes STATUS Status ==0 Success !=0 Error Table 29 MODEL READING MODE command parameters 9.12.1 Parameter transfer Parameters to be transferred to execute a MODEL READING operation, with access to the dongle on the LPT1 parallel port. LPT 01 00 Port COMMAND 4D 00 Model Reading ("M") LABEL 53 4D 41 52 54 4B 45 59 00 00 00 00 00 00 00 00 Label ("SMARTKEY") Table 30 Exchange of information for the MODEL READING MODE command If the dongle is found on the indicated port, the dongle model is available on the first byte of the Secure Data field. 9.13 Serial number reading mode This command reads the SmartKey's SerialNumber. The SerialNumber is a 32-bit number unique for every SmartKey. The exchange of information is organized like this: Models ALL Input COMMAND ‘N’ LPT Port LABEL Label Output DATA[0,1,2,3] Serial Number](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-40.png)
![41 STATUS Status ==0 Success !=0 Error Table 31 SERIAL NUMBER READING MODE command parameters 9.14 Ext model reading mode This command reads the extended information on the SmartKey dongle. The exchange of information is organized like this: Models ALL Input COMMAND ‘H’ LPT Port LABEL Label Output DATA[0] Mode = '1', FX = '2', PR = '3', EP = '9', SP = 'A', NET = 'D', XM DATA[1] Memory available on the dongle = '0', 0 bytes = '1', 64 bytes = '2', 128 bytes = '3', 416 bytes = '4', 896 bytes = '8', 8192 bytes DATA[2] Hardware model = 2, Parallel = 3, USB = 4, USB DL (Driver Less) DATA[3] Functionalities (bit mask) = 0, no special command available = 1, AES commands available STATUS Status ==0 Success !=0 Error Table 32 EXT MODEL READING MODE command parameters 9.15 Fix reading mode Reads the value of the Fix register. The exchange of information is organized like this:](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-41.png)
![42 Models EP, SP, XM, NET Input COMMAND ‘X’ LPT Port LABEL Label PASSWORD Password Output DATA[0] = 1, SmartKey Fixed = 0, SmartKey not Fixed STATUS Status ==0 Success !=0 Error Table 33 FIX READING MODE command parameters 9.16 Fail counter reading mode Reads the value of the Fail Counter register. This is the same value obtained with the READING_MODE command. With this command, you can obtain the register's value without reading all the memory. The exchange of information is organized like this: Models EP, SP, XM, NET Input COMMAND ‘A’ LPT Port LABEL Label PASSWORD Password Output FAIL_COUNTER Fail Counter value STATUS Status ==0 Success !=0 Error Table 34 FAIL COUNTER READING MODE command parameters 9.17 AES mode The AES mode, supported by all SmartKey 3 models, is based on user customization of twenty security codes. Its function is to algorithmically discover if SmartKey is present. These commands allow a new authentication way using the AES 128 bit algorithm, as alternative to the SCRAMBLING command, without the need of using a big scrambling table of known input/output scrambling pairs. 9.17.1 Authentication To identify the SmartKey dongle, the application generates a pseudo-random number and sends it to the dongle. The dongle executes the XOR operation of the number sent by the application and then it replies by encrypting the serial number previously stored RESULT = AES_ENCRYPT( RAND XOR SERIAL ) The application is so ready to decrypt the result and to get the serial number by executing the XOR operation with the pseudo-random number SERIAL = AES_DECRYPT( RESULT ) XOR RAND If the serial number is valid the application assumes that the token is present. • by using a pseudo-random value it is sure that the dongle answers differently each time and so the same answer can not be used twice](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-42.png)
![43 • the cryptography utilization allows only at the application to correctly interpret the serial number • the application can verify the serial exactness by setting beforehand part of this number equal to a fixed value. Example: having a 16 byte serial, 8 of these 16 bytes can be set to '0' for all the serial numbers. If these 8 bytes are equal to '0' after the decryption, the application is sure that the answer received from the key is really valid. This check assures that the program is talking with a real dongle and not with a fake one, assuming that an eventual trick does not have the correct encryption key. 9.17.2 Utilization In order to use the new commands, the application to be protected should use the standalone or multilan (only with the LOCAL protocol) driver that provides the common SmartKey interface and the new AES authentication commands. According to the challenge-response protocol structure, the application must contain the AES 128 bit algorithm and a pseudo-random numbers generator in order to implement the communication with the SmartKey. It is important to underline that this implementation must be included into the application and not into the SmartKey driver because moving the authenticity from the application to the SmartKey driver, the application might work even with a fake driver. The application code should also include some protection methods in order to hide the cryptographic key used by the authentication process. 9.18 AES set mode This command sets 20 different 16-byte cryptographic keys for the AES algorithm and the 16 byte serial number. The cryptographic keys and the serial number, once written on the SmartKey, can’t be extracted or overwritten any longer even if you run the command again. In other words, this command can be executed only once. WARNING! the AES keys can be set ONLY ONE TIME! This command cannot be executed from lan, it works only with a local connection with the SmartKey. The exchange of information is organized like this: Model Only USB SmartKey 3 Input COMMAND ‘G’ LPT SmartKey port LABEL SmartKey Label EXTDATA[0-15] Serial number to be set EXTDATA[16-31] First AES key … EXTDATA[320-335] Twentieth AES key Output None Table 35 AES SET MODE command parameters 9.19 AES scramble mode This command executes the authentication operation. The SmartKey works on a pseudo-random value chosen by the application and gets back a value that is recognized by the application and allows it to verify the SmartKey presence based on the communication protocol previously described. The exchange of information is organized like this: Model Only USB SmartKey 3 Input COMMAND ‘O’ LPT SmartKey port LABEL SmartKey Label DATA[0-15] Pseudo-random values to use](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-43.png)
![44 DATA[16] AES Key to use. The first key has index 0. The last key has index 19. Output DATA[0-15] Protocol result. Table 36 AES SCRAMBLE MODE command parameters 9.20 Errors After a command, in the status entry in the communication may assume one of the following values: Nome Valore Descrizione ST_OK 0 Operation completed with success. ST_NONE_KEY -1 Device not found. This error is due by: • SmartKey not correctly inserted in the Parallel or USB port. • Drivers not correctly installed. • Wrong LABEL used. ST_SYNT_ERR -2 Syntax error in the command. This error is due by: • One of the arguments of the command is invalid. • The command is not support by the specific model of SmartKey used. For example you are trying to read the memory of a SmartKey without memory. • The command is prohibited in the current SmartKey state. For example you are trying to write the memory in a SmartKey with the memory Fixing flag set. ST_LABEL_FAILED -3 Wrong LABEL used. Depending on the command or on the SmartKey model it may be returned this error or the ST_NONE_KEY error. ST_PW_DATA_FAILED -4 Wrong PASSWORD used. ST_HW_FAILURE -20 An integrity check on the hardware device is failed. 9.21 Some suggestions on using SmartKey's functions Combined use of the listed functions enables you to set up protection criteria providing high security and flexibility. However, we should make some minimum suggestions to ensure secure implementation of the protection. • Always use the LOCATING Mode to detect dongle presence. This will help you make the program independent of the parallel port where the SmartKey dongle is installed • Use the SCRAMBLING mode, in different points of the program, with values different from those of the Original Data: if the result of subsequent comparisons with the Scrambled Data is positive, you will be sure that a dongle with your Id-Code is installed on the PC. • If you are using programmable dongles, run a READING operation in different points of the program: you will be able to compare the read values with the expected values, and ensure that the software being run is really authorized thanks to the special programming of the installed SmartKey dongle. • Always remember that a security system has the same degree of vulnerability as its weakest component. The chapter 10 introduces some further suggestions for secure implementation of the protection.](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-44.png)
![48 • Names of data files, DLL. • Names of functions called on the other DLLs. 10.3 Examples of implementation This chapter contains some examples of C implementation of the guidelines we have described. Furthermore, they can be found in the archive: SmartKeyProtectionGuidelinesExample.zip. In all the examples, we suppose that you are working with a SmartKey Demo with Label “SMARTKEY” and Password “EUTRON” as default. 10.3.1 Example 1 – Basic Use This example shows the basic use of SmartKey. The purpose of the program is to initialize the variables for SmartKey and check if the dongle is actually present. The example MUST NOT BE USED IN A REAL PROGRAM, because the label and password are included in the code without using any protection technique and one could trace them by analyzing the executable file. #include "skeylink.h" #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { KEY_NET k; memset(&k,0,sizeof(k)); strncpy(k.label,"SMARTKEY",LABEL_LENGTH); strncpy(k.password,"EUTRON",PASSWORD_LENGTH); /* Open */ k.net_command = NET_KEY_OPEN; smartlink(&k); /* Chiamata a sistema */ if (k.status != ST_OK) { printf("Error in NET_KEY_OPEN\n"); exit(EXIT_FAILURE); } /* Close */ k.net_command = NET_KEY_CLOSE; smartlink(&k); if (k.status != ST_OK) { printf("Error in NET_KEY_CLOSE\n"); exit(EXIT_FAILURE); } return EXIT_SUCCESS; } 10.3.2 Example 2 – Basic use of Scrambling This example shows the basic use of the scrambling operation. This example too MUST NOT BE USED IN A REAL PROGRAM, because the values included in the code are not protected. #include "skeylink.h" #include <stdio.h> #include <stdlib.h> #include <string.h> /* Scrambling input/output */ unsigned char scrambling_in[SCRAMBLE_LENGTH] = { 0x45, 0x34, 0x67, 0x23, 0xa5, 0x8f, 0x2c, 0x6d };](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-48.png)
![49 unsigned char scrambling_out[SCRAMBLE_LENGTH] = { 0x98, 0xab, 0x22, 0x24, 0xbb, 0xe6, 0x61, 0x8f }; int main() { KEY_NET k; /* Scrambling */ k.net_command = NET_KEY_ACCESS; k.command = SCRAMBLING_MODE; memcpy(k.data,scrambling_in,SCRAMBLE_LENGTH); smartlink(&k); if (k.status != ST_OK) { printf("Error in SCRAMBLING_MODE\n"); exit(EXIT_FAILURE); } if (memcmp(k.data,scrambling_out,SCRAMBLE_LENGTH)!=0) { printf("Wrong SCRAMBLING\n"); exit(EXIT_FAILURE); } printf("Scramble ok\n"); } 10.3.3 Example 3/4 – Storing and using a C function in the SmartKey memory This example shows how to store and use a binary code of a C function in SmartKey's memory. There are some limitations: • The function's dimensions must be smaller than or equal to those of the SmartKey memory. • External functions cannot be called directly, but they can be called indirectly by passing a function pointer as the argument. • External variables cannot be used directly, but they can be used indirectly by passing a pointer as the argument. • Your project must be connected to the option /FIXED to avoid a new location in your code. Storing the function This example stores function my_func() in SmartKey's memory. #include "skeylink.h" #include <stdio.h> #include <stdlib.h> #include <string.h> /* Function type */ typedef int my_func_t(int m, int n); /* Buffer used to store the function */ char my_func_data[DATA_LENGTH + EXTENDED_DATA_LENGTH]; /* Function */ static int my_func(int m, int n) { return m * n; } /* Marker of the end of the function */ static int my_func_end(void) { return 0; } int main() { KEY_NET k; unsigned size;](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-49.png)
![50 /* Preventive use of the functions to prevent collateral effects through optimisation of the compiler.*/ my_func(1,1); my_func_end(); /* Compute the function size */ size = (char*)my_func_end - (char*)my_func; printf("Function size %d\n", size); if (size > DATA_LENGTH + EXTENDED_DATA_LENGTH) { printf("Function size %d too big\n", size); exit(EXIT_FAILURE); } /* Copy of function on the dongle*/ if (size > DATA_LENGTH) { memcpy(k.data,((char*)my_func),DATA_LENGTH); memcpy(k.ext_data,((char*)my_func) + DATA_LENGTH, size - DATA_LENGTH); } else { memcpy(k.data,((char*)my_func),size); } /* Write on SmartKey */ k.net_command = NET_KEY_ACCESS; k.command = WRITING_MODE; smartlink(&k); if (k.status != ST_OK) { printf("Error in WRITING_MODE\n"); exit(EXIT_FAILURE); } printf("Function written on the key\n"); /* Close */ k.net_command = NET_KEY_CLOSE; smartlink(&k); if (k.status != ST_OK) { printf("Error in NET_KEY_CLOSE\n"); exit(EXIT_FAILURE); } return EXIT_SUCCESS; } Use of the function This example reads the my_func() function of SmartKey's memory and executes it. #include "skeylink.h" #include <stdio.h> #include <stdlib.h> #include <string.h> /* Function type */ typedef int my_func_t(int m, int n); /* Buffer used for storing the function */ char my_func_data[DATA_LENGTH + EXTENDED_DATA_LENGTH]; int main() { KEY_NET k;](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-50.png)
![52 printf("DLL checksum %08X\n",checksum); if (checksum != 0x007ffcf1) { printf("Error invalid checksum\n"); exit(EXIT_FAILURE); } return EXIT_SUCCESS; } 10.3.5 Example 6 – Hiding Label and Password information This example shows how to hide the Label and Password information, by using a simple masking algorithm. This algorithm must be used to prevent the possibility of discovering the Label and Password from the executable file, thus frustrating all SmartKey's protections. #include "skeylink.h" #include <stdio.h> #include <stdlib.h> #include <string.h> /* Hidden values */ static unsigned char hidden_label[LABEL_LENGTH] = { 0x09, 0x2f, 0x2d, 0x2a, 0xd2, 0xdd, 0xed, 0xe5, 0xd2, 0xea, 0x04, 0x20, 0x3e, 0x5e, 0x80, 0xa4 }; static unsigned char hidden_password[PASSWORD_LENGTH] = { 0xe0, 0x91, 0xb1, 0x5a, 0x62, 0x1a, 0x7d, 0xa8, 0xd5, 0x04, 0x35, 0x68, 0x9d, 0xd4, 0x0d, 0x48 }; int main() { KEY_NET k; unsigned i; memset(&k,0,sizeof(k)); /* Calcola la label e la password corrette */ for(i=0;i<LABEL_LENGTH;++i) k.label[i] = hidden_label[i] ^ (i*(i+0x7)+0x5a); for(i=0;i<PASSWORD_LENGTH;++i) k.password[i] = hidden_password[i] ^ (i*(i+0x1e)+0xa5); /* Open */ k.net_command = NET_KEY_OPEN; smartlink(&k); if (k.status != ST_OK) { printf("Error in NET_KEY_OPEN\n"); exit(EXIT_FAILURE); } printf("Net password %d\n",k.net_password); /* Close */ k.net_command = NET_KEY_CLOSE; smartlink(&k); if (k.status != ST_OK) { printf("Error in NET_KEY_CLOSE\n"); exit(EXIT_FAILURE); }](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-52.png)
![53 return EXIT_SUCCESS; } 10.3.6 Example 7 – Scrambling confidential data This example shows how to hide confidential data with the Scrambling operation. In the example the pi value is stored as follows: #include "skeylink.h" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> /* Scrambled data */ unsigned char scrambled_data[SCRAMBLE_LENGTH] = { 0x0c, 0xd8, 0xb3, 0xf6, 0x57, 0x6f, 0x4d, 0xe5 }; /* Scrambled input */ unsigned char scrambling_in[SCRAMBLE_LENGTH] = { 0x45, 0x34, 0x67, 0x23, 0xa5, 0x8f, 0x2c, 0x6d }; int main() { KEY_NET k; unsigned i; double pi; /* Scrambling */ k.net_command = NET_KEY_ACCESS; k.command = SCRAMBLING_MODE; memcpy(k.data,scrambling_in,SCRAMBLE_LENGTH); smartlink(&k); if (k.status != ST_OK) { printf("Error in SCRAMBLING_MODE\n"); exit(EXIT_FAILURE); } for(i=0;i<sizeof(pi);++i) ((unsigned char*)&pi)[i] = k.data[i] ^ scrambled_data[i]; printf("Pi greco is %g\n",pi); /* Close */ k.net_command = NET_KEY_CLOSE; smartlink(&k); if (k.status != ST_OK) { printf("Error in NET_KEY_CLOSE\n"); exit(EXIT_FAILURE); } return EXIT_SUCCESS; } 10.3.7 Example 8/9–Generating and using a large Scrambling table This example shows how to generate and use a large scrambling table. The input values of the scrambling operation are calculated during execution, using the index as the initialization of a simple random function. Generating the “table.h” file This example generates the table.h file #include "skeylink.h" #include <stdio.h>](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-53.png)
![54 #include <stdlib.h> #include <string.h> #include <time.h> #define SCRAMBLE_MAX 1024 void scramble_in(unsigned char* dst, unsigned src) { unsigned i; for(i=0;i<SCRAMBLE_LENGTH;++i) dst[i] = (((src + 0x5a) >> i) * (i + 0x13)) ^ 0x3e; } int main() { KEY_NET k; unsigned i; FILE* f; srand(time(0)); f = fopen("table.h","wt"); if (!f) { printf("Error opening the file table.h\n"); exit(EXIT_FAILURE); } fprintf(f,"void scramble_in(unsigned char* dst, unsigned src) {\n"); fprintf(f,"\tunsigned i;\n"); fprintf(f,"\tfor(i=0;i<SCRAMBLE_LENGTH;++i)\n"); fprintf(f,"\t\tdst[i] = (((src + 0x5a) >> i) * (i + 0x13)) ^ 0x3e;\n"); fprintf(f,"}\n\n"); fprintf(f,"#define SCRAMBLE_MAX %d\n\n",SCRAMBLE_MAX); fprintf(f,"unsigned char SCRAMBLE[SCRAMBLE_MAX][SCRAMBLE_LENGTH] = {\n"); for(i=0;i<SCRAMBLE_MAX;++i) { unsigned j; k.net_command = NET_KEY_ACCESS; k.command = SCRAMBLING_MODE; scramble_in(k.data,i); smartlink(&k); if (k.status != ST_OK) { printf("Error in SCRAMBLING_MODE\n"); exit(EXIT_FAILURE); } fprintf(f,"{ "); for(j=0;j<SCRAMBLE_LENGTH;++j) { unsigned v = k.data[j]; if (j) fprintf(f,", "); fprintf(f,"0x%02x",v); } fprintf(f," }"); if (i+1!=SCRAMBLE_MAX) fprintf(f,","); fprintf(f,"\n"); } fprintf(f,"};\n"); fclose(f); printf("Scrambling table written\n");](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-54.png)
![55 /* Close */ k.net_command = NET_KEY_CLOSE; smartlink(&k); if (k.status != ST_OK) { printf("Error in NET_KEY_CLOSE\n"); exit(EXIT_FAILURE); } return EXIT_SUCCESS; } Using the Scrambling table This example uses the generated file to control the presence of the SmartKey dongle. #include "skeylink.h" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> #include "table.h" /* Return a random index in the table */ unsigned get_scrambling_index(void) { time_t t; struct tm* ptm; unsigned i; time(&t); ptm = localtime(&t); i = (rand() % (SCRAMBLE_MAX / 31)) * 31; i += ptm->tm_mday; i = i % SCRAMBLE_MAX; return i; } int main() { KEY_NET k; unsigned i; /* Initialized the random number generator */ srand(time(0)); /* Get the random index in the table */ i = get_scrambling_index(); printf("Scramble index %d\n",i); /* Do the scrambling */ k.net_command = NET_KEY_ACCESS; k.command = SCRAMBLING_MODE; scramble_in(k.data,i); smartlink(&k); if (k.status != ST_OK) { printf("Error in SCRAMBLING_MODE\n"); exit(EXIT_FAILURE); } /* Check the scramble */ if (memcmp(k.data,SCRAMBLE[i],SCRAMBLE_LENGTH)!=0) {](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-55.png)
![56 printf("Wrong SCRAMBLING\n"); exit(EXIT_FAILURE); } printf("Scramble ok\n"); /* Close */ k.net_command = NET_KEY_CLOSE; smartlink(&k); if (k.status != ST_OK) { printf("Error in NET_KEY_CLOSE\n"); exit(EXIT_FAILURE); } return EXIT_SUCCESS; } The “table.h” generated file This is the table.h generated file void scramble_in(unsigned char* dst, unsigned src) { unsigned i; for(i=0;i<SCRAMBLE_LENGTH;++i) dst[i] = (((src + 0x5a) >> i) * (i + 0x13)) ^ 0x3e; } #define SCRAMBLE_MAX 1024 unsigned char SCRAMBLE[SCRAMBLE_MAX][SCRAMBLE_LENGTH] = { { 0xa2, 0x43, 0x2d, 0xdc, 0xf0, 0x49, 0x4b, 0x5c }, { 0x00, 0x24, 0x9f, 0x6e, 0x51, 0x10, 0x9c, 0x1a }, …stripped… { 0x10, 0x0f, 0x5e, 0x8e, 0x5b, 0x44, 0x67, 0x11 }, { 0xcd, 0x0a, 0x74, 0xed, 0x78, 0xc0, 0x0a, 0x97 } }; 10.3.8 Example 10 – Code encrypting Furthermore, SmartKey can be used to encrypt the code of your executable files or of the dynamic libraries (DLL), if these are developed in Visual C. A full, extensive example can be found in the archive: SmartKeyEncryptionGuidelinesExample.zip. For further details, consult files README.txt (English) and LEGGIMI.txt (Italian) in .zip. 10.3.9 Example 11 – AES authentication The following are two examples to set AES keys and use them. Setkey This example sets the AES keys. WARNING! the AES keys can be set ONLY ONE TIME! #include "skeydrv.h" #include <stdlib.h> #include <stdio.h> #include <windows.h> /* Serial */ unsigned char serial[16] = { 0x39, 0x9d, 0x81, 0xd0, 0x6f, 0x78, 0x94, 0x41, 0xec, 0xfe, 0x71, 0xa1, 0x21, 0xd4, 0xe1, 0x6d, }; /* 20 AES keys */ unsigned char aeskey[16*20] = { 0x27, 0xe1, 0x4e, 0xf4, 0x82, 0x3a, 0x1d, 0xa2, 0xbd, 0xee, 0xc7, 0xd2, 0x50, 0xe1, 0x37, 0x66, …stripped…](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-56.png)
![57 0x57, 0x4b, 0x21, 0x94, 0x82, 0x38, 0x68, 0xf8, 0xf8, 0x54, 0x38, 0xa1, 0x6d, 0x05, 0x70, 0x39, }; int main() { SKEY_DATA key; printf("SmartKey AES example\n"); memset(&key, 0, sizeof(key)); strncpy(key.label, "SMARTKEY", LABEL_LENGTH); key.command = LOCATING_MODE; msclink(&key); if (key.status != 0) { MessageBox(NULL, "SmartKey not found", "Error", MB_ICONERROR | MB_SYSTEMMODAL); exit(1); } key.command = EXT_MODEL_READING_MODE; msclink(&key); if (key.status != 0) { MessageBox(NULL, "SmartKey not found", "Error", MB_ICONERROR | MB_SYSTEMMODAL); exit(1); } if ((key.data[3] & 0x1) == 0) { MessageBox(NULL, "This SmartKey model doesn't support AES commands", "Error", MB_ICONERROR | MB_SYSTEMMODAL); exit(1); } if (MessageBox(NULL, "Set the AES keys ? The operation cannot be undone !", "Warning", MB_YESNO | MB_ICONWARNING | MB_SYSTEMMODAL) != IDYES) { exit(1); } memcpy(key.ext_data, serial, 16); memcpy(key.ext_data + 16, aeskey, 16*20); key.command = AES_SET_MODE; msclink(&key); if (key.status != 0) { MessageBox(NULL, "Error setting the AES keys and serial.\n\rPlease note that you can set them ONLY ONE TIME!", "Error", MB_ICONERROR | MB_SYSTEMMODAL); exit(1); } MessageBox(NULL, "AES keys setup correctly", "Information", MB_ICONINFORMATION | MB_SYSTEMMODAL); return 0; } Usekey This example uses the AES keys. #include "skeydrv.h" #include "aes.h" #include <stdlib.h>](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-57.png)
![58 #include <stdio.h> #include <time.h> #include <windows.h> /* Serial */ unsigned char serial[16] = { 0x39, 0x9d, 0x81, 0xd0, 0x6f, 0x78, 0x94, 0x41, 0xec, 0xfe, 0x71, 0xa1, 0x21, 0xd4, 0xe1, 0x6d, }; /* 20 AES keys */ unsigned char aeskey[16*20] = { 0x27, 0xe1, 0x4e, 0xf4, 0x82, 0x3a, 0x1d, 0xa2, 0xbd, 0xee, 0xc7, 0xd2, 0x50, 0xe1, 0x37, 0x66, …stripped… 0x57, 0x4b, 0x21, 0x94, 0x82, 0x38, 0x68, 0xf8, 0xf8, 0x54, 0x38, 0xa1, 0x6d, 0x05, 0x70, 0x39, }; int main() { SKEY_DATA key; aes_context aes; unsigned key_index; unsigned char result_buffer[16]; unsigned char random_buffer[16]; unsigned i; printf("SmartKey AES example\n"); /* initialize the random number generator */ srand(time(0)); memset(&key, 0, sizeof(key)); strncpy(key.label, "SMARTKEY", LABEL_LENGTH); key.command = LOCATING_MODE; msclink(&key); if (key.status != 0) { MessageBox(NULL, "SmartKey not found", "Error", MB_ICONERROR | MB_SYSTEMMODAL); exit(1); } key.command = EXT_MODEL_READING_MODE; msclink(&key); if (key.status != 0) { MessageBox(NULL, "SmartKey not found", "Error", MB_ICONERROR | MB_SYSTEMMODAL); exit(1); } if ((key.data[3] & 0x1) == 0) { MessageBox(NULL, "This SmartKey model doesn't support AES commands", "Error", MB_ICONERROR | MB_SYSTEMMODAL); exit(1); } /* set the random value */ for(i=0;i<16;++i) random_buffer[i] = rand() % 256; /* set the key number */ key_index = rand() % 20; memcpy(key.data, random_buffer, 16);](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-58.png)
![59 key.data[16] = key_index; key.command = AES_SCRAMBLE_MODE; msclink(&key); if (key.status != 0) { MessageBox(NULL, "Error using the AES key", "Error", MB_ICONERROR | MB_SYSTEMMODAL); exit(1); } aes_set_key(aes, aeskey + key_index*16, 16); aes_decrypt(aes, key.data, result_buffer); for(i=0;i<16;++i) result_buffer[i] ^= random_buffer[i]; if (memcmp(result_buffer, serial, 16) != 0) { MessageBox(NULL, "Wrong serial", "Error", MB_ICONERROR | MB_SYSTEMMODAL); exit(1); } MessageBox(NULL, "Correct serial", "Information", MB_ICONINFORMATION | MB_SYSTEMMODAL); return 0; }](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-59.png)
![60 11 Manual protection in a network SmartKey NET supports the standard commands of the SP model and a set of commands slaved to the network: OPEN, ACCESS, CLOSE and USER NUMBER. All the functions explained in the following paragraphs were used in the Windows program smartdem.c, which is located in directory Sdk\Manual_Protection\Client_Windows_Libraries_And_Examples\GenericWin32Dll e Sdk\Manual_Protection\Client_Windows_Libraries_And_Examples\GenericWin32Obj. The program can be compiled with any C compiler. 11.1 Open mode The OPEN Mode is employed by the user to activate communication with SmartKey. The OPEN operation must be carried out before all operations for accessing the dongle's memory. The OPEN command generates a special password, named Net Password, which must be used in all the subsequent commands. In the first byte of the Data field is reported the type of the protocol used in the connection. If you want to prevent the use of the LOCAL protocol, you can check this byte. Generally this is useful to force the use of the SmartKey server for license management. To use this command with the Map protection you must also specify the Map code in the Data field as described in the Map chapter. The exchange of information is organized like this: Models NET Input NET_COMMAND ‘O’ LABEL Label PASSWORD Password Output NET_PASS Net Password DATA[0] Protocol type used: = 0, LOCAL = 1, IPX = 2, ANP = 3, TCPIP STATUS Status ==0 Success !=0 Error Table 37 Exchange of information for OPEN MODE 11.2 Access mode The ACCESS mode enables actual access to the dongle. It is selected with the Label, which must always be passed before carrying out any standard dongle interrogation operation. This mode requires the NET-Password, which identifies the Client requesting access and the Label identifying the dongle to which access is required. The exchange of information is organized like this: Models NET Input NET_COMMAND ‘A’ NET_PASS Net Password COMMAND SmartKey Command](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-60.png)
![64 • First program: 23 licenses, unlimited executions. • Second program: 4 licenses, 4000 executions. • Third program: 12 licenses, 100 executions. The dongle memory must be set as follows: Offset Value Meaning 0 ‘M’ (4D hex) Map identification fixed code 1 ‘A’ (41 hex) Map identification fixed code 2 23 (17 hex) Maximum 23 users for program 1 3-4 65535 (FFFF hex) Unlimited number of program executions 5 4 (04 hex) Maximum 4 users for program 2 6-7 4000 (0FA0 hex) Limitation active for 400 executions 8 12 (0C hex) Maximum 12 users for program 3 9-10 100 (64 hex) Limitation active for 100 executions … … Table 42 Program protection setting 12.3 Map automatic protection If automatic protection via the GSS utility is performed with a network dongle, a specific push-button makes it possible to associate a code with each program. This code will be used to trace the number of licenses for which the program is enabled, and any limitation to the number of program executions (see chapter 8). 12.4 Map manual protection As one can protect several programs, as regards the Open and User Number commands only, you must specify which program is being referred to (program identified by a number from 1 to 116). To this end, during the transfer of parameters referring to each of the two commands, the Data field of the relevant data structure must be initialized as follows: Offset Value Meaning 0 ‘M’ (4D hex) Map identification fixed code 1 ‘A’ (41 hex) Map identification fixed code 2 1 - 116 Program reference number Table 43 Open/User Number Mode setting For the Open command the exchange of information is organized like this: Models NET Input NET_COMMAND ‘O’ LABEL Label PASSWORD Password DATA[0] ‘M’ (4D hex) DATA[1] ‘A’ (41 hex) DATA[2] 1 – 116, Program reference number of the license to use Output NET_PASS Net Password DATA[0] Protocol type used: = 0, LOCAL](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-64.png)
![65 = 1, IPX = 2, ANP = 3, TCPIP STATUS Status ==0 Success !=0 Error Table 44 Exchange of information for OPEN MODE with Map In the first byte of the Data field is reported the type of the protocol used in the connection. If you want to prevent the use of the Local protocol, you can check this byte. Generally this is useful to force the use of the SmartKey server for license management. Please note that if the Open is not done in Map mode, the SmartKey is opened without the license check allowing any number of applications to run. For the User Number command the exchange of information is organized like this: Models NET Input NET_COMMAND ‘A’ NET_PASS Net Password COMMAND ‘U’ DATA[0] ‘M’ (4D hex) DATA[1] ‘A’ (41 hex) DATA[2] 1 – 116, Program reference number of which you want to know the number of licenses in use Output STATUS Status >=0 Number of licenses in use <0 Error Table 45 Exchange of information for USER NUMBER MODE with Map 12.4.1 Open mode Map: an example Parameters that have to be transferred to execute an OPEN operation, using Map multiple protection on a network dongle; opening of program 2 is requested. If the dongle was programmed as in the previous programming table, not more than 4 simultaneous users may use the program. NET_COMMAND 4F 00 Open ("O") LABEL 53 4D 41 52 54 4B 45 59 00 00 00 00 00 00 00 00 Label ("SMARTKEY") PASSWORD 45 55 54 52 4F 4E 00 00 00 00 00 00 00 00 00 00 Password ("EUTRON") DATA 4D 41 02 Map, 2nd program Table 46 Example of Open mode Map setting](https://usermanual.wiki/EUTRONSEC-S-p-A/AAI/User-Guide-871403-Page-65.png)
