myvtm/DevAdapter/nantian/pinpad.1.1/pinpad.nantian.1.1.cpp

#include "pinpad.nantian.1.1.h"

#include <cstring>
#include <cstdio>

//日志类
CILIXTrace* m_trace;

PinPadNantian::PinPadNantian()
{
    m_trace = new CILIXTrace(NULL, "Nantian", "Pinpad");
    m_trace->WriteTrace("PinPadNantian", "pinpad.Nantian.1.1.so - 1.0.0.1");

    char SOPath[100] = "";
    CILIX_AUX_X::CILIX_GetModuleCurPath(SOPath);
    void *handle;
    strcat(SOPath, "libXZ_F35_API_LINUX.nantian.so");
    m_trace->WriteTrace("PinPadNantian", "SOPath = %s", SOPath);
    handle=dlopen(SOPath,RTLD_LAZY);
    if(handle == NULL)
    {
        m_trace->WriteTrace("PinPadNantian", "Load libXZ_F35_API_LINUX.nantian.so Fail");
        m_trace->WriteTrace("PinPadNantian", "Exit-");
        return ;
    }
    m_trace->WriteTrace("PinPadNantian", "Load libXZ_F35_API_LINUX.nantian.so Success");

    SUNSON_OpenCom=(int(*)(const char *, long))dlsym(handle,"SUNSON_OpenCom");
    SUNSON_GetVersionNo=(int(*)(unsigned char *))dlsym(handle,"SUNSON_GetVersionNo");
    SUNSON_CloseCom=(int(*)(void))dlsym(handle,"SUNSON_CloseCom");
    SUNSON_ScanGetKey=(int(*)(unsigned char *))dlsym(handle,"SUNSON_ScanGetKey");
    SUNSON_CloseEppPlainTextMode=(int(*)(unsigned char *))dlsym(handle,
                                                                "SUNSON_CloseEppPlainTextMode");
    SUNSON_LoadSM4Key=(int(*)(int, int, int, unsigned char, unsigned char *, unsigned char *))dlsym(handle,
                                                     "SUNSON_LoadSM4Key");
    SUNSON_LoadUserKey=(int(*)(int, int, long, unsigned char, unsigned char *, unsigned char *))dlsym(handle,
                                                                                                      "SUNSON_LoadUserKey");
    SUNSON_SetKeyMark=(int(*)(long, long, long, long, unsigned char*))dlsym(handle,
                                                                            "SUNSON_SetKeyMark");
    SUNSON_GetPin=(int(*)(unsigned char, unsigned char, unsigned char, unsigned char *))dlsym(handle,
                                                                                              "SUNSON_GetPin");
    SUNSON_UseEppPlainTextMode=(int(*)(unsigned char, unsigned char, unsigned char *))dlsym(handle,
                                                                                            "SUNSON_UseEppPlainTextMode");
    SUNSON_SwitchArithmetic=(int(*)(unsigned char, unsigned char *))dlsym(handle, "SUNSON_SwitchArithmetic");
    SUNSON_GetPinBlock=(int(*)(int, int, unsigned char, unsigned char, unsigned char*, unsigned char*))dlsym(handle,
                                                                                                             "SUNSON_GetPinBlock");
    SUNSON_DataCompute=(int(*)(int, unsigned char, int, unsigned char, int, unsigned char *, unsigned char *))dlsym(handle,
                                                                                                                    "SUNSON_DataCompute");
    SUNSON_MakeMac=(int(*)(int, int, int, unsigned char *, unsigned char *))dlsym(handle, "SUNSON_MakeMac");
    SUNSON_ScanKeyPress=(int(*)(unsigned char *))dlsym(handle, "SUNSON_ScanKeyPress");
}

PinPadNantian::~PinPadNantian()
{

}

DEVICEBASE_API ErrorCodeEnum CreateDevComponent(DeviceBaseClass*& pOutDevAptObj)
{
    pOutDevAptObj = new PinPadNantian();
    if(pOutDevAptObj == NULL)
    {
        return Error_Resource;
    }

    /*cmb::log_init_config config;
    config.dev_name = "pinpad";
    config.log_dir = ("/etc/nantian");

    std::string str;
    cmb::log4vendor::init(config, str);
    char msg[100];
    LOG4VTM(TRACE, "<CreateDevComponent> - 执行init()返回信息:"<<str.c_str());*/

    return Error_Succeed;
}

DEVICEBASE_API ErrorCodeEnum  ReleaseDevComponent(DeviceBaseClass*& pInDevAptObj)
{
    if(pInDevAptObj == NULL)
    {
        return Error_Param;
    }
    if(PinPadNantian* pTmp = dynamic_cast<PinPadNantian*>(pInDevAptObj))
    {
        delete pTmp;
        pTmp = NULL;
        return Error_Succeed;
    }
    return Error_Param;

}

