liuye / etradeclient · Files

#include "stdafx.h"

#include "etradeclient/hardware/hardware_cmd.h"

#include <sstream>

#include <boost/algorithm/string.hpp>

#include "etradeclient/boost_patch/property_tree/json_parser.hpp" // WARNIING! Make sure to include our patched version.
#include "etradeclient/utility/logging.h"
#include "etradeclient/utility/string_converter.h"
#include "etradeclient/utility/application_config.h"

#include "etradeclient/hardware/pin_pad.h"
#include "etradeclient/hardware/id_card_reader.h"
#include "etradeclient/hardware/dili_card_device.h"
#include "etradeclient/hardware/bank_card_reader.h"
#include "etradeclient/hardware/password_machine.h"
#include "ETradeClient/utility/openssl_aes_cbc.h"
#include "ETradeClient/utility/DLBmpManager.h"
#include "ETradeClient/utility/string_converter.h"
#include "ETradeClient/utility/DLDes.h"

namespace StatusCode
{
	static const std::string OK = ""; // 操作成功.

	static const std::string PINPAD_CONNECT_FAILED = "100"; // 连接密码键盘失败. 
	static const std::string PINPAD_TIMEOUT = "101"; // 用户密码输入超时. 
	static const std::string PINPAD_CANCELLED = "102"; // 用户取消密码输入. 
	static const std::string PINPAD_READ_FAILED = "103"; // 读取密码失败. 

	static const std::string ID_CARD_READER_CONNECT_FAILED = "200"; // 连接身份证读卡器失败. 
	static const std::string ID_CARD_READER_VERIFY_FAILED = "201"; // 身份证验证失败.
	static const std::string ID_CARD_READER_READ_FAILED = "202"; // 读取身份证信息失败.

	static const std::string CPU_CARD_DEVICE_CONNECT_FAILED = "300"; // 打开CPU卡读卡器失败. 
	static const std::string CPU_CARD_DEVICE_CANNOT_FIND_CARD = "301"; // 无法找到卡片，请放卡到读卡器上(或重新放置卡片).
	
	static const std::string DILI_CARD_DEVICE_ACTIVATE_CARD_FAILED = "302"; // 卡片激活失败, 请检查该卡是否已处于激活状态.
	static const std::string DILI_CARD_DEVICE_RESET_CARD_FAILED = "303"; // 卡片撤销激活失败, 请检查该卡是否已处于未激活状态.
	static const std::string DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED = "304"; // 读取卡片基本信息失败.
	static const std::string DILI_CARD_DEVICE_READ_SERVICE_INFO_FAILED = "305"; // 读取卡片业务信息失败.
	static const std::string DILI_CARD_DEVICE_WRITE_SERVICE_INFO_FAILED = "306"; // 写入卡片业务信息失败.
	static const std::string DILI_CARD_DEVICE_WRITE_UNMATCHED_CARD = "307"; // 写卡卡片的序列号不匹配.
	static const std::string DILI_CARD_DEVICE_NEED_UPDATE = "308"; //卡片需要升级，请升级后继续使用。
	static const std::string DILI_CARD_DEVICE_PARSE_SEVER_DATA_FAILED = "309"; //解析服务器数据失败。

	static const std::string PWD_MACHINE_CONNECT_FAILED = "401"; // 连接加密机失败.
	static const std::string PWD_MACHINE_GET_KEY_FAILED = "402"; // 从加密机读取密钥失败.

	static const std::string BANK_CARD_READ_CARD_NUM_FAILED = "501"; // 读取银行卡卡号失败.
}

namespace EncryptTools
{
	int Encrypt(unsigned char* pSrc, unsigned char u8Len, unsigned char* pKey, unsigned char* pCiphertText)
	{
		int iResult = 0;

		uint8_t au8DataBlock[50][8] = { 0 };

		int iBlockCount = 0, iCoverPos = 0, iBlockNum = 0;
		iBlockCount = u8Len / 8;
		iCoverPos = u8Len % 8;

		while (iBlockCount > 0)
		{
			memcpy(au8DataBlock[iBlockNum], pSrc, 8);
			pSrc += 8;
			--iBlockCount;
			++iBlockNum;
		}

		if (iCoverPos)
		{
			memcpy(au8DataBlock[iBlockNum], pSrc, iCoverPos);
			au8DataBlock[iBlockNum][iCoverPos] = 0x80;
			++iCoverPos;
			for (int index = iCoverPos; iCoverPos < 8; ++iCoverPos)
			{
				au8DataBlock[iBlockNum][iCoverPos] = 0x00;
			}
		}
		else
		{
			--iBlockNum;
		}

		uint8_t au8KeyL[8] = { 0 }, au8KeyR[8] = { 0 };
		memcpy(au8KeyL, pKey, 8);
		memcpy(au8KeyR, pKey, 8);
		for (int index = 0; index <= iBlockNum; ++index)
		{
			uint8_t au8Cipher1[8] = { 0 }, au8Cipher2[8] = { 0 };
			DES(au8KeyL, au8DataBlock[index], au8Cipher1);
			_DES(au8KeyR, au8Cipher1, au8Cipher2);
			DES(au8KeyL, au8Cipher2, &pCiphertText[index * 8]);
		}

		return iResult;
	}

