myvtm/Framework/Common/RVCComm.h

#if !defined(AFX_RVCCOMM_H__12A1FE2E_023E_4CB8_99C5_E3AF870A5007__INCLUDED_)
#define AFX_RVCCOMM_H__12A1FE2E_023E_4CB8_99C5_E3AF870A5007__INCLUDED_

#ifdef RVCCOMM_LINKED_AS_STATIC_LIBRARY
#define RVCCOMM_API
#else
#ifdef _WIN32
#ifdef RVCCOMM_EXPORTS
#define RVCCOMM_API __declspec(dllexport)
#else
#define RVCCOMM_API __declspec(dllimport)
#endif
# elif ( defined(__GNUC__) &&  __GNUC__ >= 4 )
#define RVCCOMM_API __attribute__((visibility("default")))
#else // _WIN32
#define RVCCOMM_API
#endif // _WIN32

#endif


#if defined(_MSC_VER)
#include <WinSock2.h>
#include <windows.h>
#else
#include <winpr/windows.h>
#include <winpr/interlocked.h>
#endif //_MSC_VER

#ifndef RVCCOMM_TAG
#include <winpr/wlog.h>
#ifndef RVC_TAG
#define RVC_TAG(tag) "rvc." tag
#endif
#define RVCCOMM_TAG(tag) RVC_TAG("rvccomm.") tag
#endif //RVCCOMM_TAG

#include <string>
#include <vector>
#include <algorithm>
using namespace std;

#include "SmartPointer.h"

#pragma pack(1)
//// 设备信息
struct CVerifyInfo
{
	char  m_arrTerminalNo[16];		// 终端号
	BYTE  m_arrIP[4];				// IP地址
	char  m_arrServiceType[8];		// 通道类型
};

// 令牌信息(未签名)
struct CTokenInfo
{
	char  m_arrTerminalNo[16];		// 终端号
	BYTE  m_arrIP[4];				// 终端IP
	DWORD m_dwCreateTime;			// 创建时间，从2000年开始秒数
	BYTE  m_arrTempPubKey[140];		// 终端临时公钥
	BYTE  m_arrHash[16];			// 结构体MD5值
};

// 会话密钥
struct CSessionKey
{
	BYTE m_arrSessionKey[16];		// 临时会话密钥
	char m_arrServiceName[16];		// 服务名称
};

// 连接鉴权请求结构
struct CConnAuthReq
{
	BYTE m_arrVerifyInfo[128];		// 客户端私钥加密后设备信息CVerifyInfo
	BYTE m_arrVerifyToken[256];		// 准入服务签名后令牌信息CTokenInfo
};


struct CConnAuthSMReq
{
    BYTE m_arrVerifyInfo[256];		// 客户端公钥加密后设备信息CVerifyInfo
    BYTE m_arrVerifyToken[512];		// 准入服务签名后令牌信息CTokenInfo
};

struct CConnAuthSMRet
{
    BYTE m_arrEncSessionKey[256];	// 客户端公钥加密后的CSessionKey
};

// 连接鉴权返回结构
struct CConnAuthRet
{
	BYTE m_arrEncSessionKey[128];	// 客户端公钥加密后的CSessionKey
};
#pragma pack()

// 通讯包接口
struct RVCCOMM_API IPackage
{
	virtual ~IPackage(){}

	// 增加接口数据，nBufLen包括所有数组元素的总长度，nArrayNum指定数组个数
	virtual void AddStruct(const char *pStructName, bool bZip, bool bEncrpyt,
		BYTE *pDataBuf, int nBufLen, int nArrayNum = 1) =0;

	// 取接口数据长度(包括所有数组元素)
	virtual int GetStructLen(const char *pStructName) =0;

	// 取接口数据
	virtual bool GetStructData(const char *pStructName, BYTE *pDataBuf, 
		int *pBufLen, int *pArrayNum) =0;

	// 取服务代码
	virtual string GetServiceCode() =0;	

