lyfz_repos/经典版源码/kernelcode/kernel/test/Encryptlock.cpp

#include "StdAfx.h"
#include "Encryptlock.h"

namespace Encryptlockkernel
{
	CHAR *g_pHReadPassWord = NULL;
	CHAR *g_pLReadPassWord = NULL;
	CHAR *g_pHWritePassWord = NULL;
	CHAR *g_pLWritePassWord = NULL;

	BOOL g_bUSE_NEWPASSWORD = FALSE;
	// 加密解密密钥;
	CHAR *g_szEncKey[][4] = {
		{"5A11475E", "39F530AD", "DCE97937", "6BCDB275"},		// 儿童全能版;
		{"04BBE109", "E3AFEA47", "778414D1", "16785D1F"},		// 儿童座席版;
		{"4900364D", "28E42F9C", "CBD86826", "5ACCA264"},		// 儿童企业版;
		{"BA7DA71F", "A17DB814", "C411F1AE", "A34531FD"},		// 婚纱全能版;
		{"F3A690F8", "828AD936", "667E03C0", "05674C0E"},		// 婚纱座席版;
		{"EC9FC9E1", "773E7E16", "0612A764", "A907E0F2"}		// 婚纱企业版;
	};

	CHAR *g_szRom[] = {
		"9E5B96F2223FCF8CC12308DABF669CB4",			// 000
		"873A748B773F7E261623B775A907F0F3",			// 033
		"7C2359705B1752BEEEFB9B4816785D2F",			// 066
		"4EF5EF37D1D91881B0CD5D1F44B19659",			// 099
		"CA7DA7CF9951A0493845DA97DC391325",			// 132
		"1CD3CD15BFB7F66F9EAB3BFD118E6326",			// 165
		"3EE5DF32D1991480607D5D0E4F614658",			// 198
		"4FB2FC03EEAA2592819E2EDC1072676A"			// 231
		// 264 是座席数使用的地址;
		// 297 是域名值使用的地址;
		// 330 是医院系统使用的地址;
	};

	CHAR *g_szPassword[][2] = {
		//////////////////////////////////////////////////////////////////////////
		// 旧密码;
		{ "7528527A", "541C5CF4"},					// 读密码 高低;
		{ "E4F08542", "87E5CED0"},					// 写密码 高低;
		//////////////////////////////////////////////////////////////////////////
		// 新密码;
		{ "9201B009", "26B43D72"},					// 读密码 高低;
		{ "AA679BD9", "302B1952"}					// 写密码 高低;
	};

	// 用户自定义密钥;
	CHAR *g_szUserKey = { "20D30D15FFB7F6AF9EAB30FD229F797B" };

	//////////////////////////////////////////////////////////////////////////
	// 锁内存数据;
	BYTE g_byShotVersion[][10] =
	{
		{ 0x06, 0x00, 0xC2, 0xC7, 0xD2, 0x43, 0xB9, 0x01, 0x8A, 0xC3 },			// 儿童全能版;
		{ 0x06, 0x00, 0x94, 0x0B, 0xCD, 0x32, 0x04, 0xAB, 0x20, 0x27 },			// 儿童座席版;
		{ 0x06, 0x00, 0x04, 0xBB, 0x67, 0x0A, 0x3B, 0xA9, 0xF0, 0xDC },			// 儿童企业版;
		{ 0x06, 0x00, 0xBC, 0x91, 0x64, 0x2F, 0x9A, 0xB1, 0x22, 0xCD },			// 婚纱全能版;
		{ 0x06, 0x00, 0x04, 0x1D, 0x18, 0xF7, 0xBD, 0x5F, 0x53, 0x4C },			// 婚纱座席版;
		{ 0x06, 0x00, 0x89, 0xA0, 0xE6, 0xAD, 0xCA, 0x02, 0x75, 0x8E }			// 婚纱企业版;
	};