	bool HexToChar(unsigned char* pHex, int iHexLen, unsigned char* pChar)
	{
		bool bResult = true;
		if (pHex && iHexLen && pChar)
		{
			int iCharCount = 0;
			for (int index = 0; index < iHexLen; ++index)
			{
				char cNum[3] = { 0 };
				if (pHex[index] <= 0x0f)
				{
					pChar[iCharCount] = '0';
					++iCharCount;
					sprintf_s(cNum, "%X", pHex[index]);
					pChar[iCharCount] = cNum[0];
					++iCharCount;
				}
				else
				{
					sprintf_s(cNum, "%2X", pHex[index]);
					pChar[iCharCount] = cNum[0];
					++iCharCount;
					pChar[iCharCount] = cNum[1];
					++iCharCount;
				}
			}
		}
		return bResult;
	}

	bool CharToHex(unsigned char* pStr, unsigned char& cHex)
	{
		bool bResult = true;

		unsigned char aHex[2] = { 0 }, cTemp = 0;
		if (pStr)
		{
			int iCount = 2;
			do
			{
				char cStr = tolower(pStr[iCount - 1]);
				switch (cStr)
				{
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
				{
					cTemp = atoi(&cStr);
					break;
				}
				case 'a':
				{
					cTemp = 10;
					break;
				}
				case 'b':
				{
					cTemp = 11;
					break;
				}
				case 'c':
				{
					cTemp = 12;
					break;
				}
				case 'd':
				{
					cTemp = 13;
					break;
				}
				case 'e':
				{
					cTemp = 14;
					break;
				}
				case 'f':
				{
					cTemp = 15;
					break;
				}
				}
				aHex[iCount - 1] = cTemp;
				--iCount;
			} while (iCount);

			cHex = (aHex[0] << 4) + aHex[1];
		}
		else
		{
			bResult = false;
		}
		return bResult;
	}

	bool StringToHex(unsigned char* pStr, int iLen, unsigned char* pHex)
	{
		bool bResult = true;

		int iStrIndex = 0;
		int index = 0;
		while (bResult && iStrIndex < iLen)
		{
			bResult = CharToHex(&pStr[iStrIndex], pHex[index]);
			++index;
			iStrIndex += 2;
		}

		if (!bResult)
		{
			throw std::exception("9999");
		}

		return bResult;
	}
}

namespace 
{
	const PINPad& PINPad_()
	{
		static PINPad pin_pad;
		return pin_pad;
	}

	IDCardReader& IDCardReader_()
	{
		static IDCardReader id_card_reader;
		return id_card_reader;
	}

	const DILICard::RWDevice& DILICardRWDevice()
	{
		static DILICard::RWDevice dili_card_device;
		return dili_card_device;
	}

	const PWDMachine& PWDMachine_()
	{
		static PWDMachine pwd_machine;
		return pwd_machine;
	}

	const BankCardReader& BankCardReader_()
	{
		static BankCardReader bank_card_reader;
		return bank_card_reader;
	}

	std::string g_card_num;//用于办卡时，保证操作的卡片是同一张
}

ReadPINPadCmd::Reply ReadPINPadCmd::Execute(const std::string& input)
{
	LOG_TRACE(L"读取用户输入密码。");
	const uint8_t PWD_MAX_LEN = ApplicationConfig::Instance().PINPadPWDLen();
	const uint8_t TIMEOUT = ApplicationConfig::Instance().PINPadTimeout();
	auto& pin_pad = PINPad_();
	std::string pwd("");
	Reply reply;
	do
	{
		try
		{
			if (!pin_pad.Connect())
			{
				LOG_ERROR(L"连接密码键盘失败。");
				reply.error_code = StatusCode::PINPAD_CONNECT_FAILED;
				break;
			}
			pin_pad.DisplayBuiltInText(PINPad::BuiltInText::kEnterPWD);
			pin_pad.PlayVoice(PINPad::BuiltInVoice::kEnterPWD);
			pin_pad.SetPWDMaxLen(PWD_MAX_LEN);
			PINPad::StatusCode res = pin_pad.ReadUserInputPWD(PINPad::DispMode::kEncrypted, PINPad::DispLine::kL2, TIMEOUT, pwd);
			if (PINPad::StatusCode::kCancelled == res)
			{
				reply.error_code = StatusCode::PINPAD_CANCELLED;
				LOG_ERROR(L"用户取消密码输入。");
			}
			else if (PINPad::StatusCode::kTimeout == res)
			{
				reply.error_code = StatusCode::PINPAD_TIMEOUT;
				LOG_ERROR(L"用户输入密码超时。");
			}
			else if (PINPad::StatusCode::kUnknown == res)
			{
				reply.error_code = StatusCode::PINPAD_READ_FAILED;
				LOG_ERROR(L"读取用户输入密码失败，请确认密码键盘连接正常！");
			}
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取用户输入密码发生异常，异常信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::PINPAD_READ_FAILED;
			break;
		}
	} while (0);
	pin_pad.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"读取用户输入密码成功。");

	reply.data.put("password", pwd);
	return reply;
}