	// 设置返回错误结构信息
	virtual void SetErrMsg(DWORD dwSysCode, DWORD dwUserCode, const char *pErrMsg) =0;

	// 检查并返回错误结构信息
	virtual bool GetErrMsg(DWORD& dwSysCode, DWORD& dwUserCode, string& rErrMsg) =0;
};

// 客户端通讯接口类，由类库提供，封装TCP通信、鉴权、压缩、拆解包服务供业务使用
struct RVCCOMM_API IClientCommFunc
{	
	virtual ~IClientCommFunc(){}
	virtual bool IsConnectionOK() =0;
	virtual bool IsSecureConnection() =0;

	// 创建连接，@option：1、重新鉴权新建会话密钥；2、通过握手使用缓存会话密钥；3、不使用会话密钥，即非安全通道
	// 4、不协商，直接使用共享会话密钥
	virtual bool Connect(const char *pServerAddr, int nPort, int nOption) =0;

	// 关闭连接
	virtual void Close() =0;

	// 发送通讯包
	virtual string SendPackage(const CSmartPointer<IPackage>& pSendPkg) =0; 

	/*!
	 * @brief 同步接收
	 * @param[in]  nWaitSecond 单位：秒
	 */
	virtual CSmartPointer<IPackage> ReceivePackage(int nWaitSecond) =0;	

	// 返回的IPackage指针
	virtual CSmartPointer<IPackage> CreateNewPackage(const char *pServiceCode) =0;
	virtual CSmartPointer<IPackage> CreateReplyPackage(const CSmartPointer<IPackage>& pRecvPkg) =0;
};

// 客户端业务基类，提供加解密及异步接收等回调处理
struct RVCCOMM_API CSecureClientBase
{
protected:
	virtual ~CSecureClientBase(){delete m_pClientComm;}

public:
	CSecureClientBase();	

	void IncRefCount() { InterlockedIncrement(&m_nRefCount); }
	void DecRefCount() { if (0 == InterlockedDecrement(&m_nRefCount)) {delete this;} }

	CSmartPointer<IClientCommFunc> GetFunction(){return m_pClientComm;}

	// 鉴权开始，需提供Token信息和客户端私钥加密的设备信息
	virtual bool OnAuthRequestSM(CConnAuthSMReq* pReq) { return true; }

	// 临时会话密钥返回，需使用临时私钥解锁，*pBufLen返回0表示解密失败
	virtual bool OnSessionKeyRet(CConnAuthRet *pRet, BYTE *pBuf, int *pBufLen){return true;}

	virtual bool OnSessionKeySMRet(CConnAuthSMRet* pRet, BYTE* pBuf, int* pBufLen) { return true; }

	// 鉴权通过，可以发送请求包
	virtual void OnAuthPass()=0;

	// 通过回调获取共享会话密钥(从令牌实体取出共享会话密钥) 
	virtual bool OnGetSharedSK(char *pTerminalNo, int *pTerminalNoLen, BYTE *pSKBuf, int *pSKBufLen){return true;}

	// 异步接收
	virtual void OnReceivePackage(CSmartPointer<IPackage> &pRecvPkg)=0;

	// 连接中断通知
	virtual void OnClose()=0;

	// 错误回调，UserCode是后台服务自定义事件码， 如非后台服务产生的错误，则为0
	virtual void OnError(DWORD dwSysCode, DWORD dwUserCode, const char *pErrMsg) =0;

#ifndef RVCCOMM_LINKED_AS_STATIC_LIBRARY
#ifndef RVCCOMM_EXPORTS
private:
#endif
#endif

	IClientCommFunc *m_pClientComm;
	LONG m_nRefCount;		
};

