myvtm/RVCComm/Package.cpp

// CommPackageImp.cpp: implementation of the CCommPackage class.
//
//////////////////////////////////////////////////////////////////////
#include "Package.h"
#include <time.h>
#include <assert.h>
#include <memory>
#include <winpr/crt.h>

#ifdef WIN32
#include "xzip.h"
#include "xunzip.h"
//当前未使用数据加密
#endif // WIN32


#include "openssl/md5.h"
//#include "openssl/des.h"

//2019年12月8日
//#pragma comment(lib, "libeay32.lib")

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
DWORD CCommPackage::m_nLastReqTime(0);
WORD CCommPackage::m_nLastReqSN(0);

CCommPackage::CCommPackage(const BYTE sessionKey[16], const char *pServiceCode)
{
	if (sessionKey != NULL)
	{
		memcpy(m_SessionKey, sessionKey, 16);
		
		// 前8个字节作为DesKey，后8个字节作为IVec		
		DES_set_key_unchecked((BYTE(*)[8])&m_SessionKey, &m_DesKey);
		//memcpy(m_DesIVec, m_SessionKey+8, 8);

		m_bHasSessionKey = true;
	}
	else
	{
		memset(m_SessionKey, 0, 16);
		m_bHasSessionKey = false;
	}

	m_Header.m_nStructNum =0;
	m_Header.m_nPackageLen = sizeof(CPackageHeader);

	if (pServiceCode != NULL)
	{
		if (strlen(pServiceCode) >=8)
			memcpy(m_Header.m_arrServiceCode, pServiceCode, 8);
		else
			strcpy(m_Header.m_arrServiceCode, pServiceCode);
	}
}

CCommPackage::CCommPackage(CCommPackage *pkg)
{
	m_bHasSessionKey = pkg->m_bHasSessionKey;
	if (m_bHasSessionKey)
	{
		memcpy(m_SessionKey, pkg->m_SessionKey, 16);

		// 前8个字节作为DesKey，后8个字节作为IVec
		DES_set_key_unchecked((BYTE(*)[8])&m_SessionKey, &m_DesKey);
		//memcpy(m_DesIVec, m_SessionKey+8, 8);
	}
	else
	{
		memset(m_SessionKey, 0, 16);
	}

	m_Header.m_nStructNum =0;
	m_Header.m_nPackageLen = sizeof(CPackageHeader);

	// 拷贝ServiceCode
	memcpy(m_Header.m_arrServiceCode, pkg->m_Header.m_arrServiceCode, 8);

	// 拷贝ReqTime和DSN
	m_Header.m_nReqTime = pkg->m_Header.m_nReqTime;
	m_Header.m_nSN = pkg->m_Header.m_nSN;
}

CCommPackage::~CCommPackage()
{
	Clear();
}

void CCommPackage::Clear()
{
	std::vector<CStructDef *>::iterator it;
	
	for(it = m_Structs.begin(); it != m_Structs.end(); it++)
	{
		if ((*it)->m_pData != NULL)
			delete[](*it)->m_pData;

		delete *it;
	}

	m_Structs.clear();

	memset(&m_Header, 0, sizeof(CPackageHeader));
}

