534 lines
20 KiB
Plaintext
534 lines
20 KiB
Plaintext
{*******************************************************}
|
||
{ }
|
||
{ Tocsg.COLib }
|
||
{ }
|
||
{ Copyright (C) 2025 kku }
|
||
{ }
|
||
{*******************************************************}
|
||
|
||
unit Tocsg.COLib;
|
||
|
||
interface
|
||
|
||
uses
|
||
System.SysUtils, Winapi.Windows;
|
||
|
||
const
|
||
{$IFDEF WIN64}
|
||
DLL_COLIB = 'colib64.dll';
|
||
{$ELSE}
|
||
DLL_COLIB = 'colib.dll';
|
||
{$ENDIF}
|
||
|
||
(*************** Definitions / Macros *************************************)
|
||
MEM_MARGIN_1 = 1;
|
||
MPZ_WORD_LEN = 500 + MEM_MARGIN_1;
|
||
|
||
COLIB_BLOCK_LEN = 16;
|
||
SHA512_DIGEST_SIZE = 64;
|
||
SHA256_DIGEST_SIZE = 32;
|
||
|
||
COLIB_128BIT_KEY_LEN = 16;
|
||
COLIB_192BIT_KEY_LEN = 24;
|
||
COLIB_256BIT_KEY_LEN = 32;
|
||
|
||
// Error -----------------------------------------------------------------------
|
||
// TCOLIB_ERROR = (
|
||
COLIB_SUCCESS = 0;
|
||
COLIB_ERROR_FATAL = 100;
|
||
COLIB_ERROR_ALREADY_INIT = 101;
|
||
COLIB_ERROR_UNSUPPORTED_MODE = 102;
|
||
COLIB_ERROR_UNSUPPORTED_RSA_KEY = 103;
|
||
COLIB_ERROR_FILE_OPEN = 104;
|
||
COLIB_ERROR_FILE_READ = 105;
|
||
COLIB_ERROR_CHANGE_STATE = 106;
|
||
COLIB_ERROR_ALLOC = 107;
|
||
COLIB_ERROR_ENTROPY = 108;
|
||
COLIB_ERROR_SELFTEST_DRBG = 500;
|
||
COLIB_ERROR_SELFTEST_BLOCK = 501;
|
||
COLIB_ERROR_SELFTEST_HASH = 502;
|
||
COLIB_ERROR_SELFTEST_ENTROPY = 503;
|
||
COLIB_ERROR_SELFTEST_RSA = 504;
|
||
COLIB_ERROR_SELFTEST_HMAC = 505;
|
||
COLIB_ERROR_MOD_SIGN = 506;
|
||
COLIB_ERROR_CRYPTO_BLOCK = 1000;
|
||
COLIB_ERROR_CRYPTO_PAD = 1001;
|
||
COLIB_ERROR_CRYPTO_INVALID_USERKEYLEN = 1002;
|
||
COLIB_ERROR_CRYPTO_DATA_LEN = 1003;
|
||
COLIB_ERROR_CRYPTO_CIPHER_LEN = 1004;
|
||
COLIB_ERROR_CRYPTO_MODE = 1005;
|
||
COLIB_ERROR_CRYPTO_SHA = 1500;
|
||
COLIB_ERROR_CRYPTO_HMAC = 1600;
|
||
COLIB_ERROR_DRBG = 2000;
|
||
COLIB_ERROR_DRBG_SIZE_OVER = 2001;
|
||
COLIB_ERROR_DRBG_BUFFER = 2002;
|
||
COLIB_ERROR_DRBG_HASH_DF = 2003;
|
||
COLIB_ERROR_DRBG_ADDITIONAL = 2004;
|
||
COLIB_ERROR_DRBG_MEMORY = 2005;
|
||
COLIB_ERROR_DRBG_HASHGEN = 2006;
|
||
COLIB_ERROR_RSA = 3000;
|
||
COLIB_ERROR_RSA_PUBLICKEY_FORMAT_ERROR = 3001;
|
||
COLIB_ERROR_RSA_PRIVITEKEY_FORMAT_ERROR = 3002;
|
||
COLIB_ERROR_RSA_INVALID_INPUT = 3003;
|
||
COLIB_ERROR_RSA_INVALID_SIGNLEN = 3004;
|
||
COLIB_ERROR_RSA_INVALID_PSSEM_LEN = 3005;
|
||
COLIB_ERROR_RSA_INVALID_PSSEM_FORMAT = 3006;
|
||
COLIB_ERROR_RSA_INVALID_DBMASK_FORMAT = 3007;
|
||
COLIB_ERROR_RSA_FAIL_PSSVERIFY = 3008;
|
||
COLIB_ERROR_RSA_INVALID_OAEP_FORMAT = 3009;
|
||
COLIB_ERROR_RSA_INVALID_OAEP_HASH = 3010;
|
||
COLIB_ERROR_RSA_MESSAGE_OUT_OF_RANGE = 3011;
|
||
COLIB_ERROR_RSA_CIPHERTEXT_OUT_OF_RANGE = 3012;
|
||
COLIB_ERROR_RSA_ENCMESSAGE_TOO_LONG = 3013;
|
||
COLIB_ERROR_RSA_DECRYPTION = 3014;
|
||
COLIB_ERROR_RSA_ENCODING = 3015;
|
||
COLIB_ERROR_RSA_PUBLIC_OP = 3016;
|
||
COLIB_ERROR_RSA_PRIVATE_OP = 3017;
|
||
COLIB_ERROR_RSA_KEY_PAIR = 3018;
|
||
COLIB_ERROR_RSA_FAIL_MALLOC = 3019;
|
||
COLIB_ERROR_RSA_KEY_GEN = 3020;
|
||
COLIB_ERROR_BN = 4000;
|
||
// );
|
||
type
|
||
TCOLIB_MODE = (
|
||
COLIB_MODE_APPROVE = 0,
|
||
COLIB_MODE_SEED = 1,
|
||
COLIB_MODE_ARIA,
|
||
COLIB_MODE_SHA224 = 100,
|
||
COLIB_MODE_SHA256,
|
||
COLIB_MODE_SHA384,
|
||
COLIB_MODE_SHA512,
|
||
COLIB_MODE_HMAC,
|
||
COLIB_MODE_HASH_DRBG = 200,
|
||
COLIB_MODE_RSAES_OAEP = 300,
|
||
COLIB_MODE_RSASSA_PSS,
|
||
COLIB_MODE_DISAPPROVE = 10000,
|
||
COLIB_MODE_AES = 10001,
|
||
COLIB_MODE_MAX
|
||
);
|
||
TCOLIB_RSA_KEY = (
|
||
COLIB_RSA_KEY_2048 = 2048
|
||
);
|
||
TCOLIB_BLOCK_CRYPTO_MODE = (
|
||
BLOCK_CRYPTO_MODE_UNUSED = 0,
|
||
BLOCK_CRYPTO_MODE_ECB = 1,
|
||
BLOCK_CRYPTO_MODE_CBC = 2,
|
||
BLOCK_CRYPTO_MODE_OFB = 3,
|
||
BLOCK_CRYPTO_MODE_CFB = 4
|
||
);
|
||
TCOLIB_STATE = (
|
||
COLIB_STATE_INIT = 1,
|
||
COLIB_STATE_APPROVE,
|
||
COLIB_STATE_DISAPPROVE,
|
||
COLIB_STATE_FATAL_ERROR,
|
||
COLIB_STATE_WARN_ERROR = 5,
|
||
COLIB_STATE_SELFTEST,
|
||
COLIB_STATE_INIT_DONE,
|
||
COLIB_STATE_INIT_DOING
|
||
);
|
||
TCOLIB_ENC_TYPE = (
|
||
ENC_TYPE_ENCRYPT = 0,
|
||
ENC_TYPE_DECRYPT = 1
|
||
);
|
||
TCOLIB_PAD_TYPE = (
|
||
COLIB_PAD_TYPE_UNUSED = 0,
|
||
COLIB_PAD_TYPE_NO = 1,
|
||
COLIB_PAD_TYPE_PKCS = 2
|
||
);
|
||
TCOLIB_KAT_STATE = (
|
||
KAT_STATE_INIT = 0,
|
||
KAT_STATE_DOING = 1,
|
||
KAT_STATE_DONE = 2
|
||
);
|
||
TCOLIB_MODE_STATE = record
|
||
seed_enc: TCOLIB_KAT_STATE;
|
||
seed_dec: TCOLIB_KAT_STATE;
|
||
aria_enc: TCOLIB_KAT_STATE;
|
||
aria_dec: TCOLIB_KAT_STATE;
|
||
sha: TCOLIB_KAT_STATE;
|
||
hmac: TCOLIB_KAT_STATE;
|
||
hash_drbg: TCOLIB_KAT_STATE;
|
||
rsaes_oaep_enc: TCOLIB_KAT_STATE;
|
||
rsaes_oaep_dec: TCOLIB_KAT_STATE;
|
||
rsassa_pss_sign: TCOLIB_KAT_STATE;
|
||
rsassa_pss_veri: TCOLIB_KAT_STATE;
|
||
integrity: TCOLIB_KAT_STATE;
|
||
end;
|
||
|
||
(*************** New Data Types *******************************************)
|
||
UINT = Cardinal;
|
||
COUWORD = Cardinal;
|
||
UCHAR = Byte;
|
||
SINT = Integer;
|
||
PDWORD = ^DWORD;
|
||
TMPZ = record
|
||
sig : SINT; // 1:positive, 0:zero, -1:negative
|
||
dat : PDWORD; // Max 104 WORD = 104 * 32 = 3328 bit
|
||
len : SINT;
|
||
end;
|
||
PCOKEY = ^TCOKEY;
|
||
TCOKEY = record
|
||
bits : UINT;
|
||
ktype : UCHAR; // pri 0, pub 1
|
||
p : TMPZ; // 1st prime factor
|
||
q : TMPZ; // 2nd prime factor
|
||
e : TMPZ; // public exponent
|
||
n : TMPZ; // public modulus
|
||
d : TMPZ; // private exponent
|
||
dp : TMPZ; // d % (p - 1)
|
||
dq : TMPZ; // d % (q - 1)
|
||
qp : TMPZ; // 1 / (Q % P)
|
||
end;
|
||
PCOKEY_BUF = ^TCOKEY_BUF;
|
||
TCOKEY_BUF = record
|
||
p_dat : array[0..MPZ_WORD_LEN - 1] of COUWORD;
|
||
q_dat : array[0..MPZ_WORD_LEN - 1] of COUWORD;
|
||
e_dat : array[0..MPZ_WORD_LEN - 1] of COUWORD;
|
||
n_dat : array[0..MPZ_WORD_LEN - 1] of COUWORD;
|
||
d_dat : array[0..MPZ_WORD_LEN - 1] of COUWORD;
|
||
dp_dat : array[0..MPZ_WORD_LEN - 1] of COUWORD;
|
||
dq_dat : array[0..MPZ_WORD_LEN - 1] of COUWORD;
|
||
qp_dat : array[0..MPZ_WORD_LEN - 1] of COUWORD;
|
||
end;
|
||
// For RSA Hash Fucntion. This is all hash func of CUBEONE
|
||
TCORSA_HASH_TYPE = (
|
||
HASH_SHA256
|
||
);
|
||
TCORSA_KEY_TYPE = (
|
||
COKEY_TYPE_PRIVATE = 0,
|
||
COKEY_TYPE_PUBLIC = 1
|
||
);
|
||
PCIPHER_INFO = ^TCIPHER_INFO;
|
||
TCIPHER_INFO = record
|
||
colib_mode : Integer;
|
||
colib_block_crypto_mode : Integer;//TCOLIB_BLOCK_CRYPTO_MODE;
|
||
colib_pad_type : Integer;//TCOLIB_PAD_TYPE;
|
||
user_key : PBYTE;
|
||
user_key_len : UINT;
|
||
iv : PBYTE;
|
||
iv_len : UINT;
|
||
input : PBYTE;
|
||
input_len : UINT;
|
||
output : PBYTE;
|
||
output_len : PUINT;
|
||
end;
|
||
PRSA_INFO = ^TRSA_INFO;
|
||
TRSA_INFO = record
|
||
cokey : PCOKEY;
|
||
colib_mode : Integer;
|
||
rsa_hash_type : TCORSA_HASH_TYPE;
|
||
input : PBYTE;
|
||
input_len : UINT;
|
||
output : PBYTE;
|
||
output_len : PUINT;
|
||
salt : PBYTE;
|
||
salt_len : UINT;
|
||
end;
|
||
PCOLIB_VERSION = ^TCOLIB_VERSION;
|
||
TCOLIB_VERSION = record
|
||
name : array[0..5] of AnsiChar;
|
||
major : Integer;
|
||
minor : Integer;
|
||
build : Integer;
|
||
version_str : array[0..255] of AnsiChar;
|
||
end;
|
||
|
||
TCOLibSetCipherInfo = procedure(cipher_info: PCIPHER_INFO; colib_mode, colib_block_crypto_mode,
|
||
colib_pad_type: Integer; user_key: PBYTE; user_key_len: UINT;
|
||
iv: PBYTE; iv_len: UINT; input: PBYTE; input_len: UINT; output:
|
||
PBYTE; output_len: PUINT); stdcall;
|
||
// TCOLibInitCipherInfo = procedure(cipher_info: PCIPHER_INFO); stdcall; // DLL<4C><4C> <20>Լ<EFBFBD> <20><><EFBFBD><EFBFBD>, TCOLibZeroCipherInfo()<29><> <20><>ü <20>ȵ<EFBFBD>
|
||
TCOLibSetRsaInfo = procedure(rsa_info: PRSA_INFO; cokey: PCOKEY; colib_mode: Integer;
|
||
rsa_hash_type: TCORSA_HASH_TYPE; input: PBYTE; input_len: UINT;
|
||
output: PBYTE; output_len: PUINT; salt: PBYTE; salt_len: UINT); stdcall;
|
||
// TCOLibInitRsaInfo = procedure(rsa_info: PRSA_INFO); stdcall; // DLL<4C><4C> <20>Լ<EFBFBD> <20><><EFBFBD><EFBFBD>, TCOLibZeroRsaInfo()<29><> <20><>ü <20>ȵ<EFBFBD>
|
||
TCOLibGetState = function: Integer; stdcall;
|
||
TCOLibGetVersion = function(colib_version: PCOLIB_VERSION): Integer; stdcall;
|
||
TCOLibSelfTestAll = function: Integer; stdcall;
|
||
TCOLibEncrypt = function(cipher_info: PCIPHER_INFO): Integer; stdcall;
|
||
TCOLibDecrypt = function(cipher_info: PCIPHER_INFO): Integer; stdcall;
|
||
TCOLibGetKey = function(key: PBYTE; key_len: UINT): Integer; stdcall;
|
||
TCOLibDrbg = function(buf: PBYTE; buf_len: UINT; addtl: PBYTE; addtl_len: UINT; pers: PBYTE; pers_len: UINT; pr: SINT): Integer; stdcall;
|
||
TCOLibEncryptRsa = function(rsa_info: PRSA_INFO): Integer; stdcall;
|
||
TCOLibDecryptRsa = function(rsa_info: PRSA_INFO): Integer; stdcall;
|
||
TCOLibGetRsaKey = function(bits: Integer; prk, puk: PCOKEY): Integer; stdcall;
|
||
TCOLibRsaKeyInit = function(cokey: PCOKEY; cokey_buf: PCOKEY_BUF): Integer; stdcall;
|
||
TCOLibGetModeState = procedure(colib_mode_state: PInteger); stdcall;
|
||
|
||
TCOLibZeroCipherInfo = procedure(cipher_info: PCIPHER_INFO); stdcall;
|
||
TCOLibZeroRsaInfo = procedure(rsa_info: PRSA_INFO); stdcall;
|
||
|
||
TCOLibGetErrorStr = function(colib_error: Integer): PAnsiChar; stdcall;
|
||
TCOLibGetModeStr = function(colib_mode: TCOLIB_MODE): PAnsiChar; stdcall;
|
||
TCOLibGetStateStr = function(colib_state: TCOLIB_STATE): PAnsiChar; stdcall;
|
||
TCOLibGetKatStateStr = function(colib_kat_state: TCOLIB_KAT_STATE): PAnsiChar; stdcall;
|
||
|
||
procedure COLibSetCipherInfo(cipher_info: PCIPHER_INFO; colib_mode: TCOLIB_MODE; colib_block_crypto_mode: TCOLIB_BLOCK_CRYPTO_MODE;
|
||
colib_pad_type: TCOLIB_PAD_TYPE; user_key: PBYTE; user_key_len: UINT;
|
||
iv: PBYTE; iv_len: UINT; input: PBYTE; input_len: UINT;
|
||
output: PBYTE; output_len: PUINT);
|
||
procedure COLibSetRsaInfo(rsa_info: PRSA_INFO; cokey: PCOKEY; colib_mode: Integer;
|
||
rsa_hash_type: TCORSA_HASH_TYPE; input: PBYTE; input_len: UINT;
|
||
output: PBYTE; output_len: PUINT; salt: PBYTE; salt_len: UINT);
|
||
function COLibGetState: Integer;
|
||
function COLibGetVersion(colib_version: PCOLIB_VERSION): Integer;
|
||
function COLibSelfTestAll: Integer;
|
||
function COLibEncrypt(cipher_info: PCIPHER_INFO): Integer;
|
||
function COLibDecrypt(cipher_info: PCIPHER_INFO): Integer;
|
||
function COLibGetKey(key: PBYTE; key_len: UINT): Integer;
|
||
function COLibDrbg(buf: PBYTE; buf_len: UINT; addtl: PBYTE; addtl_len: UINT;
|
||
pers: PBYTE; pers_len: UINT; pr: SINT): Integer;
|
||
function COLibEncryptRsa(rsa_info: PRSA_INFO): Integer;
|
||
function COLibDecryptRsa(rsa_info: PRSA_INFO): Integer;
|
||
function COLibGetRsaKey(bits: Integer; prk, puk: PCOKEY): Integer;
|
||
function COLibRsaKeyInit(cokey: PCOKEY; cokey_buf: PCOKEY_BUF): Integer;
|
||
procedure COLibGetModeState(colib_mode_state: PInteger);
|
||
|
||
procedure COLibZeroCipherInfo(cipher_info: PCIPHER_INFO);
|
||
procedure COLibZeroRsaInfo(rsa_info: PRSA_INFO);
|
||
|
||
function COLibGetErrorStr(colib_error: Integer): PAnsiChar;
|
||
function COLibGetModeStr(colib_mode: TCOLIB_MODE): PAnsiChar;
|
||
function COLibGetStateStr(colib_state: TCOLIB_STATE): PAnsiChar;
|
||
function COLibGetKatStateStr(colib_kat_state: TCOLIB_KAT_STATE): PAnsiChar;
|
||
|
||
implementation
|
||
|
||
uses
|
||
Tocsg.Path, Tocsg.Trace;
|
||
|
||
var
|
||
_hCoLib: THandle = 0;
|
||
_fnCOLibSetCipherInfo: TCOLibSetCipherInfo = nil;
|
||
// _fnCOLibInitCipherInfo: TCOLibInitCipherInfo = nil;
|
||
_fnCOLibSetRsaInfo: TCOLibSetRsaInfo = nil;
|
||
// _fnCOLibInitRsaInfo: TCOLibInitRsaInfo = nil;
|
||
_fnCOLibGetState: TCOLibGetState = nil;
|
||
_fnCOLibGetVersion: TCOLibGetVersion = nil;
|
||
_fnCOLibSelfTestAll: TCOLibSelfTestAll = nil;
|
||
_fnCOLibEncrypt: TCOLibEncrypt = nil;
|
||
_fnCOLibDecrypt: TCOLibDecrypt = nil;
|
||
_fnCOLibGetKey: TCOLibGetKey = nil;
|
||
_fnCOLibDrbg: TCOLibDrbg = nil;
|
||
_fnCOLibEncryptRsa: TCOLibEncryptRsa = nil;
|
||
_fnCOLibDecryptRsa: TCOLibDecryptRsa = nil;
|
||
_fnCOLibGetRsaKey: TCOLibGetRsaKey = nil;
|
||
_fnCOLibRsaKeyInit: TCOLibRsaKeyInit = nil;
|
||
_fnCOLibGetModeState: TCOLibGetModeState = nil;
|
||
_fnCOLibZeroCipherInfo: TCOLibZeroCipherInfo = nil;
|
||
_fnCOLibZeroRsaInfo: TCOLibZeroRsaInfo = nil;
|
||
_fnCOLibGetErrorStr: TCOLibGetErrorStr = nil;
|
||
_fnCOLibGetModeStr: TCOLibGetModeStr = nil;
|
||
_fnCOLibGetStateStr: TCOLibGetStateStr = nil;
|
||
_fnCOLibGetKatStateStr: TCOLibGetKatStateStr = nil;
|
||
|
||
function InitCOLibProcedure: Boolean;
|
||
var
|
||
sPath: String;
|
||
begin
|
||
if _hCoLib = 0 then
|
||
begin
|
||
sPath := GetRunExePathDir + DLL_COLIB;
|
||
if not FileExists(sPath) then
|
||
begin
|
||
TTgTrace.T('Fail .. InitCOLibProcedure() .. Not found DLL, Path=%s', [sPath]);
|
||
Exit(false);
|
||
end;
|
||
|
||
_hCoLib := LoadLibrary(PChar(sPath));
|
||
if _hCoLib <> 0 then
|
||
begin
|
||
@_fnCOLibSetCipherInfo := GetProcAddress(_hCoLib, 'COLibSetCipherInfo');
|
||
ASSERT(@_fnCOLibSetCipherInfo <> nil);
|
||
// @_fnCOLibInitCipherInfo := GetProcAddress(_hCoLib, 'COLibInitCipherInfo');
|
||
// ASSERT(@_fnCOLibInitCipherInfo <> nil);
|
||
@_fnCOLibSetRsaInfo := GetProcAddress(_hCoLib, 'COLibSetRsaInfo');
|
||
ASSERT(@_fnCOLibSetRsaInfo <> nil);
|
||
// @_fnCOLibInitRsaInfo := GetProcAddress(_hCoLib, 'COLibInitRsaInfo');
|
||
// ASSERT(@_fnCOLibInitRsaInfo <> nil);
|
||
@_fnCOLibGetState := GetProcAddress(_hCoLib, 'COLibGetState');
|
||
ASSERT(@_fnCOLibGetState <> nil);
|
||
@_fnCOLibGetVersion := GetProcAddress(_hCoLib, 'COLibGetVersion');
|
||
ASSERT(@_fnCOLibGetVersion <> nil);
|
||
@_fnCOLibSelfTestAll := GetProcAddress(_hCoLib, 'COLibSelfTestAll');
|
||
ASSERT(@_fnCOLibSelfTestAll <> nil);
|
||
@_fnCOLibEncrypt := GetProcAddress(_hCoLib, 'COLibEncrypt');
|
||
ASSERT(@_fnCOLibEncrypt <> nil);
|
||
@_fnCOLibDecrypt := GetProcAddress(_hCoLib, 'COLibDecrypt');
|
||
ASSERT(@_fnCOLibDecrypt <> nil);
|
||
@_fnCOLibGetKey := GetProcAddress(_hCoLib, 'COLibGetKey');
|
||
ASSERT(@_fnCOLibGetKey <> nil);
|
||
@_fnCOLibDrbg := GetProcAddress(_hCoLib, 'COLibDrbg');
|
||
ASSERT(@_fnCOLibDrbg <> nil);
|
||
@_fnCOLibEncryptRsa := GetProcAddress(_hCoLib, 'COLibEncryptRsa');
|
||
ASSERT(@_fnCOLibEncryptRsa <> nil);
|
||
@_fnCOLibDecryptRsa := GetProcAddress(_hCoLib, 'COLibDecryptRsa');
|
||
ASSERT(@_fnCOLibDecryptRsa <> nil);
|
||
@_fnCOLibGetRsaKey := GetProcAddress(_hCoLib, 'COLibGetRsaKey');
|
||
ASSERT(@_fnCOLibGetRsaKey <> nil);
|
||
@_fnCOLibRsaKeyInit := GetProcAddress(_hCoLib, 'COLibRsaKeyInit');
|
||
ASSERT(@_fnCOLibRsaKeyInit <> nil);
|
||
@_fnCOLibGetModeState := GetProcAddress(_hCoLib, 'COLibGetModeState');
|
||
ASSERT(@_fnCOLibGetModeState <> nil);
|
||
@_fnCOLibZeroCipherInfo := GetProcAddress(_hCoLib, 'COLibZeroCipherInfo');
|
||
ASSERT(@_fnCOLibZeroCipherInfo <> nil);
|
||
@_fnCOLibZeroRsaInfo := GetProcAddress(_hCoLib, 'COLibZeroRsaInfo');
|
||
ASSERT(@_fnCOLibZeroRsaInfo <> nil);
|
||
|
||
@_fnCOLibGetErrorStr := GetProcAddress(_hCoLib, 'COLibGetErrorStr');
|
||
ASSERT(@_fnCOLibGetErrorStr <> nil);
|
||
@_fnCOLibGetModeStr := GetProcAddress(_hCoLib, 'COLibGetModeStr');
|
||
ASSERT(@_fnCOLibGetModeStr <> nil);
|
||
@_fnCOLibGetStateStr := GetProcAddress(_hCoLib, 'COLibGetStateStr');
|
||
ASSERT(@_fnCOLibGetStateStr <> nil);
|
||
@_fnCOLibGetKatStateStr := GetProcAddress(_hCoLib, 'COLibGetKatStateStr');
|
||
ASSERT(@_fnCOLibGetKatStateStr <> nil);
|
||
end;
|
||
end;
|
||
Result := _hCoLib <> 0;
|
||
end;
|
||
|
||
procedure COLibSetCipherInfo(cipher_info: PCIPHER_INFO; colib_mode: TCOLIB_MODE; colib_block_crypto_mode: TCOLIB_BLOCK_CRYPTO_MODE;
|
||
colib_pad_type: TCOLIB_PAD_TYPE; user_key: PBYTE; user_key_len: UINT;
|
||
iv: PBYTE; iv_len: UINT; input: PBYTE; input_len: UINT;
|
||
output: PBYTE; output_len: PUINT);
|
||
begin
|
||
if InitCOLibProcedure and Assigned(_fnCOLibSetCipherInfo) then
|
||
_fnCOLibSetCipherInfo(cipher_info, Integer(colib_mode), Integer(colib_block_crypto_mode),
|
||
Integer(colib_pad_type), user_key, user_key_len,
|
||
iv, iv_len, input, input_len, output, output_len);
|
||
end;
|
||
|
||
procedure COLibSetRsaInfo(rsa_info: PRSA_INFO; cokey: PCOKEY; colib_mode: Integer;
|
||
rsa_hash_type: TCORSA_HASH_TYPE; input: PBYTE; input_len: UINT;
|
||
output: PBYTE; output_len: PUINT; salt: PBYTE; salt_len: UINT);
|
||
begin
|
||
if InitCOLibProcedure and Assigned(_fnCOLibSetRsaInfo) then
|
||
_fnCOLibSetRsaInfo(rsa_info, cokey, colib_mode, rsa_hash_type, input, input_len,
|
||
output, output_len, salt, salt_len);
|
||
end;
|
||
|
||
function COLibGetState: Integer;
|
||
begin
|
||
Result := -1;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibGetState) then
|
||
Result := _fnCOLibGetState;
|
||
end;
|
||
|
||
function COLibGetVersion(colib_version: PCOLIB_VERSION): Integer;
|
||
begin
|
||
Result := -1;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibGetVersion) then
|
||
Result := _fnCOLibGetVersion(colib_version);
|
||
end;
|
||
|
||
function COLibSelfTestAll: Integer;
|
||
begin
|
||
Result := -1;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibSelfTestAll) then
|
||
Result := _fnCOLibSelfTestAll;
|
||
end;
|
||
|
||
function COLibEncrypt(cipher_info: PCIPHER_INFO): Integer;
|
||
begin
|
||
Result := -1;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibEncrypt) then
|
||
Result := _fnCOLibEncrypt(cipher_info);
|
||
end;
|
||
|
||
function COLibDecrypt(cipher_info: PCIPHER_INFO): Integer;
|
||
begin
|
||
Result := -1;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibDecrypt) then
|
||
Result := _fnCOLibDecrypt(cipher_info);
|
||
end;
|
||
|
||
function COLibGetKey(key: PBYTE; key_len: UINT): Integer;
|
||
begin
|
||
Result := -1;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibGetKey) then
|
||
Result := _fnCOLibGetKey(key, key_len);
|
||
end;
|
||
|
||
function COLibDrbg(buf: PBYTE; buf_len: UINT; addtl: PBYTE; addtl_len: UINT;
|
||
pers: PBYTE; pers_len: UINT; pr: SINT): Integer;
|
||
begin
|
||
Result := -1;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibDrbg) then
|
||
Result := _fnCOLibDrbg(buf, buf_len, addtl, addtl_len, pers, pers_len, pr);
|
||
end;
|
||
|
||
function COLibEncryptRsa(rsa_info: PRSA_INFO): Integer;
|
||
begin
|
||
Result := -1;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibEncryptRsa) then
|
||
Result := _fnCOLibEncryptRsa(rsa_info);
|
||
end;
|
||
|
||
function COLibDecryptRsa(rsa_info: PRSA_INFO): Integer;
|
||
begin
|
||
Result := -1;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibDecryptRsa) then
|
||
Result := _fnCOLibDecryptRsa(rsa_info);
|
||
end;
|
||
|
||
function COLibGetRsaKey(bits: Integer; prk, puk: PCOKEY): Integer;
|
||
begin
|
||
Result := -1;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibGetRsaKey) then
|
||
Result := _fnCOLibGetRsaKey(bits, prk, puk);
|
||
end;
|
||
|
||
function COLibRsaKeyInit(cokey: PCOKEY; cokey_buf: PCOKEY_BUF): Integer;
|
||
begin
|
||
Result := -1;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibRsaKeyInit) then
|
||
Result := _fnCOLibRsaKeyInit(cokey, cokey_buf);
|
||
end;
|
||
|
||
procedure COLibGetModeState(colib_mode_state: PInteger);
|
||
begin
|
||
if InitCOLibProcedure and Assigned(_fnCOLibGetModeState) then
|
||
_fnCOLibGetModeState(colib_mode_state);
|
||
end;
|
||
|
||
procedure COLibZeroCipherInfo(cipher_info: PCIPHER_INFO);
|
||
begin
|
||
if InitCOLibProcedure and Assigned(_fnCOLibZeroCipherInfo) then
|
||
_fnCOLibZeroCipherInfo(cipher_info);
|
||
end;
|
||
|
||
procedure COLibZeroRsaInfo(rsa_info: PRSA_INFO);
|
||
begin
|
||
if InitCOLibProcedure and Assigned(_fnCOLibZeroRsaInfo) then
|
||
_fnCOLibZeroRsaInfo(rsa_info);
|
||
end;
|
||
|
||
function COLibGetErrorStr(colib_error: Integer): PAnsiChar;
|
||
begin
|
||
Result := nil;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibGetErrorStr) then
|
||
Result := _fnCOLibGetErrorStr(colib_error);
|
||
end;
|
||
|
||
function COLibGetModeStr(colib_mode: TCOLIB_MODE): PAnsiChar;
|
||
begin
|
||
Result := nil;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibGetModeStr) then
|
||
Result := _fnCOLibGetModeStr(colib_mode);
|
||
end;
|
||
function COLibGetStateStr(colib_state: TCOLIB_STATE): PAnsiChar;
|
||
begin
|
||
Result := nil;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibGetStateStr) then
|
||
Result := _fnCOLibGetStateStr(colib_state);
|
||
end;
|
||
function COLibGetKatStateStr(colib_kat_state: TCOLIB_KAT_STATE): PAnsiChar;
|
||
begin
|
||
Result := nil;
|
||
if InitCOLibProcedure and Assigned(_fnCOLibGetKatStateStr) then
|
||
Result := _fnCOLibGetKatStateStr(colib_kat_state);
|
||
end;
|
||
|
||
end.
|