myvtm/DevAdapter/keba/PinPad.keba.1.1/ZT598MGFD_DevImpl.cpp

#include "ZT598MGFD_DevImpl.h"
LOG_EXTERN()

CZT598M1FD_DevImpl::CZT598M1FD_DevImpl(BOOL bIsFather)
{
	memset(m_bySndBuff, 0x00, sizeof(m_bySndBuff));
	memset(m_byRcvBuff, 0x00, sizeof(m_byRcvBuff));
	memset(&m_stCommInfo, 0x00, sizeof(m_stCommInfo));
	m_stCommInfo.cdSndData.lpvData = m_bySndBuff;
	m_stCommInfo.cdSndData.dwDataLen = 0;
	m_stCommInfo.cdRcvData.lpvData = m_byRcvBuff;
	m_stCommInfo.cdRcvData.dwDataLen = sizeof(m_byRcvBuff);
	m_stCommInfo.dwTimeout = 2000;
	m_lpIDevComm = NULL;
	m_lpbyUAK = NULL;
	m_lpbyKBPK = NULL;
	m_wUAKSize = 0;
	m_wKBPKSize = 0;
	m_byLastCmd = 0x00;
	if (bIsFather == FALSE)
	{
        //m_traceManager.Register("ZT598M1FDDevImpl");
	}
}

CZT598M1FD_DevImpl::~CZT598M1FD_DevImpl()
{
	if(m_lpIDevComm != NULL)
	{
		delete m_lpIDevComm;
		m_lpIDevComm = NULL;
	}
}

BOOL CZT598M1FD_DevImpl::OpenDevice(LPCommParam lpParam)
{
	CloseDevice();
	m_lpIDevComm = new CHIDComm();

	if ((m_lpIDevComm == NULL) || (lpParam == NULL))
	{
		return FALSE;
	}

	m_stCommInfo.cdSndData.dwDataLen = 0;
    CUSBParam m_CUSBParam;
    memset(&m_CUSBParam,0x00,sizeof(m_CUSBParam));

    memcpy((&m_CUSBParam.usVID),&(lpParam->usbInfo).usVID,sizeof(USHORT));
    memcpy(&m_CUSBParam.usPID,&lpParam->usbInfo.usPID,sizeof(USHORT));
    if (m_lpIDevComm->OpenDevice(m_CUSBParam) != FALSE)
	{
        //m_traceManager.TraceIn(TRM_INT, TRM_LV_COMMN, "Open device OK.");
		return TRUE;
	}
	return FALSE;
}

BOOL CZT598M1FD_DevImpl::CloseDevice()
{
	if (m_lpIDevComm != NULL)
	{
		if (m_lpIDevComm->CloseDevice() != FALSE)
		{
			delete m_lpIDevComm;
			m_lpIDevComm = NULL;
		}
	}

	memset(m_bySndBuff, 0x00, sizeof(m_bySndBuff));
	memset(m_byRcvBuff, 0x00, sizeof(m_byRcvBuff));
	memset(&m_stCommInfo, 0x00, sizeof(m_stCommInfo));
	m_stCommInfo.cdSndData.lpvData = m_bySndBuff;
	m_stCommInfo.cdSndData.dwDataLen = 0;
	m_stCommInfo.cdRcvData.lpvData = m_byRcvBuff;
	m_stCommInfo.cdRcvData.dwDataLen = sizeof(m_byRcvBuff);

	return TRUE;
}

BOOL CZT598M1FD_DevImpl::ExchangeData(const LPEPPExchangeDataField lpstSendInfo, LPEPPExchangeDataField lpstReceiveInfo)
{
    WORD wIdx = 0;
    WORD wLoop = 0;
    WORD wValue = 0;
    WORD wSndBufflen = 0;
    WORD wRcvBufflen = 0;
    WORD wFixedLen = 0;
    DWORD dwReceiveLen = 0;
    DWORD dwLen = 0;
    BYTE bySndBuffer[EXCHANGE_DATA_MAX_LEN] = {0};
    BYTE bySndBuffer_temp[EXCHANGE_DATA_MAX_LEN*2] = {0};
    BYTE byRcvBuffer[EXCHANGE_DATA_MAX_LEN] = {0};
    LPEPPExchangeDataHeadSection lpstEPPExchangeDataHeadSection;
    LPReadEntryTextResponse lpReadEntryTextRes = (LPReadEntryTextResponse)(m_byRcvBuff + sizeof(EPPExchangeDataHeadSection) + sizeof(lpstReceiveInfo->unHead));
    BOOL bRet = FALSE;
    UINT uMaskCnt = 0;
    UINT uMaskOffset[10] = {0}, uMaskLen[10] = {0};

    if ((lpstSendInfo == NULL) || (lpstReceiveInfo == NULL))
    {
        return FALSE;
    }
    if (EditCmd(lpstSendInfo, &uMaskCnt, uMaskOffset, uMaskLen) == FALSE)
    {
        return FALSE;
    }

    lpstEPPExchangeDataHeadSection = (LPEPPExchangeDataHeadSection)m_bySndBuff;
    wFixedLen = sizeof(EPPExchangeDataHeadSection) + sizeof(EPPExchangeDataTailSection);
    wSndBufflen += lpstEPPExchangeDataHeadSection->wLen + wFixedLen;
    m_stCommInfo.cdSndData.lpvData = bySndBuffer;
    m_stCommInfo.cdRcvData.lpvData = byRcvBuffer;
    m_stCommInfo.dwTimeout = 2000;
    wLoop = wSndBufflen / (EXCHANGE_DATA_MAX_LEN - 1);
    wValue = wSndBufflen % (EXCHANGE_DATA_MAX_LEN - 1);
    if (wValue > 0)
    {
        wLoop++;
    }
    dwLen = m_lpIDevComm->SendData(m_bySndBuff, wSndBufflen);
    if (dwLen == 0)
    {
        LogXE( m_bySndBuff, wSndBufflen , "Send");
        return FALSE;
    }
   LogXM(m_bySndBuff, wSndBufflen, "Send");

    if (lpstEPPExchangeDataHeadSection->byCmd == READ_ENTRY_TEXT)
    {
        if (m_byLastCmd != READ_ENTRY_TEXT)
        {
        }
    }
    else
    {
        //m_traceManager.TraceInBuffer(TRM_SND, TRM_LV_COMMN, m_bySndBuff, wSndBufflen,
            //NULL, uMaskOffset, uMaskLen, uMaskCnt);
    }

    //LogM( "Receive 1st start.....");
    INT nNeedRcvLen = 5;
    for (INT i = 0; i < 3 && dwReceiveLen ==0; i++)
    {
        usleep(10000);
        dwReceiveLen=m_lpIDevComm->ReceiveData(m_byRcvBuff,m_stCommInfo.dwTimeout, TRUE);
        if ((m_lpIDevComm->GetError() != ERROR_SUCCESS))
        {
            LogXE( m_bySndBuff, wSndBufflen , "received data:%d FAILED!", i);
            return FALSE;
        }
        if(dwReceiveLen == 0)
        {
            LogXE( m_bySndBuff, wSndBufflen , "received data:%d is empty", i);
            if(i > 2)
            {
                return FALSE;
            }
        }
    }
    lpstEPPExchangeDataHeadSection = (LPEPPExchangeDataHeadSection)m_byRcvBuff;
    nNeedRcvLen = lpstEPPExchangeDataHeadSection->wLen + 8;
    INT nRcvOffset = dwReceiveLen;
    nNeedRcvLen -= dwReceiveLen;
    while(nNeedRcvLen > 0)
    {
        dwReceiveLen=m_lpIDevComm->ReceiveData(m_byRcvBuff + nRcvOffset,m_stCommInfo.dwTimeout, TRUE);
        if ((m_lpIDevComm->GetError() != ERROR_SUCCESS))
        {
            LogXE( m_bySndBuff, wSndBufflen , "Continue received data is empty!");
            return FALSE;
        }
        nRcvOffset += dwReceiveLen;
        nNeedRcvLen -= dwReceiveLen;
    }
    LogXM( m_byRcvBuff, dwReceiveLen, "Rcv");

    bRet = ParseResponse(lpstReceiveInfo, &uMaskCnt, uMaskOffset, uMaskLen);
    if (lpstEPPExchangeDataHeadSection->byCmd == READ_ENTRY_TEXT)
    {
        if (m_byLastCmd != READ_ENTRY_TEXT || lpReadEntryTextRes->byBytesCount > 0)
        {
            //m_traceManager.TraceInBuffer(TRM_RCV, TRM_LV_COMMN, m_byRcvBuff, wRcvBufflen,
                //NULL, uMaskOffset, uMaskLen, uMaskCnt);
        }
    }
    else
    {
        //m_traceManager.TraceInBuffer(TRM_RCV, TRM_LV_COMMN, m_byRcvBuff, wRcvBufflen,
            //NULL, uMaskOffset, uMaskLen, uMaskCnt);
    }
    m_byLastCmd = lpstEPPExchangeDataHeadSection->byCmd;

    return bRet;
}