ReadPINPadCmd::Reply ReadIDCardCmd::Execute(const std::string& input)
{
	LOG_TRACE(L"读取身份证信息。");
	auto& id_card_reader = IDCardReader_();
	Reply reply;
	IDCardInfo id_card_info;

	uint8_t u8IDReaderType = ApplicationConfig::Instance().IDReaderType();

	switch (u8IDReaderType)
	{
	case 0:
	{
		do
		{
			try
			{
				if (!id_card_reader.Connect())
				{
					LOG_ERROR(L"建立身份证读卡器连接失败！");
					reply.error_code = StatusCode::ID_CARD_READER_CONNECT_FAILED;
					break;
				}
				if (!id_card_reader.VerifyCard())
				{
					LOG_ERROR(L"未找到身份证或身份证验证失败！");
					reply.error_code = StatusCode::ID_CARD_READER_VERIFY_FAILED;
					break;
				}
				id_card_info = id_card_reader.ReadCard();
			}
			catch (std::exception& ex)
			{
				LOG_FATAL(L"读取身份证信息失败，错误信息： " + str_2_wstr(ex.what()));
				reply.error_code = StatusCode::ID_CARD_READER_READ_FAILED;
				break;
			}
		} while (0);
		id_card_reader.Disconnect();
	}
	break;
	case 1:
	{
		do
		{
			try
			{
				if (!id_card_reader.SynConnect())
				{
					LOG_ERROR(L"建立身份证读卡器连接失败！");
					reply.error_code = StatusCode::ID_CARD_READER_CONNECT_FAILED;
					break;
				}
				if (!id_card_reader.SynFindCard())
				{
					LOG_ERROR(L"未找到身份证或身份证验证失败！");
					reply.error_code = StatusCode::ID_CARD_READER_VERIFY_FAILED;
					break;
				}
				id_card_info = id_card_reader.SynReadCard();
			}
			catch (std::exception& ex)
			{
				LOG_FATAL(L"读取身份证信息失败，错误信息： " + str_2_wstr(ex.what()));
				reply.error_code = StatusCode::ID_CARD_READER_READ_FAILED;
				break;
			}
		} while (0);
		id_card_reader.SynDisConnect();
	}
	break;
	}
	
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"读取身份证信息成功。");

	CDLBmpManager cBmp;
	string sBmpData = cBmp.ReadBmp(wstr_2_str(id_card_info.portrait_img_path).c_str());
	switch (u8IDReaderType)
	{
		case 0:
		{
			DeleteFile(id_card_info.portrait_img_path.c_str());
			wstring sPath = id_card_info.portrait_img_path.substr(0, id_card_info.portrait_img_path.size() - 6);
			DeleteFile((sPath + L"wz.txt").c_str());
			DeleteFile((sPath + L"xp.wlt").c_str());
		}
		break;
		case 1:
		{
			DeleteFile(id_card_info.portrait_img_path.c_str());
		}
		break;
	}
	

	reply.data.put("id", wstr_2_str(id_card_info.id_code));
	reply.data.put("name", wstr_2_str(id_card_info.name)); // Use 'wstr_2_str' to convert to UTF-8 string.
	reply.data.put("gender", wstr_2_str(id_card_info.gender));
	reply.data.put("nation", wstr_2_str(id_card_info.nation));
	reply.data.put("birthday", wstr_2_str(id_card_info.birth_date));
	reply.data.put("address", wstr_2_str(id_card_info.address));
	reply.data.put("portrait_img_path", wstr_2_str(id_card_info.portrait_img_path));
	reply.data.put("depart", wstr_2_str(id_card_info.depart));
	reply.data.put("start_date", wstr_2_str(id_card_info.start_date));
	reply.data.put("end_date", wstr_2_str(id_card_info.end_date));
	reply.data.put("img_data", sBmpData);
	return reply;
}