void CCommPackage::AddStruct(const char *pStructName, bool bZip, 
	bool bEncrypt, BYTE *pDataBuf, int nBufLen, int nArrayNum)
{
	assert(m_Header.m_nPackageLen + nBufLen + CStructDef::GetStructDefLen() < 0xFFFF);

	CStructDef *pDef = new CStructDef();
	
	if (strlen(pStructName) <8)
		strcpy(pDef->m_arrName, pStructName);
	else
		memcpy(pDef->m_arrName, pStructName, 8);

	pDef->m_nArrayNum = nArrayNum;
	pDef->m_cEncCode = 'N';
	pDef->m_cZipCode = 'N';

	pDef->m_nSourceLen = nBufLen;	
	pDef->m_nTargetLen = nBufLen;

	pDef->m_pData = new BYTE[nBufLen];
	memcpy(pDef->m_pData, pDataBuf, nBufLen);

	// 先压缩，后加密，提高压缩效率
	if (bZip)
	{
		// 压缩后最大长度不应大于源长度
		int nTempBufLen = pDef->m_nTargetLen;
		BYTE *pTempBuf = new BYTE[nTempBufLen];
		memset(pTempBuf, 0, nTempBufLen);
		
		if (ZipData(pDef->m_pData, pDef->m_nTargetLen, pTempBuf, &nTempBufLen))
		{
			delete[] pDef->m_pData;
			
			pDef->m_pData = pTempBuf;
			pDef->m_nTargetLen = nTempBufLen;
			pDef->m_cZipCode = 'Y';
		}
		else
			delete[] pTempBuf;
	}	

	// 加密，加密后长度可能变长，变成8的倍数。需要在输出数据前加上4字节长度，指明加密前长度
	if (bEncrypt && m_bHasSessionKey)
	{
		// 加密后最大长度
		int nTempBufLen = pDef->m_nTargetLen + 12;
		BYTE *pTempBuf = new BYTE[nTempBufLen];
		memset(pTempBuf, 0, nTempBufLen);		

		if (EncryptData(pDef->m_pData, pDef->m_nTargetLen, pTempBuf, &nTempBufLen))
		{
			delete[] pDef->m_pData;

			pDef->m_pData = pTempBuf;
			pDef->m_nTargetLen = nTempBufLen;	// 加密后实际长度
			pDef->m_cEncCode = 'Y';
		}
		else
		{
			delete[] pTempBuf;
		}
	}

	// 保存到结构定义
	m_Structs.push_back(pDef);

	// 处理包头
	m_Header.m_nStructNum++;
	m_Header.m_nPackageLen += pDef->m_nTargetLen + CStructDef::GetStructDefLen();
}

void CCommPackage::SetErrMsg(DWORD dwSysCode, DWORD dwUserCode, const char *pErrMsg)
{
	char buf[512];
	memset(buf, 0, sizeof(buf));
	
	CErrorReturn *pErrRet = (CErrorReturn*) buf;

	pErrRet->m_dwSysCode = dwSysCode;
	pErrRet->m_dwUserCode = dwUserCode;

	int nDataLen =8;
	if (strlen(pErrMsg) >= 256)	
	{
		memcpy(pErrRet->m_arrErrMsg, pErrMsg, 256);
		nDataLen += 256;
	}
	else
	{
		strcpy(pErrRet->m_arrErrMsg, pErrMsg);
		nDataLen += strlen(pErrMsg);
		//nDataLen += 256;	// 考虑与C#对接，故不使用变长字段
	}
	
	AddStruct("ERRORRET", false, false, (BYTE*)buf, nDataLen, 1);
}

bool CCommPackage::GetErrMsg(DWORD& dwSysCode, DWORD& dwUserCode, string& rErrMsg)
{
	std::vector<CStructDef *>::iterator it;

	for(it = m_Structs.begin(); it != m_Structs.end(); it++)
	{
		if (memcmp((*it)->m_arrName, "ERRORRET", 8) ==0)
			break;
	}

	if (it == m_Structs.end())
		return false;

	assert((*it)->m_cEncCode == 'N');
	assert((*it)->m_cZipCode == 'N');

	CErrorReturn *pErrRet = (CErrorReturn*)(*it)->m_pData;
	
	dwSysCode = pErrRet->m_dwSysCode;
	dwUserCode = pErrRet->m_dwUserCode;

	int nErrMsgLen = (*it)->m_nSourceLen - 8;
	char buf[512];
	memset(buf, 0, sizeof(buf));
	memcpy(buf, pErrRet->m_arrErrMsg, nErrMsgLen);

	rErrMsg = buf;
	return true;
}

string CCommPackage::GetServiceCode()
{
	if (m_Header.m_arrServiceCode[7] == 0)
		return  m_Header.m_arrServiceCode;
	else
	{
		char buf[9];
		memset(buf, 0, sizeof(buf));
		memcpy(buf, m_Header.m_arrServiceCode, 8);
		return buf;
	}
}

