//#include "stdafx.h"
#include "ccdb2BaseLib.h"
#include <stdio.h>
#include <openssl/err.h>
#include <openssl/sha.h>
#include <openssl/des.h>

char szErrorMsg[1024];

static unsigned char cbc_iv  [8]={0x0e,0xd1,0xba,0x9a,0xf6,0x5c,0x38,0x19};

#define ATL_BASE64_FLAG_NONE	0
#define ATL_BASE64_FLAG_NOPAD	1
#define ATL_BASE64_FLAG_NOCRLF  2

inline int Base64EncodeGetRequiredLength(int nSrcLen, DWORD dwFlags=ATL_BASE64_FLAG_NONE) throw()
{
	int nRet = nSrcLen*4/3;

	if ((dwFlags & ATL_BASE64_FLAG_NOPAD) == 0)
		nRet += nSrcLen % 3;

	int nCRLFs = nRet / 76 + 1;
	int nOnLastLine = nRet % 76;

	if (nOnLastLine)
	{
		if (nOnLastLine % 4)
			nRet += 4-(nOnLastLine % 4);
	}

	nCRLFs *= 2;

	if ((dwFlags & ATL_BASE64_FLAG_NOCRLF) == 0)
		nRet += nCRLFs;

	return nRet;
}

inline int Base64DecodeGetRequiredLength(int nSrcLen) throw()
{
	return nSrcLen;
}

