1449 lines
40 KiB
C
1449 lines
40 KiB
C
#ifndef _DEMO_API_H_
|
||
#include "demo_api.h"
|
||
#endif
|
||
|
||
#define SM4_BATCH_NUM 4
|
||
#define SM4_MAC_BATCH_NUM 4
|
||
|
||
static const char g_cHexToAsc1[] = "0123456789ABCDEF";
|
||
|
||
static int g_iTable_ASC_HEX[] =
|
||
{
|
||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
||
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
||
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
|
||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
||
0x40, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
|
||
};
|
||
/*乱序*/
|
||
void IniOrgData(char *pcData, int iOrgDataLen, int k)
|
||
{
|
||
int i = 0;
|
||
for (i = 0; i < iOrgDataLen; i++, k++)
|
||
{
|
||
memset(pcData + i, k, 1);
|
||
if (k == 9)
|
||
{
|
||
k = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
void PrintHex(const char* Title, unsigned char* Data, int DataLen)
|
||
{
|
||
int i;
|
||
printf("[%s][len=%d]:", Title, DataLen);
|
||
for (i = 0; i < DataLen; i++)
|
||
{
|
||
if (!(i % 16)) printf("\n ");
|
||
printf(" %02X", Data[i]);
|
||
}
|
||
printf("\n");
|
||
}
|
||
|
||
void HexToBin(int iLen, unsigned char* pucInBuf, unsigned char* pucOutBuf)
|
||
{
|
||
for (; iLen > 0; iLen -= 2, pucInBuf += 2)
|
||
{
|
||
(*pucOutBuf++) = (g_iTable_ASC_HEX[(*pucInBuf)] << 4) | g_iTable_ASC_HEX[*(pucInBuf + 1)];
|
||
}
|
||
}
|
||
|
||
void BinToHex(int iLen, unsigned char* pucInBuf, unsigned char* pucOutBuf)
|
||
{
|
||
for (; iLen > 0; iLen--)
|
||
{
|
||
(*pucOutBuf++) = g_cHexToAsc1[((*pucInBuf) >> 4) & 0xf];
|
||
(*pucOutBuf++) = g_cHexToAsc1[(*pucInBuf++) & 0xf];
|
||
}
|
||
}
|
||
|
||
//精确到微秒
|
||
int us_difftime(struct timeval start_time, struct timeval end_time)
|
||
{
|
||
long start = start_time.tv_sec * 1000000 + start_time.tv_usec;
|
||
long end = end_time.tv_sec * 1000000 + end_time.tv_usec;
|
||
return end - start;
|
||
}
|
||
|
||
//精确到微秒
|
||
int ms_difftime(struct timeval start_time, struct timeval end_time)
|
||
{
|
||
long start = start_time.tv_sec * 1000 + start_time.tv_usec * 0.001;
|
||
long end = end_time.tv_sec * 1000 + end_time.tv_usec * 0.001;
|
||
return end - start;
|
||
}
|
||
|
||
int SM4_ShortData_Test(void *hHandle)
|
||
{
|
||
int iRet = 0, i = 0;
|
||
char cEncData[4096 + 16] = {0};
|
||
int iEncDataLen = 0;
|
||
char cDecData[4096 + 16] = {0};
|
||
int iDecDataLen = 0;
|
||
char cOrgData[4096] = { 0 };
|
||
IniOrgData(cOrgData, 2048, 1);
|
||
|
||
for(i = 1; i <= 1024; i++)
|
||
{
|
||
iEncDataLen = i + 16;
|
||
iRet = SYD_SM4_ShortData(hHandle, KEYINDEX, cOrgData, i, SM4_ENCRYPT, cEncData, &iEncDataLen);
|
||
if(iRet != 0)
|
||
{
|
||
LOG("SYD_SM4_ShortData ret=%08x, i=%d", iRet, i);
|
||
return iRet;
|
||
}
|
||
|
||
iDecDataLen = i;
|
||
iRet = SYD_SM4_ShortData(hHandle, KEYINDEX, cEncData, iEncDataLen, SM4_DECRYPT, cDecData, &iDecDataLen);
|
||
if(iRet != 0)
|
||
{
|
||
LOG("SYD_SM4_ShortData ret=%08x, i=%d", iRet, i);
|
||
return iRet;
|
||
}
|
||
|
||
if(iDecDataLen != i)
|
||
{
|
||
LOG("iDecDataLen(%d) != (%d)", iDecDataLen, i);
|
||
return -1;
|
||
}
|
||
|
||
if(memcmp(cDecData, cOrgData, i))
|
||
{
|
||
LOG("memcmp err i=%d", i);
|
||
return -1;
|
||
}
|
||
printf("i=%d\r", i);
|
||
fflush(stdout);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM4_BatchData_Test(void *hHandle)
|
||
{
|
||
int ret = 0, i = 0, j = 0, k = 0, iBatchNum = 0;
|
||
int iKeyIdex[SM4_BATCH_NUM] = {0};
|
||
char cEncData[SM4_BATCH_NUM][2048 + 16] = {{0}};
|
||
int iEncDataLen[SM4_BATCH_NUM] = {0};
|
||
char cDecData[SM4_BATCH_NUM][4096 + 16] = {{0}};
|
||
int iDecDataLen[SM4_BATCH_NUM] = {0};
|
||
char cOrgData[SM4_BATCH_NUM][2048] = {{0}};
|
||
int iOrgDataLen[SM4_BATCH_NUM] = {0};
|
||
char *pTmpOrgData[SM4_BATCH_NUM] = {0};
|
||
int iTmpOrgDataLen[SM4_BATCH_NUM] = {0};
|
||
char *pTmpEncData[SM4_BATCH_NUM] = {0};
|
||
char *pTmpDecData[SM4_BATCH_NUM] = {0};
|
||
|
||
for(i = 0; i < SM4_BATCH_NUM; i++)
|
||
{
|
||
IniOrgData(cOrgData[i], 2048, i);
|
||
iKeyIdex[i] = KEYINDEX;
|
||
pTmpOrgData[i] = cOrgData[i];
|
||
pTmpEncData[i] = cEncData[i];
|
||
pTmpDecData[i] = cDecData[i];
|
||
}
|
||
|
||
for(i = 1; i <= 1024; i++)
|
||
{
|
||
for(j = 0; j < SM4_BATCH_NUM; j++)
|
||
{
|
||
iTmpOrgDataLen[j] = i;
|
||
iEncDataLen[j] = i + 16;
|
||
iDecDataLen[j] = i;
|
||
}
|
||
|
||
/* 特殊测试 pcData为NULL测试 */
|
||
ret = SYD_SM4_BatchData(hHandle, iKeyIdex, NULL, iTmpOrgDataLen, SM4_BATCH_NUM, SM4_ENCRYPT, pTmpEncData, iEncDataLen);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4_BatchData ret=%08x, i=%d", ret, i);
|
||
return ret;
|
||
}
|
||
|
||
/* 特殊测试 iSize为0测试 */
|
||
ret = SYD_SM4_BatchData(hHandle, iKeyIdex, pTmpOrgData, iTmpOrgDataLen, 0, SM4_ENCRYPT, pTmpEncData, iEncDataLen);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4_BatchData ret=%08x, i=%d", ret, i);
|
||
return ret;
|
||
}
|
||
|
||
ret = SYD_SM4_BatchData(hHandle, iKeyIdex, pTmpOrgData, iTmpOrgDataLen, SM4_BATCH_NUM, SM4_ENCRYPT, pTmpEncData, iEncDataLen);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4_BatchData ret=%08x, i=%d", ret, i);
|
||
return ret;
|
||
}
|
||
|
||
ret = SYD_SM4_BatchData(hHandle, iKeyIdex, pTmpEncData, iEncDataLen, SM4_BATCH_NUM, SM4_DECRYPT, pTmpDecData, iDecDataLen);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4_BatchData ret=%08x, i=%d", ret, i);
|
||
return ret;
|
||
}
|
||
|
||
for(j = 0; j < SM4_BATCH_NUM; j++)
|
||
{
|
||
if(iDecDataLen[j] != i)
|
||
{
|
||
LOG("iDecDataLen[%d](%d) != (%d)", j, iDecDataLen[j], i);
|
||
return -1;
|
||
}
|
||
|
||
if(memcmp(pTmpDecData[j], pTmpOrgData[j], i))
|
||
{
|
||
LOG("memcmp err i=%d, j=%d", i, j);
|
||
return -1;
|
||
}
|
||
}
|
||
printf("i=%d\r", i);
|
||
fflush(stdout);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM4_LongData_Test_Special(void *hHandle)
|
||
{
|
||
int ret = 0;
|
||
char bEncData[9000] = { 0 };
|
||
int ulEncDataLen = 9000;
|
||
char bDecData[9000] = { 0 };
|
||
int ulDecDataLen = 0;
|
||
int ulDecDataLen1 = 0;
|
||
void *hEncProchandle = NULL;
|
||
void *hDecProchandle = NULL;
|
||
/*1、0长度数据测试*/
|
||
ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_ENCRYPT, &hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataInit, ret=%08x", ret);
|
||
return ret;
|
||
}
|
||
|
||
ret = SYD_SM4_LongDataFinal(hHandle, bEncData, &ulEncDataLen, hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataFinal ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_DECRYPT, &hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataInit, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
ret = SYD_SM4_LongDataUpdate(hHandle, bEncData, ulEncDataLen, bDecData, &ulDecDataLen, hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataUpdate, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
ret = SYD_SM4_LongDataFinal(hHandle, bDecData, &ulDecDataLen1, hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataFinal ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
if(ulDecDataLen != 0)
|
||
{
|
||
LOG("ulDecDataLen != 0");
|
||
goto END;
|
||
}
|
||
END:
|
||
SYD_CloseHandle(hEncProchandle);
|
||
SYD_CloseHandle(hDecProchandle);
|
||
return 0;
|
||
}
|
||
|
||
int SM4_LongData_Test(void *hHandle)
|
||
{
|
||
int ret = 0;
|
||
int k = 0, iEncDecNum = 10240, iSymSingleBytes = 0;
|
||
int ulDataLen = 0;
|
||
char bEncData[10240 + 16] = { 0 };
|
||
int ulEncDataLen = 0;
|
||
char* pbEncTemp = NULL;
|
||
int ulTempEncLen = 0;
|
||
char bDecData[10240] = { 0 };
|
||
int ulDecDataLen = 0;
|
||
char* pbDecTemp = NULL;
|
||
int ulTempDecLen = 0;
|
||
void *hEncProchandle = NULL;
|
||
void *hDecProchandle = NULL;
|
||
|
||
char cOrgData[10240] = {0};
|
||
IniOrgData(cOrgData, 10240, 1);
|
||
|
||
for (iSymSingleBytes = 1; iSymSingleBytes <= 6144; iSymSingleBytes++)
|
||
{
|
||
/*加密*/
|
||
ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_ENCRYPT, &hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataInit, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
pbEncTemp = bEncData;
|
||
for (k = 0; k < iEncDecNum / iSymSingleBytes; k++)
|
||
{
|
||
ulEncDataLen = 10240;
|
||
ret = SYD_SM4_LongDataUpdate(hHandle, cOrgData + (k * iSymSingleBytes), iSymSingleBytes, pbEncTemp, &ulEncDataLen, hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
ulTempEncLen += ulEncDataLen;
|
||
pbEncTemp += ulEncDataLen;
|
||
}
|
||
|
||
if (iEncDecNum % iSymSingleBytes != 0)
|
||
{
|
||
ulEncDataLen = 10240;
|
||
ret = SYD_SM4_LongDataUpdate(hHandle, cOrgData + (iEncDecNum - (iEncDecNum % iSymSingleBytes)), iEncDecNum % iSymSingleBytes, pbEncTemp, &ulEncDataLen, hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataUpdate ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
ulTempEncLen += ulEncDataLen;
|
||
pbEncTemp += ulEncDataLen;
|
||
}
|
||
|
||
ulEncDataLen = 10240;
|
||
ret = SYD_SM4_LongDataFinal(hHandle, pbEncTemp, &ulEncDataLen, hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataFinal ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
ulTempEncLen += ulEncDataLen;
|
||
|
||
/*解密*/
|
||
ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_DECRYPT, &hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataInit, ulRet=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
pbDecTemp = bDecData;
|
||
for (k = 0; k < ulTempEncLen / iSymSingleBytes; k++)
|
||
{
|
||
ulDecDataLen = 10240;
|
||
ret = SYD_SM4_LongDataUpdate(hHandle, bEncData + (k * iSymSingleBytes), iSymSingleBytes, pbDecTemp, &ulDecDataLen, hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
ulTempDecLen += ulDecDataLen;
|
||
pbDecTemp += ulDecDataLen;
|
||
}
|
||
|
||
if (ulTempEncLen % iSymSingleBytes != 0)
|
||
{
|
||
ulDecDataLen = 10240;
|
||
ret = SYD_SM4_LongDataUpdate(hHandle, bEncData + (ulTempEncLen - (ulTempEncLen % iSymSingleBytes)), ulTempEncLen % iSymSingleBytes, pbDecTemp, &ulDecDataLen, hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SKF_DecryptUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
ulTempDecLen += ulDecDataLen;
|
||
pbDecTemp += ulDecDataLen;
|
||
}
|
||
|
||
ulDecDataLen = 10240;
|
||
ret = SYD_SM4_LongDataFinal(hHandle, pbDecTemp, &ulDecDataLen, hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SKF_DecryptFinal ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
ulTempDecLen += ulDecDataLen;
|
||
|
||
SYD_CloseHandle(hEncProchandle);
|
||
SYD_CloseHandle(hDecProchandle);
|
||
|
||
if (ulTempDecLen != iEncDecNum)
|
||
{
|
||
LOG("iSymSingleBytes=%d, ulTempDecLen=%d", iSymSingleBytes, ulTempDecLen);
|
||
return 0;
|
||
}
|
||
|
||
if (memcmp(cOrgData, bDecData, ulTempDecLen))
|
||
{
|
||
LOG("memcmp iSymSingleBytes=%d, ulTempDecLen=%d", iSymSingleBytes, ulTempDecLen);
|
||
return 0;
|
||
}
|
||
memset(bEncData, 0, sizeof(bEncData));
|
||
memset(bDecData, 0, sizeof(bDecData));
|
||
ulTempEncLen = 0;
|
||
ulTempDecLen = 0;
|
||
printf("count: %d\r", iSymSingleBytes);
|
||
fflush(stdout);
|
||
}
|
||
END:
|
||
if(ret != 0)
|
||
{
|
||
SYD_CloseHandle(hEncProchandle);
|
||
SYD_CloseHandle(hDecProchandle);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM3_ShortHash_Test(void *hHandle)
|
||
{
|
||
int ret = 0;
|
||
char cOrgData[2048] = {0};
|
||
int iOrgDataLen = 0;
|
||
char cHash[33] = {0};
|
||
IniOrgData(cOrgData, 2048, 1);
|
||
for(iOrgDataLen = 0; iOrgDataLen <= 1024; iOrgDataLen++)
|
||
{
|
||
ret = SYD_SM3_Hash_ShortData(hHandle, cOrgData, iOrgDataLen, cHash);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_ShortData ret=%08x", ret);
|
||
return 0;
|
||
}
|
||
printf("iOrgDataLen=%d\r", iOrgDataLen);
|
||
fflush(stdout);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM3_LongHash_Test_Special(void *hHandle)
|
||
{
|
||
int ret = 0;
|
||
void* hHash = NULL;
|
||
char cOrgData[256] = {0};
|
||
char cHash[33] = {0};
|
||
ret = SYD_SM3_Hash_Init(&hHash);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Init ret=%08x", ret);
|
||
return ret;
|
||
}
|
||
|
||
ret = SYD_SM3_Hash_Final(hHandle, cHash, hHash);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Final ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
PrintHex("cHash", cHash, 32);
|
||
SYD_CloseHandle(hHash);
|
||
|
||
ret = SYD_SM3_Hash_Init(&hHash);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Init ret=%08x", ret);
|
||
return ret;
|
||
}
|
||
|
||
ret = SYD_SM3_Hash_Update(hHandle, cOrgData, 0, hHash);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Update ret=%08x", ret);
|
||
return ret;
|
||
}
|
||
|
||
ret = SYD_SM3_Hash_Final(hHandle, cHash, hHash);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Final ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
PrintHex("cHash", cHash, 32);
|
||
SYD_CloseHandle(hHash);
|
||
END:
|
||
if(ret != 0)
|
||
{
|
||
SYD_CloseHandle(hHash);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM3_LongHash_Test(void *hHandle)
|
||
{
|
||
int ulRet = 0, i = 0, num = 0;
|
||
void* hHash = NULL;
|
||
char bHash[32] = { 0 }, bTmpHash[32] = { 0 };
|
||
int ulHashLen = 0, ulTmpHashLen = 0;
|
||
int ulHashBytes = 0, ulMultBytes = 0;
|
||
char cOrgData[9000] = {0};
|
||
IniOrgData(cOrgData, 9000, 1);
|
||
for (ulHashBytes = 1; ulHashBytes <= 64; ulHashBytes++)
|
||
{
|
||
for (ulMultBytes = 1; ulMultBytes < ulHashBytes + 1; ulMultBytes++)
|
||
{
|
||
/*带公钥的HASH*/
|
||
ulRet = SYD_SM3_Hash_Init(&hHash);
|
||
if (ulRet != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Init ulRet=%08x", ulRet);
|
||
return ulRet;
|
||
}
|
||
|
||
for (i = 0; i < ulHashBytes / ulMultBytes; i++)
|
||
{
|
||
ulRet = SYD_SM3_Hash_Update(hHandle, cOrgData + (i * ulMultBytes), ulMultBytes, hHash);
|
||
if (ulRet != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Update ulRet=%08x", ulRet);
|
||
goto END;
|
||
}
|
||
}
|
||
|
||
if (ulHashBytes % ulMultBytes != 0)
|
||
{
|
||
ulRet = SYD_SM3_Hash_Update(hHandle, cOrgData + (ulHashBytes - (ulHashBytes % ulMultBytes)), ulHashBytes % ulMultBytes, hHash);
|
||
if (ulRet != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Update ulRet=%08x", ulRet);
|
||
goto END;
|
||
}
|
||
}
|
||
|
||
ulRet = SYD_SM3_Hash_Final(hHandle, bHash, hHash);
|
||
if (ulRet != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Final ulRet=%08x", ulRet);
|
||
goto END;
|
||
}
|
||
SYD_CloseHandle(hHash);
|
||
|
||
ulRet = SYD_SM3_Hash_ShortData(hHandle, cOrgData, ulHashBytes, bTmpHash);
|
||
if(ulRet != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_ShortData ulRet=%08x", ulRet);
|
||
return 0;
|
||
}
|
||
|
||
if (memcmp(bTmpHash, bHash, 32))
|
||
{
|
||
LOG("memcmp err");
|
||
return 0;
|
||
}
|
||
}
|
||
printf("ulHashBytes=%d\r", ulHashBytes);
|
||
fflush(stdout);
|
||
}
|
||
|
||
END:
|
||
if (ulRet != 0)
|
||
{
|
||
SYD_CloseHandle(hHash);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM4Mac_ShortData(void *hHandle)
|
||
{
|
||
int ret = 0;
|
||
char cOrgData[2048] = {0};
|
||
int iOrgDataLen = 0;
|
||
char cMac[33] = {0};
|
||
IniOrgData(cOrgData, 2048, 1);
|
||
|
||
/*1、未校验MAC*/
|
||
for(iOrgDataLen = 0; iOrgDataLen <= 1024; iOrgDataLen++)
|
||
{
|
||
ret = SYD_SM4Mac_ShortData(hHandle, KEYINDEX, cOrgData, iOrgDataLen, cMac, NULL);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_ShortData ret=%08x", ret);
|
||
return 0;
|
||
}
|
||
printf("iOrgDataLen=%d\r", iOrgDataLen);
|
||
fflush(stdout);
|
||
}
|
||
|
||
/*2、校验MAC*/
|
||
int iCheckRet = -1;
|
||
/*
|
||
*注意：手算校验值时不要忘记填充值也是原始数据的一部分
|
||
*这里用的密钥分量为
|
||
分量1:31313131313131313131313131313131
|
||
分量2:32323232323232323232323232323232
|
||
合成后的分量:03030303030303030303030303030303
|
||
*/
|
||
|
||
char cCheckMac[] = "A3B596312F67832C4F8B74F8E68FD394";
|
||
HexToBin(32, cCheckMac, cMac);
|
||
ret = SYD_SM4Mac_ShortData(hHandle, KEYINDEX, cOrgData, 32, cMac, &iCheckRet);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_ShortData ret=%08x", ret);
|
||
return 0;
|
||
}
|
||
|
||
if(iCheckRet != 0)
|
||
{
|
||
LOG("mac check err iCheckRet=%08x\n", iCheckRet);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM4Mac_BatchData(void *hHandle)
|
||
{
|
||
int ret = 0, i = 0, j = 0;
|
||
int iKeyIdex[SM4_MAC_BATCH_NUM] = {0};
|
||
int iCheckRet[SM4_MAC_BATCH_NUM] = {0};
|
||
char cOrgData[SM4_MAC_BATCH_NUM][2048] = {{0}};
|
||
int iOrgDataLen[SM4_MAC_BATCH_NUM] = {0};
|
||
char cMac[SM4_MAC_BATCH_NUM][33] = {{0}};
|
||
char *pTmpMac[SM4_MAC_BATCH_NUM] = {0};
|
||
char *pTmpOrgData[SM4_MAC_BATCH_NUM] = {0};
|
||
|
||
for(i = 0; i < SM4_MAC_BATCH_NUM; i++)
|
||
{
|
||
IniOrgData(cOrgData[i], 2048, i);
|
||
iKeyIdex[i] = KEYINDEX;
|
||
pTmpOrgData[i] = cOrgData[i];
|
||
pTmpMac[i] = cMac[i];
|
||
}
|
||
|
||
/*不校验MAC*/
|
||
for(i = 1; i <= 1024; i++)
|
||
{
|
||
for(j = 0; j < SM4_MAC_BATCH_NUM; j++)
|
||
{
|
||
iOrgDataLen[j] = i;
|
||
}
|
||
|
||
/* 特殊测试 pcData为NULL*/
|
||
ret = SYD_SM4Mac_BatchData(hHandle, iKeyIdex, NULL, iOrgDataLen, SM4_MAC_BATCH_NUM, pTmpMac, NULL);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_BatchData ret=%08x", ret);
|
||
return 0;
|
||
}
|
||
|
||
/* 特殊测试 iSize为0 */
|
||
ret = SYD_SM4Mac_BatchData(hHandle, iKeyIdex, pTmpOrgData, iOrgDataLen, 0, pTmpMac, NULL);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_BatchData ret=%08x", ret);
|
||
return 0;
|
||
}
|
||
|
||
ret = SYD_SM4Mac_BatchData(hHandle, iKeyIdex, pTmpOrgData, iOrgDataLen, SM4_MAC_BATCH_NUM, pTmpMac, NULL);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_BatchData ret=%08x", ret);
|
||
return 0;
|
||
}
|
||
printf("i=%d\r", i);
|
||
fflush(stdout);
|
||
}
|
||
|
||
/*校验MAC*/
|
||
char cCheckMac[10][33] = {0};
|
||
char cCheckMac_Bin[10][17] = {0};
|
||
strcpy(cCheckMac[0], "4A590763CFD67F045BE26A7570D8FDB1");
|
||
strcpy(cCheckMac[1], "7CEDAE1E836889962F8C06C0501613F8");
|
||
strcpy(cCheckMac[2], "60F34B352AB359A3109C3C7A343BA881");
|
||
strcpy(cCheckMac[3], "2A6600B4397FA5331F7310DBECE475EE");
|
||
|
||
for(j = 0; j < SM4_MAC_BATCH_NUM; j++)
|
||
{
|
||
iOrgDataLen[j] = 1;
|
||
HexToBin(32, cCheckMac[j], cCheckMac_Bin[j]);
|
||
pTmpMac[j] = cCheckMac_Bin[j];
|
||
}
|
||
|
||
memset(iCheckRet, '1', sizeof(iCheckRet));
|
||
ret = SYD_SM4Mac_BatchData(hHandle, iKeyIdex, pTmpOrgData, iOrgDataLen, SM4_MAC_BATCH_NUM, pTmpMac, iCheckRet);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_BatchData ret=%08x", ret);
|
||
return 0;
|
||
}
|
||
|
||
for(j = 0; j < SM4_MAC_BATCH_NUM; j++)
|
||
{
|
||
if(iCheckRet[j] != 0)
|
||
{
|
||
LOG("mac check err iCheckRet[%d]=%08x\n", j, iCheckRet[j]);
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM4Mac_LongData_Special(void *hHandle)
|
||
{
|
||
int ret = 0;
|
||
char cData[16] = {0};
|
||
char cMac[64] = {0};
|
||
void *hMacProchandle = NULL;
|
||
ret = SYD_SM4Mac_LongDataInit(KEYINDEX, &hMacProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_LongDataInit, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
ret = SYD_SM4Mac_LongDataUpdate(hHandle, cData, 0, hMacProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_LongDataUpdate, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
ret = SYD_SM4Mac_LongDataFinal(hHandle, cMac, NULL, hMacProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_LongDataFinal ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
SYD_CloseHandle(hMacProchandle);
|
||
PrintHex("cMac", cMac, 64);
|
||
END:
|
||
if(ret != 0)
|
||
{
|
||
SYD_CloseHandle(hMacProchandle);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM4Mac_LongData(void *hHandle)
|
||
{
|
||
int ret = 0;
|
||
int k = 0, iEncDecNum = 10240, iSymSingleBytes = 0;
|
||
char cCheckMac[64] = {0};
|
||
char cMac[64] = {0};
|
||
void *hMacProchandle = NULL;
|
||
char cOrgData[10240] = {0};
|
||
IniOrgData(cOrgData, 10240, 1);
|
||
char mac_hex[] = "9222B9CDFBCF1F75469A118762F415C9";
|
||
char mac_bin[32] = {0};
|
||
HexToBin(32, mac_hex, mac_bin);
|
||
for (iSymSingleBytes = 1; iSymSingleBytes <= 6144; iSymSingleBytes++)
|
||
{
|
||
ret = SYD_SM4Mac_LongDataInit(KEYINDEX, &hMacProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_LongDataInit, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
for (k = 0; k < iEncDecNum / iSymSingleBytes; k++)
|
||
{
|
||
ret = SYD_SM4Mac_LongDataUpdate(hHandle, cOrgData + (k * iSymSingleBytes), iSymSingleBytes, hMacProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_LongDataUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
}
|
||
|
||
if (iEncDecNum % iSymSingleBytes != 0)
|
||
{
|
||
ret = SYD_SM4Mac_LongDataUpdate(hHandle, cOrgData + (iEncDecNum - (iEncDecNum % iSymSingleBytes)), iEncDecNum % iSymSingleBytes, hMacProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_LongDataUpdate ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
}
|
||
|
||
ret = SYD_SM4Mac_LongDataFinal(hHandle, cMac, NULL, hMacProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_LongDataFinal ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
SYD_CloseHandle(hMacProchandle);
|
||
|
||
if(memcmp(cMac, mac_bin, 16))
|
||
{
|
||
LOG("memcmp err iSymSingleBytes=%d", iSymSingleBytes);
|
||
PrintHex("mac_bin", mac_bin, 32);
|
||
PrintHex("cMac", cMac, 32);
|
||
goto END;
|
||
}
|
||
printf("count: %d\r", iSymSingleBytes);
|
||
fflush(stdout);
|
||
}
|
||
END:
|
||
if(ret != 0)
|
||
{
|
||
SYD_CloseHandle(hMacProchandle);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM4_ShortData_CheckValue(void *hHandle)
|
||
{
|
||
int ret = 0, i = 0;
|
||
char cMac[33] = {0};
|
||
char cOrgData[2048] = { 0 };
|
||
IniOrgData(cOrgData, 2048, 1);
|
||
char cEncryptData[2048] = {0};
|
||
int iEncryptDataLen = 0;
|
||
char cCheckValue[17] = {0};
|
||
char cDecryptData[2048] = {0};
|
||
int iDecryptDataLen = 0;
|
||
char cErrMac[] = "1234567812345678";
|
||
|
||
for(i = 1; i <= 1024; i++)
|
||
{
|
||
iEncryptDataLen = i + 16;
|
||
ret = SYD_SM4_Encrypt_Mac_ShortData(hHandle, KEYINDEX, CHECKINDEX, cOrgData, i, \
|
||
cEncryptData, &iEncryptDataLen, cCheckValue);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_Encrypt_Mac_ShortData ret=%08x", ret);
|
||
return ret;
|
||
}
|
||
|
||
iDecryptDataLen = sizeof(cDecryptData);
|
||
ret = SYD_SM4_Decrypt_Mac_ShortData(hHandle, KEYINDEX, CHECKINDEX, \
|
||
cEncryptData, iEncryptDataLen, cCheckValue, cDecryptData, &iDecryptDataLen);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_Decrypt_Mac_ShortData ret=%08x", ret);
|
||
return ret;
|
||
}
|
||
|
||
if(iDecryptDataLen != i)
|
||
{
|
||
LOG("iDecryptDataLen(%d) != (%d)", iDecryptDataLen, i);
|
||
return -1;
|
||
}
|
||
|
||
if(memcmp(cDecryptData, cOrgData, iDecryptDataLen))
|
||
{
|
||
LOG("memcmp err i=%d", i);
|
||
return -1;
|
||
}
|
||
|
||
/* 错误场景,输入错误的MAC值 */
|
||
iDecryptDataLen = sizeof(cDecryptData);
|
||
ret = SYD_SM4_Decrypt_Mac_ShortData(hHandle, KEYINDEX, CHECKINDEX, \
|
||
cEncryptData, iEncryptDataLen, cErrMac, cDecryptData, &iDecryptDataLen);
|
||
if (ret != 0x01000010)
|
||
{
|
||
LOG("SYD_SM4_Decrypt_Mac_ShortData ret=%08x", ret);
|
||
return ret;
|
||
}
|
||
printf("iOrgDataLen=%d\r", i);
|
||
fflush(stdout);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM4_BatchData_CheckValue(void *hHandle)
|
||
{
|
||
int ret = 0, i = 0, j = 0;
|
||
int iEncKeyIdex[SM4_BATCH_NUM] = {0};
|
||
int iCheckKeyIdex[SM4_BATCH_NUM] = {0};
|
||
char cOrgData[SM4_BATCH_NUM][2048] = {{0}};
|
||
int iOrgDataLen[SM4_BATCH_NUM] = {0};
|
||
char cEncData[SM4_BATCH_NUM][1024 + 16] = {{0}};
|
||
int iEncDataLen[SM4_BATCH_NUM] = {0};
|
||
char cDecData[SM4_BATCH_NUM][1024] = {{0}};
|
||
int iDecDataLen[SM4_BATCH_NUM] = {0};
|
||
char cCheckValue[SM4_BATCH_NUM][17] = {0};
|
||
char *pTmpOrgData[SM4_BATCH_NUM] = {0};
|
||
char *pTmpEncData[SM4_BATCH_NUM] = {0};
|
||
char *pTmpDecData[SM4_BATCH_NUM] = {0};
|
||
char *pTmpCheckValue[SM4_BATCH_NUM] = {0};
|
||
char cErrMac[SM4_BATCH_NUM][17] = {0};
|
||
char *pTmpErrMac[SM4_BATCH_NUM] = {0};
|
||
int iCheckRet[SM4_MAC_BATCH_NUM] = {0};
|
||
|
||
for(i = 0; i < SM4_BATCH_NUM; i++)
|
||
{
|
||
IniOrgData(cOrgData[i], 2048, i);
|
||
iEncKeyIdex[i] = KEYINDEX;
|
||
iCheckKeyIdex[i] = CHECKINDEX;
|
||
pTmpOrgData[i] = cOrgData[i];
|
||
pTmpEncData[i] = cEncData[i];
|
||
pTmpDecData[i] = cDecData[i];
|
||
pTmpCheckValue[i] = cCheckValue[i];
|
||
memcpy(cErrMac[i], "1234567812345678", 16);
|
||
pTmpErrMac[i] = cErrMac[i];
|
||
}
|
||
|
||
for(i = 1; i <= 1024; i++)
|
||
{
|
||
for(j = 0; j < SM4_BATCH_NUM; j++)
|
||
{
|
||
iOrgDataLen[j] = i;
|
||
iEncDataLen[j] = i + 16;
|
||
iDecDataLen[j] = i;
|
||
iCheckRet[j] = 1;
|
||
}
|
||
|
||
/* 特殊测试pcData为NULL */
|
||
ret = SYD_SM4_Encrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, NULL, iOrgDataLen, \
|
||
SM4_BATCH_NUM, pTmpEncData, iEncDataLen, pTmpCheckValue);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4_Encrypt_Mac_BatchData ret=%08x, i=%d", ret, i);
|
||
return ret;
|
||
}
|
||
|
||
/* 特殊测试iSize为0 */
|
||
ret = SYD_SM4_Encrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, pTmpOrgData, iOrgDataLen, \
|
||
0, pTmpEncData, iEncDataLen, pTmpCheckValue);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4_Encrypt_Mac_BatchData ret=%08x, i=%d", ret, i);
|
||
return ret;
|
||
}
|
||
|
||
ret = SYD_SM4_Encrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, pTmpOrgData, iOrgDataLen, \
|
||
SM4_BATCH_NUM, pTmpEncData, iEncDataLen, pTmpCheckValue);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4_Encrypt_Mac_BatchData ret=%08x, i=%d", ret, i);
|
||
return ret;
|
||
}
|
||
|
||
/* 特殊测试pcData为NULL */
|
||
ret = SYD_SM4_Decrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, NULL, iEncDataLen, \
|
||
pTmpCheckValue, SM4_BATCH_NUM, pTmpDecData, iDecDataLen, iCheckRet);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4_Decrypt_Mac_BatchData ret=%08x, i=%d", ret, i);
|
||
return ret;
|
||
}
|
||
|
||
/* 特殊测试iSize为0 */
|
||
ret = SYD_SM4_Decrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, pTmpEncData, iEncDataLen, \
|
||
pTmpCheckValue, 0, pTmpDecData, iDecDataLen, iCheckRet);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4_Decrypt_Mac_BatchData ret=%08x, i=%d", ret, i);
|
||
return ret;
|
||
}
|
||
|
||
ret = SYD_SM4_Decrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, pTmpEncData, iEncDataLen, \
|
||
pTmpCheckValue, SM4_BATCH_NUM, pTmpDecData, iDecDataLen, iCheckRet);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4_Decrypt_Mac_BatchData ret=%08x, i=%d", ret, i);
|
||
return ret;
|
||
}
|
||
|
||
for(j = 0; j < SM4_BATCH_NUM; j++)
|
||
{
|
||
if(iCheckRet[j] != 0)
|
||
{
|
||
LOG("mac check err iCheckRet[%d]=%08x\n", j, iCheckRet[j]);
|
||
}
|
||
|
||
if(iDecDataLen[j] != i)
|
||
{
|
||
LOG("iDecDataLen[%d](%d) != (%d)", j, iDecDataLen[j], i);
|
||
return -1;
|
||
}
|
||
|
||
if(memcmp(pTmpDecData[j], pTmpOrgData[j], i))
|
||
{
|
||
LOG("memcmp err i=%d, j=%d", i, j);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
/* 错误场景,输入错误的MAC值 */
|
||
|
||
for(j = 0; j < SM4_BATCH_NUM; j++)
|
||
{
|
||
iDecDataLen[j] = 0;
|
||
}
|
||
|
||
ret = SYD_SM4_Decrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, pTmpEncData, iEncDataLen, \
|
||
pTmpErrMac, SM4_BATCH_NUM, pTmpDecData, iDecDataLen, iCheckRet);
|
||
if(ret != 0)
|
||
{
|
||
LOG("SYD_SM4_Decrypt_Mac_BatchData ret=%08x", ret);
|
||
return ret;
|
||
}
|
||
|
||
for(j = 0; j < SM4_MAC_BATCH_NUM; j++)
|
||
{
|
||
if(iDecDataLen[j] != 0)
|
||
{
|
||
LOG("decdatalen err\n");
|
||
}
|
||
|
||
if(iCheckRet[j] != 0x01000010)
|
||
{
|
||
LOG("mac check err iCheckRet[%d]=%08x\n", j, iCheckRet[j]);
|
||
}
|
||
}
|
||
printf("i=%d\r", i);
|
||
fflush(stdout);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int XN_SM4_Enc_LongData_Test(void *hHandle, int datasize)
|
||
{
|
||
if(datasize < 1024 || datasize % 16 != 0)
|
||
{
|
||
LOG("datasize er");
|
||
return -1;
|
||
}
|
||
int ret = 0, k = 0;
|
||
int singlebytes = 6144;
|
||
char bEncData[8192] = { 0 };
|
||
int ulEncDataLen = 0;
|
||
void *hEncProchandle = NULL;
|
||
char cOrgData[8192] = {0};
|
||
IniOrgData(cOrgData, 8192, 1);
|
||
|
||
/*加密*/
|
||
ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_ENCRYPT, &hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataInit, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
for (k = 0; k < datasize / singlebytes; k++)
|
||
{
|
||
ulEncDataLen = 9000;
|
||
ret = SYD_SM4_LongDataUpdate(hHandle, cOrgData, singlebytes, bEncData, &ulEncDataLen, hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
}
|
||
|
||
ulEncDataLen = 9000;
|
||
ret = SYD_SM4_LongDataFinal(hHandle, bEncData, &ulEncDataLen, hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataFinal ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
SYD_CloseHandle(hEncProchandle);
|
||
END:
|
||
if(ret != 0)
|
||
{
|
||
SYD_CloseHandle(hEncProchandle);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int XN_SM4_Dec_LongData_Test(void *hHandle, int datasize)
|
||
{
|
||
if(datasize < 1024 || datasize % 16 != 0)
|
||
{
|
||
LOG("datasize er");
|
||
return -1;
|
||
}
|
||
int ret = 0, k = 0;
|
||
int singlebytes = 6144;
|
||
char bDecData[8192] = { 0 };
|
||
int ulDecDataLen = 0;
|
||
void *hDecProchandle = NULL;
|
||
char cOrgData[8192] = {0};
|
||
IniOrgData(cOrgData, 8192, 1);
|
||
|
||
/*解密-这里使用随机数据作为密文，而且final不判断返回值， 这里只做吞吐量的验证，不做正确性的验证*/
|
||
ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_DECRYPT, &hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataInit, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
for (k = 0; k < datasize / singlebytes; k++)
|
||
{
|
||
ulDecDataLen = 9000;
|
||
ret = SYD_SM4_LongDataUpdate(hHandle, cOrgData, singlebytes, bDecData, &ulDecDataLen, hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_LongDataUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
}
|
||
ulDecDataLen = 9000;
|
||
SYD_SM4_LongDataFinal(hHandle, bDecData, &ulDecDataLen, hDecProchandle);
|
||
SYD_CloseHandle(hDecProchandle);
|
||
END:
|
||
if(ret != 0)
|
||
{
|
||
SYD_CloseHandle(hDecProchandle);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int XN_SM4Mac_LongData_Test(void *hHandle, int datasize)
|
||
{
|
||
if(datasize < 1024 || datasize % 16 != 0)
|
||
{
|
||
LOG("datasize err");
|
||
return -1;
|
||
}
|
||
int ret = 0, k = 0;
|
||
int singlebytes = 6144;
|
||
char cMac[64] = {0};
|
||
void *hMacProchandle = NULL;
|
||
char cOrgData[9000] = {0};
|
||
IniOrgData(cOrgData, 9000, 1);
|
||
|
||
ret = SYD_SM4Mac_LongDataInit(KEYINDEX, &hMacProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_LongDataInit, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
for (k = 0; k < datasize / singlebytes; k++)
|
||
{
|
||
ret = SYD_SM4Mac_LongDataUpdate(hHandle, cOrgData, singlebytes, hMacProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_LongDataUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
}
|
||
|
||
ret = SYD_SM4Mac_LongDataFinal(hHandle, cMac, NULL, hMacProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4Mac_LongDataFinal ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
SYD_CloseHandle(hMacProchandle);
|
||
END:
|
||
if(ret != 0)
|
||
{
|
||
SYD_CloseHandle(hMacProchandle);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int XN_SM3_LongHash_Test(void *hHandle, int datasize)
|
||
{
|
||
if(datasize < 1024 || datasize % 16 != 0)
|
||
{
|
||
LOG("datasize err");
|
||
return -1;
|
||
}
|
||
int ulRet = 0, i = 0;
|
||
int singlebytes = 6144;
|
||
void* hHash = NULL;
|
||
char bHash[32] = { 0 };
|
||
char cOrgData[9000] = {0};
|
||
IniOrgData(cOrgData, 9000, 1);
|
||
|
||
/*带公钥的HASH*/
|
||
ulRet = SYD_SM3_Hash_Init(&hHash);
|
||
if (ulRet != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Init ulRet=%08x", ulRet);
|
||
return ulRet;
|
||
}
|
||
|
||
for (i = 0; i < datasize / singlebytes; i++)
|
||
{
|
||
ulRet = SYD_SM3_Hash_Update(hHandle, cOrgData, singlebytes, hHash);
|
||
if (ulRet != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Update ulRet=%08x", ulRet);
|
||
goto END;
|
||
}
|
||
}
|
||
|
||
ulRet = SYD_SM3_Hash_Final(hHandle, bHash, hHash);
|
||
if (ulRet != 0)
|
||
{
|
||
LOG("SYD_SM3_Hash_Final ulRet=%08x", ulRet);
|
||
goto END;
|
||
}
|
||
SYD_CloseHandle(hHash);
|
||
|
||
END:
|
||
if (ulRet != 0)
|
||
{
|
||
SYD_CloseHandle(hHash);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int XN_SM4EncMac_LongData_Test(void *hHandle, int datasize)
|
||
{
|
||
if(datasize < 1024 || datasize % 16 != 0)
|
||
{
|
||
LOG("datasize er");
|
||
return -1;
|
||
}
|
||
int ret = 0, k = 0;
|
||
int singlebytes = 6144;
|
||
char bEncData[8192] = { 0 };
|
||
int ulEncDataLen = 0;
|
||
char cMac[64] = {0};
|
||
void *hEncProchandle = NULL;
|
||
char cOrgData[8192] = {0};
|
||
IniOrgData(cOrgData, 8192, 1);
|
||
|
||
/*加密*/
|
||
ret = SYD_SM4EncDecMac_LongDataInit(KEYINDEX, CHECKINDEX, SM4_ENCRYPT, &hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4EncDecMac_LongDataInit, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
for (k = 0; k < datasize / singlebytes; k++)
|
||
{
|
||
ulEncDataLen = 8192;
|
||
ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, cOrgData, singlebytes, bEncData, &ulEncDataLen, hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4EncDecMac_LongDataUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
}
|
||
|
||
ulEncDataLen = 8192;
|
||
ret = SYD_SM4EncDecMac_LongDataFinal(hHandle, bEncData, &ulEncDataLen, cMac, hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4EncDecMac_LongDataFinal ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
SYD_CloseHandle(hEncProchandle);
|
||
END:
|
||
if(ret != 0)
|
||
{
|
||
SYD_CloseHandle(hEncProchandle);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int XN_SM4DecMac_LongData_Test(void *hHandle, int datasize)
|
||
{
|
||
if(datasize < 1024 || datasize % 16 != 0)
|
||
{
|
||
LOG("datasize er");
|
||
return -1;
|
||
}
|
||
int ret = 0, k = 0;
|
||
int singlebytes = 6144;
|
||
char bDecData[8192] = { 0 };
|
||
int ulDecDataLen = 0;
|
||
char cMac[64] = {0};
|
||
void *hDecProchandle = NULL;
|
||
char cOrgData[8192] = {0};
|
||
IniOrgData(cOrgData, 8192, 1);
|
||
|
||
/*解密-这里使用随机数据作为密文，而且final不判断返回值， 这里只做吞吐量的验证，不做正确性的验证*/
|
||
ret = SYD_SM4EncDecMac_LongDataInit(KEYINDEX, CHECKINDEX, SM4_DECRYPT, &hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4EncDecMac_LongDataInit, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
for (k = 0; k < datasize / singlebytes; k++)
|
||
{
|
||
ulDecDataLen = 8192;
|
||
ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, cOrgData, singlebytes, bDecData, &ulDecDataLen, hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4EncDecMac_LongDataUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
}
|
||
ulDecDataLen = 8192;
|
||
SYD_SM4EncDecMac_LongDataFinal(hHandle, bDecData, &ulDecDataLen, cMac, hDecProchandle);
|
||
SYD_CloseHandle(hDecProchandle);
|
||
END:
|
||
if(ret != 0)
|
||
{
|
||
SYD_CloseHandle(hDecProchandle);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
int SM4_LongData_CheckValue(void *hHandle)
|
||
{
|
||
int ret = 0;
|
||
int k = 0, iEncDecNum = 1024, iSingleBytes = 0;
|
||
char bEncData[10240 + 16] = { 0 };
|
||
int ulEncDataLen = 0;
|
||
char* pbEncTemp = NULL;
|
||
int ulTempEncLen = 0;
|
||
char bDecData[10240] = { 0 };
|
||
int ulDecDataLen = 0;
|
||
char* pbDecTemp = NULL;
|
||
int ulTempDecLen = 0;
|
||
void *hEncProchandle = NULL;
|
||
void *hDecProchandle = NULL;
|
||
char cOrgData[10240] = {0};
|
||
char cMac[64] = {0};
|
||
IniOrgData(cOrgData, 10240, 1);
|
||
|
||
char cShortEncData[2048] = {0};
|
||
int iShortEncDataLen = 0;
|
||
char cShortDecData[2048] = {0};
|
||
int iShortDecDataLen = 0;
|
||
char cShortMac[64] = {0};
|
||
|
||
for (iSingleBytes = 1; iSingleBytes <= 6144; iSingleBytes++)
|
||
{
|
||
/* 长数据加密并mac */
|
||
ret = SYD_SM4EncDecMac_LongDataInit(KEYINDEX, CHECKINDEX, SM4_ENCRYPT, &hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4EncDecMac_LongDataInit, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
pbEncTemp = bEncData;
|
||
for (k = 0; k < iEncDecNum / iSingleBytes; k++)
|
||
{
|
||
ulEncDataLen = 10240;
|
||
ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, cOrgData + (k * iSingleBytes), iSingleBytes, \
|
||
pbEncTemp, &ulEncDataLen, hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4EncDecMac_LongDataUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
ulTempEncLen += ulEncDataLen; pbEncTemp += ulEncDataLen;
|
||
}
|
||
|
||
if (iEncDecNum % iSingleBytes != 0)
|
||
{
|
||
ulEncDataLen = 10240;
|
||
ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, cOrgData + (iEncDecNum - (iEncDecNum % iSingleBytes)), \
|
||
iEncDecNum % iSingleBytes, pbEncTemp, &ulEncDataLen, hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4EncDecMac_LongDataUpdate ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
ulTempEncLen += ulEncDataLen; pbEncTemp += ulEncDataLen;
|
||
}
|
||
|
||
ulEncDataLen = 10240;
|
||
ret = SYD_SM4EncDecMac_LongDataFinal(hHandle, pbEncTemp, &ulEncDataLen, cMac, hEncProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4EncDecMac_LongDataFinal ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
ulTempEncLen += ulEncDataLen;
|
||
#if 1
|
||
/* 使用短数据加密并校验MAC接口来对比密文和MAC值是否一致 */
|
||
iShortEncDataLen = sizeof(cShortEncData);
|
||
ret = SYD_SM4_Encrypt_Mac_ShortData(hHandle, KEYINDEX, CHECKINDEX, cOrgData, iEncDecNum, \
|
||
cShortEncData, &iShortEncDataLen, cShortMac);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4_Encrypt_Mac_ShortData ret=%08x", ret);
|
||
return ret;
|
||
}
|
||
|
||
if(iShortEncDataLen != ulTempEncLen)
|
||
{
|
||
LOG("iShortEncDataLen(%d) != ulTempEncLen(%d)", iShortEncDataLen, ulTempEncLen);
|
||
return 0;
|
||
}
|
||
|
||
if(memcmp(cShortEncData, bEncData, ulTempEncLen))
|
||
{
|
||
LOG("memcmp cShortEncData != bEncData");
|
||
return 0;
|
||
}
|
||
|
||
if(memcmp(cShortMac, cMac, 16))
|
||
{
|
||
LOG("memcmp cShortMac != cMac");
|
||
return 0;
|
||
}
|
||
#endif
|
||
/* 长数据解密并校验mac */
|
||
ret = SYD_SM4EncDecMac_LongDataInit(KEYINDEX, CHECKINDEX, SM4_DECRYPT, &hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4EncDecMac_LongDataInit, ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
|
||
pbDecTemp = bDecData;
|
||
for (k = 0; k < ulTempEncLen / iSingleBytes; k++)
|
||
{
|
||
ulDecDataLen = 10240;
|
||
ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, bEncData + (k * iSingleBytes), iSingleBytes, \
|
||
pbDecTemp, &ulDecDataLen, hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SYD_SM4EncDecMac_LongDataUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
ulTempDecLen += ulDecDataLen; pbDecTemp += ulDecDataLen;
|
||
}
|
||
|
||
if (ulTempEncLen % iSingleBytes != 0)
|
||
{
|
||
ulDecDataLen = 10240;
|
||
ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, bEncData + (ulTempEncLen - (ulTempEncLen % iSingleBytes)), \
|
||
ulTempEncLen % iSingleBytes, pbDecTemp, &ulDecDataLen, hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SKF_DecryptUpdate k=%d, ret=%08x", k, ret);
|
||
goto END;
|
||
}
|
||
ulTempDecLen += ulDecDataLen; pbDecTemp += ulDecDataLen;
|
||
}
|
||
|
||
ulDecDataLen = 10240;
|
||
ret = SYD_SM4EncDecMac_LongDataFinal(hHandle, pbDecTemp, &ulDecDataLen, cMac, hDecProchandle);
|
||
if (ret != 0)
|
||
{
|
||
LOG("SKF_DecryptFinal ret=%08x", ret);
|
||
goto END;
|
||
}
|
||
ulTempDecLen += ulDecDataLen;
|
||
|
||
SYD_CloseHandle(hEncProchandle);
|
||
SYD_CloseHandle(hDecProchandle);
|
||
|
||
if (ulTempDecLen != iEncDecNum)
|
||
{
|
||
LOG("iSingleBytes=%d, ulTempDecLen=%d", iSingleBytes, ulTempDecLen);
|
||
return 0;
|
||
}
|
||
|
||
if (memcmp(cOrgData, bDecData, ulTempDecLen))
|
||
{
|
||
LOG("memcmp iSingleBytes=%d, ulTempDecLen=%d", iSingleBytes, ulTempDecLen);
|
||
return 0;
|
||
}
|
||
memset(bEncData, 0, sizeof(bEncData));
|
||
memset(bDecData, 0, sizeof(bDecData));
|
||
ulTempEncLen = 0;
|
||
ulTempDecLen = 0;
|
||
printf("count: %d\r", iSingleBytes);
|
||
fflush(stdout);
|
||
}
|
||
|
||
END:
|
||
if(ret != 0)
|
||
{
|
||
SYD_CloseHandle(hEncProchandle);
|
||
SYD_CloseHandle(hDecProchandle);
|
||
}
|
||
return 0;
|
||
} |