int CCommPackage::GetStructLen(const char *pStructName)
{
	int nCompLen = strlen(pStructName);
	if (nCompLen >8 )
		nCompLen = 8;

	std::vector<CStructDef *>::iterator it;

	for(it = m_Structs.begin(); it != m_Structs.end(); it++)
	{
		if (memcmp((*it)->m_arrName, pStructName, nCompLen) ==0)
			break;
	}

	if (it == m_Structs.end())
		return -1;

	return (*it)->m_nSourceLen;
}


bool CCommPackage::GetStructData(const char *pStructName, BYTE *pDataBuf, int *pBufLen, int *pArrayNum)
{
	int nCompLen = strlen(pStructName);
	if (nCompLen >8 )
		nCompLen = 8;

	std::vector<CStructDef *>::iterator it;

	for(it = m_Structs.begin(); it != m_Structs.end(); it++)
	{
		if (memcmp((*it)->m_arrName, pStructName, nCompLen) ==0)
			break;
	}

	if (it == m_Structs.end())
		return false;

	*pArrayNum = (*it)->m_nArrayNum;
	
	int nCopyLen = (*it)->m_nSourceLen;
	if (nCopyLen > *pBufLen)
		nCopyLen = *pBufLen;

	*pBufLen = nCopyLen;
	memcpy(pDataBuf, (*it)->m_pData, nCopyLen);

	return true;
}


bool CCommPackage::ParseRecvData(BYTE *pData, int *pLen, string& strErrMsg)
{
	if (*pLen < sizeof(CPackageHeader))
	{
		strErrMsg = "pack len < sizeof(CPackageHeader)";
		return false;
	}

	CPackageHeader *pHeader = (CPackageHeader *)pData;
	
	// 校验标志位
	if (pHeader->m_nFlag != 0xA5C3)
	{
		strErrMsg = "Header->m_nFlag != 0xA5C3";
		return false;
	}

	// 检查版本
	if (pHeader->m_nVersion != 1)
	{
		strErrMsg = "Header->m_nVersion != 1";
		return false;
	}

	// 检查Mac
	BYTE pkgMac[8];
	memcpy(pkgMac, pHeader->m_arrMac, 8);
	
	// 清空Mac，方便检验
	memset(pHeader->m_arrMac, 0, 8);
	
	BYTE genMac[8];
	if (GenerateMac(pData, *pLen, genMac))
	{
		// 比较两个Mac
		if (memcmp(pkgMac, genMac, 8) != 0)
		{
			strErrMsg = "mac check not pass";
			return false;
		}
	}

	// 保存包头信息
	memcpy(&m_Header, pHeader, sizeof(CPackageHeader));

	int nStructDefLen = CStructDef::GetStructDefLen();

	// 处理接口定义
	CStructDef *pIDef = (CStructDef *) (pData + sizeof(CPackageHeader));
	BYTE *pIData = pData + sizeof(CPackageHeader) + m_Header.m_nStructNum * nStructDefLen;

	bool bParseSuc = true;

	for(int i=0; i<m_Header.m_nStructNum; i++)
	{
		// 拷贝接口定义
		CStructDef *pDef = new CStructDef();
		memcpy(pDef, pIDef, nStructDefLen);

		// 拷贝接口数据
		int nBufLen = pDef->m_nTargetLen > pDef->m_nSourceLen ? pDef->m_nTargetLen : pDef->m_nSourceLen;
		pDef->m_pData = new BYTE[nBufLen];
		memset(pDef->m_pData, 0, nBufLen);
		memcpy(pDef->m_pData, pIData, pDef->m_nTargetLen);

		// 改变指针位置		
		pIDef = (CStructDef *)(((BYTE *) pIDef) + nStructDefLen);
		pIData += pDef->m_nTargetLen;

		int nLastLength = pDef->m_nTargetLen;

		// 先解密
		if (pDef->m_cEncCode == 'Y')
		{
			assert(m_bHasSessionKey);

			// 解密后长度最大长度为源长度+12
			int nTempBufLen = pDef->m_nSourceLen + 12;
			BYTE *pTempBuf = new BYTE[nTempBufLen];
			memset(pTempBuf, 0, nTempBufLen);

			if (DecryptData(pDef->m_pData, pDef->m_nTargetLen, pTempBuf, &nTempBufLen))
			{
				assert(nTempBufLen <= pDef->m_nSourceLen);
				delete[] pDef->m_pData;

				pDef->m_pData = pTempBuf;
				nLastLength = nTempBufLen;	// 解密后实际长度
			}
			else
			{
				strErrMsg = "decrypt data fail";
				delete[] pTempBuf;
				bParseSuc = false;
			}
		}

		// 解压
		if (bParseSuc && pDef->m_cZipCode == 'Y')
		{
			// 解压后最大长度不超过源长度
			int nTempBufLen = pDef->m_nSourceLen;
			BYTE *pTempBuf = new BYTE[nTempBufLen];
			memset(pTempBuf, 0, nTempBufLen);

			if (UnzipData(pDef->m_pData, nLastLength, pTempBuf, &nTempBufLen))
			{
				delete[] pDef->m_pData;

				pDef->m_pData = pTempBuf;
				nLastLength = nTempBufLen;
			}
			else
			{
				strErrMsg = "unzip data fail";
				delete[] pTempBuf;
				bParseSuc = false;
			}
		}

		// 保存接口
		m_Structs.push_back(pDef);

		if (nLastLength != pDef->m_nSourceLen)
		{
			memset(pDef->m_pData, 0, pDef->m_nSourceLen);
			strErrMsg = "parsed length != m_nSourceLen";
			bParseSuc = false;
		}
	}

	*pLen = m_Header.m_nPackageLen;
	return bParseSuc;
}

