dealall.cpp

用于处理证书请求,生成证书的CA服务器源码,

#include "caSocket.h"
#include "certcreate.h"
#include "DealAll.h"
#include "certextern.h"
#include "certglobal.h"
#include "certtools.h"
#include "certcreate.h"
#include "dhodbc.h"

int DealAll(char *pInBuf,int nInDataLen,char *pOutBuf,int nOutBufLen,int *pOutDataLen)
{
	CASTHEAD casthead,castrt;
	int	nRemain=0;
	int	nRtn=0,nErr=0;
	DWORD	nValid=0;
	int	 nPWDLen=0;

	while(1)
	{
		memset(&casthead,0,sizeof(casthead));
		if(nInDataLen <= CASTHEAD_LEN)
		{
			nRtn = -4000;
			break;
		}
		memcpy(&casthead,pInBuf,sizeof(casthead));
		memcpy(&castrt,&casthead,sizeof(castrt));

		switch(casthead.nType){
		case ISSUECERT:
			ISUCERT isucert;
			HAVEISUCERT haveisucert;

			if(nOutBufLen < CASTHEAD_LEN + HAVEISUCERT_LEN)
			{
				nRtn = -4001;//缓存太小
				break;
			}		

			memset(&isucert,0,sizeof(isucert));
			memset(&haveisucert,0,sizeof(haveisucert));
			memcpy(&isucert,pInBuf+CASTHEAD_LEN,sizeof(isucert));
			nErr = doISSUECERT(&isucert,&haveisucert);

			if(nErr == 0)
			{
				castrt.nType += 1;
				castrt.nLen = HAVEISUCERT_LEN;
				memcpy(pOutBuf+CASTHEAD_LEN,&haveisucert,HAVEISUCERT_LEN);
				*pOutDataLen = CASTHEAD_LEN + HAVEISUCERT_LEN;
			}
			else
			{
				castrt.nType += 1;
				castrt.nLen = sizeof(nErr);
				memcpy(pOutBuf+CASTHEAD_LEN,&nErr,sizeof(nErr));
				*pOutDataLen = CASTHEAD_LEN + sizeof(nErr);
			}

			if(g_nDebug)
				printf("ISSUECERT Success!\n");

			break;


		case DECRYPTPWD:
			
			char szPWD[200];
			
			if(nOutBufLen < CASTHEAD_LEN + 128)
			{
				nRtn = -4003;//缓存太小
				break;
			}

			memset(szPWD,0,sizeof(szPWD));
			memcpy(szPWD,pInBuf+CASTHEAD_LEN,sizeof(szPWD));
			
			nPWDLen = strlen(szPWD);
			nErr = doDECRYPTPWD(szPWD,&nPWDLen,sizeof(szPWD));
			if(nErr == 0 )
			{
				castrt.nType += 1;
				castrt.nLen = nPWDLen;
				memcpy(pOutBuf+CASTHEAD_LEN,szPWD,nPWDLen);
				*pOutDataLen = CASTHEAD_LEN + nPWDLen;
			}
			else
			{
				castrt.nType += 1;
				castrt.nLen = 4;
				memcpy(pOutBuf+CASTHEAD_LEN,"FFFF",4);
				*pOutDataLen = CASTHEAD_LEN + 4;
			}


			if(g_nDebug)
				if(nErr == 0)
					printf("DECRYPTPWD Success!\n");
				else
					printf("DECRYPTPWD Fail!\n");

			break;

		case VERISIGN:
			VERIFYSIGN verifysign;

			if(nOutBufLen < CASTHEAD_LEN + 4)
			{
				nRtn = -4003;//缓存太小
				break;
			}

			memset(&verifysign,0,sizeof(verifysign));
			memcpy(&verifysign,pInBuf+CASTHEAD_LEN,sizeof(verifysign));
			
			nErr = doVERISIGN(&verifysign);

			castrt.nType += 1;
			castrt.nLen = sizeof(nErr);
			memcpy(pOutBuf+CASTHEAD_LEN,&nErr,sizeof(nErr));
			*pOutDataLen = CASTHEAD_LEN + sizeof(nErr);

			if(g_nDebug)
				printf("VERISIGN Success!\n");

			break;
		default:
			nRtn = -4004;		//应用类型错误
			break;
		}
		break;
	} //end while

	if(nRtn != 0)
	{
		memcpy(castrt.sHead,PKHEAD,4);
		castrt.nType = 0x0;
		castrt.nLen = 0x0;
		*pOutDataLen = CASTHEAD_LEN;
	}

	memcpy(pOutBuf,&castrt,sizeof(castrt));
	return nRtn;
}