ErrorCodeEnum PinPadNantian::GetDevCategory(DevCategoryInfo &devCategory)
{
    m_trace->WriteTrace("GetDevCategory","Enter-");

    //赋值
    strcpy(devCategory.szType,"PinPad");
    strcpy(devCategory.szVendor,"nantian");
    devCategory.version.wMajor = 1;
    devCategory.version.wMinor = 0;
    devCategory.version.wRevision = 0;
    devCategory.version.wBuild = 1;

    //设备未连接
    if(m_Open == false)
    {
            strcpy(devCategory.szModel,"");
            devCategory.eState = DEVICE_STATUS_NOT_READY;
            m_trace->WriteTrace("GetDevCategory", "设备未连接");
            m_trace->WriteTrace("GetDevCategory", "Exit-");
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"设备未连接");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
            return Error_Succeed;
    }

    strcpy(devCategory.szModel,"SE8098BV1.0");

    char ver[100] = "";
    int sret = SUNSON_GetVersionNo((unsigned char *)ver);
    m_trace->WriteTrace("GetDevCategory","执行SUNSON_GetVersionNo返回%d", sret);
    if (sret == 0)
    {
            m_trace->WriteTrace("GetDevCategory", "查设备状态失败");
            m_trace->WriteTrace("GetDevCategory", "Exit-");
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"查设备状态失败");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
            devCategory.eState = DEVICE_STATUS_FAULT;
    }

    m_trace->WriteTrace("GetDevCategory", "Exit-");
    devCategory.eState = DEVICE_STATUS_NORMAL;
    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::Reset()
{
    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::DevClose()
{
    SUNSON_CloseCom();
    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::GetLastErr(DevErrorInfo &devErrInfo)
{
    memset(devErrInfo.szErrMsg,0,sizeof(devErrInfo.szErrMsg));
    devErrInfo.dwErrMsgLen = m_Error.dwErrMsgLen;
    memcpy(devErrInfo.szErrMsg,m_Error.szErrMsg,m_Error.dwErrMsgLen);
    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::DevOpen(DWORD dwPort, DWORD dwBaudRate)
{
    /*LOG4VTM(TRACE, "<DevOpen> - "<<"Enter-");
    LOG4VTM(TRACE, "<DevOpen> - "<<"dwPort = "<<dwPort<<", dwBaudRate = "<<dwBaudRate);*/

    m_trace->WriteTrace("DevOpen","Enter-");
    m_trace->WriteTrace("DevOpen","dwPort = %d", dwPort);

    char sztty[100];
    sprintf(sztty, "/dev/ttyXRUSB%d", dwPort-1);
    m_trace->WriteTrace("DevOpen","sztty = %s", sztty);

    int sret = SUNSON_OpenCom(sztty, 9600);
    m_trace->WriteTrace("DevOpen","执行SUNSON_OpenCom返回%d", sret);
    if (sret != 1)
    {
        m_trace->WriteTrace("DevOpen", "设备打开失败");
        m_trace->WriteTrace("DevOpen", "Exit-");

        m_Open = FALSE;
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备打开失败");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        return Error_DevConnFailed;
    }

    m_trace->WriteTrace("DevOpen", "设备打开成功");
    m_trace->WriteTrace("DevOpen", "Exit-");
    m_Open = TRUE;
    memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
    strcpy(m_Error.szErrMsg,"设备打开成功");
    m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::KeyRead(BYTE &ch)
{
    if (m_Open != TRUE)
    {
        m_trace->WriteTrace("KeyRead","设备未打开");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备未打开，不能做键值读取操作");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        return Error_NotInit;
    }

    //按键值
    unsigned char fKey = 0;
    int iret = SUNSON_ScanKeyPress(&fKey);
    //********无按键
    if (iret == 0)
    {
        return Error_DevCommFailed;
    }

    unsigned char fResult[100] = "";
    //********有按键
    if (iret == 1)
    {
        if (g_flag == 1)//密文模式
        {
            //密码键
            if (fKey == 0x2A)
            {
                m_trace->WriteTrace("KeyRead", "keypress *");
                //记录输入位数
                m_PinNum++;

                if (m_PinNum>=6 && g_Auto == 1)
                {
                    //输入终止
                    ch = 0x3f;
                    SUNSON_CloseEppPlainTextMode(fResult);
                    m_trace->WriteTrace("KeyRead", "键盘关闭");
                }
                else
                {
                    ch = 0x3f;
                }
            }

            //Enter
            if (fKey == 0x0D)
            {
                if(g_Auto == 0)
                {
                    m_trace->WriteTrace("KeyRead", "keypress Enter");
                    ch = 0x0D;
                    SUNSON_CloseEppPlainTextMode(fResult);
                    m_trace->WriteTrace("KeyRead", "键盘关闭");
                }
                else
                {
                    return Error_DevCommFailed;
                }
            }

            //Up
            if (fKey == 0x54)
            {
                m_trace->WriteTrace("KeyRead", "keypress Up");
                return Error_DevCommFailed;
            }

            //Down
            if (fKey == 0x23)
            {
                m_trace->WriteTrace("KeyRead", "keypress Down");
                return Error_DevCommFailed;
            }

            //Cancel
            if (fKey == 0x1B)
            {
                ch = 0x1B;
                m_trace->WriteTrace("KeyRead", "keypress CANCEL");
                //清空输入
                m_PinNum = 0;
            }

            //Backspace
            if (fKey == 0x08)
            {
                m_trace->WriteTrace("KeyRead", "keypress BACKSPACE");
                ch = 0x08;
                //后退一格
                if (m_PinNum > 0)
                        m_PinNum --;
                //清空输入
                m_PinNum = 0;
            }
        }
        if (g_flag == 0)//明文模式
        {
            m_trace->WriteTrace("KeyRead", "fKey = 0x%02X",fKey);
            switch(fKey)
            {
                case 0x30://0
                        ch = 0x30;
                        m_trace->WriteTrace("KeyRead", "keypress 0");
                        break;
                case 0x31://1
                        ch = 0x31;
                        m_trace->WriteTrace("KeyRead", "keypress 1");
                        break;
                case 0x32://2
                        ch = 0x32;
                        m_trace->WriteTrace("KeyRead", "keypress 2");
                        break;
                case 0x33://3
                        ch = 0x33;
                        m_trace->WriteTrace("KeyRead", "keypress 3");
                        break;
                case 0x34://4
                        ch = 0x34;
                        m_trace->WriteTrace("KeyRead", "keypress 4");
                        break;
                case 0x35://5
                        ch = 0x35;
                        m_trace->WriteTrace("KeyRead", "keypress 5");
                        break;
                case 0x36://6
                        ch = 0x36;
                        m_trace->WriteTrace("KeyRead", "keypress 6");
                        break;
                case 0x37://7
                        ch = 0x37;
                        m_trace->WriteTrace("KeyRead", "keypress 7");
                        break;
                case 0x38://8
                        ch = 0x38;
                        m_trace->WriteTrace("KeyRead", "keypress 8");
                        break;
                case 0x39://9
                        ch = 0x39;
                        m_trace->WriteTrace("KeyRead", "keypress 9");
                        break;
                case 0x08://BackSpace
                        ch = 0x08;
                        m_trace->WriteTrace("KeyRead", "keypress BackSpace");
                        break;
                case 0x2e://.
                        ch = 0x2e;
                        m_trace->WriteTrace("KeyRead", "keypress .");
                        break;
                case 0x0d://ENTER
                        ch = 0x0d;
                        m_trace->WriteTrace("KeyRead", "keypress ENTER");
                        break;
                case 0x1b:////ESC
                        ch = 0x1b;
                        m_trace->WriteTrace("KeyRead", "keypress ESC");
                        break;
                case 0x54:////00
                        ch = 0x4f;
                        m_trace->WriteTrace("KeyRead", "keypress 00");
                        break;
                case 0x23:////ESC
                        ch = 0x23;
                        m_trace->WriteTrace("KeyRead", "keypress DOWN");
                        break;
                default:
                        ch = 0x00;
                        break;
            }
        }
    }

    m_trace->WriteTrace("KeyRead", "获取键值成功,获取的键值为0x%02X",ch);
    memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
    strcpy(m_Error.szErrMsg,"获取键值成功");
    m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
    return Error_Succeed;
}

int m_Encryptmethod;
int m_MacAlgorithm;
int m_PinAlgorithm;
int m_ECB_CBC_Mode;

ErrorCodeEnum PinPadNantian::SetParam(SetParamTypeEnum eType, SetParamValueEnum eValue)
{
    m_trace->WriteTrace("SetParam","Enter-");
    m_trace->WriteTrace("SetParam","eType = %d, eValue = %d",eType, eValue);

    switch (eType)
    {
        case EPP_PT_SET_ENCRYPT_METHOD:
            if (eValue == EPP_ALGO_METHOD_DES)
            {
                m_Encryptmethod = 0;
            }
            else if (eValue == EPP_ALGO_METHOD_3DES)
            {
                m_Encryptmethod = 1;
            }
            else if (eValue == EPP_ALGO_METHOD_DES_TMK)
            {
                m_Encryptmethod = 2;
            }
            else if (eValue == EPP_ALGO_METHOD_3DES_TMK)
            {
                m_Encryptmethod = 3;
            }
            else if (eValue == EPP_ALGO_METHOD_SM4)
            {
                m_Encryptmethod = 4;
            }
            else
            {
                m_trace->WriteTrace("SetParam","EPP_PT_SET_ENCRYPT_METHOD中的eValue值不符合");
                memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
                strcpy(m_Error.szErrMsg,"参数错误");
                m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
                return Error_Param;
            }
            break;
        case EPP_PT_SET_MAC_ALGORITH:
            if (eValue == EPP_MAC_ALGO_ASNIX99)
            {
                if (m_Encryptmethod == 0) //DES
                {
                         m_MacAlgorithm = 1;
                }
                else if (m_Encryptmethod == 1) //3DES
                {
                        m_MacAlgorithm = 2;
                }
                else if (m_Encryptmethod == 4) //SM4
                {
                        m_MacAlgorithm = 3;
                }
            }
            else if (eValue == EPP_MAC_ALGO_PBOC)
            {
                m_trace->WriteTrace("SetParam","不支持除了EPP_MAC_ALGO_ASNIX99以外的其它MAC算法");
                memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
                strcpy(m_Error.szErrMsg,"不支持的算法");
                m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
                return Error_NoPrivilege;
            }
            else if (eValue == EPP_MAC_ALGO_UNIONPAY)
            {
                m_trace->WriteTrace("SetParam","不支持除了EPP_MAC_ALGO_ASNIX99以外的其它MAC算法");
                memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
                strcpy(m_Error.szErrMsg,"不支持的算法");
                m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
                return Error_NoPrivilege;
            }
            else
            {
                m_trace->WriteTrace("SetParam","EPP_PT_SET_MAC_ALGORITH的eValue值不符合");
                memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
                strcpy(m_Error.szErrMsg,"参数错误");
                m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
                return Error_Param;
            }
            break;
        case EPP_PT_SET_PIN_ALGORITH:
            if (eValue == EPP_PIN_ALGO_ISO9564_1_ANSI)
            {
                //确定为ANSI算法
                m_PinAlgorithm = 1; //ANSI算法
            }
            else if (eValue == EPP_PIN_ALGO_IBM3624)
            {
                //确定为IBM3624算法
                m_PinAlgorithm = 2; //IBM3624算法
            }
            else if (eValue == EPP_PIN_ALGO_SM4)
            {
                m_PinAlgorithm = 3;
            }
            else
            {
                m_trace->WriteTrace("SetParam","EPP_PT_SET_PIN_ALGORITH的eValue值不符合");
                memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
                strcpy(m_Error.szErrMsg,"参数错误");
                m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
                return Error_Param;
            }
            break;
        case EPP_PT_SET_ECB_CBC_MODE:
            if (eValue == EPP_ALGO_MODE_ECB || eValue == EPP_ALGO_MODE_DEC_ECB || eValue == EPP_ALGO_MODE_3DEC_ECB)
            {
                m_ECB_CBC_Mode = 1;
            }
            else if (eValue == EPP_ALGO_MODE_CBC || eValue == EPP_ALGO_MODE_DEC_CBC || eValue == EPP_ALGO_MODE_3DEC_CBC)
            {
                m_ECB_CBC_Mode = 2;
            }
            else
            {
                m_trace->WriteTrace("SetParam","EPP_PT_SET_ECB_CBC_MODE的eValue值不符合");
                memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
                strcpy(m_Error.szErrMsg,"参数错误");
                m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
                return Error_Param;
            }
            break;
        default:
            m_trace->WriteTrace("SetParam","参数错误");
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"参数错误");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
            return Error_Param;
            break;
    }

    m_trace->WriteTrace("SetParam", "Exit-");
    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::SetAccNo(AccountInfo accInfo)
{
    m_trace->WriteTrace("SetAccNo","Enter-");

    m_trace->WriteTrace("SetAccNo","accInfo.dwAccLen = %d", accInfo.dwAccLen);

    m_trace->WriteTrace(CILIXTRACE_L_DEBUG, "SetAccNo", "accInfo.account = %s", accInfo.account);

    if (accInfo.dwAccLen < 0 || accInfo.dwAccLen > 12)
    {
        m_trace->WriteTrace("SetAccNo","输入的客户账号长度错误，账号长度为 accInfo.dwAccLen =  %d",
                            accInfo.dwAccLen);
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"参数错误");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("SetAccNo", "Exit-");
        return Error_Param;
    }
    if (accInfo.account == NULL)
    {
        m_trace->WriteTrace("SetAccNo","输入的客户账号为空");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"参数为空");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("SetAccNo", "Exit-");
        return Error_Null;
    }

    g_CardNo.dwAccLen = accInfo.dwAccLen;
    memset(g_CardNo.account,0,sizeof(g_CardNo.account));
    memcpy(g_CardNo.account,accInfo.account,accInfo.dwAccLen);
    strcpy(m_Error.szErrMsg,"设置账户信息成功");
    m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
    m_trace->WriteTrace("SetAccNo", "Exit-");
    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::LoadMasterKey(MasterKeyParam masterKey)
{
    m_trace->WriteTrace("LoadMasterKey","Enter-");

    m_trace->WriteTrace("LoadMasterKey", "masterKey.dwMasterSN = %d", masterKey.dwSN);
    m_trace->WriteTrace(CILIXTRACE_L_DEBUG, "LoadMasterKey", "masterKey.key = %s", masterKey.key);

    if (m_Open != TRUE)
    {
        m_trace->WriteTrace("LoadMasterKey","设备未打开，不能做加载主密钥操作");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备未打开");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("LoadMasterKey", "Exit-");
        return Error_NotInit;
    }
    if ((masterKey.smFlag != 0 && masterKey.smFlag != 1) || (masterKey.key == NULL) ||
        (masterKey.dwSN < 0 ))
    {
        m_trace->WriteTrace("LoadMasterKey","输入参数错误或为空");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"输入参数错误或为空");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("LoadMasterKey", "Exit-");
        return Error_Param;
    }

    //压缩数据
    unsigned char fswData[1025] = "";
    CILIX_AUX_X::CILIX_uti_pack((unsigned char*)masterKey.key, fswData, 32);

    //导入
    if (masterKey.smFlag == 1)//国密
    {
        if (masterKey.dwSN < 0 || masterKey.dwSN > 12 || masterKey.key == NULL)
        {
            m_trace->WriteTrace("LoadMasterKey","国密：输入秘钥号超出键盘规定的最大值");
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"输入参数错误");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
            m_trace->WriteTrace("LoadMasterKey", "Exit-");
            return Error_Param;
        }

        unsigned char fResult[1025] = "";
        int sret = SUNSON_LoadSM4Key(masterKey.dwSN, 65535, 0x27, 16, (unsigned char*)fswData,
                                     fResult);
        m_trace->WriteTrace("LoadMasterKey","国密：加载主密钥操作返回值sret = %d,fResult[0] = 0x%02x",
                            sret,fResult[0]);
        if (sret != 1)
        {
                memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
                strcpy(m_Error.szErrMsg,"导入SM4主密钥失败");
                m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
                m_trace->WriteTrace("LoadMasterKey", "Exit-");
                return Error_Hardware;
        }
        m_trace->WriteTrace("LoadMasterKey","国密：加载主密钥操作成功");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"操作成功");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        return Error_Succeed;
    }
    else
    {
        masterKey.dwSN += 10;
        if (masterKey.dwSN < 0 || masterKey.dwSN > 63 || masterKey.key == NULL)
        {
            m_trace->WriteTrace("LoadMasterKey","非国密：输入秘钥号超出键盘规定的最大值");
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"输入参数错误");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
            m_trace->WriteTrace("LoadMasterKey", "Exit-");
            return Error_Param;
        }

        unsigned char fResult[1025] = "";
        int sret = SUNSON_LoadUserKey(masterKey.dwSN, 65535, 0x27, 16, (unsigned char*)fswData, fResult);
        m_trace->WriteTrace("LoadMasterKey","非国密：invoke SUNSON_LoadUserKey,sret = %d,fResult[0] = 0x%02x",sret,fResult[0]);
        if (sret != 1)
        {
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"导入3DES主密钥失败");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
            m_trace->WriteTrace("LoadMasterKey", "Exit-");
            return Error_Hardware;
        }

        m_trace->WriteTrace("LoadMasterKey","非国密：加载3DES主密钥操作成功");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"操作成功");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("LoadMasterKey", "Exit-");
        return Error_Succeed;
    }
}