inline BOOL Base64Encode(
	const BYTE *pbSrcData,
	int nSrcLen,
	LPSTR szDest,
	int *pnDestLen,
	DWORD dwFlags=ATL_BASE64_FLAG_NONE) throw()
{
	static const char s_chBase64EncodingTable[64] = {
		'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
		'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',	'h',
		'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
		'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };

	if (!pbSrcData || !szDest || !pnDestLen)
	{
		return FALSE;
	}

	if(*pnDestLen < Base64EncodeGetRequiredLength(nSrcLen, dwFlags))
	{
//		_ASSERT(FALSE);
		return FALSE;
	}

	int nWritten( 0 );
	int nLen1( (nSrcLen/3)*4 );
	int nLen2( nLen1/76 );
	int nLen3( 19 );

	for (int i=0; i<=nLen2; i++)
	{
		if (i==nLen2)
			nLen3 = (nLen1%76)/4;

		for (int j=0; j<nLen3; j++)
		{
			DWORD dwCurr(0);
			for (int n=0; n<3; n++)
			{
				dwCurr |= *pbSrcData++;
				dwCurr <<= 8;
			}
			for (int k=0; k<4; k++)
			{
				BYTE b = (BYTE)(dwCurr>>26);
				*szDest++ = s_chBase64EncodingTable[b];
				dwCurr <<= 6;
			}
		}
		nWritten+= nLen3*4;

		if ((dwFlags & ATL_BASE64_FLAG_NOCRLF)==0)
		{
			*szDest++ = '\r';
			*szDest++ = '\n';
			nWritten+= 2;
		}
	}

	if (nWritten && (dwFlags & ATL_BASE64_FLAG_NOCRLF)==0)
	{
		szDest-= 2;
		nWritten -= 2;
	}

	nLen2 = nSrcLen%3 ? nSrcLen%3 + 1 : 0;
	if (nLen2)
	{
		DWORD dwCurr(0);
		for (int n=0; n<3; n++)
		{
			if (n<(nSrcLen%3))
				dwCurr |= *pbSrcData++;
			dwCurr <<= 8;
		}
		for (int k=0; k<nLen2; k++)
		{
			BYTE b = (BYTE)(dwCurr>>26);
			*szDest++ = s_chBase64EncodingTable[b];
			dwCurr <<= 6;
		}
		nWritten+= nLen2;
		if ((dwFlags & ATL_BASE64_FLAG_NOPAD)==0)
		{
			nLen3 = nLen2 ? 4-nLen2 : 0;
			for (int j=0; j<nLen3; j++)
			{
				*szDest++ = '=';
			}
			nWritten+= nLen3;
		}
	}

	*pnDestLen = nWritten;
	return TRUE;
}

inline int DecodeBase64Char(unsigned int ch) throw()
{
	// returns -1 if the character is invalid
	// or should be skipped
	// otherwise, returns the 6-bit code for the character
	// from the encoding table
	if (ch >= 'A' && ch <= 'Z')
		return ch - 'A' + 0;	// 0 range starts at 'A'
	if (ch >= 'a' && ch <= 'z')
		return ch - 'a' + 26;	// 26 range starts at 'a'
	if (ch >= '0' && ch <= '9')
		return ch - '0' + 52;	// 52 range starts at '0'
	if (ch == '+')
		return 62;
	if (ch == '/')
		return 63;
	return -1;
}

inline BOOL Base64Decode(LPCSTR szSrc, int nSrcLen, BYTE *pbDest, int *pnDestLen) throw()
{
	// walk the source buffer
	// each four character sequence is converted to 3 bytes
	// CRLFs and =, and any characters not in the encoding table
	// are skiped

	if (szSrc == NULL || pnDestLen == NULL)
	{
//		ATLASSERT(FALSE);
		return FALSE;
	}

	LPCSTR szSrcEnd = szSrc + nSrcLen;
	int nWritten = 0;

	BOOL bOverflow = (pbDest == NULL) ? TRUE : FALSE;

	while (szSrc < szSrcEnd)
	{
		DWORD dwCurr = 0;
		int i;
		int nBits = 0;
		for (i=0; i<4; i++)
		{
			if (szSrc >= szSrcEnd)
				break;
			int nCh = DecodeBase64Char(*szSrc);
			szSrc++;
			if (nCh == -1)
			{
				// skip this char
				i--;
				continue;
			}
			dwCurr <<= 6;
			dwCurr |= nCh;
			nBits += 6;
		}

		if(!bOverflow && nWritten + (nBits/8) > (*pnDestLen))
			bOverflow = TRUE;

		// dwCurr has the 3 bytes to write to the output buffer
		// left to right
		dwCurr <<= 24-nBits;
		for (i=0; i<nBits/8; i++)
		{
			if(!bOverflow)
			{
				*pbDest = (BYTE) ((dwCurr & 0x00ff0000) >> 16);
				pbDest++;
			}
			dwCurr <<= 8;
			nWritten++;
		}
	}

	*pnDestLen = nWritten;

	if(bOverflow)
	{
//		if(pbDest != NULL)
//			ATLASSERT(FALSE);

		return FALSE;
	}

	return TRUE;
}

void ccClearErrorString()
{
	szErrorMsg[0]='\0';
}

const char *ccGetErrStr()
{
	return szErrorMsg;
}
void ccSetErrorString(const char *szFormat,...)
{
	va_list arg;
	va_start(arg,szFormat);
	int nRet=_vsnprintf_s(szErrorMsg,
		sizeof(szErrorMsg),
		1024,
		szFormat,
		arg);
	va_end(arg);
	if(0==nRet)
		szErrorMsg[0]=0;
}

DWORD SimpleSign(const BYTE *pBuf,DWORD nLen)
{
	DWORD nRet(0);
	for(DWORD i=0;i<nLen;i++)
		nRet+=pBuf[i];
	return nRet;
}
void PrintfCryptError()
{
	char Buffer[1024];
	ccSetErrorString("%s\n",ERR_error_string(ERR_get_error(),Buffer));
}

SmartBuffer ccHash(const BYTE *pInBuf,int nInSize)
{
	SmartBuffer RetHash(20);
	if(SHA1(pInBuf,nInSize,RetHash.pBuf)==NULL)
	{
		PrintfCryptError();
		RetHash.Clear();
	}
	return RetHash;
}


SmartBuffer ccPublicDecryptStream(RSA *pPublicKey,const BYTE *pInBuf,int nLen,SmartBuffer &Signer)
{
	int nRsaSize=RSA_size(pPublicKey);
	int nCryptDesLen=nLen-nRsaSize;
	if(nCryptDesLen<8 || nCryptDesLen%8!=0)
	{
		ccSetErrorString("The crypt stream is demaged\n");
		return SmartBuffer();
	}
	SmartBuffer OrgSign(nRsaSize);
	OrgSign.nLen=RSA_public_decrypt(nRsaSize,pInBuf+nLen-nRsaSize,OrgSign.pBuf,pPublicKey,RSA_PKCS1_PADDING);
	if(OrgSign.nLen==-1)
	{
		PrintfCryptError();
		return SmartBuffer();
	}
	short nSignerLen=*(short *)OrgSign.pBuf;
	if(nSignerLen!=(int)(OrgSign.nLen-sizeof(short)-sizeof(DES_cblock)))
	{
		ccSetErrorString("The Sign data is invalid\n");
		return SmartBuffer();
	}
	Signer.SetStr((char *)OrgSign.pBuf+sizeof(short));
	DES_cblock *pDesKey=(DES_cblock *)(OrgSign.pBuf+sizeof(short)+nSignerLen);
	SmartBuffer OrgBuf(nCryptDesLen);

	DES_cblock iv;
	memcpy(iv,cbc_iv,sizeof(cbc_iv));
	DES_key_schedule Key;
	DES_set_key_unchecked(pDesKey,&Key);
	DES_cbc_encrypt(pInBuf,OrgBuf.pBuf,nCryptDesLen,&Key,&iv,DES_DECRYPT);
	int RetBufLen=*(int *)OrgBuf.pBuf;
	if(RetBufLen>(int)(nCryptDesLen-sizeof(int)-sizeof(DWORD)) || RetBufLen<(int)(nCryptDesLen-sizeof(int)-sizeof(DWORD)-8))
	{
		ccSetErrorString("The OrgBuf is invalid len\n");
		return SmartBuffer();
	}
	SmartBuffer RetBuf(RetBufLen+1);
	RetBuf.nLen=RetBufLen;
	memcpy(RetBuf.pBuf,OrgBuf.pBuf+sizeof(int)+sizeof(DWORD),RetBufLen);
	DWORD OrgSimple=*(DWORD *)(OrgBuf.pBuf+sizeof(int));
	DWORD Simple=SimpleSign(RetBuf.pBuf,RetBufLen);
	if(Simple!=OrgSimple)
	{
		ccSetErrorString("The OrgBuf is demaged\n");
		return SmartBuffer();
	}
	return RetBuf;
}


RSA *ccD2I_RsaPublic(const BYTE *pBuf,int nLen)
{
	RSA *pPublicKey=d2i_RSAPublicKey(NULL,&pBuf,nLen);
	if(pPublicKey==NULL)
		PrintfCryptError();
	return pPublicKey;
}