	// start---------------加密表达式加密后的数组----------------------;
	CONST BYTE g_byCalExVersion[][114] =
	{
		// 儿童全能版;
		{ 109, 0, 26, 222, 0, 239, 199, 199, 188, 225, 180, 168, 178, 208, 21, 79, 62, 90, 51, 31, 88, 128, 180, 105, 53, 137, 230, 254, 244, 50, 195,
		49, 167, 143, 168, 125, 130, 125, 8, 73, 224, 120, 80, 95, 178, 49, 44, 158, 38, 38, 247, 169, 62, 187, 119, 192, 77, 194, 118, 246, 133, 241,
		157, 62, 144, 24, 94, 173, 49, 192, 46, 250, 249, 239, 82, 78, 135, 3, 86, 154, 8, 135, 180, 168, 178, 208, 21, 79, 62, 90, 51, 31, 88,
		128, 180, 105, 53, 137, 230, 254, 244, 50, 195, 49, 167, 143, 241, 214, 38, 180, 198, 3, 158, 165 },

		// 儿童座席版;
		{ 109, 0, 90, 15, 108, 138, 37, 190, 82, 8, 20, 252, 32, 162, 7, 8, 254, 255, 56, 245, 194, 4, 46, 120, 49, 120, 156, 27, 17, 164, 217,
		79, 167, 146, 197, 69, 55, 117, 197, 149, 42, 217, 151, 195, 254, 145, 187, 197, 232, 188, 114, 223, 40, 229, 151, 245, 116, 177, 141, 94, 134, 14,
		13, 169, 165, 94, 5, 216, 235, 60, 176, 38, 174, 121, 187, 174, 16, 30, 17, 20, 246, 34, 20, 252, 32, 162, 7, 8, 254, 255, 56, 245, 194,
		4, 46, 120, 49, 120, 156, 27, 17, 164, 217, 79, 167, 146, 143, 132, 219, 173, 211, 2, 99, 180 },

		// 儿童企业版;
		{ 109, 0, 229, 36, 223, 222, 213, 46, 70, 55, 240, 207, 237, 75, 226, 68, 133, 100, 42, 119, 89, 131, 79, 104, 158, 17, 172, 239, 4, 158, 201,
		51, 62, 51, 94, 232, 14, 124, 81, 64, 100, 141, 187, 85, 156, 59, 205, 116, 200, 24, 108, 218, 145, 22, 7, 36, 45, 7, 156, 255, 170, 130,
		165, 140, 99, 216, 120, 72, 171, 196, 27, 49, 138, 199, 137, 246, 214, 247, 121, 114, 215, 199, 240, 207, 237, 75, 226, 68, 133, 100, 42, 119, 89,
		131, 79, 104, 158, 17, 172, 239, 4, 158, 201, 51, 62, 51, 248, 214, 27, 254, 221, 208, 181, 209 },

	
		// 婚纱全能版;
		{ 109, 0, 139, 145, 163, 176, 66, 18, 207, 79, 172, 200, 12, 124, 89, 151, 248, 238, 26, 85, 137, 146, 119, 58, 76, 194, 151, 239, 204, 104, 18,
		166, 208, 54, 37, 85, 3, 174, 28, 74, 154, 156, 120, 194, 8, 112, 79, 42, 27, 89, 81, 95, 238, 74, 59, 199, 160, 101, 117, 179, 51, 138,
		70, 176, 239, 182, 160, 212, 11, 33, 224, 74, 155, 143, 216, 10, 220, 71, 8, 168, 18, 175, 172, 200, 12, 124, 89, 151, 248, 238, 26, 85, 137,
		146, 119, 58, 76, 194, 151, 239, 204, 104, 18, 166, 208, 54, 114, 118, 181, 24, 252, 41, 246, 88 },

		// 婚纱座席版;
		{ 109, 0, 128, 13, 164, 143, 252, 87, 30, 48, 20, 21, 145, 114, 160, 96, 49, 127, 181, 32, 144, 213, 109, 99, 142, 219, 71, 26, 22, 220, 177,
		179, 191, 82, 138, 45, 173, 160, 9, 83, 162, 106, 182, 175, 47, 92, 214, 78, 93, 21, 202, 165, 167, 200, 198, 172, 218, 74, 236, 194, 194, 228,
		40, 27, 95, 60, 160, 173, 66, 185, 178, 7, 159, 220, 58, 71, 140, 19, 20, 37, 66, 84, 20, 21, 145, 114, 160, 96, 49, 127, 181, 32, 144,
		213, 109, 99, 142, 219, 71, 26, 22, 220, 177, 179, 191, 82, 232, 182, 45, 27, 13, 195, 225, 204 },

		// 婚纱企业版;
		{ 109, 0, 94, 220, 40, 182, 30, 120, 56, 193, 78, 101, 1, 144, 68, 206, 192, 52, 67, 9, 243, 20, 9, 195, 153, 15, 22, 217, 243, 79, 177,
		22, 24, 171, 185, 157, 172, 67, 117, 124, 153, 165, 3, 41, 218, 47, 149, 150, 48, 152, 75, 250, 204, 253, 92, 53, 121, 147, 242, 140, 80, 66,
		34, 194, 16, 109, 237, 17, 222, 161, 96, 8, 11, 194, 58, 45, 86, 15, 207, 121, 247, 104, 78, 101, 1, 144, 68, 206, 192, 52, 67, 9, 243,
		20, 9, 195, 153, 15, 22, 217, 243, 79, 177, 22, 24, 171, 122, 243, 190, 146, 77, 222, 208, 129 }

	};
	// endof---------------加密表达式加密后的数组----------------------;