ErrorCodeEnum PinPadNantian::LoadWorkingKey(WorkKeyParam wkKey)
{
    m_trace->WriteTrace("LoadWorkingKey","Enter-");

    m_trace->WriteTrace("LoadWorkingKey","wkKey.dwMasterSN = %d, wkKey.dwWorkingSN = %d",
                        wkKey.dwMasterSN, wkKey.dwWorkingSN);
    m_trace->WriteTrace(CILIXTRACE_L_DEBUG, "LoadWorkingKey","wkKey.key = %s", wkKey.key);

    if (m_Open != TRUE)
    {
        m_trace->WriteTrace("LoadWorkingKey","设备未打开，不能做加载主密钥操作");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备未打开");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("LoadWorkingKey", "Exit-");
        return Error_NotInit;
    }
    if ((wkKey.smFlag != 0 && wkKey.smFlag != 1) || (wkKey.dwMasterSN < 0 || wkKey.dwWorkingSN < 0) || (wkKey.key == NULL))
    {
        m_trace->WriteTrace("LoadWorkingKey","输入参数错误或为空");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"输入参数错误或为空");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("LoadWorkingKey", "Exit-");
        return Error_Param;
    }

    unsigned char fswData[1025] = "";
    CILIX_AUX_X::CILIX_uti_pack((unsigned char*)wkKey.key, fswData, 32);

    if (wkKey.smFlag == 1)//国密
    {
        wkKey.dwWorkingSN += 2;
        if (wkKey.dwWorkingSN <0 || wkKey.dwWorkingSN > 12 || wkKey.dwMasterSN < 0 || wkKey.dwMasterSN > 12 || wkKey.key == NULL)
        {
            m_trace->WriteTrace("LoadWorkingKey","国密：输入秘钥号处理后，超出键盘规定的最大值输入秘钥号");
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"输入参数错误");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
            return Error_Param;
        }
        //导入
        unsigned char fResult[1025] = "";
        int sret = SUNSON_LoadSM4Key(wkKey.dwWorkingSN, wkKey.dwMasterSN, 0x07, 16, fswData, fResult);
        m_trace->WriteTrace("LoadWorkingKey","国密：加载工作密钥操作返回值sret = %d,fResult[0] = 0x%02x",sret,fResult[0]);
        if (sret != 1)
        {
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"导入SM4工作密钥失败");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
            m_trace->WriteTrace("LoadWorkingKey", "Exit-");
            return Error_Hardware;
        }
        m_trace->WriteTrace("LoadWorkingKey","国密：加载SM4工作密钥操作成功");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"操作成功");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        return Error_Succeed;
    }
    else
    {
        wkKey.dwWorkingSN += 11;
        wkKey.dwMasterSN += 10;
        if (wkKey.dwWorkingSN <0 || wkKey.dwWorkingSN > 64 || wkKey.dwMasterSN < 0 || wkKey.dwMasterSN > 32 || wkKey.key == NULL)
        {
            m_trace->WriteTrace("LoadWorkingKey","非国密：超出键盘规定的最大值输入秘钥号");
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"输入参数错误");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
            m_trace->WriteTrace("LoadWorkingKey", "Exit-");
            return Error_Param;
        }

        unsigned char fResult[1025] = "";
        int sret = SUNSON_LoadUserKey(wkKey.dwWorkingSN, wkKey.dwMasterSN, 0x07, 16, (unsigned char*)fswData, fResult);
        m_trace->WriteTrace("LoadWorkingKey","非国密：invoke SUNSON_LoadUserKey,sret = %d,fResult[0] = 0x%02x",sret,fResult[0]);
        if (sret != 1)
        {
                memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
                strcpy(m_Error.szErrMsg,"导入3DES工作密钥失败");
                m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
                m_trace->WriteTrace("LoadWorkingKey", "Exit-");
                return Error_Hardware;
        }

        m_trace->WriteTrace("LoadWorkingKey","非国密：加载3DES工作密钥操作成功");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"操作成功");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("LoadWorkingKey", "Exit-");
        return Error_Succeed;
    }
}