//--------------------------------- DevImpl ---------------------------------
// (Edit command data & Execute command)
BOOL CZT598M1FD_DevImpl::EditCmd(const LPEPPExchangeDataField lpstExchangeDataField,
	LPUINT lpuTraceMaskCount/* = NULL*/, LPUINT lpuMaskOffsetArray/* = NULL*/, LPUINT lpuMaskLenArray/* = NULL*/)
{
	BYTE byHighCode = 0;
	LPEPPExchangeDataHeadSection lpstEPPExchangeDataHeadSection = (LPEPPExchangeDataHeadSection)m_bySndBuff;
	LPEPPExchangeDataTailSection lpstEPPExchangeDataTailSection = NULL;
	LPBYTE lpbySndDate = m_bySndBuff + sizeof(EPPExchangeDataHeadSection);
    int a=sizeof(EPPExchangeDataHeadSection);
	BYTE byEnumHead = 0;
	WORD wParamLen = 0;
	WORD wParamHead = 0;

	memset(m_bySndBuff, 0x00, sizeof(m_bySndBuff));
	if (lpuTraceMaskCount != NULL)
	{
		*lpuTraceMaskCount = 0;
	}
	
	if (lpstExchangeDataField == NULL)
	{
		return FALSE;
	}
	lpstEPPExchangeDataHeadSection->bySignatureHead = EXCHANGE_SIGNATURE_HEAD;
	lpstEPPExchangeDataHeadSection->byTRNB = EXCHANGE_TRNB;
	lpstEPPExchangeDataHeadSection->byCmd = lpstExchangeDataField->unHead.byCmd;
	memcpy(lpbySndDate, &lpstEPPExchangeDataHeadSection->byCmd, sizeof(lpstEPPExchangeDataHeadSection->byCmd));
	wParamLen += sizeof(lpstEPPExchangeDataHeadSection->byCmd);
	switch (lpstEPPExchangeDataHeadSection->byCmd)
	{
	case SET_ENTRY_MODE:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPSetEntryModeParam lpstSetEntryModeParam = (LPSetEntryModeParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			byEnumHead = (BYTE)lpstSetEntryModeParam->enSwitchMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			byHighCode = lpstSetEntryModeParam->wKeybordDisCode >> 8;
			memcpy(lpbySndDate + wParamLen, &byHighCode, sizeof(byHighCode));
			memcpy(lpbySndDate + wParamLen + 1, &lpstSetEntryModeParam->wKeybordDisCode, sizeof(BYTE));
			wParamLen += sizeof(lpstSetEntryModeParam->wKeybordDisCode);
			//memcpy(lpbySndDate + wParamLen, &lpstSetEntryModeParam->wFuncKeybordDisCode, sizeof(lpstSetEntryModeParam->wFuncKeybordDisCode));
			byHighCode = lpstSetEntryModeParam->wFuncKeybordDisCode >> 8;
			memcpy(lpbySndDate + wParamLen, &byHighCode, sizeof(byHighCode));
			memcpy(lpbySndDate + wParamLen + 1, &lpstSetEntryModeParam->wFuncKeybordDisCode, sizeof(BYTE));
			wParamLen += sizeof(lpstSetEntryModeParam->wFuncKeybordDisCode);
		}
		break;
	case READ_ENTRY_TEXT:
		break;
	case VIRTUAL_KEY_PRESS:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPVirtualKeyPressParam lpstVirtualKeyPressParam = (LPVirtualKeyPressParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, lpstVirtualKeyPressParam->byKeyTable, lpstVirtualKeyPressParam->wKeyTableLen);
			wParamLen += lpstVirtualKeyPressParam->wKeyTableLen;
		}
		break;
	case DEL_ENTRY_BUFFER:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPDelEntryBufferParam lpstDelEntryBufferParam = (LPDelEntryBufferParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			if (lpstDelEntryBufferParam->wContrlParemeterlen == 0)
			{
				break;
			}
			memcpy(lpbySndDate + wParamLen, &lpstDelEntryBufferParam->enControlParameter, lpstDelEntryBufferParam->wContrlParemeterlen);
			wParamLen += lpstDelEntryBufferParam->wContrlParemeterlen;
		}
		break;
	case SET_KEYBOARD_CODE:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPSetKeyboardCodeParam lpstSetKeyBoardCodeParam = (LPSetKeyboardCodeParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			byEnumHead = (BYTE)lpstSetKeyBoardCodeParam->enSetKeyboardCodeMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, lpstSetKeyBoardCodeParam->byEPPTableNaturalMode, sizeof(lpstSetKeyBoardCodeParam->byEPPTableNaturalMode));
			wParamLen += sizeof(lpstSetKeyBoardCodeParam->byEPPTableNaturalMode);
			memcpy(lpbySndDate + wParamLen, lpstSetKeyBoardCodeParam->byEPPTableShiftMode, sizeof(lpstSetKeyBoardCodeParam->byEPPTableShiftMode));
			wParamLen += sizeof(lpstSetKeyBoardCodeParam->byEPPTableShiftMode);
			memcpy(lpbySndDate + wParamLen, lpstSetKeyBoardCodeParam->byExFunKeyNaturalMode, sizeof(lpstSetKeyBoardCodeParam->byExFunKeyNaturalMode));
			wParamLen += sizeof(lpstSetKeyBoardCodeParam->byExFunKeyNaturalMode);
			memcpy(lpbySndDate + wParamLen, lpstSetKeyBoardCodeParam->byExFunKeyShiftMode, sizeof(lpstSetKeyBoardCodeParam->byExFunKeyShiftMode));
			wParamLen += sizeof(lpstSetKeyBoardCodeParam->byExFunKeyShiftMode);
		}
		break;
	case SET_CONTROL_MODE:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPSetControlModeParam lpstSetControlModeParam = (LPSetControlModeParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			byEnumHead = (BYTE)lpstSetControlModeParam->enControlMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, &lpstSetControlModeParam->byControlCode, sizeof(lpstSetControlModeParam->byControlCode));
			wParamLen += sizeof(lpstSetControlModeParam->byControlCode);
		}
		break;
	case READ_EPP_INFO:
		break;
	case WRITE_USER_DATA:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPWriteUserDataParam lpstWriteUserDataParam = (LPWriteUserDataParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstWriteUserDataParam->byUserBlockAdress, sizeof(lpstWriteUserDataParam->byUserBlockAdress));
			wParamLen += sizeof(lpstWriteUserDataParam->byUserBlockAdress);
			memcpy(lpbySndDate + wParamLen, lpstWriteUserDataParam->byUserData, sizeof(lpstWriteUserDataParam->byUserData));
			wParamLen += sizeof(lpstWriteUserDataParam->byUserData);
		}
		break;
	case READ_USER_DATA:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPReadUserDataParam lpstReadUserDataParam = (LPReadUserDataParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, lpstReadUserDataParam, sizeof(*lpstReadUserDataParam));
			wParamLen += sizeof(*lpstReadUserDataParam);
		}
		break;
	case REMOVE_INSTALL_AUTH:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPRemoveInstallAuthParam lpstRemoveInstallAuthParam = (LPRemoveInstallAuthParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			byEnumHead = (BYTE)*lpstRemoveInstallAuthParam;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
		}
		break;
	case UPDATE_PASSWORD:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPUpdatePasswordParam lpstUpdatePasswordParam = (LPUpdatePasswordParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			wParamHead = (WORD)lpstUpdatePasswordParam->enPWDKey;
			memcpy(lpbySndDate + wParamLen, &wParamHead, sizeof(wParamHead));
			wParamLen += sizeof(wParamHead);
			memcpy(lpbySndDate + wParamLen, &lpstUpdatePasswordParam->byUpdataMode, sizeof(lpstUpdatePasswordParam->byUpdataMode));
			wParamLen += sizeof(lpstUpdatePasswordParam->byUpdataMode);
		}
		break;
	case LOAD_KEY:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPLoadKeyParam lpstLoadKeyParam = (LPLoadKeyParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstLoadKeyParam->wKeyID, sizeof(lpstLoadKeyParam->wKeyID));
			wParamLen += sizeof(lpstLoadKeyParam->wKeyID);
			byEnumHead = (BYTE)lpstLoadKeyParam->enLoadKeyWriteMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, &lpstLoadKeyParam->Attributes, sizeof(lpstLoadKeyParam->Attributes));
			wParamLen += sizeof(lpstLoadKeyParam->Attributes);
			byEnumHead = (BYTE)lpstLoadKeyParam->enLoadKeyVerifyMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			byEnumHead = (BYTE)lpstLoadKeyParam->enLoadKeyCheckMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpbySndDate + wParamLen - m_bySndBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = lpstLoadKeyParam->wKeyCheckValueLen + sizeof(lpstLoadKeyParam->byPlainTextKey);
				(*lpuTraceMaskCount)++;
			}
			memcpy(lpbySndDate + wParamLen, &lpstLoadKeyParam->byKeyCheckValue, lpstLoadKeyParam->wKeyCheckValueLen);
			wParamLen += lpstLoadKeyParam->wKeyCheckValueLen;
			memcpy(lpbySndDate + wParamLen, lpstLoadKeyParam->byPlainTextKey, sizeof(lpstLoadKeyParam->byPlainTextKey));
			wParamLen += sizeof(lpstLoadKeyParam->byPlainTextKey);
			if ((m_lpbyKBPK != NULL) &&
				((CAlgorithm::CalcMAC(MAC_ALG_X919, lpbySndDate, wParamLen, (LPBYTE)(m_lpbyKBPK), m_wKBPKSize,
				lpstLoadKeyParam->byKeyBlockMACValue, sizeof(lpstLoadKeyParam->byKeyBlockMACValue))) != FALSE))
			{
				memcpy(lpbySndDate + wParamLen, lpstLoadKeyParam->byKeyBlockMACValue,sizeof(lpstLoadKeyParam->byKeyBlockMACValue));
				wParamLen += sizeof(lpstLoadKeyParam->byKeyBlockMACValue);
			}
			else
			{
				return FALSE;
			}
		}
		break;
	case EXCHANGE_KEY:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPExChangeKeyParam lpstExChangeKeyParam = (LPExChangeKeyParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstExChangeKeyParam->wKeyID1, sizeof(lpstExChangeKeyParam->wKeyID1));
			wParamLen += sizeof(lpstExChangeKeyParam->wKeyID1);
			memcpy(lpbySndDate + wParamLen, &lpstExChangeKeyParam->wVariationIndex1, sizeof(lpstExChangeKeyParam->wVariationIndex1));
			wParamLen += sizeof(lpstExChangeKeyParam->wVariationIndex1);
			memcpy(lpbySndDate + wParamLen, &lpstExChangeKeyParam->wKeyID2, sizeof(lpstExChangeKeyParam->wKeyID2));
			wParamLen += sizeof(lpstExChangeKeyParam->wKeyID2);
			byEnumHead = (BYTE)lpstExChangeKeyParam->enKeyWriteMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, &lpstExChangeKeyParam->Attributes2, sizeof(lpstExChangeKeyParam->Attributes2));
			wParamLen += sizeof(lpstExChangeKeyParam->Attributes2);
			byEnumHead = (BYTE)lpstExChangeKeyParam->enKeyVerifyMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			byEnumHead = (BYTE)lpstExChangeKeyParam->enKCVCheckMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpbySndDate + wParamLen - m_bySndBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = lpstExChangeKeyParam->wKeyCheckValueLen;
				(*lpuTraceMaskCount)++;
			}
			memcpy(lpbySndDate + wParamLen, lpstExChangeKeyParam->byKeyCheckValue, lpstExChangeKeyParam->wKeyCheckValueLen);
			wParamLen += lpstExChangeKeyParam->wKeyCheckValueLen;
			memcpy(lpbySndDate + wParamLen, lpstExChangeKeyParam->byKeyCipherText, lpstExChangeKeyParam->wKeyCipherTextLen);
			wParamLen += lpstExChangeKeyParam->wKeyCipherTextLen;
			if ((m_lpbyKBPK != NULL) &&
				((CAlgorithm::CalcMAC(MAC_ALG_X919, lpbySndDate, wParamLen, (LPBYTE)(m_lpbyKBPK), m_wKBPKSize,
				lpstExChangeKeyParam->byKeyBlockMACValue, sizeof(lpstExChangeKeyParam->byKeyBlockMACValue))) != FALSE))
			{
				memcpy(lpbySndDate + wParamLen, &lpstExChangeKeyParam->byKeyBlockMACValue, sizeof(lpstExChangeKeyParam->byKeyBlockMACValue));
				wParamLen += sizeof(lpstExChangeKeyParam->byKeyBlockMACValue);
			}
			else
			{
				return FALSE;
			}
		}
		break;
	case GENERATE_RANDOM_DATA:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPGenerateRandomDataParam lpstGenerateRandomDataParam = (LPGenerateRandomDataParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, lpstGenerateRandomDataParam, sizeof(*lpstGenerateRandomDataParam));
			wParamLen += sizeof(*lpstGenerateRandomDataParam);
		}
		break;
	case AUTHENTICATION:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPAuthenticationParam lpstAuthenticationParam = (LPAuthenticationParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstAuthenticationParam->wKeyID, sizeof(lpstAuthenticationParam->wKeyID));
			wParamLen += sizeof(lpstAuthenticationParam->wKeyID);
			byEnumHead = (BYTE)lpstAuthenticationParam->enAuthenticationMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, lpstAuthenticationParam->byEPPRandomData, sizeof(lpstAuthenticationParam->byEPPRandomData));
			wParamLen += sizeof(lpstAuthenticationParam->byEPPRandomData);
			memcpy(lpbySndDate + wParamLen, lpstAuthenticationParam->byHOSTRandomData, sizeof(lpstAuthenticationParam->byHOSTRandomData));
			wParamLen += sizeof(lpstAuthenticationParam->byHOSTRandomData);
			if ((m_lpbyUAK != NULL) &&
				((CAlgorithm::CalcMAC(MAC_ALG_X919, lpbySndDate, wParamLen, (LPBYTE)m_lpbyUAK, m_wUAKSize,
				lpstAuthenticationParam->byMACData, sizeof(lpstAuthenticationParam->byMACData))) != FALSE))
			{
				memcpy(lpbySndDate + wParamLen, lpstAuthenticationParam->byMACData, sizeof(lpstAuthenticationParam->byMACData));
				wParamLen += sizeof(lpstAuthenticationParam->byMACData);
			}
			else
			{
				return FALSE;
			}
		}
		break;
	case DELETE_KEY:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPDeleteKeyParam lpstDeleteKeyParam = (LPDeleteKeyParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, lpstDeleteKeyParam, sizeof(*lpstDeleteKeyParam));
			wParamLen += sizeof(*lpstDeleteKeyParam);
		}
		break;
	case READ_KEY_ATTRIBUTES:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPReadKeyAttributesParam lpstReadKeyAttributesParam = (LPReadKeyAttributesParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstReadKeyAttributesParam->wKeyID, sizeof(lpstReadKeyAttributesParam->wKeyID));
			wParamLen += sizeof(lpstReadKeyAttributesParam->wKeyID);
			byEnumHead = (BYTE)lpstReadKeyAttributesParam->enKeyCheckMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, &lpstReadKeyAttributesParam->wVariationIndex, sizeof(lpstReadKeyAttributesParam->wVariationIndex));
			wParamLen += sizeof(lpstReadKeyAttributesParam->wVariationIndex);
		}
		break;
	case ENCTYPT_PIN_BLOCK:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPEncryptPinBlockParam lpstEncryptPinBlockParam = (LPEncryptPinBlockParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstEncryptPinBlockParam->wKeyID, sizeof(lpstEncryptPinBlockParam->wKeyID));
			wParamLen += sizeof(lpstEncryptPinBlockParam->wKeyID);
			memcpy(lpbySndDate + wParamLen, &lpstEncryptPinBlockParam->wVariationIndex, sizeof(lpstEncryptPinBlockParam->wVariationIndex));
			wParamLen += sizeof(lpstEncryptPinBlockParam->wVariationIndex);
			byEnumHead = (BYTE)lpstEncryptPinBlockParam->enPinBlockEnctryptionMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			byEnumHead = (BYTE)lpstEncryptPinBlockParam->enPinFormat;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, &lpstEncryptPinBlockParam->wKeyID2, sizeof(lpstEncryptPinBlockParam->wKeyID2));
			wParamLen += sizeof(lpstEncryptPinBlockParam->wKeyID2);
			memcpy(lpbySndDate + wParamLen, &lpstEncryptPinBlockParam->wVariationIdex2, sizeof(lpstEncryptPinBlockParam->wVariationIdex2));
			wParamLen += sizeof(lpstEncryptPinBlockParam->wVariationIdex2);
			memcpy(lpbySndDate + wParamLen, lpstEncryptPinBlockParam->byInitialPINPattern, sizeof(lpstEncryptPinBlockParam->byInitialPINPattern));
			wParamLen += sizeof(lpstEncryptPinBlockParam->byInitialPINPattern);
			memcpy(lpbySndDate + wParamLen, &lpstEncryptPinBlockParam->byPINOffset, sizeof(lpstEncryptPinBlockParam->byPINOffset));
			wParamLen += sizeof(lpstEncryptPinBlockParam->byPINOffset);
			memcpy(lpbySndDate + wParamLen, &lpstEncryptPinBlockParam->byPINLength, sizeof(lpstEncryptPinBlockParam->byPINLength));
			wParamLen += sizeof(lpstEncryptPinBlockParam->byPINLength);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpbySndDate + wParamLen - m_bySndBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = sizeof(lpstEncryptPinBlockParam->byXORPINBlockPattern);
				(*lpuTraceMaskCount)++;
			}
			memcpy(lpbySndDate + wParamLen, lpstEncryptPinBlockParam->byXORPINBlockPattern, sizeof(lpstEncryptPinBlockParam->byXORPINBlockPattern));
			wParamLen += sizeof(lpstEncryptPinBlockParam->byXORPINBlockPattern);
			memcpy(lpbySndDate + wParamLen, lpstEncryptPinBlockParam->byXORPINBlockPattern2, sizeof(lpstEncryptPinBlockParam->byXORPINBlockPattern2));
			wParamLen += sizeof(lpstEncryptPinBlockParam->byXORPINBlockPattern2);
		}
		break;
	case DES_CRYPT_DATA:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPDesCryptDataParam lpstDesCryptDataParam = (LPDesCryptDataParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstDesCryptDataParam->wKeyID, sizeof(lpstDesCryptDataParam->wKeyID));
			wParamLen += sizeof(lpstDesCryptDataParam->wKeyID);
			memcpy(lpbySndDate + wParamLen, &lpstDesCryptDataParam->wVariationIndex, sizeof(lpstDesCryptDataParam->wVariationIndex));
			wParamLen += sizeof(lpstDesCryptDataParam->wVariationIndex);
			memcpy(lpbySndDate + wParamLen, &lpstDesCryptDataParam->wKeyID2, sizeof(lpstDesCryptDataParam->wKeyID2));
			wParamLen += sizeof(lpstDesCryptDataParam->wKeyID2);
			memcpy(lpbySndDate + wParamLen, lpstDesCryptDataParam->byIV, sizeof(lpstDesCryptDataParam->byIV));
			wParamLen += sizeof(lpstDesCryptDataParam->byIV);
			byEnumHead = (BYTE)lpstDesCryptDataParam->enIVMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, &lpstDesCryptDataParam->byDesMode, sizeof(lpstDesCryptDataParam->byDesMode));
			wParamLen += sizeof(lpstDesCryptDataParam->byDesMode);
			byEnumHead = (BYTE)lpstDesCryptDataParam->enCryptionMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, lpstDesCryptDataParam->lpInputData, lpstDesCryptDataParam->wInputDataLen);
			wParamLen += lpstDesCryptDataParam->wInputDataLen;
		}
		break;
	case MAC_ENCRYPT_DATA:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPMACEnCryptDataParam lpstMACEnCryptDataParam = (LPMACEnCryptDataParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstMACEnCryptDataParam->wKeyID, sizeof(lpstMACEnCryptDataParam->wKeyID));
			wParamLen += sizeof(lpstMACEnCryptDataParam->wKeyID);
			memcpy(lpbySndDate + wParamLen, &lpstMACEnCryptDataParam->wVariationIndex, sizeof(lpstMACEnCryptDataParam->wVariationIndex));
			wParamLen += sizeof(lpstMACEnCryptDataParam->wVariationIndex);
			memcpy(lpbySndDate + wParamLen, &lpstMACEnCryptDataParam->wKeyID2, sizeof(lpstMACEnCryptDataParam->wKeyID2));
			wParamLen += sizeof(lpstMACEnCryptDataParam->wKeyID2);
			memcpy(lpbySndDate + wParamLen, lpstMACEnCryptDataParam->byIV, sizeof(lpstMACEnCryptDataParam->byIV));
			wParamLen += sizeof(lpstMACEnCryptDataParam->byIV);
			byEnumHead = (BYTE)lpstMACEnCryptDataParam->enIVMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			byEnumHead = (BYTE)lpstMACEnCryptDataParam->enMACMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			byEnumHead = (BYTE)lpstMACEnCryptDataParam->enCryptionMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, lpstMACEnCryptDataParam->lpInputData, lpstMACEnCryptDataParam->wInputDataLen);
			wParamLen += lpstMACEnCryptDataParam->wInputDataLen;
		}
		break;
	case GET_EPP_SENSOR_DATA:
		break;
	case GET_KEYBOARD_CODE:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPGetKeyBoardCodeParam lpstGetKeyBoardCodeParam = (LPGetKeyBoardCodeParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			byEnumHead = (BYTE)*lpstGetKeyBoardCodeParam;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
		}		
		break;
	case SET_SYSTEM_TIME:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			memcpy(lpbySndDate + wParamLen, lpstExchangeDataField->unBody.lpbyParamInfo, sizeof(SetSystemTimeParam));
			wParamLen += sizeof(SetSystemTimeParam);
		}
		break;
	case GET_SYSTEM_TIME:
		break;
	case SM4_LOAD_TEXT_KEY:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPSM4LoadTextKeyParam lpstLoadSM4KeyParam = (LPSM4LoadTextKeyParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstLoadSM4KeyParam->wKeyIndex, sizeof(lpstLoadSM4KeyParam->wKeyIndex));
			wParamLen += sizeof(lpstLoadSM4KeyParam->wKeyIndex);
			byEnumHead = (BYTE)lpstLoadSM4KeyParam->enWritrMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpbySndDate + wParamLen - m_bySndBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = sizeof(lpstLoadSM4KeyParam->byKeyData);
				(*lpuTraceMaskCount)++;
			}
			memcpy(lpbySndDate + wParamLen, lpstLoadSM4KeyParam->byKeyData, sizeof(lpstLoadSM4KeyParam->byKeyData));
			wParamLen += sizeof(lpstLoadSM4KeyParam->byKeyData);
			memcpy(lpbySndDate + wParamLen, &lpstLoadSM4KeyParam->Attributes2, sizeof(lpstLoadSM4KeyParam->Attributes2));
			wParamLen += sizeof(lpstLoadSM4KeyParam->Attributes2);
		}
		break;
	case SM4_EXCHANGE_KEY:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPSM4ExchangeKeyParam lpstSM4ExchangeKeyParam = (LPSM4ExchangeKeyParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstSM4ExchangeKeyParam->wKeyID1, sizeof(lpstSM4ExchangeKeyParam->wKeyID1));
			wParamLen += sizeof(lpstSM4ExchangeKeyParam->wKeyID1);
			memcpy(lpbySndDate + wParamLen, &lpstSM4ExchangeKeyParam->wKeyID2, sizeof(lpstSM4ExchangeKeyParam->wKeyID2));
			wParamLen += sizeof(lpstSM4ExchangeKeyParam->wKeyID2);
			memcpy(lpbySndDate + wParamLen, lpstSM4ExchangeKeyParam->byCiphertextKey, sizeof(lpstSM4ExchangeKeyParam->byCiphertextKey));
			wParamLen += sizeof(lpstSM4ExchangeKeyParam->byCiphertextKey);
			memcpy(lpbySndDate + wParamLen, &lpstSM4ExchangeKeyParam->Attributes2, sizeof(lpstSM4ExchangeKeyParam->Attributes2));
			wParamLen += sizeof(lpstSM4ExchangeKeyParam->Attributes2);
		}
		break;
	case SM4_CRYPT:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPSM4CryptParam lpstSM4CryptParam = (LPSM4CryptParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstSM4CryptParam->wKeyIndex, sizeof(lpstSM4CryptParam->wKeyIndex));
			wParamLen += sizeof(lpstSM4CryptParam->wKeyIndex);
			byEnumHead = (BYTE)lpstSM4CryptParam->enCryptMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			byEnumHead = (BYTE)lpstSM4CryptParam->enCryptSM4Mode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, lpstSM4CryptParam->byIVData, sizeof(lpstSM4CryptParam->byIVData));
			wParamLen += sizeof(lpstSM4CryptParam->byIVData);
			memcpy(lpbySndDate + wParamLen, lpstSM4CryptParam->lpInputData, lpstSM4CryptParam->wInputDataLen);
			wParamLen += lpstSM4CryptParam->wInputDataLen;
		}
		break;
	case SM4_MAC:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPSM4MACParam lpstSM4MACParam = (LPSM4MACParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstSM4MACParam->wKeyIndex, sizeof(lpstSM4MACParam->wKeyIndex));
			wParamLen += sizeof(lpstSM4MACParam->wKeyIndex);
			memcpy(lpbySndDate + wParamLen, lpstSM4MACParam->byIVData, sizeof(lpstSM4MACParam->byIVData));
			wParamLen += sizeof(lpstSM4MACParam->byIVData);
			byEnumHead = (BYTE)lpstSM4MACParam->enMACMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, lpstSM4MACParam->lpInputData, lpstSM4MACParam->wInputDataLen);
			wParamLen += lpstSM4MACParam->wInputDataLen;
		}
		break;
	case SM4_GET_PIN_BLOCK:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPSM4GetPinBlockParam lpstSM4GetPinBlockParam = (LPSM4GetPinBlockParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstSM4GetPinBlockParam->wKeyID, sizeof(lpstSM4GetPinBlockParam->wKeyID));
			wParamLen += sizeof(lpstSM4GetPinBlockParam->wKeyID);
			byEnumHead = (BYTE)lpstSM4GetPinBlockParam->enEncryptionMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, &lpstSM4GetPinBlockParam->wKeyID2, sizeof(lpstSM4GetPinBlockParam->wKeyID2));
			wParamLen += sizeof(lpstSM4GetPinBlockParam->wKeyID2);
			memcpy(lpbySndDate + wParamLen, &lpstSM4GetPinBlockParam->byPinFormat, sizeof(lpstSM4GetPinBlockParam->byPinFormat));
			wParamLen += sizeof(lpstSM4GetPinBlockParam->byPinFormat);
			memcpy(lpbySndDate + wParamLen, lpstSM4GetPinBlockParam->byInitialPinPattern, sizeof(lpstSM4GetPinBlockParam->byInitialPinPattern));
			wParamLen += sizeof(lpstSM4GetPinBlockParam->byInitialPinPattern);
			memcpy(lpbySndDate + wParamLen, &lpstSM4GetPinBlockParam->byPinOffset, sizeof(lpstSM4GetPinBlockParam->byPinOffset));
			wParamLen += sizeof(lpstSM4GetPinBlockParam->byPinOffset);
			memcpy(lpbySndDate + wParamLen, &lpstSM4GetPinBlockParam->byPinLength, sizeof(lpstSM4GetPinBlockParam->byPinLength));
			wParamLen += sizeof(lpstSM4GetPinBlockParam->byPinLength);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpbySndDate + wParamLen - m_bySndBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = sizeof(lpstSM4GetPinBlockParam->byXORPinBlockPattern);
				(*lpuTraceMaskCount)++;
			}
			memcpy(lpbySndDate + wParamLen, lpstSM4GetPinBlockParam->byXORPinBlockPattern, sizeof(lpstSM4GetPinBlockParam->byXORPinBlockPattern));
			wParamLen += sizeof(lpstSM4GetPinBlockParam->byXORPinBlockPattern);
			memcpy(lpbySndDate + wParamLen, lpstSM4GetPinBlockParam->byXORPinBlockPattern2, sizeof(lpstSM4GetPinBlockParam->byXORPinBlockPattern2));
			wParamLen += sizeof(lpstSM4GetPinBlockParam->byXORPinBlockPattern2);
		}
		break;
	case SM_DELETE_KEY:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPSMDeleteKeyParam lpstSMDeleteKeyParam = (LPSMDeleteKeyParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, lpstSMDeleteKeyParam, sizeof(SMDeleteKeyParam));
			wParamLen += sizeof(SMDeleteKeyParam);
		}
		break;
	case READ_A980_FW_VERSION:
	case SM_GET_VERSION:
		break;
	case SM_READ_KEY_ATTRIBUTES:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPSMReadKeyAttributeParam lpstSMReadKeyAttributeParam = (LPSMReadKeyAttributeParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstSMReadKeyAttributeParam->wKeyID, sizeof(lpstSMReadKeyAttributeParam->wKeyID));
			wParamLen += sizeof(lpstSMReadKeyAttributeParam->wKeyID);
			byEnumHead = (BYTE)lpstSMReadKeyAttributeParam->enKeyCheckMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
		}
		break;
	case GENERATE_RSA_KEYPAIR:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPGenerateRsaKeyPairParam lpstGenerateRsaKeyPairParam = (LPGenerateRsaKeyPairParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstGenerateRsaKeyPairParam->wPrivateKeyId, sizeof(lpstGenerateRsaKeyPairParam->wPrivateKeyId));
			wParamLen += sizeof(lpstGenerateRsaKeyPairParam->wPrivateKeyId);
			memcpy(lpbySndDate + wParamLen, &lpstGenerateRsaKeyPairParam->wPublicKeyId, sizeof(lpstGenerateRsaKeyPairParam->wPublicKeyId));
			wParamLen += sizeof(lpstGenerateRsaKeyPairParam->wPublicKeyId);
			memcpy(lpbySndDate + wParamLen, &lpstGenerateRsaKeyPairParam->wModulusLength, sizeof(lpstGenerateRsaKeyPairParam->wModulusLength));
			wParamLen += sizeof(lpstGenerateRsaKeyPairParam->wModulusLength);
			memcpy(lpbySndDate + wParamLen, &lpstGenerateRsaKeyPairParam->dwExponentData, sizeof(lpstGenerateRsaKeyPairParam->dwExponentData));
			wParamLen += sizeof(lpstGenerateRsaKeyPairParam->dwExponentData);
		}
		break;
	case EXP_EPP_PUBLIC_KEY:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPExpEppPKParam lpstExpEppPublicKeyParam = (LPExpEppPKParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstExpEppPublicKeyParam->wKeyId, sizeof(lpstExpEppPublicKeyParam->wKeyId));
			wParamLen += sizeof(lpstExpEppPublicKeyParam->wKeyId);
			memcpy(lpbySndDate + wParamLen, &lpstExpEppPublicKeyParam->wSignatureId, sizeof(lpstExpEppPublicKeyParam->wSignatureId));
			wParamLen += sizeof(lpstExpEppPublicKeyParam->wSignatureId);
		}
		break;
	case IMPORT_DES_KEY:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPImportDesKeyParam lpstImportDesKeyParam = (LPImportDesKeyParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			USHORT usOffset = 0;
			memcpy(lpbySndDate + wParamLen, &lpstImportDesKeyParam->wDesKeyId, sizeof(lpstImportDesKeyParam->wDesKeyId));
			wParamLen += sizeof(lpstImportDesKeyParam->wDesKeyId);
			memcpy(lpbySndDate + wParamLen, &lpstImportDesKeyParam->stKeyAttributes, sizeof(lpstImportDesKeyParam->stKeyAttributes));
			wParamLen += sizeof(lpstImportDesKeyParam->stKeyAttributes);
			memcpy(lpbySndDate + wParamLen, &lpstImportDesKeyParam->wEppSkDecKeyId, sizeof(lpstImportDesKeyParam->wEppSkDecKeyId));
			wParamLen += sizeof(lpstImportDesKeyParam->wEppSkDecKeyId);
			byEnumHead = (BYTE)lpstImportDesKeyParam->enSigAlgorithm;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			byEnumHead = (BYTE)lpstImportDesKeyParam->enVerifyMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			byEnumHead = (BYTE)lpstImportDesKeyParam->enDesKCM;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			memcpy(lpbySndDate + wParamLen, lpstImportDesKeyParam->byKCV, lpstImportDesKeyParam->wKCVLen);
			wParamLen += lpstImportDesKeyParam->wKCVLen;
			memcpy(lpbySndDate + wParamLen, &lpstImportDesKeyParam->wVerifySigPkId, sizeof(lpstImportDesKeyParam->wVerifySigPkId));
			wParamLen += sizeof(lpstImportDesKeyParam->wVerifySigPkId);
			byEnumHead = (BYTE)lpstImportDesKeyParam->enEncipherAlgorithm;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			byEnumHead = (BYTE)lpstImportDesKeyParam->enRandomMode;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			if (EditDerTag(lpbySndDate + wParamLen, (LPBYTE)&lpstImportDesKeyParam->stDerEncDesKeytag, DER_TAG_ENCRYPTED_DES_KEY, usOffset) == FALSE)
			{
				return FALSE;
			}
			wParamLen += usOffset;
		}
		break;
	case IMPORT_RSA_KEY:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPImportRsaKeyParam lpstImportRsaKeyParam = (LPImportRsaKeyParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			USHORT usOffset = 0;
			memcpy(lpbySndDate + wParamLen, &lpstImportRsaKeyParam->wKeyId, sizeof(lpstImportRsaKeyParam->wKeyId));
			wParamLen += sizeof(lpstImportRsaKeyParam->wKeyId);
			memcpy(lpbySndDate + wParamLen, &lpstImportRsaKeyParam->stKeyAttributes, sizeof(lpstImportRsaKeyParam->stKeyAttributes));
			wParamLen += sizeof(lpstImportRsaKeyParam->stKeyAttributes);
			memcpy(lpbySndDate + wParamLen, &lpstImportRsaKeyParam->wSigKeyId, sizeof(lpstImportRsaKeyParam->wSigKeyId));
			wParamLen += sizeof(lpstImportRsaKeyParam->wSigKeyId);
			byEnumHead = (BYTE)lpstImportRsaKeyParam->enSigAlgorithm;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			if (EditDerTag(lpbySndDate + wParamLen, (LPBYTE)&lpstImportRsaKeyParam->stDerRsaKeyWithSigTag, DER_TAG_RSA_KEY_WITH_SIG, usOffset) == FALSE)
			{
				return FALSE;
			}
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpbySndDate + wParamLen - m_bySndBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = usOffset;
				(*lpuTraceMaskCount)++;
			}
			wParamLen += usOffset;
		}
		break;
	case IMPORT_EPP_SERIAL_NUMBER:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPImportEppSNParam lpstImportEppSNParam = (LPImportEppSNParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			USHORT usOffset = 0;
			memcpy(lpbySndDate + wParamLen, &lpstImportEppSNParam->wKeyId, sizeof(lpstImportEppSNParam->wKeyId));
			wParamLen += sizeof(lpstImportEppSNParam->wKeyId);
			memcpy(lpbySndDate + wParamLen, &lpstImportEppSNParam->stKeyAttributes, sizeof(lpstImportEppSNParam->stKeyAttributes));
			wParamLen += sizeof(lpstImportEppSNParam->stKeyAttributes);
			memcpy(lpbySndDate + wParamLen, &lpstImportEppSNParam->wSigKeyId, sizeof(lpstImportEppSNParam->wSigKeyId));
			wParamLen += sizeof(lpstImportEppSNParam->wSigKeyId);
			byEnumHead = (BYTE)lpstImportEppSNParam->enSigAlgorithm;
			memcpy(lpbySndDate + wParamLen, &byEnumHead, sizeof(byEnumHead));
			wParamLen += sizeof(byEnumHead);
			if (EditDerTag(lpbySndDate + wParamLen, (LPBYTE)&lpstImportEppSNParam->stDerEppSNTag, DER_TAG_EPP_SERIAL_NUMBER, usOffset) == FALSE)
			{
				return FALSE;
			}
			wParamLen += usOffset;
		}
		break;
	case EXP_EPP_SERIAL_NUMBER:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPExpEppSNParam lpstExpEppSNParam = (LPExpEppSNParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstExpEppSNParam->wKeyId, sizeof(lpstExpEppSNParam->wKeyId));
			wParamLen += sizeof(lpstExpEppSNParam->wKeyId);
			memcpy(lpbySndDate + wParamLen, &lpstExpEppSNParam->wSignatureId, sizeof(lpstExpEppSNParam->wSignatureId));
			wParamLen += sizeof(lpstExpEppSNParam->wSignatureId);
		}
		break;
	case RSA_CRYPT_DATA:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPRSACryptDataParam lpstRSACryptDataParam = (LPRSACryptDataParam)lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, &lpstRSACryptDataParam->wKeyId, sizeof(lpstRSACryptDataParam->wKeyId));
			wParamLen += sizeof(lpstRSACryptDataParam->wKeyId);
			memcpy(lpbySndDate + wParamLen, &lpstRSACryptDataParam->usDataLen, sizeof(lpstRSACryptDataParam->usDataLen));
			wParamLen += sizeof(lpstRSACryptDataParam->usDataLen);
			memcpy(lpbySndDate + wParamLen, lpstRSACryptDataParam->byData, lpstRSACryptDataParam->usDataLen);
			wParamLen += lpstRSACryptDataParam->usDataLen;
		}
		break;
	case START_GM_FW_LOAD:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPBYTE lpbyFWType = lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, lpbyFWType, sizeof(BYTE));
			wParamLen += sizeof(BYTE);
		}
		break;
	case LOADING_GM_FW_CODE:
		{
			if (lpstExchangeDataField->unBody.lpbyParamInfo == NULL)
			{
				return FALSE;
			}
			LPBYTE lpbyFWCode = lpstExchangeDataField->unBody.lpbyParamInfo;
			memcpy(lpbySndDate + wParamLen, lpbyFWCode, 1024);
			wParamLen += 1024;
		}
		break;
	case END_GM_FW_LOAD:
		break;
	default:
		return FALSE;
	}

    if ((lpuTraceMaskCount != NULL) /*&&
        (CTraceManager::m_bTraceMask == FALSE)*/)
	{
		*lpuTraceMaskCount = 0;
	}

	lpstEPPExchangeDataHeadSection->wLen = wParamLen;
    int temp_a=sizeof (EPPExchangeDataHeadSection);
	lpstEPPExchangeDataTailSection = (LPEPPExchangeDataTailSection)(m_bySndBuff + sizeof(EPPExchangeDataHeadSection) + wParamLen);
	lpstEPPExchangeDataTailSection->bySignatureEnd = EXCHANGE_SIGNATURE_END;
	WORD wCRC;
	if ((CAlgorithm::CalcCRC(16, (LPBYTE)m_bySndBuff, sizeof(EPPExchangeDataHeadSection) + wParamLen +
		sizeof(lpstEPPExchangeDataTailSection->bySignatureEnd), &wCRC)) == FALSE)
	{
		return FALSE;
	}
	lpstEPPExchangeDataTailSection->wCRC = wCRC;
	return TRUE;
}

