myvtm/RVCComm/RVCComm.cpp

// RVCComm.cpp : Defines the entry point for the DLL application.
//
#include "RVCComm.h"
#include "ClientComm.h"
//#include "ServerComm.h"
#include <assert.h>
#include "rsa.h"
#include "md5.h"
//#include <applink.c>
#include "pem.h"
#include <err.h>
#include <winpr/locale.h>


CSecureClientBase::CSecureClientBase()
{
	m_nRefCount = 1;		// Entity持有, CClientComm生命期由CSecureClientBase控制，故持有不占用计数
	m_pClientComm = new CClientComm(this);
}

bool InitSocket()
{
	//Initialize Winsock
	WSADATA wsaData;

	int nResult = WSAStartup(MAKEWORD(2,2), &wsaData);
	return nResult ==0;
}


void UninitSocket()
{
	WSACleanup();
}
#ifdef _WIN32
BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
	bool bRet(true);

    switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
			OpenSSL_add_all_ciphers();
			OpenSSL_add_all_digests();
			ERR_load_crypto_strings();

			bRet = InitSocket();
			break;

		case DLL_THREAD_ATTACH:
			break;

		case DLL_THREAD_DETACH:
			break;

		case DLL_PROCESS_DETACH:
			UninitSocket();
			break;
    }

    return bRet ? TRUE : FALSE;
}
#endif


// 客户端通过此函数获得通讯类实例
/*
RVCCOMM_API IClientCommFunc* GetClientComm(CSecureClientBase *pCallback)
{
	assert(pCallback != NULL);
	if (pCallback == NULL)
		return NULL;

	pCallback->m_pClientComm = new CClientComm(pCallback);
	return pCallback->m_pClientComm;
}

// 服务端通过此函数获得通讯类实例
RVCCOMM_API CServerCommBase* GetServerComm(CServerCallback *pCallback)
{
	assert(pCallback != NULL);
	if (pCallback == NULL)
		return NULL;

	pCallback->m_pServerComm = new CServerComm(pCallback);
	return pCallback->m_pServerComm;
}*/


string GetSysErrorMsg(int nErrorCode)
{
	char pMsg[1024];
	memset(pMsg, 0, sizeof(pMsg));

	if(::FormatMessage(
			FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
			NULL,
			nErrorCode,
			MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
			pMsg,
			sizeof(pMsg)/sizeof(char),
			NULL))
	{
		pMsg[sizeof(pMsg)/sizeof(char)-1]=0;

		int nLen = strlen(pMsg);
		if (pMsg[nLen-1] == '\n' && pMsg[nLen-2] == '\r')
			pMsg[nLen-2] = 0;
	}

	return pMsg;
}


bool CreateRsaKeyPair(BYTE *pPubKeyBuf, int *pPubKeyBufLen, BYTE *pPriKeyBuf, int *pPriKeyBufLen)
{
	if (*pPubKeyBufLen < 140 || *pPriKeyBufLen <608)
		return false;

	memset(pPubKeyBuf, 0, *pPubKeyBufLen);
	memset(pPriKeyBuf, 0, *pPriKeyBufLen);

	RSA *rsa = RSA_generate_key(1024, RSA_F4, NULL, NULL);
	if (rsa == NULL)
		return false;

	*pPubKeyBufLen = i2d_RSAPublicKey(rsa, &pPubKeyBuf);
	*pPriKeyBufLen = i2d_RSAPrivateKey(rsa, &pPriKeyBuf);

	RSA_free(rsa);
	return (*pPubKeyBufLen >0 && *pPriKeyBufLen >0);
}

// 使用RSA公钥加密
bool EncWithRsaPubKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, RSA* rsa_pub)
{
	// 公钥加密
	assert(*pDestLen >= nSourceLen);

	BYTE *pFrom = pSource;
	BYTE *pEnd = pSource + nSourceLen;
	int nTotalLen = 0;

	while(pFrom < pEnd)
	{
		if (*pDestLen - nTotalLen < 128)
		{
			RSA_free(rsa_pub);
			return false;
		}
			
		int nBlockLen = (pEnd - pFrom) <= 117 ? (pEnd - pFrom) : 117;
		int nRet = RSA_public_encrypt(nBlockLen, pFrom, pDest + nTotalLen, rsa_pub, RSA_PKCS1_PADDING);
		if (nRet <= 0)
		{
			RSA_free(rsa_pub);
			return false;
		}

		pFrom += nBlockLen;
		nTotalLen += nRet;
	}

	*pDestLen = nTotalLen;
	RSA_free(rsa_pub);
	return true;
}

// 使用RSA公钥加密
bool EncWithRsaPubKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, BYTE *pRsaPubKey, int nKeyLen)
{
	// 还原RSA公钥
	const BYTE *p = pRsaPubKey;
	RSA *rsa_pub = d2i_RSAPublicKey(NULL, &p, nKeyLen);

	if (rsa_pub == NULL)
		return false;

	return EncWithRsaPubKey(pSource, nSourceLen, pDest, pDestLen, rsa_pub);
}