	CONST YtError g_YtError[] = {
		{-1,	_T("未找到返回结果变量\n")},
		{-2,	_T("未找到 = 符号\n")},
		{-3,	_T("代表没有找到相应常数\n")},
		//{-4,	_T("未找到返回结果变量\n")},
		{-5,	_T("代表找不到字符串的第一个双引号\n")},
		{-6,	_T("代表找不到字符串的第二个双引号\n")},
		{-7,	_T("IF语句没有找到goto字符\n")},
		{-8,	_T("IF语句没有找到第一个比较字符\n")},
		{-9,	_T("IF语句没有找到比较符号\n")},
		{-10,	_T("两边变量类型不相符\n")},
		{-11,	_T("没有找到NOT符号\n")},
		{-12,	_T("不是整形变量\n")},
		{-13,	_T("代表没有找到相应整形常数\n")},
		{-14,	_T("代表没有找到相应字符串常数\n")},
		{-15,	_T("代表没有找到相应浮点常数\n")},
		{-16,	_T("代表不支持这个运算\n")},
		{-17,	_T("代表没有左边括号\n")},
		{-18,	_T("代表没有变量\n")},
		{-19,	_T("代表没“，”\n")},
		{-20,	_T("代表没有右边括号\n")},
		{-21,	_T("代表常数超过指这定的范围\n")},
		{-22,	_T("代表储存器的地址超过指定的范围，整数不能超过EEPROM_LEN-4，浮点不能超过EEPROM_LEN-8\n")},
		{-23,	_T("代表储存器的地址超过指定的范围，字符串不能超过EEPROM_LEN-LEN，其中LEN为字符串的长度\n")},
		{-24,	_T("除法中，被除数不能为0\n")},
		{-25,	_T("未知错误\n")},
		{-26,	_T("第二个变量不在指定的位置\n")},
		{-27,	_T("字符串常量超过指定的长度\n")},
		{-28,	_T("不是字符串变量\n")},
		{-29,	_T("没有第三个变量\n")},
		{-30,	_T("GOTO的标识语句不能全为数字\n")},
		{-31,	_T("不能打开ENC文件\n")},
		{-32,	_T("不能读ENC文件\n")},
		{-33,	_T("GOTO CALL不能找到指定的跳转位置\n")},
		{-34,	_T("智能卡运算中，未知数据类型\n")},
		{-35,	_T("智能卡运算中，未知代码类型\n")},
		{-36,	_T("字符串长度超出50\n")},
		{-37,	_T("操作时超长，负长\n")},
		{-38,	_T("标识重复\n")},
		{-39,	_T("程序堆栈溢出\n")},
		{-40,	_T("堆栈溢出\n")},
		{-41,	_T("不能建立编译文件，请查看文件是否有只读属性，或被其它文件打开\n")},
		{-42,	_T("不能写文件，请查看文件是否有只读属性，或被其它文件打开\n")},
		{-43,	_T("程序被中途使用END语句结束\n")},
		{-44,	_T("程序跳转到外部的空间\n")},
		{-45,	_T("传送数据失败\n")},
		{-46,	_T("程序超出运算次数，可能是死循环\n")},
		{-47,	_T("写密码不正确\n")},
		{-48,	_T("读密码不正确\n")},
		{-49,	_T("读写EEPROM时，地址溢出\n")},
		{-50,	_T("USB操作失败，可能是没有找到相关的指令\n")},
		{-51,	_T("打开USB文件句柄失败\n")},
		{-52,	_T("使用加密锁加密自定义表达式，生成加密代码时生产错误\n")},
		{-53,	_T("无法打开usb设备，可能驱动程序没有安装或没有插入加密锁\n")},
		//{-54,	_T("未找到返回结果变量\n")},
		{-55,	_T("要加密的数据少于8个字节\n")},
		{-56,	_T("返回结果变量错误\n")},
		{-57,	_T("初始化密钥错误\n")},
		{-58,	_T("e密钥或n模不能为0\n")},
		{-59,	_T("初始化MD5错误\n")},
		{-60,	_T("MD5运算错误\n")},
		{-61,	_T("计算MD5结果时错误\n")},
		{-62,	_T("授权次数溢出，不能再进行授权\n")},
		{-63,	_T("不能打开指定的文件\n")},
		{-64,	_T("不能建立指定的文件\n")},
		{-65,	_T("验证码错误，可能是输入解密密钥错误，或注册授权码错误\n")},
		{-66,	_T("执行TIMEOUT函数时，输入的ID与锁ID不相符\n")},
		{-67,	_T("执行TIMEOUT函数时，智能卡运行函数已到期\n")},
		{-68,	_T("操作浮点运算时，输入的参数将会导致返回值是一个无穷值\n")},
		{-69,	_T("代表没足够的变量参数\n")},
		{-70,	_T("返回变量与函数不相符\n")},
		{-71,	_T("浮点数转换字符串时，要转换的数据太大\n")},
		{-72,	_T("初始化服务器错误\n")},
		{-73,	_T("对缓冲区进行MD5运算时错误\n")},
		{-74,	_T("MD5验证IPVAR错误\n")},
		{-75,	_T("MD5验证IPCount错误\n")},
		{-76,	_T("没有找到对应的SOCKET连接\n")},
		{-77,	_T("没有找到要删除的对应的SOCKET连接\n")},
		{-78,	_T("没有找到要删除的对应的功能模块号连接\n")},
		{-79,	_T("没有找到要增加的对应的功能模块号连接\n")},
		{-80,	_T("用户数已超过限制的授权数量\n")},
		{-81,	_T("找不到对应的INI文件条目\n")},
		{-82,	_T("没有进行初始化服务工作\n")},
		{-83,	_T("ref不能应用于常数\n")},
		{-84,	_T("代表使用scall,ccall等指令时，传递的参数太多\n")},
		{-85,	_T("表示调用scall,ccall,sloadlib,cloadlib等指令时，不能返回运行代码\n")},
		{-86,	_T("表示调用scall,ccall,sloadlib,cloadlib等指令时，不能将结果变量返回\n")},
		{-87,	_T("表示调用外部DLL时，不能读取指定的DLL\n")},
		{-88,	_T("表示调用外部DLL时，不能获取对应函数所在的地址\n")},
		//{-89,	_T("未找到返回结果变量\n")},

		//////////////////////////////////////////////////////////////////////////
		{-252,	_T("密码不正确\n")},
		{-253,	_T("打开加密锁时PIN码错误\n")},
		{-254,	_T("设置PIN码错误\n")},
		{-255,	_T("操作加密锁时没有进行PIN操作\n")},

		//////////////////////////////////////////////////////////////////////////
		{-1052,	_T("可能是输入的授权号不正确\n")},
		{-1053,	_T("系统上没有任何智能锁\n")},
		{-1088,	_T("发送数据错误\n")},
		{-1089,	_T("获取数据错误\n")},
		{-1092,	_T("找不到对应的服务端操作码\n")},
		{-1093,	_T("表示连接服务时错误\n")},
		{-1095,	_T("获取主机名称失败\n")},
		{-1097,	_T("建立套字接错误\n")},
		{-1098,	_T("绑定套字节端口错误\n")},
		{-1099,	_T("表示无效连接，不能进行相关的操作\n")},
		{-2002,	_T("表示监听时产生错误\n")},
		{-2003,	_T("表示发送的数据长度与接收的数据长度不相符\n")},
		{-2005,	_T("表示当前服务不存在任何连接\n")},
		{-2006,	_T("表示当前查询节点超出集合范范围\n")},
		{-2009,	_T("表示关闭连接错误\n")},
		
		//////////////////////////////////////////////////////////////////////////
		{-10000,_T("未知错误代码\n")}
	};