BOOL CZT598M1FD_DevImpl::ParseResponse(LPEPPExchangeDataField lpstReceiveInfo, LPUINT lpuTraceMaskCount/* = NULL*/, LPUINT lpuMaskOffsetArray/* = NULL*/, LPUINT lpuMaskLenArray/* = NULL*/)
{
	DWORD dwInfoSizeoff = 0;
	WORD wNeedCheckLen = 0;
	WORD wCRC = 0;
	LPEPPExchangeDataTailSection lpstEPPExchangeDataTailSection = NULL;
	LPEPPExchangeDataHeadSection lpstEPPExchangeDataHeadSection = NULL;

	LPBYTE lpstRcvDate = m_byRcvBuff + sizeof(EPPExchangeDataHeadSection);
	BYTE byExpectCmd = 0x00;

	if (lpuTraceMaskCount != NULL)
	{
		*lpuTraceMaskCount = 0;
	}
	if (lpstReceiveInfo == NULL)
	{
		return FALSE;
	}
	lpstEPPExchangeDataHeadSection = (LPEPPExchangeDataHeadSection)m_bySndBuff;
	byExpectCmd = lpstEPPExchangeDataHeadSection->byCmd;
	lpstEPPExchangeDataHeadSection = (LPEPPExchangeDataHeadSection)m_byRcvBuff;
	if (lpstEPPExchangeDataHeadSection->byCmd != byExpectCmd)
	{
		return FALSE;
	}

	wNeedCheckLen = lpstEPPExchangeDataHeadSection->wLen;
	wNeedCheckLen += sizeof(EPPExchangeDataHeadSection);
	lpstEPPExchangeDataTailSection = (LPEPPExchangeDataTailSection)(m_byRcvBuff + wNeedCheckLen);
	wNeedCheckLen += sizeof(lpstEPPExchangeDataTailSection->bySignatureEnd);

	CAlgorithm::CalcCRC(16, m_byRcvBuff, wNeedCheckLen, &wCRC);
	if (memcmp(&wCRC, &lpstEPPExchangeDataTailSection->wCRC, sizeof(wCRC)) != 0)
	{
		return FALSE;
	}
	memcpy (&lpstReceiveInfo->unHead.byStatus, lpstRcvDate, sizeof(lpstReceiveInfo->unHead.byStatus));
	dwInfoSizeoff += sizeof(lpstReceiveInfo->unHead.byStatus);
	switch(lpstEPPExchangeDataHeadSection->byCmd)
	{
	case SET_ENTRY_MODE:
		break;
	case READ_ENTRY_TEXT:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPReadEntryTextResponse lpstReadEntryTextResponse = (LPReadEntryTextResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			memcpy(&lpstReadEntryTextResponse->byBytesCount, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEntryTextResponse->byBytesCount));
			dwInfoSizeoff += sizeof(lpstReadEntryTextResponse->byBytesCount);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpstRcvDate + dwInfoSizeoff - m_byRcvBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = sizeof(lpstReadEntryTextResponse->byDataOfGTB);
				(*lpuTraceMaskCount)++;
			}
			memcpy(lpstReadEntryTextResponse->byDataOfGTB, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEntryTextResponse->byDataOfGTB));
		}
		break;
	case VIRTUAL_KEY_PRESS:
		break;
	case DEL_ENTRY_BUFFER:
		break;
	case SET_KEYBOARD_CODE:
		break;
	case SET_CONTROL_MODE:
		break;
	case READ_EPP_INFO:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPReadEPPInfoResponse lpstReadEPPInfoResponse = (LPReadEPPInfoResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			memcpy(&lpstReadEPPInfoResponse->byEPPType, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->byEPPType));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->byEPPType);
			memcpy(&lpstReadEPPInfoResponse->wDESKeyNumber, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->wDESKeyNumber));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->wDESKeyNumber);
			memcpy(&lpstReadEPPInfoResponse->wRSAKeyNumber, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->wRSAKeyNumber));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->wRSAKeyNumber);
			memcpy(&lpstReadEPPInfoResponse->wCertificateNumber, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->wCertificateNumber));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->wCertificateNumber);
			memcpy(&lpstReadEPPInfoResponse->wCryptAlgorithms, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->wCryptAlgorithms));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->wCryptAlgorithms);
			memcpy(&lpstReadEPPInfoResponse->byDerivationAlgorithms, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->byDerivationAlgorithms));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->byDerivationAlgorithms);
			memcpy(&lpstReadEPPInfoResponse->byPresentationAlgorithms, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->byPresentationAlgorithms));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->byPresentationAlgorithms);
			memcpy(&lpstReadEPPInfoResponse->byValidationAlgorithms, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->byValidationAlgorithms));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->byValidationAlgorithms);
			memcpy(&lpstReadEPPInfoResponse->wPinFormat, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->wPinFormat));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->wPinFormat);
			memcpy(&lpstReadEPPInfoResponse->byKeyCheckModes, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->byKeyCheckModes));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->byKeyCheckModes);
			memcpy(&lpstReadEPPInfoResponse->wUseDESKey, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->wUseDESKey));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->wUseDESKey);
			memcpy(&lpstReadEPPInfoResponse->byICCard, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->byICCard));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->byICCard);
			memcpy(&lpstReadEPPInfoResponse->byDisPlay, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->byDisPlay));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->byDisPlay);
			memcpy(&lpstReadEPPInfoResponse->byPressKeyNumber, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->byPressKeyNumber));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->byPressKeyNumber);
			memcpy(lpstReadEPPInfoResponse->byVersionNumber, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->byVersionNumber));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->byVersionNumber);
			memcpy(lpstReadEPPInfoResponse->byProductModel, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->byProductModel));
			dwInfoSizeoff += sizeof(lpstReadEPPInfoResponse->byProductModel);
			memcpy(lpstReadEPPInfoResponse->byMainChipSN, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadEPPInfoResponse->byMainChipSN));
		}
		break;
	case WRITE_USER_DATA:
		break;
	case READ_USER_DATA:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			ReadUserDataResponse lpstReadUserDataResponse;
			memcpy(lpstReadUserDataResponse, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadUserDataResponse));
			dwInfoSizeoff += sizeof(lpstReadUserDataResponse);
			memcpy(lpstReceiveInfo->unBody.lpbyResInfo, lpstReadUserDataResponse, sizeof(lpstReadUserDataResponse));
		}
		break;
	case REMOVE_INSTALL_AUTH:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			RemoveInstallAuthResponse RemoveInstallAuthRes;
			memcpy(RemoveInstallAuthRes, lpstRcvDate + dwInfoSizeoff, sizeof(RemoveInstallAuthRes));
			dwInfoSizeoff += sizeof(RemoveInstallAuthRes);
			memcpy(lpstReceiveInfo->unBody.lpbyResInfo, RemoveInstallAuthRes, sizeof(RemoveInstallAuthRes));
		}
		break;
	case UPDATE_PASSWORD:
		break;
	case LOAD_KEY:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPLoadKeyResponse lpstLoadKeyResponse = (LPLoadKeyResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			lpstLoadKeyResponse->wKeyCheckValueLen = lpstEPPExchangeDataHeadSection->wLen;
			lpstLoadKeyResponse->wKeyCheckValueLen -= sizeof(lpstReceiveInfo->unHead.byStatus);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpstRcvDate + dwInfoSizeoff - m_byRcvBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = lpstLoadKeyResponse->wKeyCheckValueLen;
				(*lpuTraceMaskCount)++;
			}
			memcpy(lpstLoadKeyResponse->byKeyCheckValue, lpstRcvDate + dwInfoSizeoff, lpstLoadKeyResponse->wKeyCheckValueLen);
		}
		break;
	case EXCHANGE_KEY:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPExChangeKeyResponse lpstExChangeKeyResponse = (LPExChangeKeyResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			lpstExChangeKeyResponse->wKCVLen = lpstEPPExchangeDataHeadSection->wLen;
			lpstExChangeKeyResponse->wKCVLen -= sizeof(lpstReceiveInfo->unHead.byStatus);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpstRcvDate + dwInfoSizeoff - m_byRcvBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = lpstExChangeKeyResponse->wKCVLen;
				(*lpuTraceMaskCount)++;
			}
			memcpy(lpstExChangeKeyResponse->byKCV, lpstRcvDate + dwInfoSizeoff, lpstExChangeKeyResponse->wKCVLen);
		}
		break;
	case GENERATE_RANDOM_DATA:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPGenerateRandomDataResponse lpstGenerateRandomDataResponse = (LPGenerateRandomDataResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			lpstGenerateRandomDataResponse->wGeneratedDataLen = lpstEPPExchangeDataHeadSection->wLen;
			lpstGenerateRandomDataResponse->wGeneratedDataLen -= sizeof(lpstReceiveInfo->unHead.byStatus);
			memcpy(lpstGenerateRandomDataResponse->byGeneratedData, lpstRcvDate + dwInfoSizeoff, lpstGenerateRandomDataResponse->wGeneratedDataLen);
		}
		break;
	case AUTHENTICATION:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPAuthenticationResponse lpstAuthenticationResponse = (LPAuthenticationResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			memcpy(lpstAuthenticationResponse->byHOSTRandomData, lpstRcvDate + dwInfoSizeoff, sizeof(lpstAuthenticationResponse->byHOSTRandomData));
			dwInfoSizeoff += sizeof(lpstAuthenticationResponse->byHOSTRandomData);
			memcpy(lpstAuthenticationResponse->byEPPRandomData, lpstRcvDate + dwInfoSizeoff, sizeof(lpstAuthenticationResponse->byEPPRandomData));
			dwInfoSizeoff += sizeof(lpstAuthenticationResponse->byEPPRandomData);
			memcpy(lpstAuthenticationResponse->byMACData, lpstRcvDate + dwInfoSizeoff, sizeof(lpstAuthenticationResponse->byMACData));
		}
		break;
	case DELETE_KEY:
		break;
	case READ_KEY_ATTRIBUTES:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPReadKeyAttributesResponse lpstReadKeyAttributesResponse = (LPReadKeyAttributesResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			memcpy(&lpstReadKeyAttributesResponse->Attributes, lpstRcvDate + dwInfoSizeoff, sizeof(lpstReadKeyAttributesResponse->Attributes));
			dwInfoSizeoff += sizeof(lpstReadKeyAttributesResponse->Attributes);
			lpstReadKeyAttributesResponse->wKCVLen = lpstEPPExchangeDataHeadSection->wLen;
			lpstReadKeyAttributesResponse->wKCVLen -= sizeof(lpstReceiveInfo->unHead.byStatus);
			lpstReadKeyAttributesResponse->wKCVLen -= sizeof(lpstReadKeyAttributesResponse->Attributes);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpstRcvDate + dwInfoSizeoff - m_byRcvBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = lpstReadKeyAttributesResponse->wKCVLen;
				(*lpuTraceMaskCount)++;
			}
			memcpy(lpstReadKeyAttributesResponse->byKCV, lpstRcvDate + dwInfoSizeoff, lpstReadKeyAttributesResponse->wKCVLen);
		}
		break;
	case ENCTYPT_PIN_BLOCK:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			EncryptPinBlockResponse EncryptPinBlockRes;
			memcpy(EncryptPinBlockRes, lpstRcvDate + dwInfoSizeoff, sizeof(EncryptPinBlockRes));
			dwInfoSizeoff += sizeof(EncryptPinBlockRes);
			memcpy(lpstReceiveInfo->unBody.lpbyResInfo, EncryptPinBlockRes, sizeof(EncryptPinBlockRes));
		}
		break;
	case DES_CRYPT_DATA:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPDesCryptDataResponse lpstDesCryptDataResponse = (LPDesCryptDataResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			lpstDesCryptDataResponse->wOutputDataLen = lpstEPPExchangeDataHeadSection->wLen;
			lpstDesCryptDataResponse->wOutputDataLen -= sizeof(lpstReceiveInfo->unHead.byStatus);
			memcpy(lpstDesCryptDataResponse->lpOutputData, lpstRcvDate + dwInfoSizeoff, lpstDesCryptDataResponse->wOutputDataLen);
		}
		break;
	case MAC_ENCRYPT_DATA:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPMACEnCryptDataResponse lpstMACEnCryptDataResponse = (LPMACEnCryptDataResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			lpstMACEnCryptDataResponse->wOutputDataLen = lpstEPPExchangeDataHeadSection->wLen;
			lpstMACEnCryptDataResponse->wOutputDataLen -= sizeof(lpstReceiveInfo->unHead.byStatus);
			memcpy(lpstMACEnCryptDataResponse->lpOutputData, lpstRcvDate + dwInfoSizeoff, lpstMACEnCryptDataResponse->wOutputDataLen);
		}
		break;
	case GET_EPP_SENSOR_DATA:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPGetEPPSensorDataResponse lpstGetEPPSensorDataResponse = (LPGetEPPSensorDataResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			memcpy(&lpstGetEPPSensorDataResponse->ExternalSensor, lpstRcvDate + dwInfoSizeoff, sizeof(BYTE));
			dwInfoSizeoff += sizeof(BYTE);
			memcpy(&lpstGetEPPSensorDataResponse->InternalSensorState, lpstRcvDate + dwInfoSizeoff, sizeof(BYTE));
			dwInfoSizeoff += sizeof(BYTE);
			memcpy(&lpstGetEPPSensorDataResponse->BatteryState, lpstRcvDate + dwInfoSizeoff, sizeof(BYTE));
		}
		break;
	case GET_KEYBOARD_CODE:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPGetKeyBoardCodeResponse lpstGetKeyBoardCodeResponse = (LPGetKeyBoardCodeResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			memcpy(lpstGetKeyBoardCodeResponse->byEPPTableNaturalMode, lpstRcvDate + dwInfoSizeoff, sizeof(lpstGetKeyBoardCodeResponse->byEPPTableNaturalMode));
			dwInfoSizeoff += sizeof(lpstGetKeyBoardCodeResponse->byEPPTableNaturalMode);
			memcpy(lpstGetKeyBoardCodeResponse->byEPPTableShiftMode, lpstRcvDate + dwInfoSizeoff, sizeof(lpstGetKeyBoardCodeResponse->byEPPTableShiftMode));
			dwInfoSizeoff += sizeof(lpstGetKeyBoardCodeResponse->byEPPTableShiftMode);
			memcpy(lpstGetKeyBoardCodeResponse->byExFunKeyNaturalMode, lpstRcvDate + dwInfoSizeoff, sizeof(lpstGetKeyBoardCodeResponse->byExFunKeyNaturalMode));
			dwInfoSizeoff += sizeof(lpstGetKeyBoardCodeResponse->byExFunKeyNaturalMode);
			memcpy(lpstGetKeyBoardCodeResponse->byExFunKeyShiftMode, lpstRcvDate + dwInfoSizeoff, sizeof(lpstGetKeyBoardCodeResponse->byExFunKeyShiftMode));
		}	
		break;
	case SET_SYSTEM_TIME:
		break;
	case GET_SYSTEM_TIME:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			GetSystemTimeResponse GetSystemTimeRes;
			memcpy(GetSystemTimeRes, lpstRcvDate + dwInfoSizeoff, sizeof(GetSystemTimeRes));
			dwInfoSizeoff += sizeof(GetSystemTimeRes);
			memcpy(lpstReceiveInfo->unBody.lpbyResInfo, GetSystemTimeRes, sizeof(GetSystemTimeRes));
		}
		break;
	case SM4_LOAD_TEXT_KEY:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			SM4LoadTextKeyResponse SM4LoadTextKeyRes;
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpstRcvDate + dwInfoSizeoff - m_byRcvBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = sizeof(SM4LoadTextKeyRes);
				(*lpuTraceMaskCount)++;
			}
			memcpy(SM4LoadTextKeyRes, lpstRcvDate + dwInfoSizeoff, sizeof(SM4LoadTextKeyRes));
			dwInfoSizeoff += sizeof(SM4LoadTextKeyRes);
			memcpy(lpstReceiveInfo->unBody.lpbyResInfo, SM4LoadTextKeyRes, sizeof(SM4LoadTextKeyRes));
		}
		break;
	case SM4_EXCHANGE_KEY:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			SM4ExchangeKeyResponse SM4ExchangeKeyRes;
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpstRcvDate + dwInfoSizeoff - m_byRcvBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = sizeof(SM4ExchangeKeyRes);
				(*lpuTraceMaskCount)++;
			}
			memcpy(SM4ExchangeKeyRes, lpstRcvDate + dwInfoSizeoff, sizeof(SM4ExchangeKeyRes));
			dwInfoSizeoff += sizeof(SM4ExchangeKeyRes);
			memcpy(lpstReceiveInfo->unBody.lpbyResInfo, SM4ExchangeKeyRes, sizeof(SM4ExchangeKeyRes));
		}
		break;
	case SM4_CRYPT:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPSM4CryptResponse lpstSM4CryptResponse = (LPSM4CryptResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			lpstSM4CryptResponse->wEncryptDataLen = lpstEPPExchangeDataHeadSection->wLen;
			lpstSM4CryptResponse->wEncryptDataLen -= sizeof(lpstReceiveInfo->unHead.byStatus);
			memcpy(lpstSM4CryptResponse->lpEncryptData, lpstRcvDate + dwInfoSizeoff, lpstSM4CryptResponse->wEncryptDataLen);
		}
		break;
	case SM4_MAC:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			SM4MACResponse SM4MACRes;
			memcpy(SM4MACRes, lpstRcvDate + dwInfoSizeoff, sizeof(SM4MACRes));
			dwInfoSizeoff += sizeof(SM4MACRes);
			memcpy(lpstReceiveInfo->unBody.lpbyResInfo, SM4MACRes, sizeof(SM4MACRes));
		}
		break;
	case SM4_GET_PIN_BLOCK:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			SM4GetPinBlockResponse SM4GetPinBlockRes;
			memcpy(SM4GetPinBlockRes, lpstRcvDate + dwInfoSizeoff, sizeof(SM4GetPinBlockRes));
			dwInfoSizeoff += sizeof(SM4GetPinBlockRes);
			memcpy(lpstReceiveInfo->unBody.lpbyResInfo, SM4GetPinBlockRes, sizeof(SM4GetPinBlockRes));
		}
		break;
	case SM_DELETE_KEY:
		break;
	case READ_A980_FW_VERSION:
	case SM_GET_VERSION:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			SMGetVersionResponse SMGetVersionRes;
			memcpy(SMGetVersionRes, lpstRcvDate + dwInfoSizeoff, sizeof(SMGetVersionRes));
			dwInfoSizeoff += sizeof(SMGetVersionRes);
			memcpy(lpstReceiveInfo->unBody.lpbyResInfo, SMGetVersionRes, sizeof(SMGetVersionRes));
		}
		break;
	case SM_READ_KEY_ATTRIBUTES:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPSMReadKeyAttributeResponse lpstSMReadKeyAttributeRes = (LPSMReadKeyAttributeResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			memcpy(&lpstSMReadKeyAttributeRes->Attributes, lpstRcvDate + dwInfoSizeoff, sizeof(lpstSMReadKeyAttributeRes->Attributes));
			dwInfoSizeoff += sizeof(lpstSMReadKeyAttributeRes->Attributes);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpstRcvDate + dwInfoSizeoff - m_byRcvBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = sizeof(lpstSMReadKeyAttributeRes->byKeyCheckValue);
				(*lpuTraceMaskCount)++;
			}
			memcpy(&lpstSMReadKeyAttributeRes->byKeyCheckValue, lpstRcvDate + dwInfoSizeoff, sizeof(lpstSMReadKeyAttributeRes->byKeyCheckValue));
		}
		break;
	case GENERATE_RSA_KEYPAIR:
		break;
	case EXP_EPP_PUBLIC_KEY:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPExpEppPKResponse lpstExpEppPKRes = (LPExpEppPKResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			USHORT usOffset = 0;
			memcpy(&lpstExpEppPKRes->enSigAlgorithm, lpstRcvDate + dwInfoSizeoff, sizeof(BYTE));
			dwInfoSizeoff += sizeof(BYTE);
			if (lpstExpEppPKRes->enSigAlgorithm == SIGN_NA)
			{
				lpstExpEppPKRes->stDerRsaKeyWithSigTag.usLength = 0;
				lpstExpEppPKRes->stDerRsaKeyWithSigTag.lpbyBuffer = NULL;
				lpstExpEppPKRes->stDerRsaKeyWithSigTag.stDerRsaKeyTag.usLength = GetDerTagLength(lpstRcvDate + dwInfoSizeoff);
				memcpy(lpstExpEppPKRes->stDerRsaKeyWithSigTag.stDerRsaKeyTag.lpbyBuffer, lpstRcvDate + dwInfoSizeoff, lpstExpEppPKRes->stDerRsaKeyWithSigTag.stDerRsaKeyTag.usLength);
				ParseDerTag(lpstExpEppPKRes->stDerRsaKeyWithSigTag.stDerRsaKeyTag.lpbyBuffer, (LPBYTE)&lpstExpEppPKRes->stDerRsaKeyWithSigTag.stDerRsaKeyTag, DER_TAG_RSA_KEY, usOffset);
			}
			else
			{
				lpstExpEppPKRes->stDerRsaKeyWithSigTag.usLength = GetDerTagLength(lpstRcvDate + dwInfoSizeoff);
				memcpy(lpstExpEppPKRes->stDerRsaKeyWithSigTag.lpbyBuffer, lpstRcvDate + dwInfoSizeoff, lpstExpEppPKRes->stDerRsaKeyWithSigTag.usLength);
				ParseDerTag(lpstExpEppPKRes->stDerRsaKeyWithSigTag.lpbyBuffer, (LPBYTE)&lpstExpEppPKRes->stDerRsaKeyWithSigTag, DER_TAG_RSA_KEY_WITH_SIG, usOffset);
			}
		}
		break;
	case IMPORT_DES_KEY:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPImportDesKeyResponse lpstImportDesKeyRes = (LPImportDesKeyResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			lpstImportDesKeyRes->wKCVLen = lpstEPPExchangeDataHeadSection->wLen;
			lpstImportDesKeyRes->wKCVLen -= sizeof(lpstReceiveInfo->unHead.byStatus);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpstRcvDate + dwInfoSizeoff - m_byRcvBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = lpstImportDesKeyRes->wKCVLen;
				(*lpuTraceMaskCount)++;
			}
			memcpy(&lpstImportDesKeyRes->byKCV, lpstRcvDate + dwInfoSizeoff, lpstImportDesKeyRes->wKCVLen);
		}
		break;
	case IMPORT_RSA_KEY:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPImportRsaKeyResponse lpstImportRsaKeyRes = (LPImportRsaKeyResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			memcpy(&lpstImportRsaKeyRes->enRsaKCM, lpstRcvDate + dwInfoSizeoff, sizeof(BYTE));
			dwInfoSizeoff += sizeof(BYTE);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpstRcvDate + dwInfoSizeoff - m_byRcvBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = sizeof(lpstImportRsaKeyRes->byRsaKCV);
				(*lpuTraceMaskCount)++;
			}
			memcpy(&lpstImportRsaKeyRes->byRsaKCV, lpstRcvDate + dwInfoSizeoff, sizeof(lpstImportRsaKeyRes->byRsaKCV));
		}
		break;
	case IMPORT_EPP_SERIAL_NUMBER:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPImportEppSNResponse lpstImportEppSNRes = (LPImportEppSNResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			memcpy(&lpstImportEppSNRes->enRsaKCM, lpstRcvDate + dwInfoSizeoff, sizeof(BYTE));
			dwInfoSizeoff += sizeof(BYTE);
			if (lpuTraceMaskCount != NULL && lpuMaskOffsetArray != NULL && lpuMaskLenArray != NULL)
			{
				lpuMaskOffsetArray[*lpuTraceMaskCount] = lpstRcvDate + dwInfoSizeoff - m_byRcvBuff;
				lpuMaskLenArray[*lpuTraceMaskCount] = sizeof(lpstImportEppSNRes->byRsaKCV);
				(*lpuTraceMaskCount)++;
			}
			memcpy(&lpstImportEppSNRes->byRsaKCV, lpstRcvDate + dwInfoSizeoff, sizeof(lpstImportEppSNRes->byRsaKCV));
		}
		break;
	case EXP_EPP_SERIAL_NUMBER:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPExpEppSNResponse lpstExpEppSNRes = (LPExpEppSNResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			USHORT usOffset = 0;
			memcpy(&lpstExpEppSNRes->enSigAlgorithm, lpstRcvDate + dwInfoSizeoff, sizeof(BYTE));
			dwInfoSizeoff += sizeof(BYTE);
			lpstExpEppSNRes->stDerEppSNTag.usLength = GetDerTagLength(lpstRcvDate + dwInfoSizeoff);
			memcpy(lpstExpEppSNRes->stDerEppSNTag.lpbyBuffer, lpstRcvDate + dwInfoSizeoff, lpstExpEppSNRes->stDerEppSNTag.usLength);
			ParseDerTag(lpstExpEppSNRes->stDerEppSNTag.lpbyBuffer, (LPBYTE)&lpstExpEppSNRes->stDerEppSNTag, DER_TAG_EPP_SERIAL_NUMBER, usOffset);
		}
		break;
	case RSA_CRYPT_DATA:
		{
			if (lpstReceiveInfo->unBody.lpbyResInfo == NULL)
			{
				return FALSE;
			}
			LPRSACryptDataResponse lpstRSACryptDataRes = (LPRSACryptDataResponse)lpstReceiveInfo->unBody.lpbyResInfo;
			lpstRSACryptDataRes->usDataLen = lpstEPPExchangeDataHeadSection->wLen;
			lpstRSACryptDataRes->usDataLen -= sizeof(lpstReceiveInfo->unHead.byStatus);
			memcpy(lpstRSACryptDataRes->byData, lpstRcvDate + dwInfoSizeoff, lpstRSACryptDataRes->usDataLen);
		}
		break;
	case START_GM_FW_LOAD:
	case LOADING_GM_FW_CODE:
	case END_GM_FW_LOAD:
		break;
	default:
		{
			return FALSE;
		}	
	}

    if ((lpuTraceMaskCount != NULL) /*&&
        /*(CTraceManager::m_bTraceMask == FALSE)*/)
	{
		*lpuTraceMaskCount = 0;
	}

	return TRUE;
}