ErrorCodeEnum PinPadNantian::ActiveWorkingKey(DWORD dwMkSN, DWORD dwWkSN)
{
    m_trace->WriteTrace("ActiveWorkingKey","Enter-");

    m_trace->WriteTrace("ActiveWorkingKey","dwMkSN = %d,dwWkSN = %d",dwMkSN,dwWkSN);

    if (m_Open != TRUE)
    {
        m_trace->WriteTrace("ActiveWorkingKey", "设备未打开，不能做激活工作秘钥操作");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备未打开");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("ActiveWorkingKey", "Exit-");
        return Error_NotInit;
    }

    g_dwMkSN = dwMkSN;
    g_dwWkSN = dwWkSN;

    memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
    strcpy(m_Error.szErrMsg,"操作成功");
    m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

    m_trace->WriteTrace("ActiveWorkingKey", "Exit-");
    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::StartPinInput(BYTE byLen)
{
    m_trace->WriteTrace("StartPinInput","Enter-");

    if (m_Open != TRUE)
    {
        m_trace->WriteTrace("StartPinInput","设备未打开，不能做Pin输入操作");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备未打开");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("StartPinInput", "Exit-");
        return Error_NotInit;
    }

    char fResult[1025] = "";
    SUNSON_SetKeyMark(0x1FFF, 0, 0, 0, (unsigned char*)fResult);

    //重置输入位数
    m_PinNum = 0;
    g_flag = 1;//标记是密文输入
    g_Auto = 1;//标记自动结束

    memset(fResult,0,sizeof(fResult));
    //激活密码输入
    int iret = SUNSON_GetPin(1, 6, 0x01, (unsigned char*)fResult);
    m_trace->WriteTrace("StartPinInput", "invoke SUNSON_GetPin return %d, fResult[0] = 0x%02x", iret, fResult[0]);
    if (iret != 1)
    {
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"开启密文输入失败");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("StartPinInput", "Exit-");
        return Error_Hardware;
    }

    memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
    strcpy(m_Error.szErrMsg,"操作成功");
    m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

    m_trace->WriteTrace("StartPinInput", "Exit-");
    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::StartPinInputConfirm(BYTE byLen)
{
    m_trace->WriteTrace("StartPinInputConfirm","Enter-");

    if (m_Open != TRUE)
    {
        m_trace->WriteTrace("StartPinInputConfirm","设备未打开，不能做Pin输入操作");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备未打开");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("StartPinInputConfirm", "Exit-");
        return Error_NotInit;
    }

    char fResult[1025] = "";
    SUNSON_SetKeyMark(0x1FFF, 0, 0, 0, (unsigned char*)fResult);

    //重置输入位数
    m_PinNum = 0;
    g_flag = 1;//标记是密文输入
    g_Auto = 0;//标记自动结束

    memset(fResult,0,sizeof(fResult));
    //激活密码输入
    int iret = SUNSON_GetPin(1, 6, 0x00, (unsigned char*)fResult);
    m_trace->WriteTrace("StartPinInputConfirm", "invoke SUNSON_GetPin return %d, fResult[0] = 0x%02x", iret, fResult[0]);
    if (iret != 1)
    {
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"开启密文输入失败");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("StartPinInputConfirm", "Exit-");
        return Error_Hardware;
    }

    memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
    strcpy(m_Error.szErrMsg,"操作成功");
    m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

    m_trace->WriteTrace("StartPinInputConfirm", "Exit-");
    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::StartPlainInput()
{
    m_trace->WriteTrace("StartPlainInput","Enter-");

    if (m_Open != TRUE)
    {
        m_trace->WriteTrace("StartPlainInput","设备未打开，不能做明文输入操作");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备未打开");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("StartPlainInput", "Exit-");
        return Error_NotInit;
    }

    char fResult[1025] = "";
    SUNSON_SetKeyMark(0x1AFFF, 0, 0, 0, (unsigned char*)fResult);

    g_flag = 0;//标记是明文输入

    //激活密码输入
    memset(fResult, 0, sizeof(fResult));
    int iret = SUNSON_UseEppPlainTextMode(0,0,(unsigned char*)fResult);
    m_trace->WriteTrace("StartPlainInput", "invoke SUNSON_UseEppPlainTextMode return %d, fResult[0] = 0x%02x", iret,fResult[0]);
    if (iret != 1)
    {
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"开启明文输入失败");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
        m_trace->WriteTrace("StartPlainInput", "Exit-");
        return Error_Hardware;
    }

    memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
    strcpy(m_Error.szErrMsg,"操作成功");
    m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

    m_trace->WriteTrace("StartPlainInput", "Exit-");
    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::StopInput()
{
    m_trace->WriteTrace("StopInput","Enter-");

    if (m_Open != TRUE)
    {
        m_trace->WriteTrace("StopInput","设备未打开,直接返回");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备未打开");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("StopInput", "Exit-");
        return Error_NotInit;
    }

    unsigned char fResult[1025] = "";
    int iret = SUNSON_CloseEppPlainTextMode(fResult);
    m_trace->WriteTrace("StopInput","执行SUNSON_CloseEppPlainTextMode返回%d,fResult[0] = 0x%02x",iret,fResult[0]);
    if (iret == 0)
    {
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"键盘关闭失败");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("StopInput", "Exit-");
        return Error_DevCommFailed;
    }

    memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
    strcpy(m_Error.szErrMsg,"键盘关闭成功");
    m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

    m_trace->WriteTrace("StopInput", "Exit-");
    return Error_Succeed;
}