	CHAR g_szKeyPath[MAX_PATH] = {0};

	void ReSetPassWord()
	{
		if ( !g_bUSE_NEWPASSWORD )
		{
			g_pHReadPassWord = g_szPassword[0][0];
			g_pLReadPassWord = g_szPassword[0][1];

			g_pHWritePassWord = g_szPassword[1][0];
			g_pLWritePassWord = g_szPassword[1][1];
		}
		else
		{
			g_pHReadPassWord = g_szPassword[2][0];
			g_pLReadPassWord = g_szPassword[2][1];

			g_pHWritePassWord = g_szPassword[3][0];
			g_pLWritePassWord = g_szPassword[3][1];
		}
	}

	BOOL ReadYtInfoVer1(IN CONST INT &nUSBStartPos, OUT YtInfoVer1 &Infover1, OUT INT &nUSBPort, OUT CHAR* pszKeyPath, IN CONST INT &nKeypath)
	{
		INT nRetval = 0;
		INT nVal[8] = { 0 };
		DOUBLE fVal[8] = { 0.0 };
		CHAR s0[50] = "", s1[50] = "", s2[50] = "", s3[50] = "", s4[50] = "", s5[50] = "", s6[50] = "", s7[50] = "";

		BOOL bFind = FALSE;
		CHAR szKeyPath[MAX_PATH] = "";
		for (INT nIndex = nUSBStartPos; nIndex < 256; nIndex++)
		{
			memset(szKeyPath, 0, sizeof(szKeyPath));
			nRetval = FindPort(nIndex, szKeyPath);
			if (nRetval != 0 && nIndex == 0) 
			{
				GetYtUSBKey32ErrInfo(nRetval);
				continue;
			}

			if (nRetval != 0)
			{
				GetYtUSBKey32ErrInfo(nRetval);
				continue;
			}

			for (int i = 0; i < 6; i++)
			{
				// 使用该设备路径锁进行运算;
				nRetval = CalEx(g_byShotVersion[i], 10,
					&nVal[0], &nVal[1], &nVal[2], &nVal[3], &nVal[4], &nVal[5], &nVal[6], &nVal[7],
					&fVal[0], &fVal[1], &fVal[2], &fVal[3], &fVal[4], &fVal[5], &fVal[6], &fVal[7],
					s0, s1, s2, s3, s4, s5, s6, s7, szKeyPath, 20000);
				//如果正确，则返回该设备路径供以后使用;
				if (nRetval == -63) continue;
				if ((nRetval == 0) && (nVal[0] == 123))
				{
					nUSBPort = nIndex;
					if (pszKeyPath)
						sprintf_s(pszKeyPath, nKeypath, "%s",szKeyPath);

					bFind = TRUE;
					Infover1.nSoftVer = i;
					// 获取加密锁座席数量;
					if ( (nRetval = YtReadString(Infover1.szCCount, 264, ENCRYPT_BLOCK_LEN, g_pHReadPassWord, g_pLReadPassWord, szKeyPath)) != 0 )
						GetYtUSBKey32ErrInfo(nRetval);
					
					// 获取加密锁域名值;
					if ( (nRetval = YtReadString(Infover1.szBranchId, 297, ENCRYPT_BLOCK_LEN, g_pHReadPassWord, g_pLReadPassWord, szKeyPath)) != 0)
						GetYtUSBKey32ErrInfo(nRetval);

					// 获取医院跟踪系统;
					if ( (nRetval = YtReadString(Infover1.szHospital, 330, ENCRYPT_BLOCK_LEN, g_pHReadPassWord, g_pLReadPassWord, szKeyPath)) != 0)
						GetYtUSBKey32ErrInfo(nRetval);

					// 返回加密锁已运行时间;
					if ( (nRetval = GetRunTimer(Infover1.szHasRunyears, Infover1.szHasRunmonths, Infover1.szHasRundays, Infover1.szHasRunhours, Infover1.szHasRunminutes, Infover1.szHasRunseconds, szKeyPath)) != 0)
						GetYtUSBKey32ErrInfo(nRetval);

					// 返回加密锁可运行时间;
					DWORD dwShortID = 0;	// 锁短ID;
					CHAR szOutString[100] = {0};
					CHAR HKey[50] = {0}, LKey[50] = {0};

					// 30000以后的储存空间为公共区域;
					if ( (nRetval = ReadTimeAuthFromEprom(HKey, LKey, szOutString, &dwShortID, 30128, "FFFFFFFF", "FFFFFFFF", szKeyPath)) != 0)
						GetYtUSBKey32ErrInfo(nRetval);

					std::string str = szOutString;
					int nStrPos = str.find("年");
					if ( nStrPos != std::string::npos )
					{
						sprintf_s(Infover1.szCanRunyears, "%s", str.substr(0,nStrPos).c_str());
						str = str.substr(nStrPos + strlen("年"));

						nStrPos = str.find("月");
						sprintf_s(Infover1.szCanRunmonths, "%s", str.substr(0,nStrPos).c_str());
						str = str.substr(nStrPos + strlen("月"));

						nStrPos = str.find("日");
						sprintf_s(Infover1.szCanRundays, "%s", str.substr(0,nStrPos).c_str());
						str = str.substr(nStrPos + strlen("日"));

						nStrPos = str.find("小时");
						sprintf_s(Infover1.szCanRunhours, "%s", str.substr(0,nStrPos).c_str());
						str = str.substr(nStrPos + strlen("小时"));

						nStrPos = str.find("分钟");
						sprintf_s(Infover1.szCanRunminutes, "%s", str.substr(0,nStrPos).c_str());
						//str = str.substr(nStrPos + strlen("分钟"));
					}

					break;
				}
			}

			if (bFind) break;
		}

		return bFind;
	}