ReadPINPadCmd::Reply ActivateDILICardCmd::Execute(const std::string& input)
{
	Reply reply;
	LOG_TRACE(L"卡片激活。");
	
	std::string card_sn;
	std::string key_DCCK, key_F0015_DACK, key_F0015_DEAK, key_F0015_DAMK1, key_F0005_DAMK1;
	DILICard::BasicInfo card_basic_info;
	SecurityLevel slLevel = (SecurityLevel)ApplicationConfig::Instance().SecurityLevel();
	EncryptType etEncrypType = (EncryptType)ApplicationConfig::Instance().EncryptType();
	auto& dili_card_device = DILICardRWDevice();
	do 
	{
		try
		{
			dili_card_device.Connect();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"连接读卡器失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
			break;
		}
		try
		{
			dili_card_device.FindCard();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"寻卡失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
			break;
		}

		DILICard::BasicInfo card_basic_info;
		try { card_basic_info = dili_card_device.ReadCardBasicInfo(); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取卡片基本信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED;
			break;
		}

		LOG_TRACE(L"计算SN。");
		card_sn = card_basic_info.chip_num + std::string("44494c49") + card_basic_info.chip_num;

		if (slLevel == HardwareCmd::SL_0)
		{
			card_basic_info.device_id = card_sn;
			card_basic_info = card_basic_info;
			reply.error_code = StatusCode::OK;
			break;
		}

		if (etEncrypType == ET_PWM)
		{
			LOG_TRACE(L"加密机模式计算主控秘钥。");
			const std::string PWD_MACHINE_IP = ApplicationConfig::Instance().PWDMachineIP();
			const uint32_t PWD_MACHINE_PORT = ApplicationConfig::Instance().PWDMachinePort();
			const uint8_t TIMEOUT = ApplicationConfig::Instance().PWDMachineTimeout();

			auto& pwd_machine = PWDMachine_();

			if (!pwd_machine.Connect(PWD_MACHINE_IP, PWD_MACHINE_PORT))
			{
				LOG_ERROR(L"连接加密机失败！");
				reply.error_code = StatusCode::PWD_MACHINE_CONNECT_FAILED;
			}

			try
			{
				key_DCCK = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kDCCK>(), card_sn, TIMEOUT);
				key_F0015_DACK = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DACK>(), card_sn, TIMEOUT);
				key_F0015_DEAK = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DEAK>(), card_sn, TIMEOUT);
				key_F0015_DAMK1 = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DAMK1>(), card_sn, TIMEOUT);
				key_F0005_DAMK1 = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DAMK1>(), card_sn, TIMEOUT);
			}
			catch (std::exception& ex)
			{
				LOG_FATAL(L"从加密机读取密钥失败，错误信息： " + str_2_wstr(ex.what()));
				reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
				break;
			}

			pwd_machine.Disconnect();
		}
		else if (etEncrypType == ET_DES)
		{
			LOG_TRACE(L"软加密模式计算主控秘钥。");
			try
			{
				const char* pDCCKDL = "43434bff43434bff";
				const char* pDACKDL = "41434bff41434bff";
				const char* pDEAKDL = "45414bff45414bff";
				const char* pDAMKDL = "414d4b31414d4b31";

				unsigned char aucCardSNHex[16] = { 0 };
				unsigned char aucDCCKDL[8] = { 0 }, aucDACKDL[8] = { 0 }, aucDEAKDL[8] = { 0 }, aucDAMKDL[8] = { 0 };
				EncryptTools::StringToHex((unsigned char*)pDCCKDL, 16, aucDCCKDL);
				EncryptTools::StringToHex((unsigned char*)pDACKDL, 16, aucDACKDL);
				EncryptTools::StringToHex((unsigned char*)pDEAKDL, 16, aucDEAKDL);
				EncryptTools::StringToHex((unsigned char*)pDAMKDL, 16, aucDAMKDL);
				EncryptTools::StringToHex((unsigned char*)card_sn.c_str(), 32, aucCardSNHex);

				unsigned char aucNewDAMKHex[16] = { 0 }, aucNewDCCKHex[16] = { 0 }, aucNewDACKHex[16] = { 0 }, aucNewDEAKHex[16] = { 0 };
				unsigned char aucNewDAMK[32] = { 0 }, aucNewDCCK[32] = { 0 }, aucNewDACK[32] = { 0 }, aucNewDEAK[32] = { 0 };

				EncryptTools::Encrypt(aucCardSNHex, 16, aucDAMKDL, aucNewDAMKHex);
				EncryptTools::Encrypt(aucCardSNHex, 16, aucDCCKDL, aucNewDCCKHex);
				EncryptTools::Encrypt(aucCardSNHex, 16, aucDACKDL, aucNewDACKHex);
				EncryptTools::Encrypt(aucCardSNHex, 16, aucDEAKDL, aucNewDEAKHex);

				EncryptTools::HexToChar(aucNewDAMKHex, 16, aucNewDAMK);
				EncryptTools::HexToChar(aucNewDCCKHex, 16, aucNewDCCK);
				EncryptTools::HexToChar(aucNewDACKHex, 16, aucNewDACK);
				EncryptTools::HexToChar(aucNewDEAKHex, 16, aucNewDEAK);

				std::string sDAMKKey((char*)aucNewDAMK, 32);
				std::string sDCCKKey((char*)aucNewDCCK, 32);
				std::string sDACKKey((char*)aucNewDACK, 32);
				std::string sDEAKKey((char*)aucNewDEAK, 32);

				key_F0005_DAMK1 = key_F0015_DAMK1 = sDAMKKey;
				key_DCCK = sDCCKKey;
				key_F0015_DACK = sDACKKey;
				key_F0015_DEAK = sDEAKKey;
				
			}
			catch (std::exception& ex)
			{
				LOG_FATAL(L"软加密密钥失败");
				reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
				break;
			}
		}

		try
		{
			dili_card_device.ActivateCard(card_sn, key_DCCK, key_F0015_DACK, key_F0015_DEAK, key_F0015_DAMK1);
			card_basic_info = dili_card_device.ReadCardBasicInfo();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"卡片激活失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_ACTIVATE_CARD_FAILED;
			break;
		}
		
	} while (0);
	
	dili_card_device.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"卡片激活成功。");

	reply.data.put("chipNo", card_basic_info.chip_num);
	reply.data.put("deviceId", card_basic_info.device_id);
	reply.data.put("type", card_basic_info.type_code);
	reply.data.put("issuerCode", card_basic_info.issuer_code);
	reply.data.put("verifyCode", card_basic_info.verify_code);
	return reply;
}