ErrorCodeEnum PinPadNantian::GetPinBlock(PinBlock &block)
{
    m_trace->WriteTrace("GetPinBlock","Enter-");

    if (m_Open != TRUE)
    {
        m_trace->WriteTrace("GetPinBlock","设备未打开，不能做GetPinBlock操作");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备未打开");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("GetPinBlock", "Exit-");
        return Error_NotInit;
    }

    m_trace->WriteTrace("GetPinBlock","g_dwWkSN = %d",g_dwWkSN);

    int WkSN = 0;

    if (m_PinAlgorithm == 3)
    {
        char ReturnInfo[100] = "";
        int sret = SUNSON_SwitchArithmetic(2, (unsigned char *)ReturnInfo);
        m_trace->WriteTrace("GetPinBlock","国密：invoke SUNSON_SwitchArithmetic,sret = %d, ReturnInfo[0] = 0x%02x",sret, ReturnInfo[0]);
        if (sret != 1)
        {
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"切换国密算法失败");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

            m_trace->WriteTrace("GetPinBlock", "Exit-");
            return Error_DevMedia;
        }

        if(g_dwWkSN == 99)
        {
                WkSN = g_dwMkSN;
        }
        else
        {
                WkSN = g_dwWkSN + 2;
        }
    }
    else
    {
        char ReturnInfo[100] = "";
        int sret = SUNSON_SwitchArithmetic(0, (unsigned char *)ReturnInfo);
        m_trace->WriteTrace("GetPinBlock","非国密：invoke SUNSON_SwitchArithmetic,sret = %d, ReturnInfo[0] = 0x%02x",sret, ReturnInfo[0]);
        if (sret != 1)
        {
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"切换非国密算法失败");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

            m_trace->WriteTrace("GetPinBlock", "Exit-");
            return Error_DevMedia;
        }

        if(g_dwWkSN == 99)
        {
            WkSN = g_dwMkSN;
        }
        else
        {
            WkSN = g_dwWkSN + 11;
        }
    }

    unsigned char fResult[1025] = "";
    //计算PINBLOCK
    int sret = SUNSON_GetPinBlock(WkSN,0x02,0x0F,g_CardNo.dwAccLen,(unsigned char*)g_CardNo.account,fResult);
    m_trace->WriteTrace("GetPinBlock", "invoke  SUNSON_GetPinBlock return %d,f_result[0] = 0x%02X", sret,fResult[0]);
    memset(block.data,0,sizeof(block.data));
    if(sret > 0)
    {
        //扩展并拷贝计算结果
        CILIX_AUX_X::CILIX_uti_unpack(fResult, (unsigned char*)block.data, sret);
        block.dwSize = sret*2;
        m_trace->WriteTrace("GetPinBlock","GetPinBlock操作成功");
        m_trace->WriteTrace(CILIXTRACE_L_DEBUG, "GetPinBlock", "block.data=%s",block.data);
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"操作成功");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("GetPinBlock", "Exit-");
        return Error_Succeed;
    }
    else
    {
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"获取pinblock失败");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("EncryptData", "Exit-");
        return Error_Hardware;
    }
}