VOID CZT598M1FD_DevImpl::SetKeyInfo(const LPBYTE lpbyUAK, WORD wUAKSize, const LPBYTE lpbyKBPK, WORD wKBPKSize)
{
	m_lpbyUAK = lpbyUAK;
	m_wUAKSize = wUAKSize;
	m_lpbyKBPK = lpbyKBPK;
	m_wKBPKSize = wKBPKSize;
}

BOOL CZT598M1FD_DevImpl::EditDerTag(LPBYTE lpbyBuffer, LPBYTE lpbyDerTag, DerTagType enDerTagType, USHORT &usOffset)
{
	BOOL bRet = TRUE;
	USHORT usInternalOffset = 0;
	LPDerTagHead lpDerTagHead = (LPDerTagHead)lpbyDerTag;

	if (lpbyBuffer == NULL || lpbyDerTag == NULL)
	{
		return FALSE;
	}
	switch (enDerTagType)
	{
	case DER_TAG_INTEGER:
		if (((LPDerIntegerTag)lpbyDerTag)->usLength > 0 && ((LPDerIntegerTag)lpbyDerTag)->lpbyBuffer != NULL)
		{
			memcpy(lpbyBuffer, ((LPDerIntegerTag)lpbyDerTag)->lpbyBuffer, ((LPDerIntegerTag)lpbyDerTag)->usLength);
			usOffset += ((LPDerIntegerTag)lpbyDerTag)->usLength;
			return TRUE;
		}
		break;
	case DER_TAG_RSA_KEY:
		if (((LPDerRsaKeyTag)lpbyDerTag)->usLength > 0 && ((LPDerRsaKeyTag)lpbyDerTag)->lpbyBuffer != NULL)
		{
			memcpy(lpbyBuffer, ((LPDerRsaKeyTag)lpbyDerTag)->lpbyBuffer, ((LPDerRsaKeyTag)lpbyDerTag)->usLength);
			usOffset += ((LPDerRsaKeyTag)lpbyDerTag)->usLength;
			return TRUE;
		}
		break;
	case DER_TAG_RSA_KEY_WITH_SIG:
		if (((LPDerRsaKeyWithSigTag)lpbyDerTag)->usLength > 0 && ((LPDerRsaKeyWithSigTag)lpbyDerTag)->lpbyBuffer != NULL)
		{
			memcpy(lpbyBuffer, ((LPDerRsaKeyWithSigTag)lpbyDerTag)->lpbyBuffer, ((LPDerRsaKeyWithSigTag)lpbyDerTag)->usLength);
			usOffset += ((LPDerRsaKeyWithSigTag)lpbyDerTag)->usLength;
			return TRUE;
		}
		break;
	case DER_TAG_ENCRYPTED_DES_KEY:
		if (((LPDerEncDesKeytag)lpbyDerTag)->usLength > 0 && ((LPDerEncDesKeytag)lpbyDerTag)->lpbyBuffer != NULL)
		{
			memcpy(lpbyBuffer, ((LPDerEncDesKeytag)lpbyDerTag)->lpbyBuffer, ((LPDerEncDesKeytag)lpbyDerTag)->usLength);
			usOffset += ((LPDerEncDesKeytag)lpbyDerTag)->usLength;
			return TRUE;
		}
		break;
	case DER_TAG_EPP_SERIAL_NUMBER:
		if (((LPDerEppSNTag)lpbyDerTag)->usLength > 0 && ((LPDerEppSNTag)lpbyDerTag)->lpbyBuffer != NULL)
		{
			memcpy(lpbyBuffer, ((LPDerEppSNTag)lpbyDerTag)->lpbyBuffer, ((LPDerEppSNTag)lpbyDerTag)->usLength);
			usOffset += ((LPDerEppSNTag)lpbyDerTag)->usLength;
			return TRUE;
		}
		break;
	default:
		break;
	}
	memcpy(lpbyBuffer + usOffset, &lpDerTagHead->byFieldType, sizeof(lpDerTagHead->byFieldType));
	usOffset += sizeof(lpDerTagHead->byFieldType);
	if (lpDerTagHead->byLengthType == RSA_DER_TAG_LENGTH_TYPE_LONG_ONE)
	{
		memcpy(lpbyBuffer + usOffset, &lpDerTagHead->byLengthType, sizeof(lpDerTagHead->byLengthType));
		usOffset += sizeof(lpDerTagHead->byLengthType);
		memcpy(lpbyBuffer + usOffset, &(lpDerTagHead->usLength), 1);
		usOffset += 1;
	}
	else if (lpDerTagHead->byLengthType == RSA_DER_TAG_LENGTH_TYPE_LONG_TWO)
	{
		memcpy(lpbyBuffer + usOffset, &lpDerTagHead->byLengthType, sizeof(lpDerTagHead->byLengthType));
		usOffset += sizeof(lpDerTagHead->byLengthType);
		memcpy(lpbyBuffer + usOffset, (LPBYTE)&(lpDerTagHead->usLength) + 1, 1);
		usOffset += 1;
		memcpy(lpbyBuffer + usOffset, &(lpDerTagHead->usLength), 1);
		usOffset += 1;
	}
	else
	{
		memcpy(lpbyBuffer + usOffset, &(lpDerTagHead->usLength), 1);
		usOffset += 1;
	}
	switch (enDerTagType)
	{
	case DER_TAG_INTEGER:
		if (((LPDerIntegerTag)lpbyDerTag)->lpbyValues != NULL)
		{
			memcpy(lpbyBuffer + usOffset, ((LPDerIntegerTag)lpbyDerTag)->lpbyValues, lpDerTagHead->usLength);
		}
		usOffset += lpDerTagHead->usLength;
		break;
	case DER_TAG_RSA_KEY:
		if (EditDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerRsaKeyTag)lpbyDerTag)->stModulusTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		usInternalOffset = 0;
		if (EditDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerRsaKeyTag)lpbyDerTag)->stExponentTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		break;
	case DER_TAG_RSA_KEY_WITH_SIG:
		if (EditDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerRsaKeyWithSigTag)lpbyDerTag)->stDerRsaKeyTag, DER_TAG_RSA_KEY, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		usInternalOffset = 0;
		if (EditDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerRsaKeyWithSigTag)lpbyDerTag)->stSigTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		break;
	case DER_TAG_ENCRYPTED_DES_KEY:
		if (EditDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerEncDesKeytag)lpbyDerTag)->stEncDesKeyTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		usInternalOffset = 0;
		if (EditDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerEncDesKeytag)lpbyDerTag)->stSigTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		break;
	case DER_TAG_EPP_SERIAL_NUMBER:
		if (EditDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerEppSNTag)lpbyDerTag)->stSNTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		usInternalOffset = 0;
		if (EditDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerEppSNTag)lpbyDerTag)->stSigTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		break;
	default:
		bRet = FALSE;
		break;
	}
	return bRet;
}