ReadPINPadCmd::Reply ResetDILICardCmd::Execute(const std::string& input)
{

	LOG_TRACE(L"卡片撤销激活。");
	auto& dili_card_device = DILICardRWDevice();
	
	Reply reply;
	std::string card_sn;
	std::string key_DCCK, key_F0015_DACK;
	DILICard::BasicInfo card_basic_info;

	SecurityLevel slLevel = (SecurityLevel)ApplicationConfig::Instance().SecurityLevel();
	EncryptType etEncrypType = (EncryptType)ApplicationConfig::Instance().EncryptType();

	do
	{
		try
		{
			dili_card_device.Connect();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"连接读卡器失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
			break;
		}
		try
		{
			dili_card_device.FindCard();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"寻卡失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
			break;
		}

		DILICard::BasicInfo stuCardBasicInfo;
		try { stuCardBasicInfo = dili_card_device.ReadCardBasicInfo(); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取卡片基本信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED;
			break;
		}
		
		if (slLevel == HardwareCmd::SL_0)
		{
			card_basic_info = stuCardBasicInfo;
			reply.error_code = StatusCode::OK;
			break;
		}

		LOG_TRACE(L"计算SN。");
		if (slLevel == HardwareCmd::SL_1)
		{
			card_sn = stuCardBasicInfo.device_id;
		}
		else if (slLevel == HardwareCmd::SL_2)
		{
			card_sn = stuCardBasicInfo.chip_num + "44494c49" + stuCardBasicInfo.chip_num;
		}

		if (etEncrypType == ET_PWM)
		{
			LOG_TRACE(L"加密机模式计算主控秘钥。");
			const std::string PWD_MACHINE_IP = ApplicationConfig::Instance().PWDMachineIP();
			const uint32_t PWD_MACHINE_PORT = ApplicationConfig::Instance().PWDMachinePort();
			const uint8_t TIMEOUT = ApplicationConfig::Instance().PWDMachineTimeout();

			auto& pwd_machine = PWDMachine_();

			if (!pwd_machine.Connect(PWD_MACHINE_IP, PWD_MACHINE_PORT))
			{
				LOG_ERROR(L"连接加密机失败！");
				reply.error_code = StatusCode::PWD_MACHINE_CONNECT_FAILED;
			}

			try
			{
				key_DCCK = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kDCCK>(), card_sn, TIMEOUT);
				key_F0015_DACK = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DACK>(), card_sn, TIMEOUT);
			}
			catch (std::exception& ex)
			{
				LOG_FATAL(L"从加密机读取密钥失败，错误信息： " + str_2_wstr(ex.what()));
				reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
				break;
			}

			pwd_machine.Disconnect();
		}
		else if (etEncrypType == ET_DES)
		{
			LOG_TRACE(L"软加密模式计算主控秘钥。");
			try
			{
				const char* pDCCKDL = "43434bff43434bff";
				const char* pDACKDL = "41434bff41434bff";

				unsigned char aucCardSNHex[16] = { 0 };
				unsigned char aucDCCKDL[8] = { 0 }, aucDACKDL[8] = { 0 };
				EncryptTools::StringToHex((unsigned char*)pDCCKDL, 16, aucDCCKDL);
				EncryptTools::StringToHex((unsigned char*)pDACKDL, 16, aucDACKDL);
				EncryptTools::StringToHex((unsigned char*)card_sn.c_str(), 32, aucCardSNHex);

				unsigned char aucNewDCCKHex[16] = { 0 }, aucNewDACKHex[16] = { 0 };
				unsigned char aucNewDCCK[32] = { 0 }, aucNewDACK[32] = { 0 };

				EncryptTools::Encrypt(aucCardSNHex, 16, aucDCCKDL, aucNewDCCKHex);
				EncryptTools::Encrypt(aucCardSNHex, 16, aucDACKDL, aucNewDACKHex);

				EncryptTools::HexToChar(aucNewDCCKHex, 16, aucNewDCCK);
				EncryptTools::HexToChar(aucNewDACKHex, 16, aucNewDACK);

				std::string sDCCKKey((char*)aucNewDCCK, 32);
				std::string sDACKKey((char*)aucNewDACK, 32);

				key_DCCK = sDCCKKey;
				key_F0015_DACK = sDACKKey;

			}
			catch (std::exception& ex)
			{
				LOG_FATAL(L"软加密密钥失败");
				reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
				break;
			}
		}

		if (slLevel == HardwareCmd::SL_2)
		{
			LOG_TRACE(L"验证卡片。");
			if (!dili_card_device.AuthenticationKey(key_DCCK))
			{
				LOG_FATAL(L"秘钥验证失败，卡片需要升级！");
				reply.error_code = StatusCode::DILI_CARD_DEVICE_NEED_UPDATE;
				break;
			}
		}
		

		try
		{
			dili_card_device.ResetCard(key_DCCK, key_F0015_DACK);
			card_basic_info = dili_card_device.ReadCardBasicInfo();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"卡片撤销激活失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_RESET_CARD_FAILED;
			break;
		}
	} while (0);
	dili_card_device.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"卡片撤销激活成功。");

	reply.data.put("chipNo", card_basic_info.chip_num);
	reply.data.put("deviceId", card_basic_info.device_id);
	reply.data.put("type", card_basic_info.type_code);
	reply.data.put("issuerCode", card_basic_info.issuer_code);
	reply.data.put("verifyCode", card_basic_info.verify_code);
	return reply;
}