ErrorCodeEnum PinPadNantian::EncryptData(EnDecryptInfo srcInfo, EnDecryptInfo &destInfo)
{
    m_trace->WriteTrace("EncryptData","Enter-");

    m_trace->WriteTrace("EncryptData","srcInfo.dwSize = %d",srcInfo.dwSize);
    m_trace->WriteTrace(CILIXTRACE_L_DEBUG,"EncryptData","srcInfo.data = %s",srcInfo.data);

    if (m_Open != TRUE)
    {
        m_trace->WriteTrace("EncryptData","设备未打开，不能做GetPinBlock操作");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备未打开");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("EncryptData", "Exit-");
        return Error_NotInit;
    }

    if (srcInfo.data == NULL)
    {
         m_trace->WriteTrace("EncryptData","EncryptData输入参数srcInfo.data为空");
         memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
         strcpy(m_Error.szErrMsg,"输入参数为空");
         m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

         m_trace->WriteTrace("EncryptData", "Exit-");
         return Error_Null;
    }

    if (srcInfo.dwSize % 16 !=0 || srcInfo.dwSize % 8 !=0)
    {
        m_trace->WriteTrace("EncryptData","EncryptData输入参数srcInfo.dwSize不是8或16的整数倍");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"输入参数错误");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("EncryptData", "Exit-");
        return Error_Param;
    }

    //压缩数据
    unsigned char fswData[1025] = "";
    CILIX_AUX_X::CILIX_uti_pack((unsigned char*)srcInfo.data, fswData, srcInfo.dwSize);

    int WkSN = 0;
    if (m_Encryptmethod == 4)
    {
        char ReturnInfo[100] = "";
        int sret = SUNSON_SwitchArithmetic(2, (unsigned char *)ReturnInfo);
        m_trace->WriteTrace("EncryptData","国密：invoke SUNSON_SwitchArithmetic,sret = %d, ReturnInfo[0] = 0x%02x",sret, ReturnInfo[0]);
        if (sret != 1)
        {
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"切换国密算法失败");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

            m_trace->WriteTrace("EncryptData", "Exit-");
            return Error_DevMedia;
        }

        if(g_dwWkSN == 99)
        {
            WkSN = g_dwMkSN;
        }
        else
        {
            WkSN = g_dwWkSN + 2;
        }
    }
    else
    {
        char ReturnInfo[100] = "";
        int sret = SUNSON_SwitchArithmetic(0, (unsigned char *)ReturnInfo);
        m_trace->WriteTrace("EncryptData","非国密：invoke SUNSON_SwitchArithmetic,sret = %d, ReturnInfo[0] = 0x%02x",sret, ReturnInfo[0]);
        if (sret != 1)
        {
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"切换非国密算法失败");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

            m_trace->WriteTrace("EncryptData", "Exit-");
            return Error_DevMedia;
        }

        if(g_dwWkSN == 99)
        {
            WkSN = g_dwMkSN + 10;
        }
        else
        {
            WkSN = g_dwWkSN + 11;
        }
    }

    int mode = 0;
    if (m_Encryptmethod == 0)
    {
        if(m_ECB_CBC_Mode == 1)
        {
            mode = 1;
        }
        if(m_ECB_CBC_Mode == 2)
        {
            mode = 2;
        }
    }
    if (m_Encryptmethod == 1)
    {
        if(m_ECB_CBC_Mode == 1)
        {
            mode = 0x40;
        }
        if(m_ECB_CBC_Mode == 2)
        {
            mode = 0x80;
        }
    }
    if (m_Encryptmethod == 4)
    {
        if(m_ECB_CBC_Mode == 1)
        {
            mode = 0x40;
        }
        if(m_ECB_CBC_Mode == 2)
        {
            mode = 0x80;
        }
    }

    //加密结果
    BYTE crypt_out[1024*100] = "";
    char sresult[2050] = "";
    //计算
    int sret = SUNSON_DataCompute(WkSN,0x01,mode,0X00,srcInfo.dwSize/2,fswData,(unsigned char*)sresult);
    m_trace->WriteTrace("EncryptData", "EncryptData操作返回值sret = %d,sresult[0] = 0x%02x",sret,sresult[0]);
    if (sret > 0)
    {
        //拷贝输出结果
        memcpy(crypt_out, sresult,sret);
        memset(destInfo.data, 0, 512);
        CILIX_AUX_X::CILIX_uti_unpack((BYTE*)crypt_out, (BYTE*)destInfo.data, sret);
        destInfo.dwSize = sret*2;
        m_trace->WriteTrace("EncryptData", "EncryptData操作成功, destInfo.dwSize=%d",destInfo.dwSize);
        m_trace->WriteTrace(CILIXTRACE_L_DEBUG, "EncryptData", "destInfo.data = %s",destInfo.data);
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"操作成功");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("EncryptData", "Exit-");
        return Error_Succeed;
    }
    else
    {
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"加密失败");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("EncryptData", "Exit-");
        return Error_Hardware;
    }
}