	BOOL ModifyYtVer1Info(IN CHAR* pszKeypath, IN YtInfoVer1 &Infover1, IN CONST INT &nModifyType)
	{
		// 修改类型有：加减运行时间、加减座席数量、开通或关闭医院功能。
		switch(nModifyType)
		{
		case VER1_ADDCCOUNT:
			break;
		case VER1_MINUSCCOUNT:
			break;
		case VER1_HOSPITAL:
			break;
		case VER1_ADDTIME:
			break;
		case VER1_MINUSTIME:
			break;
		default:
			break;
		}
		return TRUE;
	}

	/************************************************************************/
	/*
	函数:ClearEncryptlockInfo
	描述:清空加密所有加密信息;
	参数:
	[IN] nStartUSBPort 加密狗起始USB搜索位置;
	返回:清除成功返回TRUE;
	*/
	/************************************************************************/
	BOOL ClearEncryptlockInfo(IN const int &nStartUSBPort)
	{
		int nRet = 0;
		int nVersion = -1;	// 锁版本;
		DWORD dwShortKey = 0;	// 锁短ID;
		CHAR szKeyPath[MAX_PATH] = { 0 };	// USB锁物理位置;

		// 从nStartUSBPort的USB的位置开始查找加密锁;
		if (0 != FindPort(nStartUSBPort, szKeyPath))
		{
			// 返回非0表示失败;
			return FALSE;
		}

		// 返回锁的短ID及版本号;
		if (0 != GetIDVersion(&dwShortKey, &nVersion, szKeyPath))
		{
			// 返回非0表示失败;
			return FALSE;
		}

		if (dwShortKey == -1)
		{
			// 不是域天智能锁;
			return FALSE;
		}

		// 清空所有版本锁的rom空间地内容;
		CHAR szRom[ENCRYPT_BLOCK_LEN] = { 0 };	// 包含结束符;
		for (int i = 0; i < 11; i++)
		{
			nRet = YtWriteString(szRom, i * 33, g_pHWritePassWord, g_pLWritePassWord, szKeyPath);
			if (nRet <= 0)
			{
				// 执行失败;
				GetYtUSBKey32ErrInfo(nRet);
			}
		}

		// 清除写密码;
		nRet = SetWritePassword(g_pHWritePassWord, g_pLWritePassWord, "FFFFFFFF", "FFFFFFFF", szKeyPath);
		if ( nRet != 0)
		{
			// 执行失败;
			GetYtUSBKey32ErrInfo(nRet);
			AfxMessageBox(_T("清除写密码失败"));
			//return FALSE;
		}

		// 清除读密码;//设置读密码,必须用写密码;
		if ((nRet = SetReadPassword("FFFFFFFF", "FFFFFFFF", "FFFFFFFF", "FFFFFFFF", szKeyPath)) != 0)
		{
			// 执行失败;
			GetYtUSBKey32ErrInfo(nRet);
			AfxMessageBox(_T("清除读密码失败"));
			//return FALSE;
		}

		// 清空所有版本锁的加密解密的密钥;
		BOOL bErased = FALSE;
		for (int i = 0; i < 6; i++)
		{
			if (0 == ( nRet = WriteEncKey(g_szEncKey[i][0], g_szEncKey[i][1], g_szEncKey[i][2], g_szEncKey[i][3], "FFFFFFFF", "FFFFFFFF", "FFFFFFFF", "FFFFFFFF", szKeyPath)))
			{
				bErased = TRUE;
				break;
			}
			else
			{
				GetYtUSBKey32ErrInfo(nRet);
			}
		}

		if (!bErased)
		{
			AfxMessageBox(_T("清除加密锁失败,该锁可能已经清除过~"));
		}

		return TRUE;
	}