USHORT CZT598M1FD_DevImpl::GetDerTagLength(LPBYTE lpbySource)
{
	USHORT usLength = 0;
	BYTE byLengthTemp[2] = {0};

	if (lpbySource == NULL)
	{
		return 0;
	}
	if (lpbySource[1] == RSA_DER_TAG_LENGTH_TYPE_LONG_ONE)
	{
		usLength = (USHORT)lpbySource[2];
		usLength += 3;
	}
	else if (lpbySource[1] == RSA_DER_TAG_LENGTH_TYPE_LONG_TWO)
	{
		byLengthTemp[0] = lpbySource[3];
		byLengthTemp[1] = lpbySource[2];
		usLength = *(LPUSHORT)byLengthTemp;
		usLength += 4;
	}
	else
	{
		usLength = (USHORT)lpbySource[1];
		usLength += 2;
	}
	return usLength;
}

BOOL CZT598M1FD_DevImpl::ParseDerTag(LPBYTE lpbyBuffer, LPBYTE lpbyDerTag, DerTagType enDerTagType, USHORT &usOffset)
{
	BOOL bRet = TRUE;
	USHORT usInternalOffset = 0;
	LPDerTagHead lpDerTagHead = (LPDerTagHead)lpbyDerTag;
	BYTE byLengthTemp[2] = {0};

	if (lpbyBuffer == NULL || lpbyDerTag == NULL)
	{
		return FALSE;
	}
	lpDerTagHead->byFieldType = lpbyBuffer[0];
	usOffset += 1;
	if (lpbyBuffer[1] == RSA_DER_TAG_LENGTH_TYPE_LONG_ONE)
	{
		lpDerTagHead->usLength = (USHORT)lpbyBuffer[2];
		usOffset += 2;
	}
	else if (lpbyBuffer[1] == RSA_DER_TAG_LENGTH_TYPE_LONG_TWO)
	{
		byLengthTemp[0] = lpbyBuffer[3];
		byLengthTemp[1] = lpbyBuffer[2];
		lpDerTagHead->usLength = *(LPUSHORT)byLengthTemp;
		usOffset += 3;
	}
	else
	{
		lpDerTagHead->usLength = (USHORT)lpbyBuffer[1];
		usOffset += 1;
	}
	
	switch (enDerTagType)
	{
	case DER_TAG_INTEGER:
		((LPDerIntegerTag)lpbyDerTag)->lpbyBuffer = lpbyBuffer;//此内存空间在devctrl模块，事先已被拷贝赋值，此时只记录地址即可
		((LPDerIntegerTag)lpbyDerTag)->lpbyValues = lpbyBuffer + usOffset;
		usOffset += lpDerTagHead->usLength;
		((LPDerIntegerTag)lpbyDerTag)->usLength = usOffset;
		break;
	case DER_TAG_RSA_KEY:
		((LPDerRsaKeyTag)lpbyDerTag)->lpbyBuffer = lpbyBuffer;
		if (ParseDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerRsaKeyTag)lpbyDerTag)->stModulusTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		usInternalOffset = 0;
		if (ParseDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerRsaKeyTag)lpbyDerTag)->stExponentTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		((LPDerRsaKeyTag)lpbyDerTag)->usLength = usOffset;
		break;
	case DER_TAG_RSA_KEY_WITH_SIG:
		((LPDerRsaKeyWithSigTag)lpbyDerTag)->lpbyBuffer = lpbyBuffer;
		if (ParseDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerRsaKeyWithSigTag)lpbyDerTag)->stDerRsaKeyTag, DER_TAG_RSA_KEY, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		usInternalOffset = 0;
		if (ParseDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerRsaKeyWithSigTag)lpbyDerTag)->stSigTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		((LPDerRsaKeyWithSigTag)lpbyDerTag)->usLength = usOffset;
		break;
	case DER_TAG_ENCRYPTED_DES_KEY:
		((LPDerEncDesKeytag)lpbyDerTag)->lpbyBuffer = lpbyBuffer;
		if (ParseDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerEncDesKeytag)lpbyDerTag)->stEncDesKeyTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		usInternalOffset = 0;
		if (ParseDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerEncDesKeytag)lpbyDerTag)->stSigTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		((LPDerEncDesKeytag)lpbyDerTag)->usLength = usOffset;
		break;
	case DER_TAG_EPP_SERIAL_NUMBER:
		((LPDerEppSNTag)lpbyDerTag)->lpbyBuffer = lpbyBuffer;
		if (ParseDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerEppSNTag)lpbyDerTag)->stSNTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		usInternalOffset = 0;
		if (ParseDerTag(lpbyBuffer + usOffset, (LPBYTE)&((LPDerEppSNTag)lpbyDerTag)->stSigTag, DER_TAG_INTEGER, usInternalOffset) == FALSE)
		{
			return FALSE;
		}
		usOffset += usInternalOffset;
		((LPDerEppSNTag)lpbyDerTag)->usLength = usOffset;
		break;
	default:
		bRet = FALSE;
		break;
	}

	return bRet;

}