/*
// 服务端通讯接口类，提供TCP通信、鉴权、压缩、拆解包服务
struct RVCCOMM_API CServerCommBase
{
	virtual ~CServerCommBase(){}
	virtual bool BeginService(int nListenPort) =0;
	virtual void EndService() =0;	
	virtual const string Send(int nConnectionID, const IPackage *pSendPkg) =0;

	// 应用使用完IPackage指针，需要手动delete
	virtual IPackage* CreateSendPackage(int nConnectionID, const char *pServiceCode) =0;
	virtual IPackage* CreateReplyPackage(IPackage *pRecvPkg) =0;
};


// 服务端回调接口，实现连接事件处理及错误处理
struct RVCCOMM_API CServerCallback
{
	virtual ~CServerCallback(){}
	virtual void OnError(int nConnectionID, const char *pErrCode, const char *pErrMsg) =0;
	virtual void OnAccept(int nConnectionID, const char *pClientAddr, int nClintPort) =0;

	// 要在方法返回前调用delete释放pRecvPkg
	virtual void OnReceive(int nConnectionID, IPackage *pRecvPkg) =0;
	
	virtual void OnClose(int nConnectionID) =0;

	CServerCommBase *m_pServerComm;
};*/

// 客户端通过此函数获得通讯类实例
//IClientCommFunc* GetClientComm(CSecureClientBase *pClientBase);

// 服务端通过此函数获得通讯类实例
//RVCCOMM_API CServerCommBase* GetServerComm(CServerCallback *pCallback);

// 生成临时RSA公私钥对, pPubKeyBufLen和pPriKeyBufLen输入时表示缓冲区长度，输出值表示实际密钥长度   （替换为SM2加密）
RVCCOMM_API bool CreateRsaKeyPair(BYTE *pPubKeyBuf, int *pPubKeyBufLen, BYTE *pPriKeyBuf, int *pPriKeyBufLen);

// 使用服务器公钥解密
RVCCOMM_API bool DecWithServerPubKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen);

// 使用RSA公钥加密
RVCCOMM_API bool EncWithRsaPubKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, BYTE *pRsaPubKey, int nKeyLen);

// 使用RSA私钥加密
RVCCOMM_API bool EncWithRsaPriKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, BYTE *pRsaPriKey, int nKeyLen);

// 使用RSA公钥解密
RVCCOMM_API bool DecWithRsaPubKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, BYTE *pRsaPubKey, int nKeyLen);

// 使用RSA私钥解密
RVCCOMM_API bool DecWithRsaPriKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, BYTE *pRsaPriKey, int nKeyLen);

// 计算MD5值 (替换为SM3Hash)
RVCCOMM_API bool MD5Hash(BYTE *pData, int nLen, BYTE md5[16]);

// 取系统错误信息
RVCCOMM_API string GetSysErrorMsg(int nErrorCode);


// 获取SM234的version, 调用打印厂商和版本号
/*
	* 功能：获取厂商信息和版本信息
	* 输入：无
	* 返回值：
	* TianDiRong-1.0-x86		天地融32位版本1.0
	* TianDiRong-1.0-x64		天地融64位版本1.0
	* KeYou-1.0-x86			科友32位版本1.0
	* KeYou-1.0-x64			科友64位版本1.0

	*/

RVCCOMM_API char* GetSMVersion();

RVCCOMM_API bool subByteArr(BYTE* src, BYTE* dst, int offset, int size);

// 计算SM3的值
RVCCOMM_API bool SM3Hash(BYTE* pData, int nLen, BYTE hash[32]);	//替换MD5
//计算文件的SM3的值
RVCCOMM_API bool SM3File(char* file, BYTE hash[32]);

/*
	功能：生成SM2公私钥对
	输入：
	pPubKeyBuf : pubkey缓冲区的长度，至少为65字节
	pPriKeyBuf：	privkey缓冲区的长度，至少为32字节
	输出：
	pPubKeyBuf：   	公钥
	pPubKeyBufLen : 公钥的字节数
	pPriKeyBuf：		私钥
	pPriKeyBufLen：	私钥的字节数
	返回值：
	*/