int  CCommPackage::GetPackageLen()
{
	return m_Header.m_nPackageLen;
}

string CCommPackage::GetPackageReqID()
{
	char szBuf[128];
	memset(szBuf, 0, sizeof(szBuf));
	sprintf(szBuf, "%d:%d", m_Header.m_nReqTime, m_Header.m_nSN);
	return szBuf;
}


bool CCommPackage::GenerateSendData(BYTE *pData, int *pLen)
{
	if (*pLen < m_Header.m_nPackageLen)
		return false;

	*pLen = m_Header.m_nPackageLen;

	// 生成发送时间
	if (m_Header.m_nReqTime ==0)
	{
		m_Header.m_nReqTime = time(NULL);

		// 生成序号
		if (m_Header.m_nReqTime == m_nLastReqTime)
			m_Header.m_nSN = ++m_nLastReqSN;
		else
			m_Header.m_nSN = m_nLastReqSN = 0;

		m_nLastReqTime = m_Header.m_nReqTime;
	}
	else
	{
		m_Header.m_nAnsTime = time(NULL);
	}

	// 拷贝包头
	BYTE *pHead = pData;
	memcpy(pHead, &m_Header, sizeof(CPackageHeader));	

	// 拷贝接口
	pData += sizeof(CPackageHeader);
	BYTE *pIntData = pData + m_Header.m_nStructNum * CStructDef::GetStructDefLen();

	std::vector<CStructDef *>::iterator it;
	for(it = m_Structs.begin(); it != m_Structs.end(); it++)
	{
		CStructDef *pIntDef = (*it);
		memcpy(pData, pIntDef, CStructDef::GetStructDefLen());
		memcpy(pIntData, pIntDef->m_pData, pIntDef->m_nTargetLen);

		pData += CStructDef::GetStructDefLen();
		pIntData += pIntDef->m_nTargetLen;
	}

	// 生成Mac
	BYTE mac[8];
	memset(mac, 0, sizeof(mac));

	// 先将相应Mac位清0
	memset(((CPackageHeader *)pHead)->m_arrMac, 0, 8);

	if (! GenerateMac(pHead,*pLen, mac))
		return false;

	memcpy(((CPackageHeader *)pHead)->m_arrMac, mac, 8);
	return true;
}