	BOOL FindYtUSB(OUT DWORD &dwShortKey, OUT INT &nVersion, OUT CHAR *pszKeyPath, IN CONST INT &nStartPort)
	{
		// 从nStartPort的USB的位置开始查找加密锁;
		if (0 != FindPort(nStartPort, pszKeyPath))
			return FALSE;

		// 返回锁的短ID及版本号;
		if (0 != GetIDVersion(&dwShortKey, &nVersion, pszKeyPath))
			return FALSE;

		return TRUE;
	}

	//////////////////////////////////////////////////////////////////////////
	/*
		函数:CreateEncryptlockInfo
		描述:生成指定版本的加密锁;
		参数:
			IN: nStartPort 起始USB搜索位置;
			IN: nSoftVer 指定生成的加密狗版本信息;
			IN: nCCount 座席版连接数量;
			IN: bHospital 是否注册医院跟踪系统功能 ;
			IN: bAdddate  授权时间是否追加生成;
			IN: szRunyears
			IN: szRunmonths
			IN: szRundays
			IN: szRunhours
			IN: szRunminutes
			OUT: lpHasRundate	返回锁已运行时间;
			OUT: lpCouldRundate	返回锁授权时间;

		返回:
	*/
	//////////////////////////////////////////////////////////////////////////
	BOOL CreateEncryptlockInfo(IN CONST INT &nStartPort,IN EncryptlockInfo &linfo,OUT LPTSTR lpHasRundate,IN CONST size_t &sizeOfhasrundate,OUT LPTSTR lpCouldRundate,IN CONST size_t &sizeOfcouldrundate, IN BOOL bfixedId /*= FALSE*/ )
	{
		int nRet = -1;
		DWORD dwShortKey = 0;
		int nVersion = -1;
		CHAR  szKeyPath[MAX_PATH] = { 0 };

		if (!FindYtUSB(dwShortKey, nVersion, szKeyPath, nStartPort))
			return FALSE;

		if (dwShortKey == -1)
		{
			// 不是域天智能锁;
			return FALSE;
		}

		nRet = SetReadPassword("FFFFFFFF", "FFFFFFFF", g_pHReadPassWord, g_pLReadPassWord, szKeyPath);
		if (nRet != 0) {
			GetYtUSBKey32ErrInfo(nRet);
			AfxMessageBox(_T("设置读密码失败"));
		}

		nRet = SetWritePassword("FFFFFFFF", "FFFFFFFF", g_pHWritePassWord, g_pLWritePassWord, szKeyPath);
		if (nRet != 0) {
			GetYtUSBKey32ErrInfo(nRet);
			AfxMessageBox(_T("设置写密码失败"));
		}

		// 从地址0~231+32,是所有加密锁共同内容;
		for (int i = 0; i < 8; i++)
		{
			if ((nRet = YtWriteString(g_szRom[i], i * 33, g_pHWritePassWord, g_pLWritePassWord, szKeyPath)) <= 0)
			{
				// 写区域错误;
				GetYtUSBKey32ErrInfo(nRet);
			}
		}

		// 264是座席数量;
		if (linfo.nCCount != 0)
		{
			CHAR szCCount[ENCRYPT_BLOCK_LEN] = { 0 };	// 包含结束符;
			sprintf_s(szCCount, "%d", linfo.nCCount);

			if ((nRet = YtWriteString(szCCount, 264, g_pHWritePassWord, g_pLWritePassWord, szKeyPath)) <= 0 )
			{
				// 设置座席数失败;
				GetYtUSBKey32ErrInfo(nRet);
				return FALSE;
			}
		}

		// 297是域名值;
		// 生成域名串 = 日期 + 短ID;
		CHAR szDomain[ENCRYPT_BLOCK_LEN] = { 0 };	// 包含结束符;

		if ( bfixedId )
		{
			sprintf_s(szDomain, "20151208000000%d.ly.com", dwShortKey);
		}
		else
		{
			CTime tt = CTime::GetCurrentTime();
			sprintf_s(szDomain, "%04d%02d%02d%02d%02d%02d%d.ly.com", tt.GetYear(), tt.GetMonth(), tt.GetDay(), tt.GetHour(), tt.GetMinute(), tt.GetSecond(), dwShortKey);
		}

		if ( ( nRet = YtWriteString(szDomain, 297, g_pHWritePassWord, g_pLWritePassWord, szKeyPath)) <= 0)
		{
			// 生成域名错误;
			GetYtUSBKey32ErrInfo(nRet);
			return FALSE;
		}

		// 330是医院跟踪系统;
		if (linfo.bHospital)
		{
			CHAR szHospital[ENCRYPT_BLOCK_LEN] = { 0 };	// 包含结束符;
			sprintf_s(szHospital, "%d", linfo.bHospital);

			if ( ( nRet = YtWriteString(szHospital, 330, g_pHWritePassWord, g_pLWritePassWord, szKeyPath)) <= 0 )
			{
				// 设置医院跟踪系统失败;
				GetYtUSBKey32ErrInfo(nRet);
				return FALSE;
			}
		}

		// 生成指定软件版本加密解密密钥;
		switch (linfo.nSoftVer)
		{
		case EN_OCHILD:
			nRet = WriteEncKey("FFFFFFFF", "FFFFFFFF", "FFFFFFFF", "FFFFFFFF", g_szEncKey[EN_OCHILD][0], g_szEncKey[EN_OCHILD][1], g_szEncKey[EN_OCHILD][2], g_szEncKey[EN_OCHILD][3], szKeyPath);
			break;
		case EN_LCHILD:
			nRet = WriteEncKey("FFFFFFFF", "FFFFFFFF", "FFFFFFFF", "FFFFFFFF", g_szEncKey[EN_LCHILD][0], g_szEncKey[EN_LCHILD][1], g_szEncKey[EN_LCHILD][2], g_szEncKey[EN_LCHILD][3], szKeyPath);
			break;
		case EN_ECHILD:
			nRet = WriteEncKey("FFFFFFFF", "FFFFFFFF", "FFFFFFFF", "FFFFFFFF", g_szEncKey[EN_ECHILD][0], g_szEncKey[EN_ECHILD][1], g_szEncKey[EN_ECHILD][2], g_szEncKey[EN_ECHILD][3], szKeyPath);
			break;
		case EN_OWDDING:
			nRet = WriteEncKey("FFFFFFFF", "FFFFFFFF", "FFFFFFFF", "FFFFFFFF", g_szEncKey[EN_OWDDING][0], g_szEncKey[EN_OWDDING][1], g_szEncKey[EN_OWDDING][2], g_szEncKey[EN_OWDDING][3], szKeyPath);
			break;
		case EN_LWDDING:
			nRet = WriteEncKey("FFFFFFFF", "FFFFFFFF", "FFFFFFFF", "FFFFFFFF", g_szEncKey[EN_LWDDING][0], g_szEncKey[EN_LWDDING][1], g_szEncKey[EN_LWDDING][2], g_szEncKey[EN_LWDDING][3], szKeyPath);
			break;
		case EN_EWDDING:
			nRet = WriteEncKey("FFFFFFFF", "FFFFFFFF", "FFFFFFFF", "FFFFFFFF", g_szEncKey[EN_EWDDING][0], g_szEncKey[EN_EWDDING][1], g_szEncKey[EN_EWDDING][2], g_szEncKey[EN_EWDDING][3], szKeyPath);
			break;
		}

		if (nRet != 0)
		{
			// 生成密钥失败;
			GetYtUSBKey32ErrInfo(nRet);
			return FALSE;
		}

		//////////////////////////////////////////////////////////////////////////
		// 授权时间码;
		CHAR szyear[10] = { 0 }, szmonth[10] = { 0 }, szday[10] = { 0 }, szhour[10] = { 0 }, szminute[10] = { 0 }, szsecond[10] = { 0 };
		if ( ( nRet = GetRunTimer(szyear, szmonth, szday, szhour, szminute, szsecond, szKeyPath)) != 0 )
		{
			// 获取运行时间失败;
			GetYtUSBKey32ErrInfo(nRet);
			return FALSE;
		}

		_stprintf_s(lpHasRundate, sizeOfhasrundate, _T("已运行 %s年%s月%s天%s时%s分"), szyear, szmonth, szday, szhour, szminute);
		if (linfo.bAdddate) // 追加时间;
		{
			sprintf_s(szyear, "%d", atoi(linfo.szRunyears) + atoi(szyear));
			sprintf_s(szmonth, "%d", atoi(linfo.szRunmonths) + atoi(szmonth));
			sprintf_s(szday, "%d", atoi(linfo.szRundays) + atoi(szday));
			sprintf_s(szhour, "%d", atoi(linfo.szRunhours) + atoi(szday));
			sprintf_s(szminute, "%d", atoi(linfo.szRunminutes) + atoi(szminute));
		}
		else
		{
			sprintf_s(szyear, "%s", linfo.szRunyears);
			sprintf_s(szmonth, "%s", linfo.szRunmonths);
			sprintf_s(szday, "%s", linfo.szRundays);
			sprintf_s(szhour, "%s", linfo.szRunhours);
			sprintf_s(szminute, "%s", linfo.szRunminutes);
		}

		// 生成时间授权码;
		CHAR szOutString[100] = { 0 };	// 返回的时间授权码;
		if (( nRet = MakeTimerAuth(g_szUserKey, dwShortKey, szyear, szmonth, szday, szhour, szminute, szOutString, szKeyPath)) != 0)
		{
			// 生成时间授权码失败;
			GetYtUSBKey32ErrInfo(nRet);
			return FALSE;
		}

		CHAR HKey[9] = "FFFFFFFF", LKey[9] = "FFFFFFFF";
		CHAR WHKey[41] = "0", WLKey[41] = "0";
		memcpy(WHKey, szOutString, 40);
		memcpy(WLKey, &szOutString[40], 40);

		// 写授权时间到加密锁中;
		if ((nRet = WriteTimeAuthToEprom(30128, HKey, LKey, WHKey, WLKey, dwShortKey, szyear, szmonth, szday, szhour, szminute, szKeyPath)) != 0 )
		{
			// 写授权时间失败;
			GetYtUSBKey32ErrInfo(nRet);
			return FALSE;
		}

		DWORD dwID;
		// 30000以后的储存空间为公共区域;
		if ( ( nRet = ReadTimeAuthFromEprom(WHKey, WLKey, szOutString, &dwID, 30128, "FFFFFFFF", "FFFFFFFF", szKeyPath)) == 0 )
		{
#ifdef UNICODE
			WCHAR *pOutString = ascii2unicode(szOutString);
			_stprintf_s(lpCouldRundate, sizeOfcouldrundate, _T("%s"), pOutString);
			delete pOutString;
			pOutString = NULL;
#else
			_stprintf_s(lpCouldRundate, sizeOfcouldrundate, _T("%s"), szOutString);
#endif
		}
		else
		{
			GetYtUSBKey32ErrInfo(nRet);
		}

		return TRUE;
	}