int doISSUECERT(void* pIsuCert,void* pHaveIsuCert)
{
	int	nRtn;
	ISUCERT *p;
	HAVEISUCERT *q;
	DWORD	dwSerialNum=50;	//从数据库中读取
	DWORD	dwValid=24;
	BYTE	pbCert[3000];
	DWORD	cbSize=3000;
	DWORD	cbData;
	
	nRtn = DBGetSetSerial(&dwSerialNum);
	p = (ISUCERT *)pIsuCert;

	nRtn = DBInsertCertReq(p,dwSerialNum);
	if(nRtn == 0)	//成功
	{
	//	printf("DBInsertCertReq nRtn = %d\n",nRtn);		
	}
	else
		return nRtn;

	nRtn = SignP10(p->name,p->pkcs10,dwSerialNum,dwValid,pbCert,&cbSize);
	if(nRtn == 0)	//成功
	{
		nRtn = DBInsertCert(dwSerialNum,pbCert,cbSize);
	//	printf("DBInsertCert nRtn = %d\n",nRtn);
	}
	else
	{
		return nRtn;
	}

	q = (HAVEISUCERT *)pHaveIsuCert;
	cbData = sizeof(q->pkcs7);
	nRtn = GenP7(pbCert,cbSize,(BYTE *)(q->pkcs7),&cbData);
	//bbc取系列号
	sprintf(q->certserial,"%d",dwSerialNum);

	return nRtn;
}

int doDECRYPTPWD(char *szPWD,int *nDataLen,int nBufLen)
{
	return DecryptPwd(szPWD,nDataLen,nBufLen);
}


int doVERISIGN(void* verifysign)
{
	int nRtn;
	DWORD dwSize=0,dwError=0;

	VERIFYSIGN* p;
	p = (VERIFYSIGN *)verifysign;

	char pUserCert[MAXCERTLEN];

	dwSize = DBGetCertUseSerial(p->serial,pUserCert,MAXCERTLEN);
		if(dwSize < 0)
		{
			dwError = GetLastError();
			return -4010;
		}

	nRtn = VerifySign((unsigned char *)pUserCert,p->signature,p->randomstr);
	return nRtn;

}

int doRestore(char* szCertFile,char* szSignKeyFile,char* szEchgKeyFile,char* szPassword)
{
	int nRtn = 0;
	int nSize,nLen;
	char pBuf[4000];

	memset(pBuf,0,sizeof(pBuf));
	nLen = 4000;
	nSize = ReadFromFile(pBuf,nLen,szSignKeyFile);
	if(nSize < 0)
	{
		return -4050;
	}
	nRtn = RestoreKey((BYTE *)pBuf,nSize,szPassword,1);
	if(nRtn < 0)
	{
		return -4051;
	}

	memset(pBuf,0,sizeof(pBuf));
	nLen = 4000;
	nSize = ReadFromFile(pBuf,nLen,szEchgKeyFile);
	if(nSize < 0)
	{
		return -4052;
	}
	nRtn = RestoreKey((BYTE *)pBuf,nSize,szPassword,1);
	if(nRtn < 0)
	{
		return -4053;
	}

	memset(pBuf,0,sizeof(pBuf));
	nLen = 4000;
	nSize = ReadFromFile(pBuf,nLen,szCertFile);
	if(nSize < 0)
	{
		return -4054;
	}
	nRtn = RestoreCert((BYTE *)pBuf,nSize);
	if(nRtn < 0)
	{
		return -4055;
	}

//	int RestoreCert(BYTE* CERTBIN,int nKeyLen);

	return 0;
}