ErrorCodeEnum PinPadNantian::MacEncrypt(EnDecryptInfo srcInfo, EnDecryptInfo &destInfo)
{
    m_trace->WriteTrace("MacEncrypt","Enter-");

    m_trace->WriteTrace("MacEncrypt","srcInfo.dwSize = %d",srcInfo.dwSize);
    m_trace->WriteTrace(CILIXTRACE_L_DEBUG,"MacEncrypt","srcInfo.data = %s",srcInfo.data);

    if (m_Open != TRUE)
    {
        m_trace->WriteTrace("MacEncrypt","设备未打开，不能做GetMAC操作");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"设备未打开");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("MacEncrypt", "Exit-");
        return Error_NotInit;
    }

    if (srcInfo.data == NULL)
    {
        m_trace->WriteTrace("MacEncrypt","MacEncrypt输入参数srcInfo.data为空");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"输入参数为空");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("MacEncrypt", "Exit-");
        return Error_Null;
    }

    if (srcInfo.dwSize % 16 !=0 || srcInfo.dwSize % 8 !=0)
    {
        m_trace->WriteTrace("MacEncrypt","MacEncrypt输入参数srcInfo.dwSize不是8或16的整数倍");
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"输入参数错误");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("MacEncrypt", "Exit-");
        return Error_Param;
    }

    //压缩数据
    unsigned char fswData[1025] = "";
    CILIX_AUX_X::CILIX_uti_pack((unsigned char*)srcInfo.data, fswData, srcInfo.dwSize);

    int WkSN = 0;
    if (m_MacAlgorithm == 3)
    {
        char ReturnInfo[100] = "";
        int sret = SUNSON_SwitchArithmetic(2, (unsigned char *)ReturnInfo);
        m_trace->WriteTrace("MacEncrypt","国密：invoke SUNSON_SwitchArithmetic,sret = %d, ReturnInfo[0] = 0x%02x",sret, ReturnInfo[0]);
        if (sret != 1)
        {
            memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
            strcpy(m_Error.szErrMsg,"切换国密算法失败");
            m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

            m_trace->WriteTrace("MacEncrypt", "Exit-");
            return Error_DevMedia;
        }
        WkSN = g_dwWkSN + 2;
    }
    else
    {
        char ReturnInfo[100] = "";
        int sret = SUNSON_SwitchArithmetic(0, (unsigned char *)ReturnInfo);
        m_trace->WriteTrace("MacEncrypt","非国密：invoke SUNSON_SwitchArithmetic,sret = %d, ReturnInfo[0] = 0x%02x",sret, ReturnInfo[0]);
        if (sret != 1)
        {
                memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
                strcpy(m_Error.szErrMsg,"切换非国密算法失败");
                m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);
                m_trace->WriteTrace("MacEncrypt", "Exit-");
                return Error_DevMedia;
        }
        WkSN = g_dwWkSN + 11;
    }

    int mode = 0;
    if (m_MacAlgorithm == 1)
    {
        mode = 0x20;
    }
    if (m_MacAlgorithm == 2)
    {
        mode = 0x0200;
    }
    if (m_MacAlgorithm == 3)
    {
        mode = 0x0200;
    }

    //加密结果
    BYTE crypt_out[1024*100] = "";
    char sresult[2050] = "";
    //计算
    int sret = SUNSON_MakeMac(WkSN,mode,srcInfo.dwSize/2,fswData,(unsigned char*)sresult);
    m_trace->WriteTrace("MacEncrypt", "MacEncrypt操作返回值sret = %d,sresult[0] = 0x%02x",sret,sresult[0]);
    if (sret > 0)
    {
        //拷贝输出结果
        memcpy(crypt_out, sresult,sret);
        memset(destInfo.data, 0, 512);
        CILIX_AUX_X::CILIX_uti_unpack((BYTE*)crypt_out, (BYTE*)destInfo.data, sret);
        destInfo.dwSize = sret*2;
        m_trace->WriteTrace("EncryptData", "MacEncrypt操作成功,destInfo.dwSize=%d",destInfo.dwSize);
        m_trace->WriteTrace(CILIXTRACE_L_DEBUG, "EncryptData", "destInfo.data = %s",destInfo.data);
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"操作成功");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("MacEncrypt", "Exit-");
        return Error_Succeed;
    }
    else
    {
        memset(m_Error.szErrMsg,0,sizeof(m_Error.szErrMsg));
        strcpy(m_Error.szErrMsg,"加密失败");
        m_Error.dwErrMsgLen = strlen(m_Error.szErrMsg);

        m_trace->WriteTrace("MacEncrypt", "Exit-");
        return Error_Hardware;
    }
}

int PinPadNantian::GetEncryptFunc()
{
    return 3;
}