ReadPINPadCmd::Reply ReadDILICardBasicInfoCmd::Execute(const std::string& input)
{
	LOG_TRACE(L"读取卡片基本信息。");
	auto& dili_card_device = DILICardRWDevice();
	Reply reply;
	DILICard::BasicInfo card_basic_info;

	do 
	{
		try
		{
			dili_card_device.Connect();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"连接读卡器失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
			break;
		}

		//读取m1卡
		do
		{
			reply.error_code = StatusCode::OK;
			//判断是否为cpu卡，以防CPU卡读卡失败
			if (card_basic_info.chip_type.compare("1") == 0)
			{
				break;
			}
			
			if (0 != dili_card_device.M1FindCard())
			{
				reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
				CString error;
				error.Format(L"m1卡寻卡失败，错误信息：%d", reply.error_code);
				LOG_FATAL(error.GetBuffer());
				break;
			}

			try
			{
				card_basic_info = dili_card_device.M1ReadBasicInfo();
			}
			catch (std::exception& ex)
			{
				LOG_FATAL(L"m1卡读取基本信息失败，错误信息： " + str_2_wstr(ex.what()));
				reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED;
				break;
			}
			card_basic_info.chip_type = "2";//m1卡类型
			card_basic_info.device_id = card_basic_info.chip_num;
			
		} while (0);

		//读取CPU卡
		do
		{
			reply.error_code = StatusCode::OK;
			//判断是否为m1卡，以防m1卡读卡失败
			if (card_basic_info.chip_type.compare("2") == 0)
			{
				break;
			}
			try
			{
				dili_card_device.FindCard();
			}
			catch (std::exception& ex)
			{
				LOG_FATAL(L"寻卡失败，错误信息： " + str_2_wstr(ex.what()));
				reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
				break;
			}

			try { card_basic_info = dili_card_device.ReadCardBasicInfo(); }
			catch (std::exception& ex)
			{
				LOG_FATAL(L"读取卡片基本信息失败，错误信息： " + str_2_wstr(ex.what()));
				reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED;
				break;
			}
			card_basic_info.chip_type = "1";//cpu卡类型

			if (SL_2 == ApplicationConfig::Instance().SecurityLevel())
			{
				LOG_TRACE(L"计算主控秘钥。");
				std::string sSN = card_basic_info.chip_num + "44494c49" + card_basic_info.chip_num;
				std::string sDCCK;

				if (ET_DES == ApplicationConfig::Instance().EncryptType())
				{
					LOG_TRACE(L"软加密模式计算主控秘钥。");
					const char* pDCCKDL = "43434bff43434bff";

					unsigned char aucCardSNHex[16] = { 0 };
					unsigned char aucDCCKDL[8] = { 0 };
					EncryptTools::StringToHex((unsigned char*)pDCCKDL, 16, aucDCCKDL);
					EncryptTools::StringToHex((unsigned char*)sSN.c_str(), 32, aucCardSNHex);

					unsigned char aucNewDCCKHex[16] = { 0 };
					unsigned char aucNewDCCK[32] = { 0 };

					EncryptTools::Encrypt(aucCardSNHex, 16, aucDCCKDL, aucNewDCCKHex);

					EncryptTools::HexToChar(aucNewDCCKHex, 16, aucNewDCCK);

					std::string sDCCKKey((char*)aucNewDCCK, 32);

					sDCCK = sDCCKKey;
				}
				else if (ET_PWM == ApplicationConfig::Instance().EncryptType())
				{
					LOG_TRACE(L"加密机模式计算主控秘钥。");
					const std::string PWD_MACHINE_IP = ApplicationConfig::Instance().PWDMachineIP();
					const uint32_t PWD_MACHINE_PORT = ApplicationConfig::Instance().PWDMachinePort();
					const uint8_t TIMEOUT = ApplicationConfig::Instance().PWDMachineTimeout();

					auto& pwd_machine = PWDMachine_();

					if (!pwd_machine.Connect(PWD_MACHINE_IP, PWD_MACHINE_PORT))
					{
						LOG_ERROR(L"连接加密机失败！");
						reply.error_code = StatusCode::PWD_MACHINE_CONNECT_FAILED;
					}

					try
					{
						sDCCK = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kDCCK>(), sSN, TIMEOUT);
					}
					catch (std::exception& ex)
					{
						LOG_FATAL(L"从加密机读取密钥失败，错误信息： " + str_2_wstr(ex.what()));
						reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
						break;
					}
					pwd_machine.Disconnect();
				}

				LOG_TRACE(L"验证卡片。");
				if (!dili_card_device.AuthenticationKey(sDCCK))
				{
					LOG_FATAL(L"秘钥验证失败，卡片需要升级！");
					reply.error_code = StatusCode::DILI_CARD_DEVICE_NEED_UPDATE;
					break;
				}

			}
		} while (0);

		
	} while (0);

	dili_card_device.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"读取卡片基本信息成功。");

	reply.data.put("chipNo", card_basic_info.chip_num);
	reply.data.put("deviceId", card_basic_info.device_id);
	reply.data.put("type", card_basic_info.type_code);
	reply.data.put("issuerCode", card_basic_info.issuer_code);
	reply.data.put("verifyCode", card_basic_info.verify_code);
	reply.data.put("subType", card_basic_info.sub_type);
	reply.data.put("makerVersion", card_basic_info.maker_version);
	reply.data.put("chipType", card_basic_info.chip_type);
	g_card_num = card_basic_info.device_id;
	return reply;
}