BOOL CZT598M1FD_DevImpl::SecureComm(BYTE byCommand, LPBYTE lpbyData, WORD &wStatusCode)
{
	LPSecureCommProtocolHead lpSecureCommProtocolHead = (LPSecureCommProtocolHead)m_bySndBuff;
	LPSecureCommProtocolTail lpSecureCommProtocolTail = NULL;
	BYTE byBuffer[EXCHANGE_DATA_MAX_LEN] = {0};
	WORD wSndBufflen = 0;
	WORD wLoop = 0;
	WORD wIdx = 0;
	DWORD dwLen = 0;
	WORD wCRC = 0;
	USHORT usBlockNum = 0;
	USHORT usCommandLen = sizeof(lpSecureCommProtocolHead->bySerialNumber) + sizeof(lpSecureCommProtocolHead->byCommandType) + sizeof(lpSecureCommProtocolHead->byCommand);
	BYTE byCRC[2] = {0};

	memset(m_bySndBuff, 0x00, sizeof(m_bySndBuff));
	lpSecureCommProtocolHead->byCommandHead = SECURE_COMM_HEAD;
	lpSecureCommProtocolHead->byDeviceNo = SECURE_COMM_DEVICE_NO;
	lpSecureCommProtocolHead->wCommandFeature = SECURE_COMM_COMMAND_FEATURE;
	lpSecureCommProtocolHead->byCommandType = SECURE_COMM_COMMAND_TYPE;
	lpSecureCommProtocolHead->byCommand = byCommand;
	switch (byCommand)
	{
	case START_MAIN_FW_UPDATE:
		break;
	case UPDATING_MAIN_FW:
		usCommandLen += sizeof(UpdatingMainFWParam);
		memcpy(m_bySndBuff + sizeof(SecureCommProtocolHead), lpbyData, sizeof(UpdatingMainFWParam));
		break;
	case FINISH_MAIN_FW_UPDATE:
		usCommandLen += 64;
		memcpy(m_bySndBuff + sizeof(SecureCommProtocolHead), lpbyData, 64);
		usBlockNum = wStatusCode;
		wStatusCode = STATUS_SUCCESS;
		break;
	default:
        //m_traceManager.TraceIn(TRM_INT, TRM_LV_ERROR, "Param Error!");
		return FALSE;
		break;
	}
	lpSecureCommProtocolHead->byCommandLength[0] = (BYTE)(usCommandLen >> 8);
	lpSecureCommProtocolHead->byCommandLength[1] = (BYTE)usCommandLen;
	lpSecureCommProtocolTail = (LPSecureCommProtocolTail)(m_bySndBuff +  sizeof(SecureCommProtocolHead) + (usCommandLen - 3));
	lpSecureCommProtocolTail->bySignatureEnd = SECURE_COMM_END;
	if ((CAlgorithm::CalcCRC(16, (LPBYTE)m_bySndBuff, sizeof(SecureCommProtocolHead) + (usCommandLen - 3) +
		sizeof(lpSecureCommProtocolTail->bySignatureEnd), &wCRC)) == FALSE)
	{
        //m_traceManager.TraceIn(TRM_INT, TRM_LV_ERROR, "CalcCRC Error!");
		return FALSE;
	}
	byCRC[0] = (BYTE)(wCRC >> 8);
	byCRC[1] = (BYTE)wCRC;
	lpSecureCommProtocolTail->wCRC = *(LPWORD)byCRC;
	wSndBufflen = sizeof(SecureCommProtocolHead) + (usCommandLen - 3) + sizeof(SecureCommProtocolTail); 

	m_stCommInfo.cdSndData.lpvData = byBuffer;
	m_stCommInfo.cdRcvData.lpvData = m_byRcvBuff;
	m_stCommInfo.dwTimeout = 5000;
	wLoop = wSndBufflen / sizeof(byBuffer);
	if (wSndBufflen % sizeof(byBuffer) > 0)
	{
		wLoop++;
	}
	m_stCommInfo.cdSndData.dwDataLen = sizeof(byBuffer);
	m_stCommInfo.cdRcvData.dwDataLen = sizeof(m_byRcvBuff);
	for (wIdx = 0; wIdx < wLoop; wIdx++)
	{
		memset(byBuffer, 0x00, sizeof(byBuffer));
		memcpy(byBuffer + 1, m_bySndBuff + wIdx * (sizeof(byBuffer) - 1), sizeof(byBuffer) - 1);
        //dwLen = m_lpIDevComm->OnlyWriteToDevice(m_stCommInfo);
        dwLen=m_lpIDevComm->ReceiveData(m_byRcvBuff,m_stCommInfo.dwTimeout);
		if (dwLen == 0)
		{
            //m_traceManager.TraceInBuffer(TRM_SND, TRM_LV_ERROR, byBuffer + 1, sizeof(byBuffer) - 1,
                //NULL/*, uMaskOffset, uMaskLen, uMaskCnt*/);
			return FALSE;
		}
        ////m_traceManager.TraceInBuffer(TRM_SND, TRM_LV_COMMN, byBuffer + 1, sizeof(byBuffer) - 1,
		//	NULL/*, uMaskOffset, uMaskLen, uMaskCnt*/);
	}
    //m_traceManager.TraceInBuffer(TRM_SND, TRM_LV_COMMN, m_bySndBuff, wSndBufflen,
        //NULL/*, uMaskOffset, uMaskLen, uMaskCnt*/);

	if (byCommand == FINISH_MAIN_FW_UPDATE)
	{
		m_stCommInfo.cdRcvData.lpvData = byBuffer;
		m_stCommInfo.cdRcvData.dwDataLen = sizeof(byBuffer);
		while (usBlockNum-- > 0)
		{
			memset(byBuffer, 0x00, sizeof(byBuffer));
            //m_traceManager.TraceInFormat(TRM_INT, TRM_LV_DEBUG, "Update %d", usBlockNum + 1);
            //dwLen = m_lpIDevComm->StartReceive(m_stCommInfo);
            dwLen=m_lpIDevComm->ReceiveData(m_bySndBuff,m_stCommInfo.dwTimeout);
			if(dwLen == 0)
			{
                //m_traceManager.TraceIn(TRM_INT, TRM_LV_ERROR, "StartReceive Empty!");
				return FALSE;
			}
			else
			{
                //m_traceManager.TraceInBuffer(TRM_RCV, TRM_LV_COMMN, byBuffer + 1, sizeof(byBuffer) - 1,
				//	NULL/*, uMaskOffset, uMaskLen, uMaskCnt*/);
			}
		}
	}
	m_stCommInfo.cdRcvData.lpvData = m_byRcvBuff;
	m_stCommInfo.cdRcvData.dwDataLen = sizeof(m_byRcvBuff);
    //dwLen = m_lpIDevComm->StartReceive(m_stCommInfo);
    dwLen=m_lpIDevComm->ReceiveData(m_bySndBuff,m_stCommInfo.dwTimeout);
	if(dwLen == 0)
	{
        //m_traceManager.TraceIn(TRM_INT, TRM_LV_ERROR, "StartReceive Empty!");
		return FALSE;
	}
    //m_traceManager.TraceInBuffer(TRM_RCV, TRM_LV_COMMN, m_byRcvBuff + 1, 64,
        //NULL/*, uMaskOffset, uMaskLen, uMaskCnt*/);
	memcpy((LPBYTE)&wStatusCode + 1, m_byRcvBuff + 1 + sizeof(SecureCommProtocolHead), 1);
	memcpy((LPBYTE)&wStatusCode, m_byRcvBuff + 1 + sizeof(SecureCommProtocolHead) + 1, 1);

	CAlgorithm::CalcCRC(16, m_byRcvBuff + 1, sizeof(SecureCommProtocolHead) + 2 + 1, &wCRC);
	byCRC[0] = (BYTE)(wCRC >> 8);
	byCRC[1] = (BYTE)wCRC;
	lpSecureCommProtocolTail = (LPSecureCommProtocolTail)(m_byRcvBuff + 1 + sizeof(SecureCommProtocolHead) + 2);
	if (memcmp(byCRC, &lpSecureCommProtocolTail->wCRC, sizeof(wCRC)) != 0)
	{
        //m_traceManager.TraceIn(TRM_INT, TRM_LV_ERROR, "CRC Check Error!");
		//return FALSE;
	}

	return TRUE;
}