// 使用RSA私钥加密
bool EncWithRsaPriKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, RSA *rsa_pri)
{
	// 私钥加密
	assert(*pDestLen >= nSourceLen);

	BYTE *pFrom = pSource;
	BYTE *pEnd = pSource + nSourceLen;
	int nTotalLen = 0;

	while(pFrom < pEnd)
	{
		if (*pDestLen - nTotalLen < 128)
		{
			RSA_free(rsa_pri);
			return false;
		}
			
		int nBlockLen = (pEnd - pFrom) <= 117 ? (pEnd - pFrom) : 117;
		int nRet = RSA_private_encrypt(nBlockLen, pFrom, pDest + nTotalLen, rsa_pri, RSA_PKCS1_PADDING);
		if (nRet <= 0)
		{
			RSA_free(rsa_pri);
			return false;
		}

		pFrom += nBlockLen;
		nTotalLen += nRet;
	}

	*pDestLen = nTotalLen;
	RSA_free(rsa_pri);
	return true;
}

// 使用RSA私钥加密
bool EncWithRsaPriKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, BYTE *pRsaPriKey, int nKeyLen)
{
	// 还原RSA私钥
	const BYTE *p = pRsaPriKey;
	RSA *rsa_pri = d2i_RSAPrivateKey(NULL, &p, nKeyLen);

	if (rsa_pri == NULL)
		return false;

	return EncWithRsaPriKey(pSource, nSourceLen, pDest, pDestLen, rsa_pri);
}

// 使用RSA公钥解密
bool DecWithRsaPubKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, RSA *rsa_pub)
{
	// 公钥解密
	assert(*pDestLen >= nSourceLen);
	assert(nSourceLen % 128 ==0);

	BYTE *pFrom = pSource;
	BYTE *pEnd = pSource + nSourceLen;
	int nTotalLen = 0;

	while(pFrom < pEnd)
	{
		if (*pDestLen - nTotalLen < 128)
		{
			RSA_free(rsa_pub);
			return false;
		}
			
		int nRet = RSA_public_decrypt(128, pFrom, pDest + nTotalLen, rsa_pub, RSA_PKCS1_PADDING);
		if (nRet <= 0)
		{
			RSA_free(rsa_pub);
			return false;
		}

		pFrom += 128;
		nTotalLen += nRet;
	}

	*pDestLen = nTotalLen;
	RSA_free(rsa_pub);
	return true;
}

// 使用RSA公钥解密
bool DecWithRsaPubKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, BYTE *pRsaPubKey, int nKeyLen)
{
	// 还原RSA公钥
	const BYTE *p = pRsaPubKey;
	RSA *rsa_pub = d2i_RSAPublicKey(NULL, &p, nKeyLen);

	if (rsa_pub == NULL)
		return false;

	return DecWithRsaPubKey(pSource, nSourceLen, pDest, pDestLen, rsa_pub);
}

// 使用RSA私钥解密
bool DecWithRsaPriKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, RSA *rsa_pri)
{
	// 私钥解密
	assert(*pDestLen >= nSourceLen);
	assert(nSourceLen % 128 ==0);

	BYTE *pFrom = pSource;
	BYTE *pEnd = pSource + nSourceLen;
	int nTotalLen = 0;

	while(pFrom < pEnd)
	{
		if (*pDestLen - nTotalLen < 128)
		{
			RSA_free(rsa_pri);
			return false;
		}
			
		int nRet = RSA_private_decrypt(128, pFrom, pDest + nTotalLen, rsa_pri, RSA_PKCS1_PADDING);
		if (nRet <= 0)
		{
			RSA_free(rsa_pri);
			return false;
		}

		pFrom += 128;
		nTotalLen += nRet;
	}

	*pDestLen = nTotalLen;
	RSA_free(rsa_pri);
	return true;
}

// 使用RSA私钥解密
bool DecWithRsaPriKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen, BYTE *pRsaPriKey, int nKeyLen)
{
	// 还原RSA私钥
	const BYTE *p = pRsaPriKey;
	RSA *rsa_pri = d2i_RSAPrivateKey(NULL, &p, nKeyLen);

	if (rsa_pri == NULL)
		return false;

	return DecWithRsaPriKey(pSource, nSourceLen, pDest, pDestLen, rsa_pri);
}


bool MD5Hash(BYTE *pData, int nLen, BYTE md5[16])
{
	MD5_CTX context;
    memset(md5, 0, 16);
    
    MD5_Init(&context);
    MD5_Update(&context, pData, nLen);
    MD5_Final(md5, &context);
	return true;
}

RSA *GetServerRSAPubKey()
{
	const char PublicKeyData[] = "-----BEGIN PUBLIC KEY-----\n"
		"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC9dYbXjQM77pdpddBS7bdEMVjT\n"
		"rMfvDyy3v+XEMAXBeh1j4M8670VoblikavFtX/xf9kP+byp3MtnnMqAhP0TkuUWw\n"
		"s8S157RuLaM8571TfHztPet4O23+2wTazpPuU/9ZVHDRxROMOCk2O6UYbEPMyQXv\n"
		"Ue2HA8c1ZRuP4+Q8RQIDAQAB\n"
		"-----END PUBLIC KEY-----";

	BIO	*bio = NULL;

	if( (bio=BIO_new_mem_buf((void *)PublicKeyData, sizeof(PublicKeyData))) == NULL)
		return NULL;

	RSA *rsa = PEM_read_bio_RSA_PUBKEY(bio, NULL, NULL, NULL);	
	BIO_free(bio);

	return rsa;
}

// 使用服务器公钥解密
bool DecWithServerPubKey(BYTE *pSource, int nSourceLen, BYTE *pDest, int *pDestLen)
{
	RSA *pkey = GetServerRSAPubKey();
	if (pkey == NULL)
		return false;


	return DecWithRsaPubKey(pSource, nSourceLen, pDest, pDestLen, pkey);
}