322 lines
11 KiB
C++
Executable File
322 lines
11 KiB
C++
Executable File
#include<pthread.h>
|
|
#include<dlfcn.h>
|
|
#include<stdlib.h>
|
|
#include<stdio.h>
|
|
#include<string.h>
|
|
|
|
#define MAX_PROVIDER_NAME_LEN 128
|
|
#define MAX_ERRMSG_LEN 256
|
|
|
|
static pthread_rwlock_t drivermutex;
|
|
|
|
typedef enum {
|
|
MODULE_AES_128_CBC = 0,
|
|
MODULE_AES_128_CTR,
|
|
MODULE_AES_128_GCM,
|
|
MODULE_AES_256_CBC,
|
|
MODULE_AES_256_CTR,
|
|
MODULE_AES_256_GCM,
|
|
MODULE_SM4_CBC,
|
|
MODULE_SM4_CTR,
|
|
MODULE_HMAC_SHA256,
|
|
MODULE_HMAC_SM3,
|
|
MODULE_DETERMINISTIC_KEY,
|
|
MODULE_ALGO_MAX = 1024
|
|
} ModuleSymmKeyAlgo;
|
|
|
|
|
|
typedef enum {
|
|
MODULE_SHA256 = 0,
|
|
MODULE_SM3,
|
|
MODULE_DIGEST_MAX = 1024
|
|
} ModuleDigestAlgo;
|
|
|
|
|
|
typedef enum {
|
|
KEY_TYPE_INVALID,
|
|
KEY_TYPE_PLAINTEXT,
|
|
KEY_TYPE_CIPHERTEXT,
|
|
KEY_TYPE_NAMEORIDX,
|
|
KEY_TYPE_MAX
|
|
} KeyType;
|
|
|
|
|
|
typedef struct {
|
|
char provider_name[MAX_PROVIDER_NAME_LEN];
|
|
KeyType key_type;
|
|
int supported_symm[MODULE_ALGO_MAX]; // 不支持算法填入0或者支持算法填入1
|
|
int supported_digest[MODULE_DIGEST_MAX]; // 不支持算法填入0或者支持算法填入1
|
|
} SupportedFeature;
|
|
|
|
|
|
typedef int (*crypto_module_init_type)(char *load_info, SupportedFeature *supported_feature);
|
|
typedef int (*crypto_module_sess_init_type)(char *key_info, void **sess);
|
|
typedef void (*crypto_module_sess_exit_type)(void *sess);
|
|
typedef int (*crypto_create_symm_key_type)(void *sess, ModuleSymmKeyAlgo algo, unsigned char *key_id, size_t *key_id_size);
|
|
typedef int (*crypto_ctx_init_type)(void *sess, void **ctx, ModuleSymmKeyAlgo algo, int enc, unsigned char *key_id, size_t key_id_size);
|
|
typedef int (*crypto_result_size_type)(void *ctx, int enc, size_t data_size);
|
|
typedef void (*crypto_ctx_clean_type)(void *ctx);
|
|
typedef int (*crypto_encrypt_decrypt_type)(void *ctx, int enc, unsigned char *data, size_t data_size, unsigned char *iv, size_t iv_size, unsigned char *result, size_t *result_size, unsigned char *tag);
|
|
typedef int (*crypto_digest_type)(void *sess, ModuleDigestAlgo algo, unsigned char * data, size_t data_size,unsigned char *result, size_t *result_size);
|
|
typedef int (*crypto_hmac_init_type)(void *sess, void **ctx, ModuleSymmKeyAlgo algo, unsigned char *key_id, size_t key_id_size);
|
|
typedef void (*crypto_hmac_clean_type)(void *ctx);
|
|
typedef int (*crypto_hmac_type)(void *ctx, unsigned char * data, size_t data_size, unsigned char *result, size_t *result_size);
|
|
typedef int (*crypto_gen_random_type)(void *sess, char *buffer, size_t size);
|
|
typedef int (*crypto_deterministic_enc_dec_type)(void *sess, int enc, unsigned char *data, unsigned char *key_id, size_t key_id_size, size_t data_size, unsigned char *result, size_t *result_size);
|
|
typedef int (*crypto_get_errmsg_type)(void *sess, char *errmsg);
|
|
|
|
|
|
void *libhandle = NULL;
|
|
crypto_module_init_type crypto_module_init_use = NULL;
|
|
crypto_module_sess_init_type crypto_module_sess_init_use = NULL;
|
|
crypto_module_sess_exit_type crypto_module_sess_exit_use = NULL;
|
|
crypto_create_symm_key_type crypto_create_symm_key_use = NULL;
|
|
crypto_ctx_init_type crypto_ctx_init_use = NULL;
|
|
crypto_result_size_type crypto_result_size_use = NULL;
|
|
crypto_ctx_clean_type crypto_ctx_clean_use = NULL;
|
|
crypto_encrypt_decrypt_type crypto_encrypt_decrypt_use = NULL;
|
|
crypto_digest_type crypto_digest_use = NULL;
|
|
crypto_hmac_init_type crypto_hmac_init_use = NULL;
|
|
crypto_hmac_clean_type crypto_hmac_clean_use = NULL;
|
|
crypto_hmac_type crypto_hmac_use = NULL;
|
|
crypto_gen_random_type crypto_gen_random_use = NULL;
|
|
crypto_deterministic_enc_dec_type crypto_deterministic_enc_dec_use = NULL;
|
|
crypto_get_errmsg_type crypto_get_errmsg_use = NULL;
|
|
|
|
static void load_lib()
|
|
{
|
|
libhandle = dlopen("/home//vastbase/contrib/common_cipher/libcommoncipher.so", RTLD_LAZY);
|
|
crypto_module_init_use = (crypto_module_init_type)dlsym(libhandle, "crypto_module_init");
|
|
crypto_module_sess_init_use = (crypto_module_sess_init_type)dlsym(libhandle, "crypto_module_sess_init");
|
|
crypto_module_sess_exit_use = (crypto_module_sess_exit_type)dlsym(libhandle, "crypto_module_sess_exit");
|
|
crypto_create_symm_key_use = (crypto_create_symm_key_type)dlsym(libhandle, "crypto_create_symm_key");
|
|
crypto_ctx_init_use = (crypto_ctx_init_type)dlsym(libhandle, "crypto_ctx_init");
|
|
crypto_result_size_use = (crypto_result_size_type)dlsym(libhandle, "crypto_result_size");
|
|
crypto_ctx_clean_use = (crypto_ctx_clean_type)dlsym(libhandle, "crypto_ctx_clean");
|
|
crypto_encrypt_decrypt_use = (crypto_encrypt_decrypt_type)dlsym(libhandle, "crypto_encrypt_decrypt");
|
|
crypto_digest_use = (crypto_digest_type)dlsym(libhandle, "crypto_digest");
|
|
crypto_hmac_init_use = (crypto_hmac_init_type)dlsym(libhandle, "crypto_hmac_init");
|
|
crypto_hmac_clean_use = (crypto_hmac_clean_type)dlsym(libhandle, "crypto_hmac_clean");
|
|
crypto_hmac_use = (crypto_hmac_type)dlsym(libhandle, "crypto_hmac");
|
|
crypto_gen_random_use = (crypto_gen_random_type)dlsym(libhandle, "crypto_gen_random");
|
|
crypto_deterministic_enc_dec_use = (crypto_deterministic_enc_dec_type)dlsym(libhandle, "crypto_deterministic_enc_dec");
|
|
crypto_get_errmsg_use = (crypto_get_errmsg_type)dlsym(libhandle, "crypto_get_errmsg");
|
|
|
|
}
|
|
|
|
static void* one_thread_func(void *data)
|
|
{
|
|
int ret = 1;
|
|
int i = 0;
|
|
char options[] = {"MODULE_TYPE=JNTAKMS,MODULE_LIB_PATH=/home//vastbase/contrib/common_cipher/libTassSDF4GHVSM.so,MODULE_CONFIG_FILE_PATH=/home//vastbase/contrib/common_cipher/"};
|
|
SupportedFeature supportedfeature;
|
|
char errmsg[MAX_ERRMSG_LEN] = {0};
|
|
void *session = NULL;
|
|
unsigned char key[32] = {0};
|
|
long unsigned int keylen = 0;
|
|
void *keyctx = NULL;
|
|
unsigned char srcdata[] = {"12345678"};
|
|
unsigned char plaint[32] = {0};
|
|
long unsigned int plaintlen = 32;
|
|
unsigned char encdata[32] = {0};
|
|
long unsigned int enclen = 32;
|
|
unsigned char encdata2[32] = {0};
|
|
long unsigned int enclen2 = 32;
|
|
unsigned char hashdata[32] = {0};
|
|
long unsigned int hashlen = 0;
|
|
unsigned char hmacdata[32] = {0};
|
|
long unsigned int hmaclen = 0;
|
|
long unsigned int needlen = 16;
|
|
char random[32] = {0};
|
|
unsigned char iv[] = {"1234567812345678"};
|
|
|
|
ret = crypto_module_init_use(options, &supportedfeature);
|
|
if (ret != 1)
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_module_init error,errmsg:%s\n", errmsg);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_module_init success\n");
|
|
printf("provider_name = %s,key_type = %d\n",supportedfeature.provider_name,supportedfeature.key_type);
|
|
for (i = 0; i < MODULE_ALGO_MAX;i++) {
|
|
if (supportedfeature.supported_symm[i] == 1)
|
|
printf("supported_symm[%d]\n",i);
|
|
}
|
|
for (i = 0; i < MODULE_DIGEST_MAX;i++) {
|
|
if (supportedfeature.supported_digest[i] == 1)
|
|
printf("supported_digest[%d]\n",i);
|
|
}
|
|
}
|
|
|
|
ret = crypto_module_sess_init_use(NULL, &session);
|
|
if (ret != 1)
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_module_sess_init error,errmsg:%s\n", errmsg);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_module_sess_init success\n");
|
|
}
|
|
|
|
ret = crypto_create_symm_key_use(session, MODULE_SM4_CBC, key, &keylen);
|
|
if (ret != 1)
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_create_symm_key_use error,errmsg:%s\n", errmsg);
|
|
crypto_module_sess_exit_use(session);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_create_symm_key_use success\n");
|
|
printf("key = %s\n",key);
|
|
}
|
|
|
|
ret = crypto_ctx_init_use(session, &keyctx, MODULE_SM4_CBC, 1, key, keylen);
|
|
if (ret != 1)
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_ctx_init_use error,errmsg:%s\n", errmsg);
|
|
crypto_module_sess_exit_use(session);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_ctx_init_use success\n");
|
|
}
|
|
|
|
ret = crypto_encrypt_decrypt_use(keyctx, 1, srcdata, 8, iv, 16, encdata, &enclen, NULL);
|
|
if (ret != 1)
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_encrypt_decrypt_use enc error,errmsg:%s\n", errmsg);
|
|
crypto_ctx_clean_use(keyctx);
|
|
crypto_module_sess_exit_use(session);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_encrypt_decrypt_use enc success\n");
|
|
}
|
|
|
|
ret = crypto_encrypt_decrypt_use(keyctx, 0, encdata, enclen, iv, 16, plaint, &plaintlen, NULL);
|
|
if (ret != 1 || strcmp((char*)plaint, (char*)srcdata))
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_encrypt_decrypt_use dec error,errmsg:%s\n", errmsg);
|
|
crypto_ctx_clean_use(keyctx);
|
|
crypto_module_sess_exit_use(session);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_encrypt_decrypt_use dec success\n");
|
|
}
|
|
|
|
printf("enc nedd len:%d\n",crypto_result_size_use(keyctx, 1, needlen));
|
|
|
|
printf("dec nedd len:%d\n",crypto_result_size_use(keyctx, 0, needlen));
|
|
|
|
crypto_ctx_clean_use(keyctx);
|
|
|
|
ret = crypto_digest_use(session, MODULE_SM3, plaint, plaintlen, hashdata, &hashlen);
|
|
if (ret != 1)
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_digest_use error,errmsg:%s\n", errmsg);
|
|
crypto_module_sess_exit_use(session);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_digest_use success\n");
|
|
printf("hashlen = %ld\n", hashlen);
|
|
}
|
|
|
|
ret = crypto_hmac_init_use(session, &keyctx, MODULE_HMAC_SM3, key, keylen);
|
|
if (ret != 1)
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_hmac_init_use error,errmsg:%s\n", errmsg);
|
|
crypto_module_sess_exit_use(session);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_hmac_init_use success\n");
|
|
}
|
|
|
|
ret = crypto_hmac_use(keyctx, plaint, plaintlen, hmacdata, &hmaclen);
|
|
if (ret != 1)
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_hmac_use error,errmsg:%s\n", errmsg);
|
|
crypto_hmac_clean_use(keyctx);
|
|
crypto_module_sess_exit_use(session);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_hmac_use success\n");
|
|
printf("hmaclen = %ld\n", hmaclen);
|
|
}
|
|
|
|
crypto_hmac_clean_use(keyctx);
|
|
|
|
ret = crypto_gen_random_use(session, random, 31);
|
|
if (ret != 1)
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_gen_random_use error,errmsg:%s\n", errmsg);
|
|
crypto_module_sess_exit_use(session);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_gen_random_use success\n");
|
|
}
|
|
|
|
ret = crypto_deterministic_enc_dec_use(session, 1, plaint, key, keylen, plaintlen, encdata, &enclen);
|
|
if (ret != 1)
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_deterministic_enc_dec_use1 enc error,errmsg:%s\n", errmsg);
|
|
crypto_module_sess_exit_use(session);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_deterministic_enc_dec_use1 enc success\n");
|
|
}
|
|
|
|
ret = crypto_deterministic_enc_dec_use(session, 1, plaint, key, keylen, plaintlen, encdata2, &enclen2);
|
|
if (ret != 1 || strcmp((char*)encdata, (char*)encdata2))
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_deterministic_enc_dec_use2 enc error,errmsg:%s\n", errmsg);
|
|
crypto_module_sess_exit_use(session);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_deterministic_enc_dec_use2 enc success\n");
|
|
}
|
|
|
|
ret = crypto_deterministic_enc_dec_use(session, 0, encdata2, key, keylen, enclen2, plaint, &plaintlen);
|
|
if (ret != 1 || strcmp((char*)plaint, (char*)srcdata))
|
|
{
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_deterministic_enc_dec_use2 dec error,errmsg:%s\n", errmsg);
|
|
crypto_module_sess_exit_use(session);
|
|
return NULL;
|
|
} else {
|
|
printf("crypto_deterministic_enc_dec_use2 dec success\n");
|
|
}
|
|
|
|
crypto_get_errmsg_use(NULL, errmsg);
|
|
printf("crypto_get_errmsg_use errmsg:%s\n", errmsg);
|
|
|
|
crypto_module_sess_exit_use(session);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int main()
|
|
{
|
|
pthread_t t1, t2, t3, t4;
|
|
|
|
load_lib();
|
|
|
|
pthread_create(&t1,0,one_thread_func,NULL);
|
|
pthread_create(&t2,0,one_thread_func,NULL);
|
|
pthread_create(&t3,0,one_thread_func,NULL);
|
|
pthread_create(&t4,0,one_thread_func,NULL);
|
|
pthread_join(t1,NULL);
|
|
pthread_join(t2,NULL);
|
|
pthread_join(t3,NULL);
|
|
pthread_join(t4,NULL);
|
|
|
|
return 0;
|
|
}
|