	//////////////////////////////////////////////////////////////////////////
	// 应用接口；
	BOOL GetFirstYtUSBSoftVer(IN INT &nSoftVer, IN CHAR *pBranchIdBuffer, IN size_t sizeOfBranchIdBuffer, IN CONST INT &nUSBStartPos /* = 0 */)
	{
		INT nRetval = 0;
		INT nVal[8] = { 0 };
		DOUBLE fVal[8] = { 0.0 };
		CHAR s0[50] = "", s1[50] = "", s2[50] = "", s3[50] = "", s4[50] = "", s5[50] = "", s6[50] = "", s7[50] = "";


		BOOL bFind = FALSE;
		CHAR szKeyPath[MAX_PATH] = "";
		for (INT nIndex = nUSBStartPos; nIndex < 256; nIndex++)
		{
			memset(szKeyPath, 0, sizeof(szKeyPath));
			nRetval = FindPort(nIndex, szKeyPath);
			if (nRetval != 0 && nIndex == 0) continue;
			if (nRetval != 0) continue;

			for (int i = 0; i < 6; i++)
			{
				// 使用该设备路径锁进行运算;
				nRetval = CalEx(g_byShotVersion[i], 10,
					&nVal[0], &nVal[1], &nVal[2], &nVal[3], &nVal[4], &nVal[5], &nVal[6], &nVal[7],
					&fVal[0], &fVal[1], &fVal[2], &fVal[3], &fVal[4], &fVal[5], &fVal[6], &fVal[7],
					s0, s1, s2, s3, s4, s5, s6, s7, szKeyPath, 20000);
				//如果正确，则返回该设备路径供以后使用;
				if (nRetval == -63) continue;
				if ((nRetval == 0) && (nVal[0] == 123))
				{
					bFind = TRUE;
					nSoftVer = i;
					sprintf_s(pBranchIdBuffer, sizeOfBranchIdBuffer, "%s", s0);
					break;
				}
			}

			if (bFind) break;
		}

		return bFind;
	}

	CONST TCHAR* GetYtUSBKey32ErrInfo(IN const long lError)
	{
		INT nIndex = -1;
		TCHAR *pErrorDescription = NULL;
		
		while ( g_YtError[++nIndex].nErrorCode != -10000 )
		{
			if ( lError == g_YtError[nIndex].nErrorCode )
			{
				pErrorDescription = g_YtError[nIndex].pErrorDescription;
				break;
			}
		}

		if ( pErrorDescription == NULL )
			pErrorDescription = _T("未知错误！\n");

		OutputDebugString(pErrorDescription);

		return pErrorDescription;
	}

};