ReadPINPadCmd::Reply ReadDILICardServiceInfoCmd::Execute(const std::string& input)
{
	SecurityLevel slLevel = (SecurityLevel)ApplicationConfig::Instance().SecurityLevel();
	EncryptType etEncrypType = (EncryptType)ApplicationConfig::Instance().EncryptType();
	LOG_TRACE(L"读取卡片业务信息。");
	auto& dili_card_device = DILICardRWDevice();
	
	Reply reply;

	//安全等级都为0了，还读个毛的业务信息，直接返回！
	if (slLevel == HardwareCmd::SL_0)
	{
		reply.error_code == StatusCode::OK;
		LOG_TRACE(L"读取卡片业务信息成功。");
		return reply;
	}

	std::string key_r;
	std::string service_data;
	do
	{
		try
		{
			dili_card_device.Connect();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"连接读卡器失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
			break;
		}
		try
		{
			dili_card_device.FindCard();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"寻卡失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
			break;
		}

		DILICard::BasicInfo card_basic_info;
		try { card_basic_info = dili_card_device.ReadCardBasicInfo(); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取卡片基本信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED;
			break;
		}

		LOG_TRACE(L"计算SN。");
		std::string sSN;
		if (slLevel == HardwareCmd::SL_1)
		{
			sSN = card_basic_info.device_id;
		}
		else if (slLevel == HardwareCmd::SL_2)
		{
			sSN = card_basic_info.chip_num + "44494c49" + card_basic_info.chip_num;
		}

		if (etEncrypType == ET_PWM)
		{
			LOG_TRACE(L"加密机模式计算主控秘钥。");
			auto& pwd_machine = PWDMachine_();
			const std::string PWD_MACHINE_IP = ApplicationConfig::Instance().PWDMachineIP();
			const uint32_t PWD_MACHINE_PORT = ApplicationConfig::Instance().PWDMachinePort();
			const uint8_t TIMEOUT = ApplicationConfig::Instance().PWDMachineTimeout();

			if (!pwd_machine.Connect(PWD_MACHINE_IP, PWD_MACHINE_PORT))
			{
				LOG_ERROR(L"连接加密机失败！");
				reply.error_code = StatusCode::PWD_MACHINE_CONNECT_FAILED;
				break;
			}

			try { key_r = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DEAK>(), sSN, TIMEOUT); }
			catch (std::exception& ex)
			{
				LOG_FATAL(L"从加密机读取密钥失败，错误信息： " + str_2_wstr(ex.what()));
				reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
				break;
			}

			pwd_machine.Disconnect();
		}
		else if (etEncrypType == ET_DES)
		{
			LOG_TRACE(L"软加密模式计算主控秘钥。");
			const char* pDEAKDL = "45414bff45414bff";

			unsigned char aucCardSNHex[16] = { 0 };
			unsigned char aucDEAKDL[8] = { 0 };
			EncryptTools::StringToHex((unsigned char*)pDEAKDL, 16, aucDEAKDL);
			EncryptTools::StringToHex((unsigned char*)sSN.c_str(), 32, aucCardSNHex);

			unsigned char aucNewDEAKHex[16] = { 0 };
			unsigned char aucNewDEAK[32] = { 0 };

			EncryptTools::Encrypt(aucCardSNHex, 16, aucDEAKDL, aucNewDEAKHex);

			EncryptTools::HexToChar(aucNewDEAKHex, 16, aucNewDEAK);

			std::string sDEAKKey((char*)aucNewDEAK, 32);

			key_r = sDEAKKey;
		}

		try { service_data = dili_card_device.ReadCardServiceInfo(key_r); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取卡片业务信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_SERVICE_INFO_FAILED;
			break;
		}
	} while (0);
	
	dili_card_device.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"读取卡片业务信息成功。");

	reply.data.put("", service_data);
	return reply;
}

ReadPINPadCmd::Reply WriteDILICardServiceInfoCmd::Execute(const std::string& input)
{
	const char DATA_SPLITER = ':';
	SecurityLevel secu_level = (SecurityLevel)ApplicationConfig::Instance().SecurityLevel();
	EncryptType encrypt_type = (EncryptType)ApplicationConfig::Instance().EncryptType();

	LOG_TRACE(L"写入卡片业务信息。");
	auto& dili_card_device = DILICardRWDevice();
	
	Reply reply;
	std::string key_w;
	do
	{
		try
		{
			dili_card_device.Connect();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"连接读卡器失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
			break;
		}

		//安全等级都为0了，还写个毛的业务信息，直接返回！
		if (secu_level == HardwareCmd::SL_0)
		{
			reply.error_code == StatusCode::OK;
			LOG_TRACE(L"读取卡片业务信息成功。");
			return reply;
		}

		try
		{
			dili_card_device.FindCard();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"寻卡失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
			break;
		}

		DILICard::BasicInfo card_basic_info;
		try { card_basic_info = dili_card_device.ReadCardBasicInfo(); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取卡片基本信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_READ_BASIC_INFO_FAILED;
			break;
		}

		LOG_TRACE(L"计算SN。");
		std::string sSN;
		if (secu_level == HardwareCmd::SL_1)
		{
			sSN = card_basic_info.device_id;
		}
		else if (secu_level == HardwareCmd::SL_2)
		{
			sSN = card_basic_info.chip_num + "44494c49" + card_basic_info.chip_num;
		}


		std::size_t index = input.find(DATA_SPLITER);
		if (std::string::npos == index) // NOT found.
		{
			LOG_ERROR(L"写入卡片业务信息失败，错误信息：请求数据错误。");
			reply.error_code = StatusCode::DILI_CARD_DEVICE_WRITE_SERVICE_INFO_FAILED;
			break;
		}
		std::string device_id = g_card_num;//用于办卡时，保证操作的卡片是同一张;
		std::string service_data = input.substr(index + 1, input.size() - index - 1);

		// 验证操作的是否是同一张卡，即device_id是否匹配
		if (!boost::iequals(sSN, device_id))
		{
			LOG_ERROR(L"写卡卡片的序列号不匹配！");
			reply.error_code = StatusCode::DILI_CARD_DEVICE_WRITE_UNMATCHED_CARD;
			break;
		}

		if (encrypt_type == ET_PWM)
		{
			LOG_TRACE(L"加密机模式计算主控秘钥。");
			auto& pwd_machine = PWDMachine_();

			const std::string PWD_MACHINE_IP = ApplicationConfig::Instance().PWDMachineIP();
			const uint32_t PWD_MACHINE_PORT = ApplicationConfig::Instance().PWDMachinePort();
			const uint8_t TIMEOUT = ApplicationConfig::Instance().PWDMachineTimeout();

			if (!pwd_machine.Connect(PWD_MACHINE_IP, PWD_MACHINE_PORT))
			{
				LOG_ERROR(L"连接加密机失败！");
				reply.error_code = StatusCode::PWD_MACHINE_CONNECT_FAILED;
				break;
			}

			try { key_w = pwd_machine.GetCardPassword(DILICard::CardKeyCode<DILICard::KeyCode::kF0015_DAMK1>(), sSN, TIMEOUT); }
			catch (std::exception& ex)
			{
				LOG_FATAL(L"从加密机读取密钥失败，错误信息： " + str_2_wstr(ex.what()));
				reply.error_code = StatusCode::PWD_MACHINE_GET_KEY_FAILED;
				break;
			}

			pwd_machine.Disconnect();
		}
		else if (encrypt_type == ET_DES)
		{
			LOG_TRACE(L"软加密模式计算15写秘钥。");
			const char* pDAMKDL = "414d4b31414d4b31";

			unsigned char aucCardSNHex[16] = { 0 };
			unsigned char aucDAMKDL[8] = { 0 };
			EncryptTools::StringToHex((unsigned char*)pDAMKDL, 16, aucDAMKDL);
			EncryptTools::StringToHex((unsigned char*)sSN.c_str(), 32, aucCardSNHex);

			unsigned char aucNewDAMKHex[16] = { 0 };
			unsigned char aucNewDAMK[32] = { 0 };

			EncryptTools::Encrypt(aucCardSNHex, 16, aucDAMKDL, aucNewDAMKHex);

			EncryptTools::HexToChar(aucNewDAMKHex, 16, aucNewDAMK);

			std::string sDAMKKey((char*)aucNewDAMK, 32);

			key_w = sDAMKKey;
		}
		
		try { dili_card_device.WriteCardServiceInfo(key_w, service_data); }
		catch (std::exception& ex)
		{
			LOG_FATAL(L"写入卡片业务信息失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::DILI_CARD_DEVICE_WRITE_SERVICE_INFO_FAILED;
			break;
		}
	} while (0);
	
	dili_card_device.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"写入卡片业务信息成功。");
	reply.data.put("", "");
	return reply;
}

