503 lines
16 KiB
Matlab
503 lines
16 KiB
Matlab
function dpsample
|
|
%DPSAMPLE Example use of the Dinkey Pro/FD API in MATLAB.
|
|
|
|
% Copyright 2015 Microcosm Ltd.
|
|
|
|
% Load the correct library for this platform
|
|
% !!!! If you rename the libraries as recommended in the user manual,
|
|
% !!!! you need to modify the lines below to use the new names.
|
|
switch computer()
|
|
case 'PCWIN64' % 64-bit Windows
|
|
loadlibrary('dpwin64.dll', @dinkeypro64proto, 'alias', 'dinkeypro');
|
|
case 'PCWIN' % 32-bit Windows
|
|
loadlibrary('dpwin32.dll', @dinkeyprowin32proto, 'alias', 'dinkeypro');
|
|
case 'GLNXA64' % 64-bit Linux
|
|
loadlibrary('dplin64.so', @dinkeypro64proto, 'alias', 'dinkeypro');
|
|
case 'GLNX86' % 32-bit Linux
|
|
loadlibrary('dplin32.so', @dinkeypro32proto, 'alias', 'dinkeypro');
|
|
case 'MACI64' % 64-bit Mac OS X
|
|
loadlibrary('dpmac64.dylib', @dinkeypro64proto, 'alias', 'dinkeypro');
|
|
case 'MAC' % 32-bit Mac OS X
|
|
loadlibrary('dpmac32.dylib', @dinkeypro32proto, 'alias', 'dinkeypro');
|
|
otherwise
|
|
disp('Error! Platform not supported!');
|
|
return
|
|
end
|
|
|
|
% Each of the functions below demonstrates different API functionality.
|
|
% Uncomment the appropriate functions to execute the examples.
|
|
% See the comments in each function for more details about the features
|
|
% that they demonstrate.
|
|
|
|
protcheck('dinkeypro');
|
|
%protcheckwithalg('dinkeypro');
|
|
%writedataarea('dinkeypro');
|
|
%readdataarea('dinkeypro');
|
|
%encryptuserdata('dinkeypro');
|
|
%protcheckenc('dinkeypro');
|
|
%writedataareaenc('dinkeypro');
|
|
%readdataareaenc('dinkeypro');
|
|
|
|
% Unload the library
|
|
unloadlibrary('dinkeypro');
|
|
end
|
|
|
|
|
|
function protcheck(libName)
|
|
% An example of a basic protection check
|
|
|
|
PROTECTION_CHECK = 1;
|
|
DEC_ONE_EXEC = 1;
|
|
START_NET_USER = 4;
|
|
|
|
% Initialise the DRIS
|
|
dris.function = PROTECTION_CHECK;
|
|
dris.flags = bitor(DEC_ONE_EXEC, START_NET_USER);
|
|
|
|
% Call the API
|
|
[retCode, dris] = ddprotcheck(libName, dris);
|
|
|
|
% Check the return value
|
|
if (retCode ~= 0)
|
|
displayerror(retCode, dris.ext_err);
|
|
return
|
|
end
|
|
|
|
% ...
|
|
|
|
% You can check other values from the DRIS in other parts of your
|
|
% program to improve security. For example:
|
|
|
|
% Check the SDSN
|
|
% !!!! "10101" is the SDSN used by the demo SDK and demo dongles
|
|
% !!!! If not using a demo, replace "10101" with your own SDSN here
|
|
if (dris.sdsn ~= 10101)
|
|
disp('Incorrect SDSN! Have you replaced "10101" with your SDSN in the sample code?');
|
|
return
|
|
end
|
|
|
|
% Check the product code
|
|
% !!!! Replace "DEMO" with the product code you specify when adding
|
|
% protection with DinkeyAdd
|
|
if (~strcmp(dris.prodcode, 'DEMO'))
|
|
disp('Incorrect product code! Have you replaced "DEMO" with your product code in the sample code?');
|
|
return
|
|
end
|
|
|
|
disp('Protection check successful');
|
|
end
|
|
|
|
|
|
function protcheckwithalg(libName)
|
|
% An example of a protection check that also executes an algorithm stored
|
|
% in the dongle.
|
|
% The best way to use this feature is to identify lines of code in your
|
|
% program that can be represented by algorithms stored in the dongle, and
|
|
% replace these lines with calls to the API. Lite dongle users cannot
|
|
% change the algorithm stored in the dongles, so should calculate the
|
|
% algorithm in their own code and compare the result with the one returned
|
|
% by the API, as in this example.
|
|
|
|
EXECUTE_ALGORITHM = 2;
|
|
|
|
% Initialise the DRIS
|
|
dris.function = EXECUTE_ALGORITHM;
|
|
dris.alg_vars = [1 2 3 4 5 6 7 8]; % The input variables to use in the algorithm
|
|
dris.alg_number = 1; % The algorithm to execute. Lite dongles ignore this field, as they contain only 1 algorithm
|
|
|
|
% Call the API
|
|
[retCode, dris] = ddprotcheck(libName, dris);
|
|
|
|
% Check the return value
|
|
if (retCode ~= 0)
|
|
displayerror(retCode, dris.ext_err);
|
|
return
|
|
end
|
|
|
|
|
|
% Check the algorithm result in another part of your program to improve
|
|
% security. !!!! Ensure the myalgorithm() function matches the
|
|
% algorithm that was executed by the protection check!
|
|
if (dris.alg_answer ~= myalgorithm(dris.alg_vars))
|
|
disp('Error! The algorithm result was not as expected.');
|
|
return
|
|
end
|
|
|
|
disp('Protection check with algorithm successful');
|
|
end
|
|
|
|
|
|
function writedataarea(libName)
|
|
% An example of a protection check that also writes data to the dongle's
|
|
% secure data area.
|
|
% This feature is not supported by Lite dongles.
|
|
% Make sure you specify a large enough data area size when adding
|
|
% protection with DinkeyAdd!
|
|
|
|
WRITE_DATA_AREA = 3;
|
|
|
|
% Initialise the DRIS
|
|
dris.function = WRITE_DATA_AREA;
|
|
dris.rw_data = 'Hello, World!'; % Data to write
|
|
dris.rw_offset = 0; % Index to start writing at. Note indices start at zero!
|
|
|
|
% Call the API
|
|
[retCode, dris] = ddprotcheck(libName, dris);
|
|
|
|
% Check the return value
|
|
if (retCode ~= 0)
|
|
displayerror(retCode, dris.ext_err);
|
|
return
|
|
end
|
|
|
|
disp('Writing data successful');
|
|
end
|
|
|
|
|
|
function readdataarea(libName)
|
|
% An example of a protection check that also reads data from the dongle's
|
|
% secure data area.
|
|
% This feature is not supported by Lite dongles.
|
|
% Make sure you specify a large enough data area size when adding
|
|
% protection with DinkeyAdd!
|
|
|
|
READ_DATA_AREA = 4;
|
|
|
|
% Initialise the DRIS
|
|
dris.function = READ_DATA_AREA;
|
|
dris.rw_offset = 0; % Index to start reading at. Note indices start at zero!
|
|
dris.rw_length = 13; % How many bytes to read
|
|
|
|
% Call the API
|
|
[retCode, dris] = ddprotcheck(libName, dris);
|
|
|
|
% Check the return value
|
|
if (retCode ~= 0)
|
|
displayerror(retCode, dris.ext_err);
|
|
return
|
|
end
|
|
|
|
disp(['Reading data successful: ' char(dris.rw_data)]);
|
|
end
|
|
|
|
|
|
function encryptuserdata(libName)
|
|
% An example of protection checks that encrypt/decrypt your data.
|
|
% This feature is not supported by Lite dongles.
|
|
|
|
ENCRYPT_USER_DATA = 5;
|
|
DECRYPT_USER_DATA = 6;
|
|
|
|
originalData = uint8(255 * rand(1, 10));
|
|
|
|
% Initialise the DRIS
|
|
dris.function = ENCRYPT_USER_DATA;
|
|
dris.rw_data = originalData;
|
|
dris.data_crypt_key_num = 1;
|
|
|
|
% Call the API
|
|
[retCode, dris] = ddprotcheck(libName, dris);
|
|
|
|
% Check the return value
|
|
if (retCode ~= 0)
|
|
displayerror(retCode, dris.ext_err);
|
|
return
|
|
end
|
|
|
|
encryptedData = dris.rw_data;
|
|
|
|
% Initialise the DRIS
|
|
dris.function = DECRYPT_USER_DATA;
|
|
|
|
% Call the API
|
|
[retCode, dris] = ddprotcheck(libName, dris);
|
|
|
|
% Check the return value
|
|
if (retCode ~= 0)
|
|
displayerror(retCode, dris.ext_err);
|
|
return
|
|
end
|
|
|
|
decryptedData = dris.rw_data;
|
|
|
|
disp('Data encryption successful');
|
|
disp('Original data:');
|
|
disp(originalData);
|
|
disp('Encrypted data:');
|
|
disp(encryptedData);
|
|
disp('Decrypted data:');
|
|
disp(decryptedData);
|
|
end
|
|
|
|
|
|
function protcheckenc(libName)
|
|
% An example of a protection check that uses DRIS encryption for extra
|
|
% security.
|
|
|
|
PROTECTION_CHECK = 1;
|
|
|
|
% Initialise the DRIS
|
|
dris.function = PROTECTION_CHECK;
|
|
dris.seed1 = uint8(255 * rand(1, 4)); % 4 random bytes
|
|
dris.seed2 = uint8(255 * rand(1, 4)); % 4 random bytes
|
|
|
|
% Call the API
|
|
[retCode, dris] = ddprotcheck(libName, dris, @cryptdris);
|
|
|
|
% Check the return value
|
|
if (retCode ~= 0)
|
|
displayerror(retCode, dris.ext_err);
|
|
return
|
|
end
|
|
|
|
|
|
% You can check other values from the DRIS in other parts of your
|
|
% program to improve security. For example:
|
|
|
|
% Check the SDSN
|
|
% !!!! "10101" is the SDSN used by the demo SDK and demo dongles
|
|
% !!!! If not using a demo, replace "10101" with your own SDSN here
|
|
if (dris.sdsn ~= 10101)
|
|
disp('Incorrect SDSN! Have you replaced "10101" with your SDSN in the sample code?');
|
|
return
|
|
end
|
|
|
|
% Check the product code
|
|
% !!!! Replace "DEMO" with the product code you specify when adding
|
|
% protection with DinkeyAdd
|
|
if (~strcmp(dris.prodcode, 'DEMO'))
|
|
disp('Incorrect product code! Have you replaced "DEMO" with your product code in the sample code?');
|
|
return
|
|
end
|
|
|
|
disp('Protection check successful');
|
|
end
|
|
|
|
|
|
function writedataareaenc(libName)
|
|
% An example of a protection check that also writes data to the dongle's
|
|
% secure data area.
|
|
% This feature is not supported by Lite dongles.
|
|
% Make sure you specify a large enough data area size when adding
|
|
% protection with DinkeyAdd! This function also uses DRIS encryption and
|
|
% encrypts the rw_data field for extra security. You must select these
|
|
% options in DinkeyAdd for this function to work correctly!
|
|
|
|
WRITE_DATA_AREA = 3;
|
|
|
|
% Initialise the DRIS
|
|
dris.function = WRITE_DATA_AREA;
|
|
dris.rw_offset = 0;
|
|
dris.seed1 = uint8(255 * rand(1, 4)); % 4 random bytes
|
|
dris.seed2 = uint8(255 * rand(1, 4)); % 4 random bytes
|
|
dris.alg_vars = randint(1 , 8, double([intmin intmax])); % 8 random signed 32-bit integers
|
|
|
|
rwAlgAnswer = myrwalgorithm(dris.alg_vars);
|
|
|
|
% Encrypt the data to be written to the dongle
|
|
dataToWrite = uint8('ABCDEFGHIJKLMNOPQRSTUVWXYZ');
|
|
dris.rw_data = cryptapidata(dataToWrite, dris.seed1, dris.seed2, rwAlgAnswer);
|
|
|
|
% Call the API
|
|
[retCode, dris] = ddprotcheck(libName, dris, @cryptdris);
|
|
|
|
% Check the return value
|
|
if (retCode ~= 0)
|
|
displayerror(retCode, dris.ext_err);
|
|
return
|
|
end
|
|
|
|
disp('Writing data successful');
|
|
end
|
|
|
|
|
|
function readdataareaenc(libName)
|
|
% An example of a protection check that also reads data from the dongle's
|
|
% secure data area.
|
|
% This feature is not supported by Lite dongles.
|
|
% Make sure you specify a large enough data area size when adding
|
|
% protection with DinkeyAdd! This function also uses DRIS encryption and
|
|
% encrypts the rw_data field for extra security. You must select these
|
|
% options in DinkeyAdd for this function to work correctly!
|
|
|
|
READ_DATA_AREA = 4;
|
|
|
|
% Initialise the DRIS
|
|
dris.function = READ_DATA_AREA;
|
|
dris.rw_offset = 0;
|
|
dris.rw_length = 10;
|
|
dris.seed1 = uint8(255 * rand(1, 4)); % 4 random bytes
|
|
dris.seed2 = uint8(255 * rand(1, 4)); % 4 random bytes
|
|
dris.alg_vars = randint(1 , 8, double([intmin intmax])); % 8 random signed 32-bit integers
|
|
|
|
% Call the API
|
|
[retCode, dris] = ddprotcheck(libName, dris, @cryptdris);
|
|
|
|
% Check the return value
|
|
if (retCode ~= 0)
|
|
displayerror(retCode, dris.ext_err);
|
|
return
|
|
end
|
|
|
|
% Decrypt the data read from the dongle
|
|
rwAlgAnswer = myrwalgorithm(dris.alg_vars);
|
|
dataRead = cryptapidata(dris.rw_data, dris.seed1, dris.seed2, rwAlgAnswer);
|
|
|
|
disp(['Reading data successful: ' char(dataRead)]);
|
|
end
|
|
|
|
|
|
function ret = myalgorithm(algVars)
|
|
% !!!! This function must match one stored in the dongle for
|
|
% protcheckwithalg() to work correctly.
|
|
% For Lite dongles, use DinkeyLook to see the algorithm pre-programmed
|
|
% into the dongle. For Plus and Net dongles, ensure this algorithm matches
|
|
% one you specified in DinkeyAdd when adding protection.
|
|
ret = algVars(1) - algVars(2) - algVars(3) - algVars(4) - algVars(5) - algVars(6) - algVars(7);
|
|
end
|
|
|
|
|
|
function ret = myrwalgorithm(algVars)
|
|
% !!!! This function must match the R/W algorithm stored in the dongle for
|
|
% writedataareaenc() and readdataareaenc() to work correctly.
|
|
ret = algVars(1) - algVars(2) - algVars(3) - algVars(4) - algVars(5) - algVars(6);
|
|
end
|
|
|
|
|
|
function dris = cryptdris(dris)
|
|
% This function can be used to encrypt/decrypt the DRIS. If using DRIS
|
|
% encryption in your own program, copy this function exactly. Modify only
|
|
% the parts indicated by !!!!
|
|
|
|
% !!!! Overwrite the encryption parameters with those chosen in
|
|
% DinkeyAdd. This example uses 123, 212, 97.
|
|
DRIS_ENCRYPTION_PARAMETERS = [123 212 97];
|
|
|
|
S = 0:255;
|
|
bigseed = zeros(256, 1);
|
|
|
|
for i = 1:8:256
|
|
for j = 0:3
|
|
bigseed(i+j) = dris(9+j);
|
|
bigseed(i+j+4) = dris(13+j);
|
|
end
|
|
end
|
|
|
|
j = 0;
|
|
for i = 0:255
|
|
j = bitand((j + S(i+1) + bigseed(i+1) + DRIS_ENCRYPTION_PARAMETERS(1)), 255);
|
|
temp = S(i+1);
|
|
S(i+1) = S(j+1);
|
|
S(j+1) = temp;
|
|
end
|
|
|
|
i = 0;
|
|
j = 0;
|
|
for k = 17:length(dris)
|
|
i = bitand((i + 1), 255);
|
|
j = bitand((j + S(i+1) + DRIS_ENCRYPTION_PARAMETERS(2)), 255);
|
|
temp = S(i+1);
|
|
S(i+1) = S(j+1);
|
|
S(j+1) = temp;
|
|
t = bitand((S(i+1) + S(j+1) + DRIS_ENCRYPTION_PARAMETERS(3)), 255);
|
|
dris(k) = bitxor(dris(k), S(t+1));
|
|
end
|
|
end
|
|
|
|
|
|
function data = cryptapidata(data, seed1, seed2, algAnswer)
|
|
% This function is used to encrypt/decrypt data passed in the rw_data DRIS
|
|
% field (applies to Plus and Net dongles only). If using this feature in
|
|
% your own program, copy this function exactly. Modify only the parts
|
|
% indicated by !!!!
|
|
|
|
% !!!! If you are using constant encryption parameters, define them
|
|
% like this:
|
|
% DATA_ENCRYPTION_PARAMETERS = [X Y Z];
|
|
|
|
|
|
% !!!! If you are using the R/W algorithm, derive the encryption
|
|
% parameters from the algorithm result like this:
|
|
|
|
% 1. Convert algAnswer to uint32 without changing underlying data
|
|
if (algAnswer < 0)
|
|
algAnswer = uint32(double(algAnswer) + hex2dec('FFFFFFFF') + 1);
|
|
else
|
|
algAnswer = uint32(algAnswer);
|
|
end
|
|
|
|
% 2. Now algAnswer is a uint32 we can use bitwise operations to derive
|
|
% the encryption parameters
|
|
DATA_ENCRYPTION_PARAMETERS = [bitand(algAnswer, 255), bitand(bitshift(algAnswer,-8), 255), bitand(bitshift(algAnswer,-16), 255)];
|
|
|
|
|
|
% The rest of the function should not be modified!
|
|
|
|
S = 0:255;
|
|
bigseed = zeros(256, 1);
|
|
|
|
for i = 1:8:256
|
|
for j = 0:3
|
|
bigseed(i+j) = seed1(j+1);
|
|
bigseed(i+j+4) = seed2(j+1);
|
|
end
|
|
end
|
|
|
|
j = 0;
|
|
for i = 0:255
|
|
j = bitand((j + S(i+1) + bigseed(i+1) + DATA_ENCRYPTION_PARAMETERS(1)), 255);
|
|
temp = S(i+1);
|
|
S(i+1) = S(j+1);
|
|
S(j+1) = temp;
|
|
end
|
|
|
|
i = 0;
|
|
j = 0;
|
|
for k = 1:length(data)
|
|
i = bitand((i + 1), 255);
|
|
j = bitand((j + S(i+1) + DATA_ENCRYPTION_PARAMETERS(2)), 255);
|
|
temp = S(i+1);
|
|
S(i+1) = S(j+1);
|
|
S(j+1) = temp;
|
|
t = bitand((S(i+1) + S(j+1) + DATA_ENCRYPTION_PARAMETERS(3)), 255);
|
|
data(k) = bitxor(data(k), S(t+1));
|
|
end
|
|
end
|
|
|
|
|
|
% An example of error reporting
|
|
% Displays descriptions for some common error codes
|
|
% IMPORTANT - THE MESSAGES DISPLAYED ARE TO HELP DEVELOPERS IMPLEMENT THE
|
|
% DINKEY PRO/FD API. THEY ARE NOT SUITABLE FOR DISPLAYING TO USERS!
|
|
function displayerror(retCode, extErr)
|
|
switch retCode
|
|
case 401
|
|
disp('Error! No dongles detected!');
|
|
case 403
|
|
disp('Error! The dongle is a different type to the one specified in DinkeyAdd.');
|
|
case 404
|
|
disp('Error! The dongle is a different model to those specified in DinkeyAdd.');
|
|
case 409
|
|
disp('Error! The dongle has not been programmed by DinkeyAdd.');
|
|
case 410
|
|
disp('Error! The dongle has a different product code to the one specified in DinkeyAdd.');
|
|
case 411
|
|
disp('Error! This program''s licence was not found in the dongle.');
|
|
case 413
|
|
disp('Error! This program has not been locked by DinkeyAdd. For guidance please read the DinkeyAdd chapter of the user manual.');
|
|
case 417
|
|
disp('Error! One or more of the parameters set in the DRIS is incorrect.');
|
|
disp('Check that you have defined the necessary input fields in the DRIS struct.');
|
|
disp('Also check if you are encrypting the DRIS in your code but did not specify DRIS encryption in DinkeyAdd - or vice versa.');
|
|
case 423
|
|
disp('Error! The number of network users has been exceeded.');
|
|
case 435
|
|
disp('Error! DinkeyServer has not been detected on the network.');
|
|
case 922
|
|
disp('Error! The Software Key has expired.');
|
|
otherwise
|
|
str = sprintf('An error occurred checking the dongle. Error: %d, Extended Error: %d', retCode, extErr);
|
|
disp(str);
|
|
end
|
|
end
|