#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;
}