RVCCOMM_API bool CreateSM2KeyPair(BYTE* pPubKeyBuf, int* pPubKeyBufLen, BYTE* pPriKeyBuf, int* pPriKeyBufLen);
/*
	功能：用SM2公钥加密数据。
	输入：
	pPubKey： 	公钥
	nKeyLen：	公钥的字节数
	pSource：     	要加密的数据
	nSourceLen：	pSource的字节数
	pDestLen : pDest缓冲区的长度，必须至少比pSource的长度多97字节
	输出：
	pDest : 加密结果
	pDestLen : 加密结果的字节数
	返回值：
	*/
RVCCOMM_API bool EncWithSM2PubKey(BYTE* pSource, int nSourceLen, BYTE* pDest, int* pDestLen, BYTE* pPubKey, int nKeyLen);

	/*
	功能：用SM2私钥解密数据。
	输入：
	pPriKey： 	私钥
	nKeyLen：	私钥的字节数
	pSource : 要解密的数据，不少于97字节。
	nSourceLen：	pSource的字节数
	pDestLen : pDest缓冲区的长度，至少为nSourceLen ~ 97字节
	输出：
	pDest : 解密结果
	pDestLen : 解密结果的字节数
	返回值：
	*/
RVCCOMM_API bool DecWithSM2PriKey(BYTE* pSource, int nSourceLen, BYTE* pDest, int* pDestLen, BYTE* pPriKey, int nKeyLen);


/*
功能：SM2签名，userid默认为“1234567812345678”
输入：
privkey： 	私钥
privkey_len： 私钥的字节数
msg : 待签名的数据
msg_len : 待签名的数据长度
sig_len：		signature缓冲区的长度
输出：
signature：  	签名
sig_len：		signature的长度
返回值：
true：		成功
len：	signature为空时，返回所需的长度
其他：	待定义
*/
RVCCOMM_API bool  SM2SignWithSM3(unsigned char* privkey, int privkey_len, unsigned char* msg, int msg_len, unsigned char* signature, int* sig_len);

/*
	功能：验证SM2签名，userid默认为“1234567812345678”
	输入：
	pubkey： 	公钥
	pubkey _len：	公钥的字节数
	msg：  		签名数据
	msg_len：	签名数据的字节数
	signature：  	签名
	sig_len：		签名的字节数
	返回值：
	true：		成功
	其他：	待定义
	*/

RVCCOMM_API bool  SM2VerifyWithSM3(unsigned char* pubkey, int pubkey_len, unsigned char* msg, int msg_len, unsigned char* signature, int sig_len);


/*
	* 功能：SM4的ECB加密
	* 输入：
	key: 输入keyStr，为字符串
	input:需要加密的数据
	length:加密数据的长度
	output：加密后数据
	output_len:输入output的最大长度，返回加密后output的长度
	* 返回值：
		是否成功
	*/



RVCCOMM_API bool EncWithSM4_ECB(std::string keyStr, BYTE* input, int length, BYTE* output, int* output_len);
/*
	* 功能：SM4的ECB解密
	* 输入：
	key: 输入keyStr，为字符串
	input:需要解密的数据
	length:解密数据的长度
	output：解密后数据
	output_len:输入output的最大长度，返回解密后output的长度
	* 返回值：
		是否成功
	*/
RVCCOMM_API bool DecWithSM4_ECB(std::string keyStr, BYTE* input, int length, BYTE* output, int* output_len);

/*
	* 功能：SM4的ECB加密
	* 输入：
	key: 输入16位的密钥，可通过SM3Hash生成
	* 返回值：
		是否成功
	*/
RVCCOMM_API bool EncWithSM4_ECB(BYTE key[16], BYTE* input, int length, BYTE* output, int* output_len);
/*
	* 功能：SM4的ECB解密
	* 输入：
	key: 输入16位的密钥，可通过SM3Hash生成
	* 返回值：
		是否成功
	*/
RVCCOMM_API bool DecWithSM4_ECB(BYTE key[16], BYTE* input, int length, BYTE* output, int* output_len);


#endif