462 lines
15 KiB
C
462 lines
15 KiB
C
|
|
#define BATCH_MAX_SIZE 4
|
|
|
|
typedef struct
|
|
{
|
|
int cycle_num; /*<单线程循环次数>*/
|
|
int cmd; /*<命令码>*/
|
|
int data_len; /*<数据长度>*/
|
|
} trd_arg_t;
|
|
|
|
typedef struct
|
|
{
|
|
int keyidex[BATCH_MAX_SIZE];
|
|
int checkidex[BATCH_MAX_SIZE];
|
|
char sm4_short_encdata[1024 + 16];
|
|
int sm4_short_encdata_len;
|
|
char sm4_short_decdata[1024];
|
|
int sm4_short_decdata_len;
|
|
char sm4_short_checkvalue[33];
|
|
int sm4_short_checkvalue_len;
|
|
char sm4_batch_encdata[BATCH_MAX_SIZE][1024 + 16];
|
|
int sm4_batch_encdata_len[BATCH_MAX_SIZE];
|
|
char *tmp_sm4_batch_encdata[BATCH_MAX_SIZE];
|
|
char sm4_batch_decdata[BATCH_MAX_SIZE][1024];
|
|
int sm4_batch_decdata_len[BATCH_MAX_SIZE];
|
|
char *tmp_sm4_batch_decdata[BATCH_MAX_SIZE];
|
|
char sm4_batch_checkvalue[BATCH_MAX_SIZE][33];
|
|
int sm4_batch_checkvalue_len[BATCH_MAX_SIZE];
|
|
char *tmp_sm4_batch_checkvalue[BATCH_MAX_SIZE];
|
|
char sm4_batch_mac[BATCH_MAX_SIZE][33];
|
|
int sm4_batch_mac_len[BATCH_MAX_SIZE];
|
|
char *tmp_sm4_batch_mac[BATCH_MAX_SIZE];
|
|
char batch_orgdata[BATCH_MAX_SIZE][2048];
|
|
int batch_orgdata_len[BATCH_MAX_SIZE];
|
|
char *tmp_batch_orgdata[BATCH_MAX_SIZE];
|
|
char hash[33];
|
|
char mac[33];
|
|
int checkret[BATCH_MAX_SIZE];
|
|
} xn_init_config_t;
|
|
|
|
xn_init_config_t g_stc_xn_init_config;
|
|
static pthread_mutex_t g_time_mutex;
|
|
static int g_thread_count = 0;
|
|
static long g_all_time[300] = {0};
|
|
static long g_all_average_time[300] = {0};
|
|
static char g_org_data[9000] = {0};
|
|
|
|
long GetTime()
|
|
{
|
|
struct timeval t_time;
|
|
gettimeofday(&t_time,NULL);
|
|
return ((long)t_time.tv_sec) * 1000000 + ((long)t_time.tv_usec);
|
|
}
|
|
|
|
static int xn_tps_init_data(int data_len)
|
|
{
|
|
if(data_len <= 0 || data_len > 1024)
|
|
{
|
|
LOG("输入数据长度错误, 范围为[1, 1024]");
|
|
return -1;
|
|
}
|
|
|
|
int ret = 0, i = 0;
|
|
int check_ret[BATCH_MAX_SIZE] = {0};
|
|
void *handle = NULL;
|
|
const char *iplist[2] = {0};
|
|
int port[2] = {0};
|
|
iplist[0] = DEV_IP;
|
|
port[0] = DEV_PORT;
|
|
ret = SYD_Connect_Ex(iplist, port, 1, CON_TIMEOUT, DEAL_TIMEOUT, 0, &handle);
|
|
if(ret != 0)
|
|
{
|
|
LOG("SYD_Connect_Ex ret=%08x", ret);
|
|
return ret;
|
|
}
|
|
memset(&g_stc_xn_init_config, 0, sizeof(xn_init_config_t));
|
|
|
|
for(i = 0; i < BATCH_MAX_SIZE; i++)
|
|
{
|
|
g_stc_xn_init_config.keyidex[i] = KEYINDEX;
|
|
g_stc_xn_init_config.checkidex[i] = CHECKINDEX;
|
|
g_stc_xn_init_config.sm4_short_encdata_len = sizeof(g_stc_xn_init_config.sm4_short_encdata);
|
|
g_stc_xn_init_config.sm4_short_decdata_len = sizeof(g_stc_xn_init_config.sm4_short_decdata);
|
|
g_stc_xn_init_config.sm4_short_checkvalue_len = sizeof(g_stc_xn_init_config.sm4_short_checkvalue);
|
|
g_stc_xn_init_config.sm4_batch_encdata_len[i] = sizeof(g_stc_xn_init_config.sm4_batch_encdata[i]);
|
|
g_stc_xn_init_config.tmp_sm4_batch_encdata[i] = g_stc_xn_init_config.sm4_batch_encdata[i];
|
|
g_stc_xn_init_config.sm4_batch_decdata_len[i] = sizeof(g_stc_xn_init_config.sm4_batch_decdata[i]);
|
|
g_stc_xn_init_config.tmp_sm4_batch_decdata[i] = g_stc_xn_init_config.sm4_batch_decdata[i];
|
|
g_stc_xn_init_config.sm4_batch_checkvalue_len[i] = sizeof(g_stc_xn_init_config.sm4_batch_checkvalue[i]);
|
|
g_stc_xn_init_config.tmp_sm4_batch_checkvalue[i] = g_stc_xn_init_config.sm4_batch_checkvalue[i];
|
|
g_stc_xn_init_config.sm4_batch_mac_len[i] = sizeof(g_stc_xn_init_config.sm4_batch_mac[i]);
|
|
g_stc_xn_init_config.tmp_sm4_batch_mac[i] = g_stc_xn_init_config.sm4_batch_mac[i];
|
|
IniOrgData(g_stc_xn_init_config.batch_orgdata[i], 2048, 1);
|
|
g_stc_xn_init_config.batch_orgdata_len[i] = data_len;
|
|
g_stc_xn_init_config.tmp_batch_orgdata[i] = g_stc_xn_init_config.batch_orgdata[i];
|
|
}
|
|
|
|
ret = SYD_SM4_Encrypt_Mac_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_stc_xn_init_config.checkidex[0], \
|
|
g_org_data, data_len, g_stc_xn_init_config.sm4_short_encdata, &g_stc_xn_init_config.sm4_short_encdata_len, \
|
|
g_stc_xn_init_config.sm4_short_checkvalue);
|
|
if(ret != 0)
|
|
{
|
|
LOG("SYD_SM4_Encrypt_Mac_ShortData ret=%08x", ret);
|
|
goto END;
|
|
}
|
|
g_stc_xn_init_config.sm4_short_checkvalue_len = 16;
|
|
|
|
ret = SYD_SM4_Encrypt_Mac_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.checkidex, \
|
|
g_stc_xn_init_config.tmp_batch_orgdata, g_stc_xn_init_config.batch_orgdata_len, BATCH_MAX_SIZE, \
|
|
g_stc_xn_init_config.tmp_sm4_batch_encdata, g_stc_xn_init_config.sm4_batch_encdata_len, \
|
|
g_stc_xn_init_config.tmp_sm4_batch_checkvalue);
|
|
if(ret != 0)
|
|
{
|
|
LOG("SYD_SM4_Encrypt_Mac_BatchData ret=%08x", ret);
|
|
goto END;
|
|
}
|
|
g_stc_xn_init_config.sm4_short_checkvalue_len = 16;
|
|
END:
|
|
SYD_DisConnect_Ex(handle);
|
|
return ret;
|
|
}
|
|
|
|
static int xn_sm4_short_enc(void* handle, unsigned int data_len)
|
|
{
|
|
int ret = 0;
|
|
unsigned int sm4_short_encdata_len = sizeof(g_stc_xn_init_config.sm4_short_encdata);
|
|
ret = SYD_SM4_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_org_data, data_len, \
|
|
SM4_ENCRYPT, g_stc_xn_init_config.sm4_short_encdata, &sm4_short_encdata_len);
|
|
if (ret != 0)
|
|
{
|
|
LOG("SYD_SM4_ShortData err ret=%08x", ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int xn_sm4_short_dec(void* handle, unsigned int data_len)
|
|
{
|
|
int ret = 0;
|
|
unsigned int sm4_short_decdata_len = sizeof(g_stc_xn_init_config.sm4_short_decdata);
|
|
ret = SYD_SM4_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_stc_xn_init_config.sm4_short_encdata, \
|
|
g_stc_xn_init_config.sm4_short_encdata_len, SM4_DECRYPT, g_stc_xn_init_config.sm4_short_decdata, \
|
|
&sm4_short_decdata_len);
|
|
if (ret != 0)
|
|
{
|
|
LOG("SYD_SM4_ShortData err ret=%08x", ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int xn_sm4_short_mac(void* handle, unsigned int data_len)
|
|
{
|
|
int ret = 0;
|
|
ret = SYD_SM4Mac_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_org_data, data_len, \
|
|
g_stc_xn_init_config.mac, NULL);
|
|
if(ret != 0)
|
|
{
|
|
LOG("SYD_SM4Mac_ShortData ret=%08x", ret);
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int xn_sm4_batch_mac(void* handle)
|
|
{
|
|
int ret = 0;
|
|
ret = SYD_SM4Mac_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.tmp_batch_orgdata, \
|
|
g_stc_xn_init_config.batch_orgdata_len, BATCH_MAX_SIZE, g_stc_xn_init_config.tmp_sm4_batch_mac, NULL);
|
|
if(ret != 0)
|
|
{
|
|
LOG("SYD_SM4Mac_BatchData ret=%08x", ret);
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int xn_sm4_batch_enc(void* handle)
|
|
{
|
|
int ret = 0;
|
|
ret = SYD_SM4_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.tmp_batch_orgdata, \
|
|
g_stc_xn_init_config.batch_orgdata_len, BATCH_MAX_SIZE, SM4_ENCRYPT, \
|
|
g_stc_xn_init_config.tmp_sm4_batch_encdata, g_stc_xn_init_config.sm4_batch_encdata_len);
|
|
if(ret != 0)
|
|
{
|
|
LOG("SYD_SM4_BatchData ret=%08x", ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int xn_sm4_batch_dec(void* handle)
|
|
{
|
|
int ret = 0;
|
|
ret = SYD_SM4_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.tmp_sm4_batch_encdata, \
|
|
g_stc_xn_init_config.sm4_batch_encdata_len, BATCH_MAX_SIZE, SM4_DECRYPT, \
|
|
g_stc_xn_init_config.tmp_sm4_batch_decdata, g_stc_xn_init_config.sm4_batch_decdata_len);
|
|
if(ret != 0)
|
|
{
|
|
LOG("SYD_SM4_BatchData ret=%08x", ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int xn_sm3_short_data(void* handle, unsigned int data_len)
|
|
{
|
|
int ret = 0;
|
|
ret = SYD_SM3_Hash_ShortData(handle, g_org_data, data_len, g_stc_xn_init_config.hash);
|
|
if(ret != 0)
|
|
{
|
|
LOG("SYD_SM3_Hash_ShortData ret=%08x", ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int xn_sm4_enc_short_checkvalue(void* handle, unsigned int data_len)
|
|
{
|
|
int ret = 0;
|
|
unsigned int sm4_short_encdata_len = sizeof(g_stc_xn_init_config.sm4_short_encdata);
|
|
ret = SYD_SM4_Encrypt_Mac_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_stc_xn_init_config.checkidex[0], \
|
|
g_org_data, data_len, g_stc_xn_init_config.sm4_short_encdata, &sm4_short_encdata_len, g_stc_xn_init_config.mac);
|
|
if(ret != 0)
|
|
{
|
|
LOG("SYD_SM4_Encrypt_Mac_ShortData ret=%08x", ret);
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int xn_sm4_dec_short_checkvalue(void* handle)
|
|
{
|
|
int ret = 0;
|
|
unsigned int sm4_short_decdata_len = sizeof(g_stc_xn_init_config.sm4_short_decdata);
|
|
ret = SYD_SM4_Decrypt_Mac_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_stc_xn_init_config.checkidex[0], \
|
|
g_stc_xn_init_config.sm4_short_encdata, g_stc_xn_init_config.sm4_short_encdata_len, g_stc_xn_init_config.sm4_short_checkvalue, \
|
|
g_stc_xn_init_config.sm4_short_decdata, &sm4_short_decdata_len);
|
|
if (ret != 0)
|
|
{
|
|
LOG("SYD_SM4_Decrypt_Mac_ShortData err ret=%08x", ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int xn_sm4_batch_enc_checkvalue(void* handle)
|
|
{
|
|
int ret = 0;
|
|
ret = SYD_SM4_Encrypt_Mac_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.checkidex, \
|
|
g_stc_xn_init_config.tmp_batch_orgdata, g_stc_xn_init_config.batch_orgdata_len, BATCH_MAX_SIZE, \
|
|
g_stc_xn_init_config.tmp_sm4_batch_encdata, g_stc_xn_init_config.sm4_batch_encdata_len, \
|
|
g_stc_xn_init_config.tmp_sm4_batch_checkvalue);
|
|
if (ret != 0)
|
|
{
|
|
LOG("SYD_SM4_Encrypt_Mac_BatchData err ret=%08x", ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int xn_sm4_batch_dec_checkvalue(void* handle)
|
|
{
|
|
int ret = 0;
|
|
ret = SYD_SM4_Decrypt_Mac_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.checkidex, \
|
|
g_stc_xn_init_config.tmp_sm4_batch_encdata, g_stc_xn_init_config.sm4_batch_encdata_len, \
|
|
g_stc_xn_init_config.tmp_sm4_batch_checkvalue, BATCH_MAX_SIZE, g_stc_xn_init_config.tmp_sm4_batch_decdata, \
|
|
g_stc_xn_init_config.sm4_batch_decdata_len, g_stc_xn_init_config.checkret);
|
|
if (ret != 0)
|
|
{
|
|
LOG("SYD_SM4_Decrypt_Mac_BatchData err ret=%08x", ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int command_tps(void* handle, int cmd, int data_len)
|
|
{
|
|
int ret = 0;
|
|
switch(cmd)
|
|
{
|
|
case 0:
|
|
ret = xn_sm4_short_enc(handle, data_len);
|
|
break;
|
|
case 1:
|
|
ret = xn_sm4_short_dec(handle, data_len);
|
|
break;
|
|
case 2:
|
|
ret = xn_sm4_batch_enc(handle);
|
|
break;
|
|
case 3:
|
|
ret = xn_sm4_batch_dec(handle);
|
|
break;
|
|
case 4:
|
|
ret = xn_sm4_short_mac(handle, data_len);
|
|
break;
|
|
case 5:
|
|
ret = xn_sm4_batch_mac(handle);
|
|
break;
|
|
case 6:
|
|
ret = xn_sm3_short_data(handle, data_len);
|
|
break;
|
|
case 7:
|
|
ret = xn_sm4_enc_short_checkvalue(handle, data_len);
|
|
break;
|
|
case 8:
|
|
ret = xn_sm4_dec_short_checkvalue(handle);
|
|
break;
|
|
case 9:
|
|
ret = xn_sm4_batch_enc_checkvalue(handle);
|
|
break;
|
|
case 10:
|
|
ret = xn_sm4_batch_dec_checkvalue(handle);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void *xn_func_tps(void *arg)
|
|
{
|
|
int ret = 0, i = 0;
|
|
long begin = 0, end = 0;
|
|
trd_arg_t *trd_arg = (trd_arg_t *)arg;
|
|
void *conn_handle = NULL;
|
|
const char *iplist[5] = {0};
|
|
int port[5] = {0};
|
|
iplist[0] = DEV_IP;
|
|
port[0] = DEV_PORT;
|
|
ret = SYD_Connect_Ex(iplist, port, 1, CON_TIMEOUT, DEAL_TIMEOUT, 0, &conn_handle);
|
|
if(ret != 0)
|
|
{
|
|
LOG("SYD_Connect_Ex ret=%08x", ret);
|
|
return NULL;
|
|
}
|
|
|
|
begin = GetTime();
|
|
for (i = 0; i < trd_arg->cycle_num; i++)
|
|
{
|
|
ret = command_tps(conn_handle, trd_arg->cmd, trd_arg->data_len);
|
|
if (ret != 0) goto END;
|
|
}
|
|
end = GetTime() - begin;
|
|
LOG_MSG("笔数=%d|总用时:%ld(us)|单笔用时:%ld(us)", trd_arg->cycle_num, end, (end/trd_arg->cycle_num));
|
|
|
|
pthread_mutex_lock(&g_time_mutex);
|
|
printf("g_thread_count=%d\n", g_thread_count);
|
|
g_all_time[g_thread_count] = end;
|
|
g_all_average_time[g_thread_count] = (end/trd_arg->cycle_num);
|
|
g_thread_count++;
|
|
pthread_mutex_unlock(&g_time_mutex);
|
|
|
|
END:
|
|
if (ret == 0)
|
|
LOG_MSG("CMD:%d ok", trd_arg->cmd);
|
|
else
|
|
LOG_MSG("CMD:%d fail", trd_arg->cmd);
|
|
|
|
ret = SYD_DisConnect_Ex(conn_handle);
|
|
if(ret != 0)
|
|
{
|
|
LOG("SYD_DisConnect_Ex ret=%08x", ret);
|
|
return NULL;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int xn_cmd_tps()
|
|
{
|
|
int ret = 0;
|
|
float all_time = 0, all_average_time = 0, tps = 0;
|
|
int i = 0, cmd = 0;
|
|
long thread_count = 0, run_count = 0;
|
|
pthread_t pthid[1000];
|
|
trd_arg_t trd_arg;
|
|
memset(&trd_arg, 0, sizeof(trd_arg_t));
|
|
IniOrgData(g_org_data, 9000, 1);
|
|
pthread_mutex_init(&g_time_mutex, NULL);
|
|
|
|
while(1)
|
|
{
|
|
LOG_MSG("/-------性能测试TPS------/");
|
|
LOG_MSG("0:SM4短数据加密");
|
|
LOG_MSG("1:SM4短数据解密 ");
|
|
LOG_MSG("2:SM4批量加密 ");
|
|
LOG_MSG("3:SM4批量解密 ");
|
|
LOG_MSG("4:SM4-MAC短数据 ");
|
|
LOG_MSG("5:SM4-MAC批量数据 ");
|
|
LOG_MSG("6:SM3短数据");
|
|
LOG_MSG("7:SM4短数据加密&校验值");
|
|
LOG_MSG("8:SM4短数据解密&校验值");
|
|
LOG_MSG("9:SM4批量数据加密&校验值");
|
|
LOG_MSG("10:SM4批量数据解密&校验值");
|
|
LOG_MSG("100:退出");
|
|
LOG_MSG("请选择测试项:");
|
|
scanf("%d", &trd_arg.cmd);
|
|
if(trd_arg.cmd == 100) goto END;
|
|
LOG_MSG("请输入线程数:");
|
|
scanf("%ld", &thread_count);
|
|
LOG_MSG("请输入循环笔数:");
|
|
scanf("%ld", &run_count);
|
|
LOG_MSG("请输入数据长度:");
|
|
scanf("%d", &trd_arg.data_len);
|
|
trd_arg.cycle_num = run_count / thread_count;
|
|
g_thread_count = 0;
|
|
|
|
ret = xn_tps_init_data(trd_arg.data_len);
|
|
if(ret != 0)
|
|
{
|
|
LOG("xn_tps_init_data err");
|
|
goto END;
|
|
}
|
|
|
|
for (i = 0; i < thread_count; i++)
|
|
{
|
|
ret = pthread_create(&pthid[i], NULL, xn_func_tps, (void *)&trd_arg);
|
|
if(ret)
|
|
{
|
|
LOG("Fail to create thread %d", (int)pthid[i]);
|
|
goto END;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < thread_count; i++)
|
|
{
|
|
ret = pthread_join(pthid[i], NULL);
|
|
if(ret)
|
|
{
|
|
LOG("thread %d join failed\n", (int)pthid[i]);
|
|
goto END;
|
|
}
|
|
}
|
|
|
|
/*计算总时间*/
|
|
all_time = 0;
|
|
all_average_time = 0;
|
|
for(i = 0; i < g_thread_count; i++)
|
|
{
|
|
all_time += g_all_time[i];
|
|
all_average_time += g_all_average_time[i];
|
|
}
|
|
|
|
if(all_time == 0)
|
|
{
|
|
all_time = 1;
|
|
}
|
|
|
|
if(all_average_time == 0)
|
|
{
|
|
all_average_time = 1;
|
|
}
|
|
/*****平均时间*****/
|
|
tps = (run_count * 1000000) / (all_time / thread_count);
|
|
LOG_MSG("[指令:%d] [笔数:%ld] [线程数:%ld] [总用时:%f(us)] [TPS:%f] [平均延时:%f(ms)]", \
|
|
trd_arg.cmd, run_count, thread_count, (all_time / thread_count), tps, ((all_average_time / thread_count) / 1000));
|
|
}
|
|
|
|
END:
|
|
pthread_mutex_destroy(&g_time_mutex);
|
|
return 0;
|
|
} |