ReadPINPadCmd::Reply ReadBankCardNumCmd::Execute(const std::string& input)
{
	LOG_TRACE(L"读取银行卡号。");
	auto& bank_card_reader = BankCardReader_();
	std::string bank_card_no("");
	Reply reply;
	do
	{
		try
		{
			if (!bank_card_reader.Connect())
			{
				LOG_ERROR(L"连接银行卡读卡器失败。");
				reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
				break;
			}
			bank_card_no = bank_card_reader.ReadBankCardNum();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"读取银行卡号失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::BANK_CARD_READ_CARD_NUM_FAILED;
			break;
		}
	} while (0);
	bank_card_reader.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"读取银行卡号成功。");

	reply.data.put("chipNo", bank_card_no);
	return reply;
}

ReadPINPadCmd::Reply ActivateDILIM1CardCmd::Execute(const std::string& input)
{
	LOG_TRACE(L"m1卡入库。");
	Reply reply;
	DILICard::BasicInfo card_basic_info;

	auto& dili_card_device = DILICardRWDevice();

	do 
	{
		try
		{
			dili_card_device.Connect();
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"连接读卡器失败，错误信息： " + str_2_wstr(ex.what()));
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CONNECT_FAILED;
			break;
		}

		int error_code = dili_card_device.M1FindCard();
		if (error_code)
		{
			CString error;
			error.Format(L"m1卡寻卡失败，错误信息： %d", error_code);
			LOG_FATAL(error.GetBuffer());
			reply.error_code = StatusCode::CPU_CARD_DEVICE_CANNOT_FIND_CARD;
			break;
		}

		try
		{
			namespace PT = boost::property_tree;
			PT::ptree ptree;
			std::stringstream ss;
			ss << input;
			PT::read_json(ss, ptree);
			card_basic_info.chip_num = ptree.get<std::string>("chipNo");
			card_basic_info.type_code = ptree.get<std::string>("type");
			card_basic_info.issuer_code = ptree.get<std::string>("issuerCode");
			card_basic_info.verify_code = ptree.get<std::string>("verifyCode");
			card_basic_info.sub_type = ptree.get<std::string>("subType");
			card_basic_info.maker_version = ptree.get<std::string>("makerVersion");
			card_basic_info.device_id = ptree.get<std::string>("deviceId");
		}
		catch (std::exception& ex)
		{
			LOG_FATAL(L"解析服务器数据失败。");
			reply.error_code = StatusCode::DILI_CARD_DEVICE_PARSE_SEVER_DATA_FAILED;
			break;
		}
		

		error_code = dili_card_device.M1WriteBasicInfo(card_basic_info.chip_num, card_basic_info.type_code, card_basic_info.issuer_code,\
			card_basic_info.verify_code, card_basic_info.sub_type, card_basic_info.maker_version);
		if (error_code)
		{
			CString error;
			error.Format(L"m1卡初始化失败，错误信息： %d", error_code);
			LOG_FATAL(error.GetBuffer());
			reply.error_code = StatusCode::DILI_CARD_DEVICE_ACTIVATE_CARD_FAILED;
			break;
		}
		card_basic_info.chip_type = "2"; //m1卡类型
	} while (0);

	dili_card_device.Disconnect();
	if (boost::iequals(reply.error_code, StatusCode::OK))
		LOG_TRACE(L"卡片激活成功。");

	reply.data.put("chipNo", card_basic_info.chip_num);
	reply.data.put("deviceId", card_basic_info.device_id);
	reply.data.put("type", card_basic_info.type_code);
	reply.data.put("issuerCode", card_basic_info.issuer_code);
	reply.data.put("verifyCode", card_basic_info.verify_code);
	reply.data.put("subType", card_basic_info.sub_type);
	reply.data.put("makerVersion", card_basic_info.maker_version);
	reply.data.put("chipType", card_basic_info.chip_type);
	return reply;

}