bool CCommPackage::ZipData(BYTE *pSourceData, int nSourceLen, BYTE *pDestBuf, int *pDestLen)
{
#ifdef _WIN32
	HZIP hz = CreateZip(0, nSourceLen, ZIP_MEMORY);

	if (hz == 0)
		return false;

	if (ZipAdd(hz, "ZIPDATA", pSourceData, nSourceLen, ZIP_MEMORY) != ZR_OK)
	{
		CloseZip(hz);
		return false;
	}

	void* pZipBuf = NULL;
	DWORD nZipLen = 0;
	if (ZipGetMemory(hz, &pZipBuf, &nZipLen) != ZR_OK)
	{
		CloseZip(hz);
		return false;
	}

	// 如果压缩长度变大，放弃压缩
	if (nZipLen >= nSourceLen)
	{
		CloseZip(hz);
		return false;
	}

	// 拷贝压缩后内容
	int nCopyLen = nZipLen <= *pDestLen ? nZipLen : *pDestLen;
	*pDestLen = nCopyLen;
	memcpy(pDestBuf, pZipBuf, nCopyLen);

	CloseZip(hz);
	return true;
#else
	return true;
#endif // WIN32

	
}

bool CCommPackage::UnzipData(BYTE *pSourceData, int nSourceLen, BYTE *pDestBuf, int *pDestLen)
{
#ifdef _WIN32
	HZIP hz = OpenZip(pSourceData, nSourceLen, ZIP_MEMORY);

	if (hz == 0)
		return false;

	ZIPENTRY ze;
	memset(&ze, 0, sizeof(ze));
	if (GetZipItem(hz, 0, &ze) != ZR_OK)
	{
		CloseZip(hz);
		return false;
	}

	memset(pDestBuf, 0, *pDestLen);
	
	if (ze.unc_size < *pDestLen)
		*pDestLen = ze.unc_size;

	if (UnzipItem(hz, 0, pDestBuf, *pDestLen, ZIP_MEMORY) != ZR_MORE || *pDestLen != ze.unc_size)
	{
		CloseZip(hz);
		return false;
	}

	CloseZip(hz);
	return true;
#else
	return true;
#endif
}

bool CCommPackage::EncryptData(BYTE *pSourceData, int nSourceLen, BYTE *pDestBuf, int *pDestLen)
{
	assert(m_bHasSessionKey);
	if (!m_bHasSessionKey)
		return false;

	int nMinBufLen = nSourceLen % 8 == 0 ? nSourceLen : (nSourceLen /8 +1) *8;
	nMinBufLen += 4;	// 4字节头指定加密前长度

	if (nMinBufLen > *pDestLen)
		return false;

	*pDestLen = nMinBufLen;
	*(int*)pDestBuf = nSourceLen;	//  保存加密前长度
	
	BYTE iv[8];
	memcpy(iv, m_SessionKey+8, 8);
	DES_ncbc_encrypt(pSourceData, pDestBuf+4, nSourceLen, &m_DesKey, &iv, DES_ENCRYPT);

	return true;
}

bool CCommPackage::DecryptData(BYTE *pSourceData, int nSourceLen, BYTE *pDestBuf, int *pDestLen)
{
	assert(m_bHasSessionKey);
	if (!m_bHasSessionKey)
		return false;

	// 取出解密后长度
	int nActLen = *(int*)pSourceData;
	if (nActLen > *pDestLen)
		return false;
	
	nSourceLen -= 4;
	int nMinBufLen = nSourceLen % 8 == 0 ? nSourceLen : (nSourceLen /8 +1) *8;
	if (nMinBufLen > *pDestLen)
		return false;

	*pDestLen = nActLen;
	
	BYTE iv[8];
	memcpy(iv, m_SessionKey+8, 8);
	DES_ncbc_encrypt(pSourceData+4, pDestBuf, nSourceLen, &m_DesKey, &iv, DES_DECRYPT);

	return true;
}

// Mac算法约定。为了减低校验码运算复杂度，使用整包进行Hash运算然后取低8位再进行加密运算的方式。
// 如果当前没有协商传输密钥，直接使用Hash低8位表示
bool CCommPackage::GenerateMac(BYTE *pData, int nLen, BYTE mac[8])
{
	BYTE md5[16];
	memset(md5, 0, 16);    
    MD5Hash(pData, nLen, md5);

	// 加密前8位
	BYTE buf[16];
	memset(buf, 0, sizeof(buf));
	int nBufLen = 16;

	if (m_bHasSessionKey)
	{
		EncryptData(md5, 8, buf, &nBufLen);
		memcpy(mac, buf+4, 8);
		return true;
	}
	else
	{
		memcpy(mac, md5, 8);
		return true;
	}
}